简单聊聊Python设计模式 - 建造者模式

Sunny_Chen
2,579 阅读6分钟

本文已参与掘金创作者训练营第三期，详情查看：掘力计划｜创作者训练营第三期正在进行，「写」出个人影响力。

📖前言

书不是看的是用的

在这里想强调一下学习方法，总有很多小伙伴对学习知识有疑惑，明明看了、看的时候也懂了，但到了实际使用的时候却用不上。或者有时候在想是不要是有更加生动的漫画或者什么对比会好些，当然这些方式可能会加快一个新人对知识的理解速度。但只要你把学习视频当电影看、学习书籍当故事看，就很难掌握这项技术栈。只有你把它用起来，逐字逐句的深挖，一点点的探求，把各项遇到的盲点全部扫清，才能让你真的掌握这项技能。

🚀建造者模式

当我们想要创建一个由多个部分构成的对象，而且他们的构建需要一步接一步的地完成，只有当各个部分都创建好，这个对象才算完整。 -- 这正是 建造者设计模式的用武之地。

  • 建造者模式（Builder Pattern） 又名生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
  • 建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。
  • 主要解决： 主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
  • 何时使用： 一些基本部件不会变，而其组合经常变化的时候。
  • 如何解决： 将变与不变分离开。
  • 关键代码： 建造者：创建和提供实例，指挥者：管理建造出来的实例的依赖关系。
  • 应用实例： 去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。
  • 优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
  • 缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
  • 使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
  • 注意事项： 与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

根据《精通Python设计模式》介绍，建造者模式通常用于补充工厂模式的不足，尤其是在如下场景中：

  1. 要求一个对象有不同的表现，并且希望将对象的构造与表现解耦。
  2. 要求在某个时间点创建对象，但在稍后的时间点再访问。

个人理解：

　　由于之前介绍了工厂模式，这边拿创建者模式进行对比下：

　　工厂模式像是从某宝输入 电脑的关键字 直接进行购买，获得一个已经完整的电脑。而创建者模式，更像是 找个一个电脑的外壳，往该外壳内一步一步的组装零件，最后得到一个完整的电脑。

应用场景：

　　最常用的一个场景就是操作数据库的 ORM。回想一下，ORM 中一个很重要的概念：延迟加载，其实就是建造者模式最常见的应用。

　　在一开始将 orm 对象构造出来，但并不实际查询数据，而是在用到具体数据的时候才向数据库进行查询。并且会根据不同的对象，向不同的表进行查询。

 　　示例：（来自书中翻译评审者精简后的代码）

class Pizza:
    def __init__(self, builder):
        self.garlic = builder.garlic
        self.extra_cheese  = builder.extra_cheese

    def __str__(self):
        garlic = 'yes' if self.garlic else 'no'
        cheese = 'yes' if self.extra_cheese else 'no'
        info = ('Garlic: {}'.format(garlic), 'Extra cheese: {}'.format(cheese))
        return '\n'.join(info)

    class PizzaBuilder:
        def __init__(self):
            self.extra_cheese = False
            self.garlic = False

        def add_garlic(self):
            self.garlic = True
            return self

        def add_extra_cheese(self):
            self.extra_cheese = True
            return self

        def build(self):
            return Pizza(self)

if __name__ == '__main__':
    pizza = Pizza.PizzaBuilder().add_garlic().add_extra_cheese().build()
    print(pizza)

　　这是一个往 pizza 中添加配料的过程，即 刚开始创建了一个原味的 pizza，随后通过 PizzaBuilder 一步步往 pizza 中添加配料，最终得到一个完整的 pizza。

　　同时这里实现了一个 链式调用，所谓的链式调用，也并不是什么神奇的事情，只是在建造者类的每一个方法在为该对象添加了属性之后返回其本身—— return self。

🐱‍🏍实例

建造者模式可以用于描述KFC如何创建套餐：套餐是一个复杂对象，它一般包含主食（如汉堡、鸡肉卷等）和饮料（如果汁、可乐等）等组成部分，不同的套餐有不同的组成部分，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构造一份完整的套餐，然后返回给顾客。

#具体产品对象
class Menu:
    Menu_A=[]
    Menu_B=[]
    def set_MenuA(self,item):
        self.Menu_A.append(item)
    def set_MenuB(self,item):
        self.Menu_B.append(item)
    def get_MenuA(self):
        return self.Menu_A
    def get_MenuB(self):
        return self.Menu_B

# Builder（抽象建造者）
# 创建一个Product对象的各个部件指定的抽象接口。
class Product:
    product = Menu()
    def build_hanbao(self):
        pass
    def build_jiroujuan(self):
        pass
    def build_kele(self):
        pass
    def build_shutiao(self):
        pass

# ConcreteBuilder（具体建造者）
# 实现抽象接口，构建和装配各个部件。
#套餐A
class product_A(Product):
    def __init__(self):
        self.producttype="A"
    def build_hanbao(self):
        self.hanbao="汉堡"
        self.product.set_MenuA(self.hanbao)
    def build_kele(self):
        self.kele="可乐"
        self.product.set_MenuA(self.kele)
    def getType(self):
        return self.producttype

# 套餐B
class product_B(Product):
    def __init__(self):
        self.producttype = "B"
    def build_shutiao(self):
        self.shutiao="薯条"
        self.product.set_MenuB(self.shutiao)
    def build_jiroujuan(self):
        self.jiroujuan="鸡肉卷"
        self.product.set_MenuB(self.jiroujuan)
    def build_kele(self):
        self.kele="可乐"
        self.product.set_MenuB(self.kele)
    def getType(self):
        return self.producttype

#Director（指挥者）
class Make:
    def __init__(self):
        self.builder = None
    def build_product(self, builder):
        self.builder = builder
        print(builder.producttype)
        if builder.producttype == "A":
            [step() for step in (builder.build_hanbao,
            builder.build_kele)]
        if builder.producttype == "B":
            [step() for step in (builder.build_shutiao,
                                 builder.build_jiroujuan,
                                 builder.build_kele)]


#不同类型选择
def validate_style(builders):
    global valid_input
    try:
        print('套餐A：汉堡、可乐'+'\n'
              '套装B：薯条、鸡肉卷、可乐')
        product_style = input('请输入您的选择：' )
        builder = builders[product_style]()
        valid_input = True
    except KeyError as err:
        print('Sorry, 没有这个套餐，请重新选择。')
        return (False, None)
    return (True, builder,product_style)

#主函数
def main():
    builders = dict(A=product_A, B=product_B)
    valid_input = False
    while not valid_input:
        valid_input, builder,product_style = validate_style(builders)
    Waiter = Make()
    Waiter.build_product(builder)
    if product_style == "A":print(builder.product.get_MenuA())
    else:print(builder.product.get_MenuB())

if __name__ =="__main__":
    main()

结果:

套餐A：汉堡、可乐
套装B：薯条、鸡肉卷、可乐
请输入您的选择：A
A
['汉堡', '可乐']

🎉最后

  • 我们学习了如何使用建造者设计模式。可以在工厂模式（工厂方法或抽象工厂）不适用的一些场景中使用建造者模式创建对象。在以下几种情况下，与工厂模式相比，建造者模式是更好的选择。

    • 想要创建一个复杂对象（对象由多个部分构成，且对象的创建要经过多个不同的步骤，这些步骤也许还需遵从特定的顺序）
    • 要求一个对象能有不同的表现，并希望将对象的构造与表现解耦
    • 想要在某个时间点创建对象，但在稍后的时间点再访问

  • 更多参考精彩博文请看这里：《陈永佳的博客》

  • 喜欢博主的小伙伴可以加个关注、点个赞哦，持续更新嘿嘿！

avatar
文章
阅读
粉丝