Python 建造者模式：构建复杂对象的优雅之道

最新推荐文章于 2024-10-28 15:38:22 发布

三带俩王

最新推荐文章于 2024-10-28 15:38:22 发布

阅读量759

点赞数 27

文章标签： python 建造者模式开发语言

本文链接：https://blog.csdn.net/liuhailong0511/article/details/142633329

版权

在软件开发中，我们常常会遇到创建复杂对象的情况。这些对象可能由多个部分组成，并且每个部分的创建过程可能会比较复杂或者具有多种配置选项。Python 中的建造者模式（Builder Pattern）为解决这类问题提供了一种优雅的解决方案。本文将深入探讨 Python 中的建造者模式，包括其定义、关键要点、示例代码、应用场景以及与其他模式的对比等内容。

一、建造者模式的定义

建造者模式是一种创建型设计模式，它将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。简单来说，就是将复杂对象的构建步骤抽象出来，通过不同的构建顺序或者参数配置，可以得到不同的最终对象实例。这种模式的核心思想是将复杂对象的构建逻辑封装在一个专门的建造者类中，而不是让客户端直接操作对象的内部构造。

二、关键要点

1. 产品类（Product）

这是最终要构建的复杂对象。它包含多个组成部分，这些部分可能是不同类型的数据或者子对象。例如，在构建一个汽车对象时，汽车可能包含引擎、车身、轮胎等不同的部件，这些部件共同构成了汽车这个产品。

class Car:
    def __init__(self):
        self.engine = None
        self.body = None
        self.tires = None

    def __str__(self):
        return f"Car with {self.engine}, {self.body}, and {self.tires}"

2. 抽象建造者类（Abstract Builder）

它定义了构建复杂对象的各个部分的抽象方法。这些方法规定了构建过程中需要执行的操作，但具体的实现由具体的建造者类来完成。抽象建造者类为具体建造者类提供了一个统一的接口。

class CarBuilder:
    def build_engine(self):
        pass

    def build_body(self):
        pass

    def build_tires(self):
        pass

    def get_car(self):
        pass

3. 具体建造者类（Concrete Builder）

继承自抽象建造者类，它实现了抽象建造者类中的抽象方法，按照特定的逻辑来构建产品对象的各个部分。每个具体建造者类可以构建出具有不同特性的产品。例如，一个具体建造者类可以构建高性能汽车，另一个可以构建经济实惠型汽车。

class SportsCarBuilder(CarBuilder):
    def __init__(self):
        self.car = Car()

    def build_engine(self):
        self.car.engine = "High - performance engine"

    def build_body(self):
        self.car.body = "Streamlined body"

    def build_tires(self):
        self.car.tires = "High - grip tires"

    def get_car(self):
        return self.car


class EconomyCarBuilder(CarBuilder):
    def __init__(self):
        self.car = Car()

    def build_engine(self):
        self.car.engine = "Fuel - efficient engine"

    def build_body(self):
        self.car.body = "Simple body"

    def build_tires(self):
        self.car.tires = "Standard tires"

    def get_car(self):
        return self.car

4. 指挥者类（Director）

指挥者类负责控制建造过程，它调用具体建造者类的方法来构建产品对象。指挥者类知道如何按照正确的顺序调用建造者的方法，以确保产品对象被正确构建。不过，指挥者类并不关心产品的具体构建细节，这些细节由具体建造者类负责。

class CarDirector:
    def __init__(self, builder):
        self.builder = builder

    def construct_car(self):
        self.builder.build_engine()
        self.builder.build_body()
        self.builder.build_tires()
        return self.builder.get_car()

三、示例代码演示

以下是一个完整的示例，展示了如何使用建造者模式构建不同类型的汽车：

# 产品类
class Car:
    def __init__(self):
        self.engine = None
        self.body = None
        self.tires = None

    def __str__(self):
        return f"Car with {self.engine}, {self.body}, and {self.tires}"


# 抽象建造者类
class CarBuilder:
    def build_engine(self):
        pass

    def build_body(self):
        pass

    def build_tires(self):
        pass

    def get_car(self):
        pass


# 具体建造者类 - 跑车建造者
class SportsCarBuilder(CarBuilder):
    def __init__(self):
        self.car = Car()

    def build_engine(self):
        self.car.engine = "High - performance engine"

    def build_body(self):
        self.car.body = "Streamlined body"

    def build_tires(self):
        self.car.tires = "High - grip tires"

    def get_car(self):
        return self.car


# 具体建造者类 - 经济车建造者
class EconomyCarBuilder(CarBuilder):
    def __init__(self):
        self.car = Car()

    def build_engine(self):
        self.car.engine = "Fuel - efficient engine"

    def build_body(self):
        self.car.body = "Simple body"

    def build_tires(self):
        self.car.tires = "Standard tires"

    def get_car(self):
        return self.car


# 指挥者类
class CarDirector:
    def __init__(self, builder):
        self.builder = builder

    def construct_car(self):
        self.builder.build_engine()
        self.builder.build_body()
        self.builder.build_tires()
        return self.builder.get_car()


# 使用示例
if __name__ == "__main__":
    sports_car_builder = SportsCarBuilder()
    director = CarDirector(sports_car_builder)
    sports_car = director.construct_car()
    print(sports_car)

    economy_car_builder = EconomyCarBuilder()
    director = CarDirector(economy_car_builder)
    economy_car = director.construct_car()
    print(economy_car)

四、应用场景

1. 复杂对象的构建 - 图形用户界面（GUI）构建

# 产品类：代表一个图形用户界面（GUI）
class GUI:
    def __init__(self):
        self.menu_bar = None
        self.tool_bar = None
        self.status_bar = None
        self.content_area = None

    def __str__(self):
        parts = []
        if self.menu_bar:
            parts.append(f"Menu Bar: {self.menu_bar}")
        if self.tool_bar:
            parts.append(f"Tool Bar: {self.tool_bar}")
        if self.status_bar:
            parts.append(f"Status Bar: {self.status_bar}")
        if self.content_area:
            parts.append(f"Content Area: {self.content_area}")
        return "\n".join(parts)


# 抽象建造者类
class GUIBuilder:
    def build_menu_bar(self):
        pass

    def build_tool_bar(self):
        pass

    def build_status_bar(self):
        pass

    def build_content_area(self):
        pass

    def get_gui(self):
        pass


# 具体建造者类 - 简单GUI建造者
class SimpleGUIBuilder(GUIBuilder):
    def __init__(self):
        self.gui = GUI()

    def build_menu_bar(self):
        self.gui.menu_bar = "Simple Menu Bar"

    def build_tool_bar(self):
        self.gui.tool_bar = "Basic Tool Bar"

    def build_status_bar(self):
        self.gui.status_bar = "Minimal Status Bar"

    def build_content_area(self):
        self.gui.content_area = "Empty Content Area"

    def get_gui(self):
        return self.gui


# 具体建造者类 - 复杂GUI建造者
class ComplexGUIBuilder(GUIBuilder):
    def __init__(self):
        self.gui = GUI()

    def build_menu_bar(self):
        self.gui.menu_bar = "Advanced Menu Bar with many options"

    def build_tool_bar(self):
        self.gui.tool_bar = "Full - featured Tool Bar"

    def build_status_bar(self):
        self.gui.status_bar = "Detailed Status Bar"

    def build_content_area(self):
        self.gui.content_area = "Rich Content Area with multiple widgets"

    def get_gui(self):
        return self.gui


# 指挥者类
class GUIDirector:
    def __init__(self, builder):
        self.builder = builder

    def construct_gui(self):
        self.builder.build_menu_bar()
        self.builder.build_tool_bar()
        self.builder.build_status_bar()
        self.builder.build_content_area()
        return self.builder.get_gui()


# 使用示例
if __name__ == "__main__":
    simple_gui_builder = SimpleGUIBuilder()
    gui_director = GUIDirector(simple_gui_builder)
    simple_gui = gui_director.construct_gui()
    print(simple_gui)

    complex_gui_builder = ComplexGUIBuilder()
    gui_director = GUIDirector(complex_gui_builder)
    complex_gui = gui_director.construct_gui()
    print(complex_gui)

2. 不同配置的对象创建 - 定制化计算机配置

# 产品类：计算机
class Computer:
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.storage = None
        self.graphics_card = None

    def __str__(self):
        parts = []
        if self.cpu:
            parts.append(f"CPU: {self.cpu}")
        if self.ram:
            parts.append(f"RAM: {self.ram}")
        if self.storage:
            parts.append(f"Storage: {self.storage}")
        if self.graphics_card:
            parts.append(f"Graphics Card: {self.graphics_card}")
        return "\n".join(parts)


# 抽象建造者类
class ComputerBuilder:
    def build_cpu(self):
        pass

    def build_ram(self):
        pass

    def build_storage(self):
        pass

    def build_graphics_card(self):
        pass

    def get_computer(self):
        pass


# 具体建造者类 - 游戏计算机建造者
class GamingComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.computer = Computer()

    def build_cpu(self):
        self.computer.cpu = "High - performance CPU for gaming"

    def build_ram(self):
        self.computer.ram = "32GB DDR4 RAM"

    def build_storage(self):
        self.computer.storage = "1TB SSD for fast loading"

    def build_graphics_card(self):
        self.computer.graphics_card = "High - end graphics card"

    def get_computer(self):
        return self.computer


# 具体建造者类 - 办公计算机建造者
class OfficeComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.computer = Computer()

    def build_cpu(self):
        self.computer.cpu = "Standard office - use CPU"

    def build_ram(self):
        self.computer.ram = "8GB DDR4 RAM"

    def build_storage(self):
        self.computer.storage = "500GB HDD"

    def build_graphics_card(self):
        self.computer.graphics_card = "Integrated graphics"

    def get_computer(self):
        return self.computer


# 指挥者类
class ComputerDirector:
    def __init__(self, builder):
        self.builder = builder

    def construct_computer(self):
        self.builder.build_cpu()
        self.builder.build_ram()
        self.builder.build_storage()
        self.builder.build_graphics_card()
        return self.builder.get_computer()


# 使用示例
if __name__ == "__main__":
    gaming_computer_builder = GamingComputerBuilder()
    computer_director = ComputerDirector(gaming_computer_builder)
    gaming_computer = computer_director.construct_computer()
    print(gaming_computer)

    office_computer_builder = OfficeComputerBuilder()
    computer_director = ComputerDirector(office_computer_builder)
    office_computer = computer_director.construct_computer()
    print(office_computer)

3. 构建过程的复用 - 构建不同风格的房屋

# 产品类：房屋
class House:
    def __init__(self):
        self.foundation = None
        self.walls = None
        self.roof = None
        self.doors = None

    def __str__(self):
        parts = []
        if self.foundation:
            parts.append(f"Foundation: {self.foundation}")
        if self.walls:
            parts.append(f"Walls: {self.walls}")
        if self.roof:
            parts.append(f"Roof: {self.roof}")
        if self.doors:
            parts.append(f"Doors: {self.doors}")
        return "\n".join(parts)


# 抽象建造者类
class HouseBuilder:
    def build_foundation(self):
        pass

    def build_walls(self):
        pass

    def build_roof(self):
        pass

    def build_doors(self):
        pass

    def get_house(self):
        pass


# 具体建造者类 - 现代风格房屋建造者
class ModernHouseBuilder(HouseBuilder):
    def __init__(self):
        self.house = House()

    def build_foundation(self):
        self.house.foundation = "Concrete foundation"

    def build_walls(self):
        self.house.walls = "Glass and steel walls"

    def build_roof(self):
        self.house.roof = "Flat roof"

    def build_doors(self):
        self.house.doors = "Sliding glass doors"

    def get_house(self):
        return self.house


# 具体建造者类 - 传统风格房屋建造者
class TraditionalHouseBuilder(HouseBuilder):
    def __init__(self):
        self.house = House()

    def build_foundation(self):
        self.house.foundation = "Stone foundation"

    def build_walls(self):
        self.house.walls = "Brick walls"

    def build_roof(self):
        self.house.roof = "Pitched roof"

    def build_doors(self):
        self.house.doors = "Wooden doors"

    def get_house(self):
        return self.house


# 指挥者类
class HouseDirector:
    def __init__(self, builder):
        self.builder = builder

    def construct_house(self):
        self.builder.build_foundation()
        self.builder.build_walls()
        self.builder.build_roof()
        self.builder.build_doors()
        return self.builder.get_house()


# 使用示例
if __name__ == "__main__":
    modern_house_builder = ModernHouseBuilder()
    house_director = HouseDirector(modern_house_builder)
    modern_house = house_director.construct_house()
    print(modern_house)

    traditional_house_builder = TraditionalHouseBuilder()
    house_director = HouseDirector(traditional_house_builder)
    traditional_house = house_director.construct_house()
    print(traditional_house)

五、与其他模式的对比

1. 与工厂模式的对比

工厂模式：主要关注对象的创建过程，根据不同的输入创建不同类型的对象。工厂模式重点在于对象的实例化，通常是创建一个完整的对象并直接返回给调用者。例如，一个汽车工厂根据订单类型生产不同型号的汽车（如轿车、SUV 等），每个型号的汽车是一个完整的产品。
建造者模式：侧重于复杂对象的构建过程，将对象的构建和表示分离。它可以逐步构建对象的各个部分，并且可以通过不同的构建顺序或者配置得到不同表示的同一类型对象。比如在建造汽车时，它更关注汽车各个部件（引擎、车身、轮胎等）的构建过程以及如何组合这些部件来得到不同类型的汽车（高性能汽车、经济实惠型汽车等）。

2. 与原型模式的对比

原型模式：通过复制现有对象来创建新的对象。如果创建一个对象的成本较高（例如对象的初始化过程涉及大量计算或者资源获取），可以使用原型模式来快速创建相似的对象。而建造者模式则是通过逐步构建对象的各个部分来创建对象，不涉及对象的复制操作。

六、总结

Python 中的建造者模式是一种强大的创建型设计模式，它通过将复杂对象的构建过程与表示分离，提供了一种灵活、可复用且易于维护的方式来创建复杂对象。通过产品类、抽象建造者类、具体建造者类和指挥者类的协同工作，可以根据不同的需求构建出各种不同配置和特性的复杂对象。在面对复杂对象的构建场景时，考虑使用建造者模式可以提高代码的质量和可维护性，同时也有助于应对对象构建过程中的复杂性和多样性需求。