「包工头」—— 建造者模式

文章目录

• 示例代码
• 完整代码
• 编译运行
• 什么是建造者模式？
• • 概念
  • 生活类比
• 建造者模式中的四个角色
• • Product（产品）
  • Builder（抽象建造者）
  • ConcreteBuilder（具体建造者）
  • Director（指挥者）
• 建造者模式示例
• • 结构图
  • 运行示例
  • 代码实现
• 建造者模式的优势
• 建造者模式的注意事项

示例代码

完整代码

完整代码

src/
├── common/                          # 共享接口包
│   ├── Product.java                # Product：产品
│   └── Builder.java                # Builder：抽象建造者
│
└── builder/                        # 建造者实现
    ├── ConcreteBuilder.java         # Concrete Builder：具体建造者
    ├── Director.java               # Director：指挥者
    └── BuilderDemo.java           # 运行入口

编译运行

# 编译
javac -d out src/common/*.java src/builder/*.java

# 运行
java -cp out builder.BuilderDemo

---

什么是建造者模式？

概念

建造者模式 是一种创建型设计模式，它的核心作用是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

简单来说，建造者模式就是在分步骤构建复杂对象

生活类比

就像盖房子：

• 地基 → 结构 → 屋顶 → 装修
• 每个步骤都很清晰
• 可以盖别墅、盖楼房、盖木屋

在代码世界中，建造者模式干的是同样的事：

• 把构建过程拆分成多个步骤
• 每个步骤由具体的 Builder 负责
• Director 指挥建造流程
• 最终得到完整的产品

---

建造者模式中的四个角色

Product（产品）

要创建的复杂对象。在我们的例子中是 Product：

// src/common/Product.java
package common;

public class Product {
    private String foundation;
    private String structure;
    private String roof;
    private String interior;

    public void setFoundation(String foundation) { ... }
    public void setStructure(String structure) { ... }
    public void setRoof(String roof) { ... }
    public void setInterior(String interior) { ... }

    @Override
    public String toString() {
        return "房屋建造完成：\n" +
               "  地基: " + foundation + "\n" +
               "  结构: " + structure + "\n" +
               "  屋顶: " + roof + "\n" +
               "  装修: " + interior;
    }
}

Builder（抽象建造者）

定义创建 Product 各部件的接口。在我们的例子中是 Builder：

// src/common/Builder.java
package common;

public interface Builder {
    void buildFoundation();
    void buildStructure();
    void buildRoof();
    void buildInterior();
    Product getResult();
}

ConcreteBuilder（具体建造者）

实现 Builder 接口，构造和装配 Product 的各个部件。在我们的例子中是 ConcreteBuilder：

// src/builder/ConcreteBuilder.java
package builder;

import common.Builder;
import common.Product;

public class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildFoundation() {
        System.out.println("  [Builder] 建造地基...");
        product.setFoundation("混凝土钢筋地基");
    }

    @Override
    public void buildStructure() {
        System.out.println("  [Builder] 建造主体结构...");
        product.setStructure("钢筋混凝土框架");
    }

    @Override
    public void buildRoof() {
        System.out.println("  [Builder] 建造屋顶...");
        product.setRoof("琉璃瓦屋顶");
    }

    @Override
    public void buildInterior() {
        System.out.println("  [Builder] 室内装修...");
        product.setInterior("精装修");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

Director（指挥者）

构造一个使用 Builder 接口的对象。在我们的例子中是 Director：

// src/builder/Director.java
package builder;

import common.Builder;

public class Director {
    public void constructHouse(Builder builder) {
        System.out.println("  [Director] 开始指挥建造流程...");
        builder.buildFoundation();
        builder.buildStructure();
        builder.buildRoof();
        builder.buildInterior();
    }

    public void constructFoundationOnly(Builder builder) {
        System.out.println("  [Director] 只建造地基...");
        builder.buildFoundation();
    }
}

---

建造者模式示例

结构图

┌─────────────┐       ┌──────────────┐
│  Director   │──────►│   Builder    │
│  (指挥者)   │ 构建   │  (抽象建造者)  │
└─────────────┘       └──────────────┘
                            ▲
                            │
                     ┌──────┴──────┐
                     │  Concrete   │
                     │   Builder   │
                     │ (具体建造者) │
                     └─────────────┘
                            │
                            ▼
                     ┌─────────────┐
                     │   Product   │
                     │   (产品)    │
                     └─────────────┘

运行示例

>>> 场景：我要建造一栋房子

[1] 雇佣建筑师（Director），开始建造
  [Director] 开始指挥建造流程...
  [Builder] 建造地基...
  [Builder] 建造主体结构...
  [Builder] 建造屋顶...
  [Builder] 室内装修...

>>> 交付结果:
房屋建造完成：
  地基: 混凝土钢筋地基
  结构: 钢筋混凝土框架
  屋顶: 琉璃瓦屋顶
  装修: 精装修

代码实现

// 创建指挥者和建造者
Director director = new Director();
Builder builder = new ConcreteBuilder();

// 指挥者控制建造流程
director.constructHouse(builder);

// 获取最终产品
Product house = builder.getResult();

---

建造者模式的优势

1. 分步构建：可以把复杂对象的构建过程分成多个步骤
2. 隔离构建和使用：客户端不需要知道产品内部细节
3. 单一职责：每个 Builder 只负责自己那部分构建逻辑
4. 灵活组合：可以通过 Director 定义不同的构建流程
5. 可复用：同一个 Builder 可以创建不同的产品表示

---

建造者模式的注意事项

1. 产品要有共同点：产品通常有共同点，才能用统一的构建流程
2. Director 可以省略：如果构建步骤简单，可以省略 Director
3. 建造顺序：某些场景下建造顺序很重要