目录

  1. 建造者模式简介
  2. 建造者模式的结构
  3. 建造者模式的优缺点
  4. 建造者模式的实现
    • 4.1 基本实现（Python 示例）
    • 4.2 链式调用的建造者模式
    • 4.3 与工厂模式的区别
  5. 建造者模式的应用场景
  6. 出站链接
  7. 站内链接
  8. 参考资料

1. 建造者模式简介

建造者模式（Builder Pattern） 是一种创建型设计模式，用于分步骤创建复杂对象，并提供不同的构造方式以创建不同类型的对象。

为什么使用建造者模式？

  • 避免复杂对象的构造方法暴露给客户端。
  • 支持不同的配置和创建方式，减少构造函数的参数数量。
  • 可以一步步构建对象，使代码更清晰。

典型应用

  • 创建 HTML 文档
  • 构造 SQL 查询
  • 生成 复杂 UI 组件
  • 游戏角色定制（不同装备、技能）

2. 建造者模式的结构

建造者模式主要包含以下四个角色：

角色作用
Product（产品类）需要创建的复杂对象
Builder（建造者接口）定义构造产品的步骤
ConcreteBuilder（具体建造者）实现建造者接口，负责具体的对象创建
Director（指挥者）负责调用建造者，按照特定顺序创建对象

UML 类图

┌──────────────────┐
│    Director      │
└────────▲────────┘
         │
┌──────────────────┐
│    Builder       │  (抽象建造者)
│ + build_part_a() │
│ + build_part_b() │
│ + get_result()   │
└────────▲────────┘
         │
┌──────────────────┐
│ ConcreteBuilder  │  (具体建造者)
│ + build_part_a() │
│ + build_part_b() │
│ + get_result()   │
└────────▼────────┘
┌──────────────────┐
│    Product       │  (产品)
└──────────────────┘

3. 建造者模式的优缺点

✅ 优点

  1. 分离对象的构造和表示，使代码更清晰。
  2. 允许逐步构建对象，支持链式调用（如 StringBuilder）。
  3. 支持创建不同的表示（例如不同类型的 House、Car）。
  4. 符合单一职责原则（SRP），简化复杂对象的创建逻辑。

❌ 缺点

  1. 增加了代码复杂性，每个产品都需要定义一个 Builder 类。
  2. 对于简单对象，使用工厂模式更合适。

4. 建造者模式的实现

4.1 基本实现（Python 示例）

场景：创建一辆汽车（Car），支持不同配置（引擎、座椅、GPS）。

# 1. 产品类
class Car:
    def __init__(self):
        self.parts = []

    def add_part(self, part):
        self.parts.append(part)

    def show(self):
        return f"Car with: {', '.join(self.parts)}"

# 2. 抽象建造者
class CarBuilder:
    def build_engine(self):
        pass

    def build_seats(self):
        pass

    def build_gps(self):
        pass

    def get_result(self):
        pass

# 3. 具体建造者
class SportsCarBuilder(CarBuilder):
    def __init__(self):
        self.car = Car()

    def build_engine(self):
        self.car.add_part("V8 Engine")

    def build_seats(self):
        self.car.add_part("Leather Seats")

    def build_gps(self):
        self.car.add_part("Advanced GPS")

    def get_result(self):
        return self.car

# 4. 指挥者类
class Director:
    def construct_sports_car(self, builder: CarBuilder):
        builder.build_engine()
        builder.build_seats()
        builder.build_gps()
        return builder.get_result()

# 5. 客户端代码
builder = SportsCarBuilder()
director = Director()
car = director.construct_sports_car(builder)
print(car.show())  # 输出：Car with: V8 Engine, Leather Seats, Advanced GPS

4.2 链式调用的建造者模式

支持链式调用，使代码更简洁：

class Car:
    def __init__(self):
        self.parts = []

    def add_part(self, part):
        self.parts.append(part)
        return self  # 允许链式调用

    def show(self):
        return f"Car with: {', '.join(self.parts)}"

# 直接使用链式调用构造
car = Car().add_part("V6 Engine").add_part("Sunroof").add_part("Sport Tires")
print(car.show())  # 输出：Car with: V6 Engine, Sunroof, Sport Tires

4.3 建造者模式 vs 工厂模式

设计模式适用场景是否支持不同表示
工厂模式（Factory）创建简单对象❌
建造者模式（Builder）创建复杂对象，分步骤构造✅

示例对比

  • 工厂模式（创建一个简单 Car）：
class CarFactory:
    @staticmethod
    def create_sports_car():
        return Car().add_part("V8 Engine").add_part("Leather Seats")

car = CarFactory.create_sports_car()
  • 建造者模式（允许更灵活的定制）：
car = Car().add_part("V6 Engine").add_part("Sport Tires").add_part("GPS")

5. 建造者模式的应用场景

适用于以下情况

  1. 创建复杂对象
    • 例如 HTMLBuilder，生成 HTML 结构。
  2. 对象构造步骤较多
    • 例如 CarBuilder，允许不同组合（GPS、引擎）。
  3. 需要多个不同表示
    • 例如 SQL Query Builder（支持 SELECT、INSERT、UPDATE）。

真实案例

  • 前端开发
    • React/Vue 组件配置（<button size="large" theme="dark" />）
  • 游戏开发
    • 角色装备（盔甲、武器、技能）
  • 数据库 ORM
    • SQL 语句生成器（QueryBuilder）
  • Java 中的 StringBuilder String result = new StringBuilder() .append("Hello ") .append("World") .toString();

6. 出站链接

7. 站内链接

8. 参考资料

  • Gamma, E., Design Patterns: Elements of Reusable Object-Oriented Software (1994).
  • Martin, R. C., Clean Code: A Handbook of Agile Software Craftsmanship (2009).

总结

  • 建造者模式适用于创建复杂对象，允许逐步构建。
  • 相比工厂模式，它提供更大的灵活性，支持不同的对象配置。
  • 适用于游戏开发、前端 UI 组件、数据库查询等场景。

如果你有特定的应用需求，欢迎讨论！🚀