设计模式之建造者模式（Builder Pattern）

设计模式之建造者模式（Builder Pattern）

---

一、简介

1.1 模式说明

隐藏创建对象的建造过程 & 细节，使得用户在不知对象的建造过程 & 细节的情况下，就可直接创建复杂的对象

1. 用户只需要给出指定复杂对象的类型和内容；
2. 建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来)

1.2 作用

1. 降低创建复杂对象的复杂度
2. 隔离了创建对象的构建过程 & 表示

从而：

• 方便用户创建复杂的对象（不需要知道实现过程）
• 代码复用性 & 封装性（将对象构建过程和细节进行封装 & 复用）

例子：造汽车 & 买汽车。

1. 工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）
2. 汽车购买者（用户）：你只需要说出你需要的型号（对象的类型和内容），然后直接购买就可以使用了（不需要知道汽车是怎么组装的（车轮、车门、发动机、方向盘等等））

二、模式原理

2.1 UML类图

2.2 模式讲解

1. 指挥者（Director）直接和客户（Client）进行需求沟通；
2. 沟通后指挥者将客户创建产品的需求划分为各个部件的建造请求（Builder）；
3. 将各个部件的建造请求委派到具体的建造者（ConcreteBuilder）；
4. 各个具体建造者负责进行产品部件的构建；
5. 最终构建成具体产品（Product）。

三、实例讲解

接下来我用一个实例来对建造者模式进行更深一步的介绍。

3.1 实例概况

• 背景
  小彭希望去电脑城买一台组装的台式主机
• 过程

1. 电脑城老板（Diretor）和小彭（Client）进行需求沟通（买来打游戏？学习？看片？）
2. 了解需求后，电脑城老板将小彭需要的主机划分为各个部件（Builder）的建造请求（CPU、主板blabla）
3. 指挥装机人员（ConcreteBuilder）去构建组件；
4. 将组件组装起来成为小彭需要的电脑（Product）

3.2 使用步骤

步骤1：定义组装的过程（Builder）：组装电脑的过程

/**
 * 定义组装的过程
 */
abstract class Builder {
    // 第一步：装CPU
    abstract fun buildCPU(cpu: String)

    // 第二步：装主板
    abstract fun buildMainBoard(mainBoard: String)

    // 第三步：装硬盘
    abstract fun buildHardDisk(hardDisk: String)

    // 返回产品
    abstract fun getComputer(): Computer
}

步骤2： 电脑城老板委派任务给装机人员（Director）

/**
 * 产品经理（跟客户沟通需求，命令组件安装员工）
 */
class Director(private val builder: Builder) {
    init {
        builder.buildCPU("i7-9700K")
        builder.buildHardDisk("2T")
        builder.buildMainBoard("M3芯片")
    }
}

步骤3： 创建具体的建造者（ConcreteBuilder）:装机人员

/**
 * 具体装机工作人员
 */
class ConcreteBuilder: Builder() {
    // 创建产品实例
    private val computer: Computer = Computer()
    override fun buildCPU(cpu: String) {
        computer.addPart(cpu)
    }

    override fun buildMainBoard(mainBoard: String) {
        computer.addPart(mainBoard)
    }

    override fun buildHardDisk(hardDisk: String) {
        computer.addPart(hardDisk)
    }

    override fun getComputer(): Computer {
        return computer
    }
}

步骤4： 定义具体产品类（Product）：电脑

/**
 * 产品
 */
class Computer {
    // 电脑组件的集合
    val computer: MutableList<String> = ArrayList()

    fun addPart(part: String) {
        computer.add(part)
    }
    // 用于将组件组装到电脑里
    fun showParts() {
        for (part in computer) {
            println("组件：$part 已安装完毕!")
        }
    }
}

步骤5：客户端调用-小彭到电脑城找老板买电脑

/**
 * 客户购买历程
 */
class Customer {
}
fun main() {
    // 装机仔实例(方便老板调遣)
    val builder: ConcreteBuilder = ConcreteBuilder()
    // 产品经理实例(与客户沟通，确认需求)
    // leader下发任务给装机仔
    val director: Director = Director(builder)

    // 拿到组装好的电脑
    val computer = builder.getComputer()
    // 展示给用户看
    computer.showParts()
}

结果输出

组件：i7-9700K 已安装完毕!
组件：2T 已安装完毕!
组件：M3芯片 已安装完毕!

四、特点

优点

• 易于解耦
  将产品本身与产品创建过程进行解耦，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
• 易于精确控制对象的创建
  将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
• 易于拓展
  增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“。

每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

缺点

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

五、应用场景

• 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。