设计模式 - 建造者模式

封面图 • 2025-11-07 • 设计模式

建造者模式（Builder Pattern）是一种**创建型设计模式**，它用于**将一个复杂对象的构建过程与其表示分离**，使得同样的构建过程可以创建不同的表示。

---

## 一、建造者模式的定义

> **建造者模式**是将一个复杂对象的构造与其表示分离，使得同样的构造过程可以创建不同的表示。

---

## 二、建造者模式的组成

建造者模式通常包含以下几个角色：

| 角色 | 说明 |
|------|------|
| **Builder（抽象建造者）** | 定义了创建一个产品各个部件的抽象方法。 |
| **ConcreteBuilder（具体建造者）** | 实现 Builder 接口，构建和装配产品的各个部件。 |
| **Product（产品）** | 被构建的复杂对象。 |
| **Director（指挥者）** | 指导建造者按照特定流程来构建产品，不直接与产品交互，而是通过 Builder 接口调用建造方法。 |

---

## 三、建造者模式的 UML 类图结构

```
           +----------------+
           |     Director   |
           +----------------+
           | + construct()  |
           +----------------+
                   |
                   v
           +----------------+
           |     Builder    |
           +----------------+
           | + buildPart1() |
           | + buildPart2() |
           +----------------+
                   |
                   v
           +----------------+
           | ConcreteBuilder|
           +----------------+
           | + buildPart1() |
           | + buildPart2() |
           +----------------+
                   |
                   v
           +----------------+
           |     Product    |
           +----------------+
           | - part1        |
           | - part2        |
           +----------------+
```

---

## 四、建造者模式的实现示例（Java）

### 1. 产品类（Product）

```java
public class House {
    private String foundation;
    private String walls;
    private String roof;

public void setFoundation(String foundation) {
        this.foundation = foundation;
    }

public void setWalls(String walls) {
        this.walls = walls;
    }

public void setRoof(String roof) {
        this.roof = roof;
    }

@Override
    public String toString() {
        return "House{" +
                "foundation='" + foundation + '\'' +
                ", walls='" + walls + '\'' +
                ", roof='" + roof + '\'' +
                '}';
    }
}
```

### 2. 抽象建造者（Builder）

```java
public abstract class HouseBuilder {
    public abstract void buildFoundation();
    public abstract void buildWalls();
    public abstract void buildRoof();
    public abstract House getHouse();
}
```

### 3. 具体建造者（ConcreteBuilder）

```java
public class WoodenHouseBuilder extends HouseBuilder {
    private House house = new House();

@Override
    public void buildFoundation() {
        house.setFoundation("Wooden Foundation");
    }

@Override
    public void buildWalls() {
        house.setWalls("Wooden Walls");
    }

@Override
    public void buildRoof() {
        house.setRoof("Wooden Roof");
    }

@Override
    public House getHouse() {
        return house;
    }
}
```

### 4. 指挥者（Director）

```java
public class HouseDirector {
    private HouseBuilder builder;

public HouseDirector(HouseBuilder builder) {
        this.builder = builder;
    }

public House constructHouse() {
        builder.buildFoundation();
        builder.buildWalls();
        builder.buildRoof();
        return builder.getHouse();
    }
}
```

### 5. 客户端代码（Client）

```java
public class Client {
    public static void main(String[] args) {
        HouseBuilder builder = new WoodenHouseBuilder();
        HouseDirector director = new HouseDirector(builder);
        House house = director.constructHouse();
        System.out.println(house);
    }
}
```

---

## 五、建造者模式的优点

- **解耦**：将产品的构建过程与表示分离，提高灵活性。
- **易于扩展**：可以方便地添加新的建造者或修改构建流程。
- **控制构建过程**：通过指挥者控制构建顺序，避免客户端直接操作对象内部。

---

## 六、建造者模式的缺点

- 增加了系统的复杂度，对于简单对象来说可能显得过于繁琐。
- 如果产品之间的差异很大，可能需要多个建造者类。

---

## 七、适用场景

建造者模式适用于以下情况：

- 当创建一个对象的算法（构建步骤）与该对象的表示（内容）相分离时。
- 当需要分步骤构建一个复杂对象时。
- 当需要创建不同形式的产品时（如不同配置的汽车、房屋等）。

---

## 八、总结

建造者模式通过将对象的构建过程封装在建造者中，实现了**构建与表示的解耦**。它特别适合用于构建**复杂对象**，并且可以灵活地组合不同的构件来生成不同的产品。

如果你有具体的业务场景，我可以帮你分析是否适合使用建造者模式。