当前位置：首页 > news >正文

Python设计模式-抽象工厂模式

news 2025/7/1 14:38:08

在这里插入图片描述

1. 什么是抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种方式来创建一系列相关或相互依赖的对象，而无需指定它们具体的类。这种模式是所有形式的工厂模式中最为抽象和最具一般性的一种。

1.1 核心概念

抽象工厂：声明一组创建一系列产品对象的方法
具体工厂：实现抽象工厂的接口，创建具体的产品对象
抽象产品：为每种产品声明接口
具体产品：实现抽象产品接口的具体类

2. 为什么需要抽象工厂模式

2.1 解决的问题

系统独立性：当一个系统需要独立于它的产品的创建、组合和表示时
产品族一致性：当一个系统需要配置多个产品族中的一个时
产品约束：当需要强调一系列相关产品对象的设计以便进行联合使用时
隐藏实现：当希望只提供产品的接口而不是实现时

2.2 优点

隔离了具体类的生成
易于交换产品系列
保证产品族的一致性
符合开闭原则（对扩展开放，对修改关闭）

2.3 缺点

难以支持新种类的产品
增加了系统的抽象性和理解难度

3. Python实现抽象工厂模式

3.1 基本实现示例

from abc import ABC, abstractmethod

# 抽象产品A
class AbstractProductA(ABC):
    @abstractmethod
    def useful_function_a(self) -> str:
        pass

# 具体产品A1
class ConcreteProductA1(AbstractProductA):
    def useful_function_a(self) -> str:
        return "The result of the product A1."

# 具体产品A2
class ConcreteProductA2(AbstractProductA):
    def useful_function_a(self) -> str:
        return "The result of the product A2."

# 抽象产品B
class AbstractProductB(ABC):
    @abstractmethod
    def useful_function_b(self) -> str:
        pass

    @abstractmethod
    def another_useful_function_b(self, collaborator: AbstractProductA) -> str:
        pass

# 具体产品B1
class ConcreteProductB1(AbstractProductB):
    def useful_function_b(self) -> str:
        return "The result of the product B1."

    def another_useful_function_b(self, collaborator: AbstractProductA) -> str:
        result = collaborator.useful_function_a()
        return f"The result of the B1 collaborating with the ({result})"

# 具体产品B2
class ConcreteProductB2(AbstractProductB):
    def useful_function_b(self) -> str:
        return "The result of the product B2."

    def another_useful_function_b(self, collaborator: AbstractProductA) -> str:
        result = collaborator.useful_function_a()
        return f"The result of the B2 collaborating with the ({result})"

# 抽象工厂
class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self) -> AbstractProductA:
        pass

    @abstractmethod
    def create_product_b(self) -> AbstractProductB:
        pass

# 具体工厂1
class ConcreteFactory1(AbstractFactory):
    def create_product_a(self) -> AbstractProductA:
        return ConcreteProductA1()

    def create_product_b(self) -> AbstractProductB:
        return ConcreteProductB1()

# 具体工厂2
class ConcreteFactory2(AbstractFactory):
    def create_product_a(self) -> AbstractProductA:
        return ConcreteProductA2()

    def create_product_b(self) -> AbstractProductB:
        return ConcreteProductB2()

# 客户端代码
def client_code(factory: AbstractFactory) -> None:
    product_a = factory.create_product_a()
    product_b = factory.create_product_b()

    print(f"{product_b.useful_function_b()}")
    print(f"{product_b.another_useful_function_b(product_a)}", end="")

if __name__ == "__main__":
    print("Client: Testing client code with the first factory type:")
    client_code(ConcreteFactory1())

    print("\n")

    print("Client: Testing the same client code with the second factory type:")
    client_code(ConcreteFactory2())

3.2 更实际的例子：UI组件工厂

from abc import ABC, abstractmethod

# 抽象产品：按钮
class Button(ABC):
    @abstractmethod
    def render(self):
        pass

    @abstractmethod
    def on_click(self):
        pass

# 具体产品：Windows按钮
class WindowsButton(Button):
    def render(self):
        print("Rendering a Windows style button")

    def on_click(self):
        print("Windows button clicked")

# 具体产品：MacOS按钮
class MacOSButton(Button):
    def render(self):
        print("Rendering a MacOS style button")

    def on_click(self):
        print("MacOS button clicked")

# 抽象产品：复选框
class Checkbox(ABC):
    @abstractmethod
    def render(self):
        pass

    @abstractmethod
    def on_check(self):
        pass

# 具体产品：Windows复选框
class WindowsCheckbox(Checkbox):
    def render(self):
        print("Rendering a Windows style checkbox")

    def on_check(self):
        print("Windows checkbox checked")

# 具体产品：MacOS复选框
class MacOSCheckbox(Checkbox):
    def render(self):
        print("Rendering a MacOS style checkbox")

    def on_check(self):
        print("MacOS checkbox checked")

# 抽象工厂
class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass

    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

# 具体工厂：Windows工厂
class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        return WindowsButton()

    def create_checkbox(self) -> Checkbox:
        return WindowsCheckbox()

# 具体工厂：MacOS工厂
class MacOSFactory(GUIFactory):
    def create_button(self) -> Button:
        return MacOSButton()

    def create_checkbox(self) -> Checkbox:
        return MacOSCheckbox()

# 应用类
class Application:
    def __init__(self, factory: GUIFactory):
        self.factory = factory
        self.button = None
        self.checkbox = None

    def create_ui(self):
        self.button = self.factory.create_button()
        self.checkbox = self.factory.create_checkbox()

    def paint(self):
        self.button.render()
        self.checkbox.render()

# 客户端代码
def configure_application(os_type: str) -> Application:
    factory = None
    if os_type == "windows":
        factory = WindowsFactory()
    elif os_type == "macos":
        factory = MacOSFactory()
    else:
        raise ValueError(f"Unknown OS type: {os_type}")
    
    app = Application(factory)
    app.create_ui()
    return app

if __name__ == "__main__":
    print("Creating Windows UI:")
    windows_app = configure_application("windows")
    windows_app.paint()

    print("\nCreating MacOS UI:")
    macos_app = configure_application("macos")
    macos_app.paint()

4. 抽象工厂模式与工厂方法模式的区别

特性	抽象工厂模式	工厂方法模式
抽象级别	更高层次的抽象	相对较低层次的抽象
产品创建	创建产品族（多个相关产品）	创建单一产品
扩展性	难以添加新产品种类	易于添加新产品
使用场景	需要确保产品兼容性	需要解耦具体产品创建逻辑
类结构	更复杂	相对简单