建造者模式

建造者模式（Builder Pattern）：复杂对象的分步构建艺术

建造者模式（又称生成器模式）是创建型设计模式的一种，核心思想是将复杂对象的构建过程与表示分离，使得同样的构建流程可以生成不同的产品表示。这种模式特别适合处理由多个部件组成、构建步骤复杂的对象（如汽车、文档、配置项等）。

建造者模式的核心结构

建造者模式通过四个核心角色实现复杂对象的构建，分工明确且各司其职：

产品（Product）

定义被构建的复杂对象，包含多个组成部件（如汽车的发动机、底盘、车身等）。
示例：Computer（包含 CPU、内存、硬盘等部件）。

建造者接口（Builder）

声明构建产品各个部件的抽象方法（如buildCPU()、buildMemory()），以及返回最终产品的方法（如getResult()）。
作用：规范构建流程，确保所有具体建造者遵循统一的步骤。

具体建造者（ConcreteBuilder）

实现建造者接口，具体实现每个部件的构建逻辑，并负责将部件组装成产品。
示例：GameComputerBuilder（构建游戏电脑，侧重高性能 CPU 和显卡）、OfficeComputerBuilder（构建办公电脑，侧重稳定性）。

指导者（Director）

负责控制构建流程，调用建造者接口的方法按顺序构建产品，不直接参与部件的具体构建。
作用：隔离客户端与构建过程，确保构建步骤的一致性。

代码实现示例

以 “自定义电脑组装” 为例，展示建造者模式的具体应用：

产品（Computer）

// 复杂产品：电脑（包含多个部件）
public class Computer {
    private String cpu;    // CPU
    private String memory; // 内存
    private String硬盘;   // 硬盘
    private String graphicsCard; // 显卡

    //  setter方法（用于建造者设置部件）
    public void setCpu(String cpu) { this.cpu = cpu; }
    public void setMemory(String memory) { this.memory = memory; }
    public void set硬盘(String 硬盘) { this.硬盘 = 硬盘; }
    public void setGraphicsCard(String graphicsCard) { this.graphicsCard = graphicsCard; }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", memory='" + memory + '\'' +
                ", 硬盘='" + 硬盘 + '\'' +
                ", graphicsCard='" + graphicsCard + '\'' +
                '}';
    }
}

建造者接口（ComputerBuilder）

// 建造者接口：定义电脑部件的构建方法
public interface ComputerBuilder {
    void buildCpu();       // 构建CPU
    void buildMemory();    // 构建内存
    void build硬盘();      // 构建硬盘
    void buildGraphicsCard(); // 构建显卡
    Computer getResult();  // 返回组装好的电脑
}

具体建造者（游戏电脑和办公电脑）

// 具体建造者1：游戏电脑（高性能配置）
public class GameComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void buildCpu() {
        computer.setCpu("Intel i9"); // 高性能CPU
    }

    @Override
    public void buildMemory() {
        computer.setMemory("32GB DDR5"); // 大内存
    }

    @Override
    public void build硬盘() {
        computer.set硬盘("1TB SSD"); // 高速硬盘
    }

    @Override
    public void buildGraphicsCard() {
        computer.setGraphicsCard("RTX 4090"); // 顶级显卡
    }

    @Override
    public Computer getResult() {
        return computer;
    }
}

// 具体建造者2：办公电脑（实用配置）
public class OfficeComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void buildCpu() {
        computer.setCpu("Intel i5"); // 中端CPU
    }

    @Override
    public void buildMemory() {
        computer.setMemory("16GB DDR4"); // 够用的内存
    }

    @Override
    public void build硬盘() {
        computer.set硬盘("512GB SSD"); // 中等硬盘
    }

    @Override
    public void buildGraphicsCard() {
        computer.setGraphicsCard("集成显卡"); // 无需独立显卡
    }

    @Override
    public Computer getResult() {
        return computer;
    }
}

指导者（Director）

// 指导者：控制电脑构建流程
public class ComputerDirector {
    private ComputerBuilder builder;

    // 注入具体建造者
    public ComputerDirector(ComputerBuilder builder) {
        this.builder = builder;
    }

    // 按固定步骤构建电脑
    public Computer construct() {
        builder.buildCpu();       // 第一步：构建CPU
        builder.buildMemory();    // 第二步：构建内存
        builder.build硬盘();      // 第三步：构建硬盘
        builder.buildGraphicsCard(); // 第四步：构建显卡
        return builder.getResult();  // 返回成品
    }
}

客户端使用

public class BuilderDemo {
    public static void main(String[] args) {
        // 1. 构建游戏电脑
        ComputerBuilder gameBuilder = new GameComputerBuilder();
        ComputerDirector gameDirector = new ComputerDirector(gameBuilder);
        Computer gamePC = gameDirector.construct();
        System.out.println("游戏电脑配置：" + gamePC);

        // 2. 构建办公电脑（仅需更换建造者，流程不变）
        ComputerBuilder officeBuilder = new OfficeComputerBuilder();
        ComputerDirector officeDirector = new ComputerDirector(officeBuilder);
        Computer officePC = officeDirector.construct();
        System.out.println("办公电脑配置：" + officePC);
    }
}

输出结果

1
2

游戏电脑配置：Computer{cpu='Intel i9', memory='32GB DDR5', 硬盘='1TB SSD', graphicsCard='RTX 4090'}
办公电脑配置：Computer{cpu='Intel i5', memory='16GB DDR4', 硬盘='512GB SSD', graphicsCard='集成显卡'}

建造者模式的核心优势

分离构建与表示
构建过程（由 Director 控制）与产品的具体部件（由 ConcreteBuilder 实现）分离，客户端无需知道产品的内部组成细节。
灵活支持不同表示
更换具体建造者（如从GameComputerBuilder换为OfficeComputerBuilder），即可在相同构建流程下生成不同产品，扩展性极强。
精确控制构建步骤
指导者（Director）定义了固定的构建步骤（如先 CPU 后内存），确保产品构建的规范性，避免部件组装顺序错误。
封装复杂创建逻辑
将多个部件的创建逻辑分散到具体建造者中，每个建造者专注于一种产品的构建，符合单一职责原则。

适用场景

复杂对象构建：当产品由多个部件组成，且部件之间有依赖关系或构建顺序要求时（如汽车、电脑、文档）。
多版本产品：需要同一构建流程生成不同配置的产品（如不同配置的手机、不同风格的报表）。
避免 telescoping 构造函数：当类的构造函数参数过多且可选参数多（如 10 + 参数）时，用建造者模式替代冗长的构造函数，提高代码可读性。

与工厂模式的区别

维度	建造者模式	工厂模式（如抽象工厂）
核心目标	分步构建复杂对象，关注 “如何组装”	快速创建产品，关注 “创建什么”
产品复杂度	处理多部件组成的复杂对象	处理单一或简单关联的产品
构建过程可见性	暴露构建步骤（由 Director 控制）	隐藏构建过程，直接返回产品
典型应用	电脑、汽车等组装产品	数据库连接、简单工具类

总结

建造者模式通过 “建造者接口 + 具体建造者 + 指导者” 的组合，完美解决了复杂对象的构建问题。它将构建流程与产品表示分离，既保证了构建的灵活性，又确保了步骤的规范性，特别适合需要多版本、多部件产品的场景。在实际开发中，当遇到 “对象构造参数多且复杂” 或 “需要多种配置的同类产品” 时，建造者模式是优于工厂模式的选择