Python 设计模式之建造者模式 Builder Pattern

柔光的暖阳◎ 2023-08-17 17:14 179阅读 0赞

## \#引入建造者模式 ##

肯德基的菜单上有 薯条， 鸡腿，鸡翅，鸡米花，可乐，橙汁，火腿汉堡，至尊虾汉堡，牛肉汉堡 ， 鸡肉卷等这些单品，也有很多套餐。

比如

套餐1：鸡翅，至尊虾汉堡，可乐，薯条

套餐2：鸡腿，火腿汉堡，橙汁，薯条

套餐3： 。。。。。

全家桶：。。。。。

这种有各种各样的单品一步一步生成各种套餐， 这种过程称的上建造者模式

使用多个简单的对象一步一步构建成一个复杂的对象，有点像造房子一样一步步从地基做起到万丈高楼。我想这也是为什么被称呼为建造者模式的原因吧！

## \#建造者定义 ##

Separate the construction of a complex object from its representation so that the same construction process can create different representations.  
将一个复杂对象的构建与它的表示进行分离，使得同样的构建过程可以创建不同的表示。

这个定义里面的 ‘不同的表示’ 意思是不同的产品， 或者是不同的功能。

简单理解：建造者模式（Builder Pattern） 具备两层含义：

*  **构建与表示分离**：*构建* 代表对象创建，*表示* 代表对象行为/方法，也就是对象的创建与行为进行分离（对应到 java 代码，其实就是使用 **接口** 规定行为，然后由具体的实现类进行构建）。
 *  **创建不同的表示**：也就是具备同样的行为，但是却由于构建的行为顺序不同或其他原因可以创建出不同的表示。

我们看完上述 建造者模式 的定义，就知道它与 工厂模式 是非常相似的。**构建与表示分离** 和 **创建不同的表示** 对于 工厂模式 同样具备。建造者模式 唯一区别于 工厂模式 主要是针对 **复杂对象的构建**。

也就是说，如果是创建简单对象，我们通常都是使用 工厂模式 进行创建；而如果是创建复杂对象，那么此时就可以考虑使用 建造者模式。

## \#主要解决 ##

当需要构建的产品具备 **复杂创建** 过程时，可以抽取出共性构建过程，然后交由具体实现类自定义构建流程，使得同样的构建行为可以生产出不同的产品，分离了构建与表示，使构建产品灵活性大大增加。

## \#使用场景 ##

看到上面的模式定义内容，可以根据内容剥离出这个模式的使用场景

1)需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；

2)隔离复杂对象的创建和使用，并使得相同的构建过程可以创建不同的产品。

## \#建造者模式的优点 ##

我在百度文库里看到了这个作者的文章，我喜欢ta的表述，不能复制，我就敲下来放这里了

1）在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建进行解耦，使得相同的创建过程可以创建不同的产品对象

2）每一个具体建造者都是独立的，与其他的具体建造者无关，，因此可以很方便的替换具体建造者或增加具体建造者，用户使用不同的具体建造者可得到不同的产品对象，由于指挥者类针对抽象建造者编程，增加新的具体建造者无需修改原有类库的代码，系统扩展方便，符合开闭原则。在编写代码中，代码复用率是尤为重要的

3）用户可以更为精细的控制产品的创建过程，将复杂的产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程

## \#建造者模式的缺点 ##

1）建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性较大，例如很多组成部分不相同，则不适合使用建造者模式，因此使用范围受到一定的限制

2）如果产品的内部变化复杂，可能需要很多具体建造者类类实现这种变化，导致系统变得庞大，增加了系统的理解难度和运行成本

## \#建造者模式 主要包含四种角色： ##

1）抽象建造者（Builder）：主要用于规范产品类的各个组成部分，并提供一个返回完整产品的接口。

2）具体建造者（Concrete Builder）：实现 *抽象建造者* 规定的各个方法，返回一个组件好的具体产品。

3）产品（Product）：构建相当复杂的类型，建造者最终创建的产品类型。

4）导演者（Director）：指导 *建造者（Builder）* 以特定行为构建出产品，并将其返回给客户。

总结：理解了 建造者模式 的四种角色，其实就已经掌握了 建造者模式 的真谛：建造者模式 最终返回一个具体的构建复杂的产品；系统中产品可能只有一种类型或多种类型，但对某些产品族来说，它们具备相同的行为，因此对这些共性行为进行抽象，抽离出 抽象建造者（Builder）；而对这些行为的具体构建过程，则交由 具体建造者（Concrete Builder） 负责，不同的 具体建造者 会构建出不同表示的产品；而具体要构建出哪种产品，由 导演者（Director） 决定。导演者 会选择不同的 具体建造者，指导它构建出产品。

## \#注意，也可以静态内部类实现 建造者模式 ##

事实上，在平常的代码中，我们通常都会忽略对象的复杂性，使用 工厂模式 创建对象，而不是 建造者模式。正如上文所讲，工厂模式 和 建造者模式 的作用都是用于创建一个产品对象，而 工厂模式 结构更加简洁直接（没有 Builder 和 Director），因此更常使用。

而 建造者模式，我们更加习惯使用 *静态内部类* 的方式进行实现，即一个 产品类 内部自动带有一个 具体建造者（Concrete Builder），由它负责该产品的组装创建。不再需要 抽象建造者（Builder） 和 导演者（Director），这样，使得产品与构建之间的联系更加紧密，结构更加紧凑，同时使得 建造者模式 形式更加简洁。

## \#举个例子 ##

这个订单系统的例子很容易理解，作者写的有点冗余，不过完全能说明这是一个建造者模式

class Burger():
        """
        主食类，价格名字
        """
        name=""
        price=0.0
        def getPrice(self):
            return self.price
        def setPrice(self,price):
            self.price=price
        def getName(self):
            return self.name
    class cheeseBurger(Burger):
        """
        奶酪汉堡
        """
        def __init__(self):
            self.name="cheese burger"
            self.price=10.0
    class spicyChickenBurger(Burger):
        """
        香辣鸡汉堡
        """
        def __init__(self):
            self.name="spicy chicken burger"
            self.price=15.0
    
    
    class Snack():
        """
        小食类，价格以及名字
        """
        name = ""
        price = 0.0
        type = "SNACK"
        def getPrice(self):
            return self.price
        def setPrice(self, price):
            self.price = price
        def getName(self):
            return self.name
    class chips(Snack):
        """
        炸薯条
        """
        def __init__(self):
            self.name = "chips"
            self.price = 6.0
    class chickenWings(Snack):
        """
        鸡翅
        """
        def __init__(self):
            self.name = "chicken wings"
            self.price = 12.0
    
    class Beverage():
        """
        饮料
        """
        name = ""
        price = 0.0
        type = "BEVERAGE"
        def getPrice(self):
            return self.price
        def setPrice(self, price):
            self.price = price
        def getName(self):
            return self.name
    class coke(Beverage):
        """
        可乐
        """
        def __init__(self):
            self.name = "coke"
            self.price = 4.0
    class milk(Beverage):
        """
        牛奶
        """
        def __init__(self):
            self.name = "milk"
            self.price = 5.0
    
    
    class order():
        """
        订单对象，一个订单中包含一份主食，一份小食，一份饮料
        """
        burger=""
        snack=""
        beverage=""
        def __init__(self,orderBuilder):
            self.burger=orderBuilder.bBurger
            self.snack=orderBuilder.bSnack
            self.beverage=orderBuilder.bBeverage
        def show(self):
            print("Burger:%s"%self.burger.getName())
            print("Snack:%s"%self.snack.getName())
            print("Beverage:%s"%self.beverage.getName())
    
    # 建造者
    class orderBuilder():
        """
        orderBuilder就是建造者模式中所谓的“建造者”，
        将订单的建造与表示相分离，以达到解耦的目的。
        在上面订单的构建过程中，如果将order直接通过参数定义好（其构建与表示没有分离），
        同时在多处进行订单生成，此时需要修改订单内容，
        则需要一处处去修改，业务风险也就提高了不少。
        """
        bBurger=""
        bSnack=""
        bBeverage=""
        def addBurger(self,xBurger):
            self.bBurger=xBurger
        def addSnack(self,xSnack):
            self.bSnack=xSnack
        def addBeverage(self,xBeverage):
            self.bBeverage=xBeverage
        def build(self):
            return order(self)
    
    # Director类
    class orderDirector():
        """
        在建造者模式中，还可以加一个Director类，用以安排已有模块的构造步骤。
        对于在建造者中有比较严格的顺序要求时，该类会有比较大的用处。
        """
        order_builder=""
        def __init__(self,order_builder):
            self.order_builder=order_builder
        def createOrder(self,burger,snack,beverage):
            self.order_builder.addBurger(burger)
            self.order_builder.addSnack(snack)
            self.order_builder.addBeverage(beverage)
            return self.order_builder.build()
    
    #场景实现
    if  __name__=="__main__":
        order_builder=orderBuilder()
        order_builder.addBurger(spicyChickenBurger())
        order_builder.addSnack(chips())
        order_builder.addBeverage(milk())
        order_1=order_builder.build()
        order_1.show()

\#参考

https://www.jianshu.com/p/47329a94f5dc

https://wenku.baidu.com/view/34a8a76cb9f67c1cfad6195f312b3169a451ea99.html

https://segmentfault.com/a/1190000019414444?utm\_source=tag-newest

https://www.jianshu.com/p/9a90ca0fc24f

https://www.cnblogs.com/welan/p/9124081.html

转载于:https://www.cnblogs.com/baxianhua/p/11535677.html