设计模式--创建模式-建造者模式

建造者模式（Builder Pattern）

建造者模式（Builder Pattern）是一种创建型设计模式，旨在将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。简而言之，建造者模式通过分步构建来创建复杂对象，它可以更好地控制复杂对象的创建过程，同时保持代码的可读性和可维护性。

1. 意图

建造者模式的目的是解耦对象的构建过程与对象的表示。它将复杂对象的构建过程分为多个步骤，每个步骤创建对象的一部分，最终将这些部分组合成一个完整的对象。

2. 结构

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

• Product（产品）：表示要构建的复杂对象。
• Builder（建造者）：声明了构建产品各个部分的抽象方法。
• ConcreteBuilder（具体建造者）：实现了构建产品各个部分的具体方法，并定义了如何将这些部分组装成最终产品。
• Director（指挥者）：负责构建一个使用Builder的对象，通常它会根据具体的需求来决定构建过程的顺序。
• Client（客户端）：通过使用Director来构建产品，客户端不直接操作建造过程。

3. UML 类图

+-------------------------+
|        Director         |
+-------------------------+
| +construct()            |
+-------------------------+
           |
           v
+------------------+      +----------------------+
|     Builder     |<>---->|    Product           |
+------------------+      +----------------------+
| +buildPart1()   |      | -part1               |
| +buildPart2()   |      | -part2               |
| +getResult()    |      | -part3               |
+------------------+      +----------------------+
           ^
           |
+----------------------------+
|  ConcreteBuilder          |
+----------------------------+
| +buildPart1()             |
| +buildPart2()             |
| +getResult()              |
+----------------------------+

4. 实现步骤

1. 产品类（Product）：构建复杂对象的最终产品，它由多个部件组成，每个部件可以通过建造者的不同实现来创建。
2. 抽象建造者（Builder）：定义创建产品各个部件的方法，包括初始化和构建各个部件的抽象方法。
3. 具体建造者（ConcreteBuilder）：实现抽象建造者中的方法，负责实现具体部件的创建并最终返回完整的产品。
4. 指挥者（Director）：负责管理建造过程，指定建造的顺序和构建哪些部件。
5. 客户端（Client）：通过指挥者来完成产品的构建过程，客户端只需要获取产品，不需要关心具体的构建过程。

5. 示例：构建一台电脑

假设我们要建造一台电脑，电脑有多个部件：处理器（CPU）、内存（RAM）、硬盘（Hard Drive）等。

5.1 定义产品（Product）

class Computer:
    def __init__(self, cpu, ram, hdd):
        self.cpu = cpu
        self.ram = ram
        self.hdd = hdd

    def __str__(self):
        return f"Computer with CPU: {self.cpu}, RAM: {self.ram}, HDD: {self.hdd}"

5.2 定义抽象建造者（Builder）

from abc import ABCMeta, abstractmethod

class ComputerBuilder(metaclass=ABCMeta):
    @abstractmethod
    def build_cpu(self):
        pass

    @abstractmethod
    def build_ram(self):
        pass

    @abstractmethod
    def build_hdd(self):
        pass

    @abstractmethod
    def get_computer(self):
        pass

5.3 定义具体建造者（ConcreteBuilder）

class GamingComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.computer = Computer(None, None, None)

    def build_cpu(self):
        self.computer.cpu = "Intel i9"
    
    def build_ram(self):
        self.computer.ram = "32GB"
    
    def build_hdd(self):
        self.computer.hdd = "2TB SSD"
    
    def get_computer(self):
        return self.computer


class OfficeComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.computer = Computer(None, None, None)

    def build_cpu(self):
        self.computer.cpu = "Intel i5"
    
    def build_ram(self):
        self.computer.ram = "8GB"
    
    def build_hdd(self):
        self.computer.hdd = "1TB HDD"
    
    def get_computer(self):
        return self.computer

5.4 定义指挥者（Director）

class Director:
    def __init__(self, builder: ComputerBuilder):
        self.builder = builder
    
    def construct_computer(self):
        self.builder.build_cpu()
        self.builder.build_ram()
        self.builder.build_hdd()

5.5 客户端代码（Client）

if __name__ == "__main__":
    # 创建具体的建造者
    gaming_builder = GamingComputerBuilder()
    office_builder = OfficeComputerBuilder()

    # 创建指挥者
    director = Director(gaming_builder)

    # 使用指挥者构建游戏电脑
    director.construct_computer()
    gaming_computer = gaming_builder.get_computer()
    print("Gaming Computer:", gaming_computer)

    # 使用指挥者构建办公电脑
    director = Director(office_builder)
    director.construct_computer()
    office_computer = office_builder.get_computer()
    print("Office Computer:", office_computer)

5.6 输出

Gaming Computer: Computer with CPU: Intel i9, RAM: 32GB, HDD: 2TB SSD
Office Computer: Computer with CPU: Intel i5, RAM: 8GB, HDD: 1TB HDD

6. 总结

• 建造者模式适用于创建复杂对象的场景，它通过将构建过程和对象的表示分离，使得可以灵活地构建不同类型的对象。
• 它通过不同的建造者（具体建造者）来控制对象的不同部分，而通过指挥者（Director）来统一管理构建过程，客户端只需要指定要构建的产品类型，而无需关注构建的细节。
• 这种模式的关键在于分步骤的构建，可以避免构造函数参数过多的问题，提高了代码的可读性和可维护性。

适用场景

• 当构造对象的算法独立于其部件的组成时。
• 当对象的构建过程非常复杂且需要分步骤时。
• 当客户端希望通过不同的方式创建不同的复杂对象时。