定义

• 将一复杂对象的构建过程和它的表现分离，使得同样的构建过程可以获取（创建）不同的表现。
• 核心思想：将产品的创建过程与产品本身分离开来，使得创建过程更加清晰，能够更加精确地控制复杂对象的创建过程，让使用者可以用相同的创建过程创建不同的产品。

与工厂模式的区别

工厂模式关注的是整个产品（整体对象）的生成，即成品的生成；而构建模式关注的是产品的创建过程和细节，一步一步地由各个子部件构建为一个成品。

比如要创建一辆汽车，如果用工厂模式，直接就创建一辆有车身、轮胎、发动机的能用的汽车。如果用构建模式，则需要由车身、轮胎、发动机一步一步地组装成一辆汽车。

与组合模式的区别

• 区别：组合模式关注的是对象内部的组成结构，强调的是部分与整体的关系。构建模式关注的是对象的创建过程，即由一个一个的子部件构建一个成品的过程。
• 联系：组合模式和构建模式其实也经常被一起使用。

构建模式的模型抽象

类图

基于框架的实现

from abc import ABCMeta, abstractmethod  
# 引入ABCMeta和abstractmethod来定义抽象类和抽象方法  
  
class Toy(metaclass=ABCMeta):  
    """玩具"""  
  
    def __init__(self, name):  
        self._name = name  
        self.__components = []  
  
    def getName(self):  
        return self._name  
  
    def addComponent(self, component, count = 1, unit = "个"):  
        self.__components.append([component, count, unit])  
        # print("%s 增加了 %d %s%s" % (self._name, count, unit, component) );  
  
    @abstractmethod  
    def feature(self):  
        pass  
  
  
class Car(Toy):  
    """小车"""  
  
    def feature(self):  
        print("我是 %s，我可以快速奔跑……" % self._name)  
  
  
class Manor(Toy):  
    """庄园"""  
  
    def feature(self):  
        print("我是 %s，我可供观赏，也可用来游玩！" % self._name)  
  
  
class ToyBuilder(metaclass=ABCMeta):  
    """玩具构建者"""  
  
    @abstractmethod  
    def buildProduct(self):  
        pass  
  
  
class CarBuilder(ToyBuilder):  
    """车的构建类"""  
  
    def buildProduct(self):  
        car = Car("迷你小车")  
        print("正在构建 %s ……" % car.getName())  
        car.addComponent("轮子", 4)  
        car.addComponent("车身", 1)  
        car.addComponent("发动机", 1)  
        car.addComponent("方向盘")  
        return car  
  
  
class ManorBuilder(ToyBuilder):  
    """庄园的构建类"""  
  
    def buildProduct(self):  
        manor = Manor("淘淘小庄园")  
        print("正在构建 %s ……" % manor.getName())  
        manor.addComponent('客厅', 1, "间")  
        manor.addComponent('卧室', 2, "间")  
        manor.addComponent("书房", 1, "间")  
        manor.addComponent("厨房", 1, "间")  
        manor.addComponent("花园", 1, "个")  
        manor.addComponent("围墙", 1, "堵")  
        return manor  
  
class BuilderMgr:  
    """建构类的管理类"""  
  
    def __init__(self):  
        self.__carBuilder = CarBuilder()  
        self.__manorBuilder = ManorBuilder()  
  
    def buildCar(self, num):  
        count = 0  
        products = []  
        while(count < num):  
            car = self.__carBuilder.buildProduct()  
            products.append(car)  
            count +=1  
            print("建造完成第 %d 辆 %s" % (count, car.getName()) )  
        return products  
  
    def buildManor(self, num):  
        count = 0  
        products = []  
        while (count < num):  
            manor = self.__manorBuilder.buildProduct()  
            products.append(manor)  
            count += 1  
            print("建造完成第 %d 个 %s" % (count, manor.getName()))  
        return products  
  
  
# Test  
# ==============================  
def testAdvancedBuilder():  
    builderMgr = BuilderMgr()  
    builderMgr.buildManor(2)  
    print()  
    builderMgr.buildCar(4)  
  
  
# testBuilder()  
testAdvancedBuilder()****

模型说明

• 设计要点
  • 在设计构建模式时要找到并区分这些角色
    • 产品（Product）：即你要构建的对象。
    • 构建者（Builder）：构建模式的核心类，负责产品的构建过程。
    • 指挥者（BuilderManager）：构建的管理类，负责管理每一种产品的创建数量和创建顺序。
• 优缺点
  • 优点：
    • 将产品（对象）的创建过程与产品（对象）本身分离开来，让使用方（调用者）可以用相同的创建过程创建不同的产品（对象）。
    • 将对象的创建过程单独分解出来，使得创建过程更加清晰，能够更加精确地控制复杂对象的创建过程。
    • 针对升级版的构建模式，每一个具体构建者都相对独立，而与其他的具体构建者无关，因此可以很方便地替换具体构建者或增加新的具体构建者。
  • 缺点：
    • 增加了很多创建类，如果产品的类型和种类比较多，将会增加很多类，使整个系统变得更加庞杂。
    • 产品之间的结构相差很大时，构建模式将很难适应。

应用场景

• 产品（对象）的创建过程比较复杂，希望将产品的创建过程和它本身的功能分离开来。
• 产品有很多种类，每个种类之间内部结构比较类似，但有很多差异；不同的创建顺序或不同的组合方式，将创建不同的产品。