建造者模式 - 元素码农

发布时间: 2025-03-21 10:57

↑

# 建造者模式

建造者模式是一种创建型设计模式，它能够分步骤创建复杂对象。该模式允许你使用相同的创建代码生成不同类型和形式的对象。

## 适用场景

1. 当需要创建的对象有多个可选配置项时
2. 当对象的创建过程需要严格的步骤或顺序时
3. 当你想要创建不同形式的产品，但它们的创建过程类似时

## UML类图

```mermaid
classDiagram
    class Director {
        -builder Builder
        +setBuilder(Builder)
        +construct()
    }
    class Builder {
        <<interface>>
        +buildPartA()
        +buildPartB()
        +buildPartC()
        +getResult()*Product
    }
    class ConcreteBuilder1 {
        -product Product
        +buildPartA()
        +buildPartB()
        +buildPartC()
        +getResult()*Product
    }
    class ConcreteBuilder2 {
        -product Product
        +buildPartA()
        +buildPartB()
        +buildPartC()
        +getResult()*Product
    }
    class Product {
        -parts []
        +addPart(part)
    }
    Director o-- Builder
    Builder <|-- ConcreteBuilder1
    Builder <|-- ConcreteBuilder2
    ConcreteBuilder1 ..> Product
    ConcreteBuilder2 ..> Product
```

## 代码示例

以下是一个使用Go语言实现的房屋建造者模式示例：

```go
package main

import "fmt"

// House 代表最终的产品
type House struct {
    foundation string
    walls     string
    roof      string
}

// HouseBuilder 定义建造房屋的接口
type HouseBuilder interface {
    buildFoundation()
    buildWalls()
    buildRoof()
    getHouse() *House
}

// Director 负责控制建造过程
type Director struct {
    builder HouseBuilder
}

func newDirector(b HouseBuilder) *Director {
    return &Director{builder: b}
}

func (d *Director) construct() *House {
    d.builder.buildFoundation()
    d.builder.buildWalls()
    d.builder.buildRoof()
    return d.builder.getHouse()
}

// StandardHouseBuilder 实现标准房屋的建造
type StandardHouseBuilder struct {
    house *House
}

func newStandardHouseBuilder() *StandardHouseBuilder {
    return &StandardHouseBuilder{house: &House{}}
}

func (b *StandardHouseBuilder) buildFoundation() {
    b.house.foundation = "标准混凝土地基"
}

func (b *StandardHouseBuilder) buildWalls() {
    b.house.walls = "标准砖墙"
}

func (b *StandardHouseBuilder) buildRoof() {
    b.house.roof = "标准瓦片屋顶"
}

func (b *StandardHouseBuilder) getHouse() *House {
    return b.house
}

// LuxuryHouseBuilder 实现豪华房屋的建造
type LuxuryHouseBuilder struct {
    house *House
}

func newLuxuryHouseBuilder() *LuxuryHouseBuilder {
    return &LuxuryHouseBuilder{house: &House{}}
}

func (b *LuxuryHouseBuilder) buildFoundation() {
    b.house.foundation = "加固钢筋混凝土地基"
}

func (b *LuxuryHouseBuilder) buildWalls() {
    b.house.walls = "隔音保温墙"
}

func (b *LuxuryHouseBuilder) buildRoof() {
    b.house.roof = "智能天窗屋顶"
}

func (b *LuxuryHouseBuilder) getHouse() *House {
    return b.house
}

func main() {
    // 建造标准房屋
    standardBuilder := newStandardHouseBuilder()
    director := newDirector(standardBuilder)
    standardHouse := director.construct()
    fmt.Printf("标准房屋:\n地基: %s\n墙: %s\n屋顶: %s\n\n",
        standardHouse.foundation,
        standardHouse.walls,
        standardHouse.roof)

// 建造豪华房屋
    luxuryBuilder := newLuxuryHouseBuilder()
    director = newDirector(luxuryBuilder)
    luxuryHouse := director.construct()
    fmt.Printf("豪华房屋:\n地基: %s\n墙: %s\n屋顶: %s\n",
        luxuryHouse.foundation,
        luxuryHouse.walls,
        luxuryHouse.roof)
}
```

## 优点

1. 可以分步创建对象，暂缓创建步骤或递归运行创建步骤
2. 生成不同形式的产品时可以复用相同的创建代码
3. 遵循单一职责原则，将复杂构建代码从产品的业务逻辑中分离出来

## 缺点

1. 需要新增多个类，代码整体复杂度会有所增加
2. 客户端必须了解产品的内部结构才能正确使用建造者

## 与其他模式的关系

1. 建造者模式聚焦于分步骤构建复杂对象，而抽象工厂模式专注于创建一系列相关对象
2. 建造者模式可以配合桥接模式使用，指挥者类扮演抽象层角色，而具体建造者及其产品则作为实现层
3. 建造者模式通常在原型模式的基础上构建，允许克隆复杂对象而不是重新构建它们

## 实际应用场景

1. 配置生成器：创建具有多个配置选项的对象（如数据库连接配置）
2. 文档生成器：构建不同格式的文档（HTML、PDF、Word等）
3. UI构建器：创建复杂的用户界面组件
4. 测试数据构建器：创建测试用例中的复杂对象