《建造者模式》｜设计模式系列第05篇

系列：创建型模式 · 建造者模式（Builder Pattern）
关键词：分步构建、复杂对象、产品组装、建造者、指挥者

一、什么是建造者模式

建造者模式（Builder Pattern）：将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。

属于创建型设计模式。

简单理解：
当一个对象构造步骤很多，构造逻辑复杂，参数繁多时，把对象的创建步骤抽离出来。不管最终产品长什么样，组装流程固定；不同建造者可以实现不同零件的组装，产出不同产品。

核心意图
分离复杂对象的构建和表示。相同的构建流程，通过不同建造者，生成不同产品。客户端不需要关心对象内部零件如何组装。

适用场景

对象创建步骤复杂，创建逻辑较长，需要多步组装
一个类构造函数参数过多，大量参数可选，容易写错参数顺序
需要通过一套固定组装流程，生成不同版本的产品
对象创建过程需要隔离，产品内部结构对外隐藏

⚠️ 缺点预警：产品差异大时不适合使用；产品内部结构变化时，建造者也需要同步修改。

二、UML结构图

角色划分：

Product（产品）：复杂对象，包含多个组成零件
Builder（抽象建造者）：定义构建产品各个零件的抽象方法，提供获取产品接口
ConcreteBuilder（具体建造者）：实现抽象建造者，完成零件构建，组装产品
Director（指挥者）：调用建造者的构建步骤，控制组装顺序，不关心产品细节

三、Java 完整示例

场景：构建电脑 Computer，电脑包含 CPU、内存、硬盘、显示器。可以组装高配电脑、低配电脑。

1. 产品 Computer

public class Computer {
    private String cpu;
    private String memory;
    private String disk;
    private String screen;

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    public void setScreen(String screen) {
        this.screen = screen;
    }

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

2. 抽象建造者 Builder

public abstract class ComputerBuilder {
    protected Computer computer = new Computer();

    public abstract void buildCpu();
    public abstract void buildMemory();
    public abstract void buildDisk();
    public abstract void buildScreen();

    public Computer getComputer() {
        return computer;
    }
}

3. 具体建造者

// 高配电脑建造者
public class HighConfigComputerBuilder extends ComputerBuilder {
    @Override
    public void buildCpu() {
        computer.setCpu("i9 处理器");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("64G 内存");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("2TB SSD");
    }

    @Override
    public void buildScreen() {
        computer.setScreen("4K 显示器");
    }
}

// 低配电脑建造者
public class LowConfigComputerBuilder extends ComputerBuilder {
    @Override
    public void buildCpu() {
        computer.setCpu("i3 处理器");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("8G 内存");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("512G SSD");
    }

    @Override
    public void buildScreen() {
        computer.setScreen("1080P 显示器");
    }
}

4. 指挥者 Director

public class Director {
    public Computer construct(ComputerBuilder builder){
        builder.buildCpu();
        builder.buildMemory();
        builder.buildDisk();
        builder.buildScreen();
        return builder.getComputer();
    }
}

5. 客户端调用

public class Client {
    public static void main(String[] args) {
        Director director = new Director();

        // 构建高配电脑
        ComputerBuilder highBuilder = new HighConfigComputerBuilder();
        Computer highPc = director.construct(highBuilder);
        System.out.println("高配电脑：" + highPc);

        // 构建低配电脑
        ComputerBuilder lowBuilder = new LowConfigComputerBuilder();
        Computer lowPc = director.construct(lowBuilder);
        System.out.println("低配电脑：" + lowPc);
    }
}

补充：日常开发中也常使用简化版建造者（链式Builder），没有独立 Director，就是我们常见的 xxx.builder().xxx().build()，例如 Lombok @Builder，属于建造者模式变种。

四、优缺点总结

✅ 优点

构建步骤清晰，创建过程拆解，方便控制对象创建细节
相同构建流程，创建不同产品；产品构建与表示分离
便于扩展新的产品实现，新增建造者即可
把复杂对象创建逻辑封装，客户端不用关心组装细节

❌ 缺点

如果产品内部结构差异巨大，不适合建造者模式
产品组件变化时，所有建造者都需要同步修改
类数量增加，代码复杂度上升

五、建造者模式 vs 工厂模式对比

模式	关注点	特点
工厂方法/抽象工厂	生产产品实例，一次性产出对象	侧重产品整体创建，不关心构建步骤
建造者模式	分步组装复杂对象	强调多步骤、顺序组装，精细控制每一个零件

六、框架源码应用

StringBuilder / StringBuffer：append 分步构建字符串，是建造者思想
Spring BeanDefinitionBuilder
Lombok @Builder 注解生成的链式构建器

七、小结

建造者核心：分步组装复杂对象，构建流程固定，零件实现可变。
当一个对象构造参数繁多、组装步骤复杂，优先考虑建造者模式。日常开发最常用简化链式 Builder（无指挥者）。