java设计模式：工厂方法 + 建造者模式

模式结合设计方案

这个设计充分利用了两种模式的优势：​​工厂方法负责创建不同类型产品的建造者​​，而​​建造者模式负责分步骤构造复杂产品​​

。

类结构设计

- Computer (产品)
- ComputerBuilder (抽象建造者) 
- GamingComputerBuilder, OfficeComputerBuilder (具体建造者)
- ComputerBuilderFactory (建造者工厂)
- ComputerDirector (指挥者)

💻 完整代码实现

1. 产品类 - Computer

public class Computer {
    private String cpu;
    private String memory;
    private String storage;
    private String graphicsCard;
    private String powerSupply;
    
    // 私有构造函数，只能通过建造者构建
    private Computer() {}
    
    // Setter方法
    public void setCpu(String cpu) { this.cpu = cpu; }
    public void setMemory(String memory) { this.memory = memory; }
    public void setStorage(String storage) { this.storage = storage; }
    public void setGraphicsCard(String graphicsCard) { this.graphicsCard = graphicsCard; }
    public void setPowerSupply(String powerSupply) { this.powerSupply = powerSupply; }
    
    @Override
    public String toString() {
        return String.format("Computer[CPU=%s, Memory=%s, Storage=%s, Graphics=%s, Power=%s]", 
                           cpu, memory, storage, graphicsCard, powerSupply);
    }
}

2. 抽象建造者 - ComputerBuilder

public interface ComputerBuilder {
    void buildCpu();
    void buildMemory();
    void buildStorage();
    void buildGraphicsCard();
    void buildPowerSupply();
    Computer getResult();
}

3. 具体建造者 - 游戏电脑和办公电脑

// 游戏电脑建造者
public class GamingComputerBuilder implements ComputerBuilder {
    private Computer computer;
    
    public GamingComputerBuilder() {
        this.computer = new Computer();
    }
    
    @Override
    public void buildCpu() {
        computer.setCpu("Intel Core i9-13900K");
    }
    
    @Override
    public void buildMemory() {
        computer.setMemory("32GB DDR5 RGB");
    }
    
    @Override
    public void buildStorage() {
        computer.setStorage("2TB NVMe SSD + 4TB HDD");
    }
    
    @Override
    public void buildGraphicsCard() {
        computer.setGraphicsCard("NVIDIA GeForce RTX 4090");
    }
    
    @Override
    public void buildPowerSupply() {
        computer.setPowerSupply("1200W 80+ Platinum");
    }
    
    @Override
    public Computer getResult() {
        return computer;
    }
}

// 办公电脑建造者
public class OfficeComputerBuilder implements ComputerBuilder {
    private Computer computer;
    
    public OfficeComputerBuilder() {
        this.computer = new Computer();
    }
    
    @Override
    public void buildCpu() {
        computer.setCpu("Intel Core i5-12400");
    }
    
    @Override
    public void buildMemory() {
        computer.setMemory("16GB DDR4");
    }
    
    @Override
    public void buildStorage() {
        computer.setStorage("512GB NVMe SSD");
    }
    
    @Override
    public void buildGraphicsCard() {
        computer.setGraphicsCard("Integrated Intel UHD Graphics");
    }
    
    @Override
    public void buildPowerSupply() {
        computer.setPowerSupply("550W 80+ Bronze");
    }
    
    @Override
    public Computer getResult() {
        return computer;
    }
}

4. 工厂方法 - 建造者工厂

public class ComputerBuilderFactory {
    public enum ComputerType {
        GAMING, OFFICE
    }
    
    public static ComputerBuilder createBuilder(ComputerType type) {
        switch (type) {
            case GAMING:
                return new GamingComputerBuilder();
            case OFFICE:
                return new OfficeComputerBuilder();
            default:
                throw new IllegalArgumentException("不支持的电脑类型: " + type);
        }
    }
}

5. 指挥者 - ComputerDirector

public class ComputerDirector {
    public Computer construct(ComputerBuilder builder) {
        // 统一的构建流程，确保所有电脑都按正确顺序组装
        builder.buildCpu();
        builder.buildMemory();
        builder.buildStorage();
        builder.buildGraphicsCard();
        builder.buildPowerSupply();
        return builder.getResult();
    }
    
    // 可选的快速构建方法
    public Computer constructGamingComputer() {
        ComputerBuilder builder = ComputerBuilderFactory.createBuilder(
            ComputerBuilderFactory.ComputerType.GAMING);
        return construct(builder);
    }
    
    public Computer constructOfficeComputer() {
        ComputerBuilder builder = ComputerBuilderFactory.createBuilder(
            ComputerBuilderFactory.ComputerType.OFFICE);
        return construct(builder);
    }
}

6. 客户端使用

public class Client {
    public static void main(String[] args) {
        ComputerDirector director = new ComputerDirector();
        
        // 方式1：通过工厂方法创建具体建造者，然后指挥者构建
        System.out.println("=== 方式1：分步构建 ===");
        ComputerBuilder gamingBuilder = ComputerBuilderFactory.createBuilder(
            ComputerBuilderFactory.ComputerType.GAMING);
        Computer gamingComputer = director.construct(gamingBuilder);
        System.out.println("游戏电脑: " + gamingComputer);
        
        // 方式2：直接使用指挥者的快捷方法
        System.out.println("\n=== 方式2：快捷构建 ===");
        Computer officeComputer = director.constructOfficeComputer();
        System.out.println("办公电脑: " + officeComputer);
        
        // 方式3：动态根据配置构建
        System.out.println("\n=== 方式3：动态构建 ===");
        String userPreference = "performance"; // 可以从配置文件中读取
        Computer dynamicComputer;
        
        if ("performance".equals(userPreference)) {
            dynamicComputer = director.constructGamingComputer();
        } else {
            dynamicComputer = director.constructOfficeComputer();
        }
        System.out.println("动态配置电脑: " + dynamicComputer);
    }
}

✨ 设计模式的优越性体现

🎯 ​​关注点分离与职责清晰​​

​​工厂方法​​专注于创建适当类型的建造者对象

​​建造者模式​​专注于分步骤构造复杂产品

​​指挥者​​控制构建过程，确保一致性

🔄 ​​极高的灵活性和可扩展性​​

新增电脑类型时，只需要增加新的具体建造者，无需修改现有代码：

// 新增轻薄本建造者
public class UltrabookComputerBuilder implements ComputerBuilder {
    // 实现所有构建方法...
}

// 在工厂中注册新类型
public static ComputerBuilder createBuilder(ComputerType type) {
    switch (type) {
        case GAMING: return new GamingComputerBuilder();
        case OFFICE: return new OfficeComputerBuilder();
        case ULTRABOOK: return new UltrabookComputerBuilder(); // 新增
        default: throw new IllegalArgumentException("不支持的电脑类型: " + type);
    }
}

🛡️ ​​构建过程的质量保证​​

指挥者确保了所有电脑都按照正确的顺序和标准构建：

public Computer construct(ComputerBuilder builder) {
    // 必须的顺序：先装基础部件，再装扩展部件
    builder.buildCpu();          // 第一步：安装CPU
    builder.buildMemory();       // 第二步：安装内存
    builder.buildStorage();      // 第三步：安装存储
    builder.buildGraphicsCard(); // 第四步：安装显卡
    builder.buildPowerSupply();  // 第五步：安装电源
    return builder.getResult();
}

💎 总结

这种结合模式充分发挥了各自的优势：​​工厂方法提供了创建对象的灵活性​​，而​​建造者模式提供了构建复杂对象的精细控制​​。

这种设计使得系统在面对变化时更加健壮，特别是在需要创建具有复杂内部结构的对象时，优势更加明显。

当你的系统需要创建多种类型的复杂对象，且每种对象都有自己特定的构建过程时，考虑使用这种工厂方法与建造者模式的组合，它能为你带来更好的代码结构性和可维护性。