一、【概念定义】—— “分步构建复杂对象，隐藏创建细节”

生成器模式（Builder Pattern）：
一种“分步构建型”创建型设计模式，它将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
核心思想：用“生成器”逐步设置对象属性，最后调用 build() 方法一次性返回完整对象。
目标：解决构造函数参数爆炸、对象创建过程复杂、需要创建不同表示的问题。

口诀：“复杂对象不好造，生成器来分步搞；隐藏细节控流程，不同表示它都包！”

二、【解决的问题】—— “手搓复杂对象”的三大灾难

想象你正在开发一个电脑配置系统：

• 超长构造函数：
  Computer(String cpu, String ram, String gpu, String storage, String psu, String cooler...)
  → 参数太多！顺序难记！可选参数怎么办？→ 重载地狱！
• Setter 方法：
  computer.setCPU("i9"); computer.setRAM("32GB"); ...
  → 对象可能被部分初始化就使用！→ 不一致状态！
• 生成器模式：
• ComputerBuilder 提供链式方法：builder.setCPU().setRAM().setGPU()...；
• build() 方法校验完整性并返回 Computer；
  → 创建过程清晰、对象完整、支持不同配置！

核心解决：

构造函数参数爆炸 → 分步设置属性；对象不完整风险 → build() 方法统一校验；创建不同表示困难 → 同一流程创建不同配置（游戏本/办公本）。

三、【适用场景】—— “复杂对象构建”的四大名器

你该用生成器模式，如果符合以下“四复原则”：

警告：如果对象简单（如 User(name, age)） —— 生成器是过度设计！

四、【经典案例】—— 四大“装配流水线王者”的成名战

1. 【电脑配置系统】—— 游戏本、办公本、设计本，一套流水线！

需要组装不同配置的电脑：游戏本（高显卡）、办公本（大内存）、设计本（高色域屏）
多个构造函数：ComputerGame(), ComputerOffice(), ComputerDesign() → 代码重复！
生成器模式：

ComputerBuilder.setCPU().setGPU().setRAM()...；buildGamingPC() → 预设 i9+RTX4090；buildOfficePC() → 预设 i5+大内存；
效果：新增“服务器配置”？只需 buildServerPC()！客户端代码无需修改！

2. 【手机套餐定制】—— 通话、流量、增值服务，自由组合！

套餐包含：基础通话、流量包、增值服务（视频会员、云存储）
Setter 方法：可能忘记设置流量 → 套餐无效！
生成器模式：

PackageBuilder.setMinutes().setData().addService()；build() 校验：必须设置通话和流量！
效果：新增“5G套餐”？只需调整 setData("100GB 5G")！套餐完整性有保障！

3. 【房屋建造系统】—— 别墅、公寓、LOFT，结构不同！

房屋包含：地基、墙体、屋顶、门窗、装修风格
直接构造：参数太多！且“屋顶”依赖“墙体”完成！
生成器模式：

HouseBuilder.buildFoundation().buildWalls().buildRoof()...；buildVilla() → 花园+泳池；buildApartment() → 简约装修；
效果：新增“智能房屋”？只需 addSmartSystem()！建造步骤可控制顺序！

4. 【SQL查询构建器】—— SELECT、WHERE、ORDER BY，链式操作！

动态构建SQL：SELECT name FROM users WHERE age>18 ORDER BY name
字符串拼接："SELECT " + columns + " FROM " + table + " WHERE " + condition... → 易出错！
生成器模式（如 MyBatis Dynamic SQL）：

sqlBuilder.select("name").from("users").where("age>18").orderBy("name")；build() 生成完整SQL并校验语法；
效果：新增“GROUP BY”？只需 groupBy() 方法！SQL构建安全又优雅！

五、【结构简述】—— 生成器宇宙的“四步装配法”

生成器模式四要素：

调用流程（无Director）：
Client → 创建 ConcreteBuilder → 调用 builder.setPartA().setPartB()... → builder.build() → 返回 Product
调用流程（有Director）：
Client → 创建 ConcreteBuilder + Director → director.construct(builder) → builder.build() → 返回 Product

六、【注意事项】—— “流水线”虽强，小心“过度设计”！

1. Director 是否必要？

Director 封装构建顺序 → 但常被客户端直接调用 Builder 替代！
建议：

简单场景 → 客户端直接调用 Builder（更灵活）；复杂固定流程 → 用 Director（如房屋建造步骤）。

2. Builder 与 Factory 的混淆

工厂方法：创建不同类型的对象（如 iOSButton / AndroidButton）；生成器：分步创建同一类型的不同表示（如 高配电脑 / 低配电脑）；
记住：工厂是“选类型”，生成器是“配参数”。

3. 性能开销

多一层 Builder 对象 → 轻微内存和调用开销（通常可忽略）
权衡：对象复杂度 > 性能损耗 时使用。

4. 现代语言的简化

Java 14+ Records、Lombok @Builder、Kotlin apply{} 可简化代码！
但理解模式本质更重要 —— 分步构建、隐藏细节、保证完整！

七、【实战应用】—— 45行代码，打造“电脑生成器系统”

java

深色版本

// 1. 产品：电脑
class Computer {
    private String cpu;
    private String ram;
    private String gpu;
    private String storage;
    private String psu; // 电源

    // 私有构造函数，强制通过 Builder 创建
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.gpu = builder.gpu;
        this.storage = builder.storage;
        this.psu = builder.psu;
        validate(); // 构建时校验完整性
    }

    private void validate() {
        if (cpu == null || ram == null || storage == null) {
            throw new IllegalStateException(" 电脑必须包含CPU、内存和存储！");
        }
    }

    @Override
    public String toString() {
        return " 电脑配置：\n" +
               "   CPU: " + cpu + "\n" +
               "   内存: " + ram + "\n" +
               "   显卡: " + (gpu != null ? gpu : "集成显卡") + "\n" +
               "   存储: " + storage + "\n" +
               "   电源: " + psu;
    }

    // 2. 生成器：静态内部类（经典实现）
    public static class Builder {
        private String cpu;
        private String ram;
        private String gpu;
        private String storage;
        private String psu = "500W"; // 默认电源

        public Builder setCpu(String cpu) {
            this.cpu = cpu;
            return this; // 链式调用
        }

        public Builder setRam(String ram) {
            this.ram = ram;
            return this;
        }

        public Builder setGpu(String gpu) {
            this.gpu = gpu;
            return this;
        }

        public Builder setStorage(String storage) {
            this.storage = storage;
            return this;
        }

        public Builder setPsu(String psu) {
            this.psu = psu;
            return this;
        }

        // 构建方法：返回完整产品
        public Computer build() {
            return new Computer(this); // 调用私有构造函数
        }
    }
}

// 3. （可选）指挥者：预设配置
class ComputerDirector {
    // 构建游戏电脑
    public Computer buildGamingComputer() {
        return new Computer.Builder()
                .setCpu("Intel i9-13900K")
                .setRam("32GB DDR5")
                .setGpu("NVIDIA RTX 4090")
                .setStorage("2TB NVMe SSD")
                .setPsu("1000W 金牌")
                .build();
    }

    // 构建办公电脑
    public Computer buildOfficeComputer() {
        return new Computer.Builder()
                .setCpu("Intel i5-13400")
                .setRam("16GB DDR4")
                .setStorage("512GB SSD") // 无独立显卡
                .build(); // 使用默认电源
    }
}

// 4. 客户端
public class BuilderDemo {
    public static void main(String[] args) {
        System.out.println(" 电脑装配流水线启动...");

        // 方式1：客户端直接使用 Builder（灵活定制）
        Computer customPC = new Computer.Builder()
                .setCpu("AMD Ryzen 7")
                .setRam("64GB DDR5")
                .setGpu("NVIDIA RTX 4080")
                .setStorage("4TB SSD")
                .setPsu("850W")
                .build();

        System.out.println(" 定制电脑：");
        System.out.println(customPC);

        // 方式2：通过 Director 获取预设配置（标准化）
        ComputerDirector director = new ComputerDirector();
        Computer gamingPC = director.buildGamingComputer();
        Computer officePC = director.buildOfficeComputer();

        System.out.println("\n 游戏电脑：");
        System.out.println(gamingPC);

        System.out.println("\n 办公电脑：");
        System.out.println(officePC);

        // 新增“设计本”？只需在 Director 中添加 buildDesignComputer()！
        // 或客户端自由组合！产品类无需修改！
    }
}

运行结果：

深色版本

 电脑装配流水线启动...
 定制电脑：
 电脑配置：
   CPU: AMD Ryzen 7
   内存: 64GB DDR5
   显卡: NVIDIA RTX 4080
   存储: 4TB SSD
   电源: 850W

 游戏电脑：
 电脑配置：
   CPU: Intel i9-13900K
   内存: 32GB DDR5
   显卡: NVIDIA RTX 4090
   存储: 2TB NVMe SSD
   电源: 1000W 金牌

 办公电脑：
 电脑配置：
   CPU: Intel i5-13400
   内存: 16GB DDR4
   显卡: 集成显卡
   存储: 512GB SSD
   电源: 500W

看到了吗？客户端可以自由组合配置，或使用预设方案！

build() 方法确保电脑必有 CPU、内存、存储！链式调用 setXXX().setYYY() 让代码清晰流畅！
新增“服务器配置”？只需：

public Computer buildServerComputer() { return new Computer.Builder() .setCpu("Dual Xeon") .setRam("128GB ECC") .setStorage("10TB RAID") .setPsu("冗余电源") .build(); }

—— 产品类和客户端代码无需修改！这就是生成器模式的力量！

最后总结：生成器模式 —— 对象界的“精密装配大师”

以前：构造函数爆炸 → 参数难记，对象易残；
现在：生成器流水线 → 分步装配，完整交付！
生成器模式就是对象界的“乐高大师” —— 把复杂对象拆解为步骤，用清晰的接口组装，让创建过程可控、安全、优雅！

记忆口诀：

复杂对象不好搞，
生成器来分步造。
链式调用真流畅，
最终交付完整性保！
电脑套餐房屋建，
不同配置它都包。
指挥预设或自选，
扩展新品不用恼！
莫为简单对象忙，
参数爆炸再登场！