创建型设计模式-构建器（builder）模式-python实现

设计模式汇总：查看

通俗示例

想象一下，你正在一家餐厅点餐。你告诉服务员你想要一个汉堡，但是汉堡有很多种配置：面包种类、肉类、蔬菜、酱料等。服务员会根据你的要求，一步一步构建出你想要的汉堡。在这里，服务员就扮演了“构建器”的角色，而汉堡则是被构建的“复杂对象”。

通俗解释

构建器模式是一种创建型设计模式，它用于创建复杂对象，允许你逐步构建对象的不同部分，而不需要一次性将所有的配置细节都告诉创建者。这种模式特别适合那些包含多个组成部分，且各部分需要灵活配置的对象。

在构建器模式中，通常包含以下角色：

1. 产品（Product）：最终要构建的复杂对象。
2. 抽象构建者（Builder）：定义构建产品的接口，规定了构建产品的各个步骤。
3. 具体构建者（Concrete Builder）：实现Builder接口，提供构建产品的具体实现，并负责构建产品的具体细节。
4. 指挥者（Director）：负责安排已有模块的构建步骤，指导具体构建者构建出产品。
5. 客户端（Client）：使用指挥者和构建者来创建对象。

构建器模式的优点

• 易于解耦：构建器的接口与实现分离，使得相同的构建过程可以创建不同的产品。
• 易于扩展：可以方便地新增具体构建者来构建新的产品。
• 精细控制：指挥者类可以精细控制产品的创建过程。

Python代码示例

例子1

# 产品类
class Burger:
    def __init__(self):
        self.bread = None
        self.meat = None
        self.veggies = []
        self.sauces = []
    
    def set_bread(self, bread):
        self.bread = bread
    
    def set_meat(self, meat):
        self.meat = meat
    
    def add_veggie(self, veggie):
        self.veggies.append(veggie)
    
    def add_sauce(self, sauce):
        self.sauces.append(sauce)
    
    def __str__(self):
        return f"Bread: {self.bread}, Meat: {self.meat}, Veggies: {self.veggies}, Sauces: {self.sauces}"

# 抽象构建者
class BurgerBuilder:
    def __init__(self):
        self.burger = Burger()
    
    def create_new_burger(self):
        pass
    
    def add_bread(self):
        pass
    
    def add_meat(self):
        pass
    
    def add_veggies(self):
        pass
    
    def add_sauces(self):
        pass
    
    def get_burger(self):
        return self.burger

# 具体构建者
class ChickenBurgerBuilder(BurgerBuilder):
    def create_new_burger(self):
        self.burger = Burger()
    
    def add_bread(self, bread):
        self.burger.set_bread(bread)
    
    def add_meat(self, meat):
        self.burger.set_meat(meat)
    
    def add_veggies(self, *veggies):
        for veggie in veggies:
            self.burger.add_veggie(veggie)
    
    def add_sauces(self, *sauces):
        for sauce in sauces:
            self.burger.add_sauce(sauce)


# 指挥者
class Chef:
    def __init__(self, builder):
        self.builder = builder
    
    def construct_burger(self, bread, meat, veggies, sauces):
        self.builder.create_new_burger()
        self.builder.add_bread(bread)
        self.builder.add_meat(meat)
        self.builder.add_veggies(*veggies)
        self.builder.add_sauces(*sauces)
        return self.builder.get_burger()


# 客户端代码
if __name__ == "__main__":
    builder = ChickenBurgerBuilder()
    chef = Chef(builder)
    burger = chef.construct_burger("Whole Wheat", "Chicken", ["Lettuce", "Tomato"], ["Mayo", "Mustard"])
    print(burger)

例子2

from collections import namedtuple


class OnlineShop(object):
    def __init__(self, builder):
        """
        初始化Macbook对象。

        使用命名元组来定义Macbook的结构，包括cpu、memory、ssd和graphics属性。
        这种方式初始化对象可以保持代码的简洁性和可读性。

        参数:
        builder - 一个构建者对象，包含了Macbook的各个部件的信息。
                   假设这个构建者对象已经通过其他方式定义并初始化了cpu、memory、ssd和graphics属性。
        """
        # 使用命名元组来创建Macbook类的实例，这种方式简洁并能明确表示实例的属性
        Macbook = namedtuple('Macbook', 'cpu memory ssd graphics')
        # 使用构建者对象的属性来初始化Macbook实例
        self.macbook = Macbook(builder.cpu, builder.memory,
                               builder.ssd, builder.graphics)

    def __str__(self):
        return str(self.macbook)

    class MacbookBuilder(object):
        def __init__(self):
            self.cpu = '2.7GHz'
            self.memory = '16G'
            self.ssd = '512GB'
            self.graphics = 'Radeon Pro 455'

        def upgrade_cpu(self, cpu):
            self.cpu = cpu
            return self

        def upgrade_memory(self, memory):
            raise ValueError('{0} is max'.format(self.memory))

        def upgrade_ssd(self, ssd):
            self.ssd = ssd
            return self

        def upgrade_graphics(self, graphics):
            self.graphics = graphics
            return self

        def build(self):
            """
            创建并返回一个OnlineShop实例。

            该方法作为Builder模式的一部分，负责组装完成后最终对象的创建。
            它避免了直接在客户端代码中进行复杂的对象组装，而是通过一步一步构建的方式来简化对象的创建过程。

            返回:
                OnlineShop: 一个在线商店的实例，包含了之前通过Builder方法设置的所有属性。
            """
            return OnlineShop(self)


if __name__ == '__main__':
    # 定制了一台 Macbook Pro 电脑的实例，在建造者模式中，
    # 需要定义一系列可供选择的方法去丰富实例，实现一个复杂的对象
    my_macbook = OnlineShop.MacbookBuilder() \
        .upgrade_cpu('2.8GHz') \
        .upgrade_ssd('1TB') \
        .upgrade_graphics('Radeon Pro 560') \
        .build()
    print(my_macbook)

总结

构建器模式适用于创建复杂对象，它将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。当你需要创建的对象有很多配置选项，且每个选项都有多种可能时，构建器模式是一个很好的选择。