建造者 (Builder)

简介

建造者 (Builder) 是一种创建型设计模式，可让你逐步构建复杂对象。该模式允许你使用相同的构造代码生成对象的不同类型和表示形式，同时避免构造函数参数过多或重载爆炸。

问题

• 对象有很多可选参数或配置，全塞进构造函数会导致参数列表过长、可读性差。
• 多种构建方式（如必填 + 多种可选组合）用重载或多种构造函数难以维护。
• 希望构建过程清晰、可分步设置属性，并复用同一套构建逻辑。

解决思路

1. Builder 核心接口：定义一步步设置产品各部分的方法（如 setA()、setB()），以及最终 build() 返回产品。
2. 产品类：可保持简化结构，由 Builder 在内部组装；或产品提供私有构造函数，仅由 Builder 调用。
3. 具体建造者：实现 Builder 接口，持有产品实例并实现各 set 与 build()。
4. 导演类 (Director)：可选。封装“如何一步步调 Builder”的固定流程，统一建造流程，客户端只调导演。
5. 客户端：通过 Builder（或 Director）按需设置参数并调用 build() 得到产品，无需关心内部构造细节。

结构概览

classDiagram
    class Director {
        -builder Builder
        +construct() void
    }
    class Builder {
        <<interface>>
        +buildPartA()* void
        +buildPartB()* void
        +getResult()* Product
    }
    class ConcreteBuilder {
        -product Product
        +buildPartA() void
        +buildPartB() void
        +getResult() Product
    }
    class Product {
        -partA String
        -partB String
    }
    Director o-- Builder
    Builder <|.. ConcreteBuilder
    ConcreteBuilder ..> Product : builds

Java 示例

产品类：

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

    public void setCpu(String cpu) { this.cpu = cpu; }
    public void setMemory(String memory) { this.memory = memory; }
    public void setDisk(String disk) { this.disk = disk; }

    @Override
    public String toString() {
        return "Computer[cpu=" + cpu + ", memory=" + memory + ", disk=" + disk + "]";
    }
}

Builder 接口与实现：

public interface ComputerBuilder {
    ComputerBuilder cpu(String cpu);
    ComputerBuilder memory(String memory);
    ComputerBuilder disk(String disk);
    Computer build();
}

public class ConcreteComputerBuilder implements ComputerBuilder {
    private final Computer computer = new Computer();

    @Override
    public ComputerBuilder cpu(String cpu) {
        computer.setCpu(cpu);
        return this;
    }

    @Override
    public ComputerBuilder memory(String memory) {
        computer.setMemory(memory);
        return this;
    }

    @Override
    public ComputerBuilder disk(String disk) {
        computer.setDisk(disk);
        return this;
    }

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

导演类（可选）：

public class Director {
    public Computer buildHighEnd(ComputerBuilder builder) {
        return builder.cpu("i9").memory("32GB").disk("1TB SSD").build();
    }

    public Computer buildLowEnd(ComputerBuilder builder) {
        return builder.cpu("i5").memory("8GB").disk("256GB SSD").build();
    }
}

客户端使用：

public class Client {
    public static void main(String[] args) {
        ComputerBuilder builder = new ConcreteComputerBuilder();
        // 链式调用
        Computer pc = builder.cpu("i7").memory("16GB").disk("512GB SSD").build();
        System.out.println(pc);

        // 或通过 Director 固定流程
        Director director = new Director();
        Computer highEnd = director.buildHighEnd(builder);
        System.out.println(highEnd);
    }
}

总结

建造者将复杂对象的构建与表示分离，通过链式或分步调用生成不同配置的对象，代码更清晰、易扩展，且便于保证构建过程的一致性和有效性。