面试题：Java构建者模式在复杂系统中的优化与拓展

优化和拓展方向及思路

构建步骤复用
- 思路：分析构建步骤，提取公共部分并复用。例如，如果多个复杂对象构建过程中都有初始化数据库连接的步骤，可以将这一步骤提取出来作为公共方法，不同构建者复用此方法，减少重复代码和不必要的初始化开销。
- 代码示例：

class DatabaseConnection {
    // 数据库连接相关代码
    public DatabaseConnection() {
        // 初始化连接逻辑
    }
}

class CommonBuilderSteps {
    public DatabaseConnection initDatabaseConnection() {
        return new DatabaseConnection();
    }
}

class ComplexObjectBuilder1 extends CommonBuilderSteps {
    private ComplexObject1 complexObject1 = new ComplexObject1();
    public void buildPart1() {
        DatabaseConnection connection = initDatabaseConnection();
        // 使用connection构建part1逻辑
    }
    public ComplexObject1 getResult() {
        return complexObject1;
    }
}

class ComplexObjectBuilder2 extends CommonBuilderSteps {
    private ComplexObject2 complexObject2 = new ComplexObject2();
    public void buildPart1() {
        DatabaseConnection connection = initDatabaseConnection();
        // 使用connection构建part1逻辑
    }
    public ComplexObject2 getResult() {
        return complexObject2;
    }
}

构建过程并行化
- 思路：对于一些相互独立的构建步骤，可以利用多线程并行执行。比如在构建一个复杂报表对象时，报表数据的获取和图表的生成可能相互独立，可并行处理。
- 代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class ReportPart1 {
    // 报表部分1相关代码
    public ReportPart1() {
        // 构建逻辑
    }
}

class ReportPart2 {
    // 报表部分2相关代码
    public ReportPart2() {
        // 构建逻辑
    }
}

class ReportBuilder {
    private ReportPart1 part1;
    private ReportPart2 part2;
    public void build() {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future<ReportPart1> future1 = executorService.submit(() -> {
            return new ReportPart1();
        });
        Future<ReportPart2> future2 = executorService.submit(() -> {
            return new ReportPart2();
        });
        try {
            part1 = future1.get();
            part2 = future2.get();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
    public Report getReport() {
        return new Report(part1, part2);
    }
}

class Report {
    private ReportPart1 part1;
    private ReportPart2 part2;
    public Report(ReportPart1 part1, ReportPart2 part2) {
        this.part1 = part1;
        this.part2 = part2;
    }
}

缓存构建结果
- 思路：如果相同参数组合的复杂对象构建频繁，可以缓存构建结果。例如在构建用户个性化配置对象时，若某些用户具有相同的配置参数组合，可缓存已构建好的对象。
- 代码示例：

import java.util.HashMap;
import java.util.Map;

class UserConfig {
    private int param1;
    private String param2;
    public UserConfig(int param1, String param2) {
        this.param1 = param1;
        this.param2 = param2;
    }
}

class UserConfigBuilder {
    private static Map<String, UserConfig> configCache = new HashMap<>();
    public UserConfig build(int param1, String param2) {
        String key = param1 + "-" + param2;
        if (configCache.containsKey(key)) {
            return configCache.get(key);
        }
        UserConfig config = new UserConfig(param1, param2);
        configCache.put(key, config);
        return config;
    }
}

使用建造者抽象类或接口简化维护
- 思路：将构建者的公共方法和属性提取到抽象类或接口中，使得具体构建者类继承或实现，提高代码的可维护性和扩展性。当需要修改构建逻辑时，只需要在抽象类或接口处修改，具体构建者类会自动应用修改。
- 代码示例：

// 抽象建造者
abstract class AbstractComplexObjectBuilder {
    protected ComplexObject complexObject;
    public abstract void buildPart1();
    public abstract void buildPart2();
    public ComplexObject getResult() {
        return complexObject;
    }
}

// 具体建造者1
class ComplexObjectBuilder1 extends AbstractComplexObjectBuilder {
    public ComplexObjectBuilder1() {
        complexObject = new ComplexObject();
    }
    @Override
    public void buildPart1() {
        // 构建part1逻辑
    }
    @Override
    public void buildPart2() {
        // 构建part2逻辑
    }
}

// 具体建造者2
class ComplexObjectBuilder2 extends AbstractComplexObjectBuilder {
    public ComplexObjectBuilder2() {
        complexObject = new ComplexObject();
    }
    @Override
    public void buildPart1() {
        // 构建part1逻辑
    }
    @Override
    public void buildPart2() {
        // 构建part2逻辑
    }
}

class ComplexObject {
    // 复杂对象相关代码
}

星途面试题库

面试题：Java构建者模式在复杂系统中的优化与拓展

知识考点

面试题答案

优化和拓展方向及思路