设计模式——工厂方法模式

工厂方法模式简介

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让一个类的实例化延迟到其子类。

工厂方法模式的组成部分

1. 产品（Product）：定义工厂方法所创建对象的接口。
2. 具体产品（ConcreteProduct）：实现产品接口的具体类。
3. 创建者（Creator）：声明工厂方法，该方法返回一个产品类型的对象。创建者的子类通常会提供这个工厂方法的实现。
4. 具体创建者（ConcreteCreator）：实现工厂方法，返回具体产品实例。

工厂方法模式的结构

from abc import ABC, abstractmethod

# 产品接口
class Product(ABC):
    @abstractmethod
    def use(self):
        pass

# 具体产品
class ConcreteProductA(Product):
    def use(self):
        return "Using Product A"

class ConcreteProductB(Product):
    def use(self):
        return "Using Product B"

# 创建者
class Creator(ABC):
    @abstractmethod
    def factory_method(self) -> Product:
        pass

    def some_operation(self) -> str:
        product = self.factory_method()
        result = f"Creator: The same creator's code has just worked with {product.use()}"
        return result

# 具体创建者
class ConcreteCreatorA(Creator):
    def factory_method(self) -> Product:
        return ConcreteProductA()

class ConcreteCreatorB(Creator):
    def factory_method(self) -> Product:
        return ConcreteProductB()

# 使用工厂方法
def client_code(creator: Creator) -> None:
    print(f"Client: I'm not aware of the creator's class, but it still works.\n{creator.some_operation()}")

print("App: Launched with ConcreteCreatorA.")
client_code(ConcreteCreatorA())

print("\nApp: Launched with ConcreteCreatorB.")
client_code(ConcreteCreatorB())

Factory和Method的含义

• Factory（工厂）：在工厂方法模式中，"工厂"指的是负责创建对象的角色。具体来说，工厂是一个方法，它提供对象的创建逻辑。这个方法由抽象创建者声明，具体创建者实现。

• Method（方法）：工厂方法是一个方法（函数），这个方法的职责是创建并返回一个产品对象的实例。工厂方法模式中的"方法"强调的是通过这个方法来进行对象的创建，而不是直接调用构造函数。

工厂方法模式的应用场景

1. 需要生成不同类型的对象：当系统需要生成不同类型或不同配置的对象时，可以使用工厂方法模式来实现对象的创建。
2. 客户端不需要知道所创建对象的具体类：客户端通过工厂方法来获取对象的实例，而不需要知道具体的实现类。
3. 系统的产品类较为复杂且易变：当产品类的创建逻辑复杂或容易发生变化时，工厂方法模式可以将创建逻辑封装在子类中，使得主类代码简洁且稳定。

工厂方法模式的示例

1. 文档生成器

假设我们有一个文档生成系统，可以生成不同格式的文档，例如 PDF 和 Word 文档。我们可以使用工厂方法模式来创建具体的文档生成器。

from abc import ABC, abstractmethod

class Document(ABC):
    @abstractmethod
    def save(self):
        pass

class PDFDocument(Document):
    def save(self):
        return "Saving as PDF"

class WordDocument(Document):
    def save(self):
        return "Saving as Word"

class DocumentCreator(ABC):
    @abstractmethod
    def create_document(self) -> Document:
        pass

class PDFCreator(DocumentCreator):
    def create_document(self) -> Document:
        return PDFDocument()

class WordCreator(DocumentCreator):
    def create_document(self) -> Document:
        return WordDocument()

def client_code(creator: DocumentCreator):
    document = creator.create_document()
    print(document.save())

print("Client: Creating a PDF document.")
client_code(PDFCreator())

print("\nClient: Creating a Word document.")
client_code(WordCreator())

2. 数据库连接

假设我们有一个应用程序，可以连接到不同类型的数据库，例如 MySQL 和 PostgreSQL。我们可以使用工厂方法模式来创建具体的数据库连接器。

from abc import ABC, abstractmethod

class DatabaseConnection(ABC):
    @abstractmethod
    def connect(self):
        pass

class MySQLConnection(DatabaseConnection):
    def connect(self):
        return "Connecting to MySQL"

class PostgreSQLConnection(DatabaseConnection):
    def connect(self):
        return "Connecting to PostgreSQL"

class DatabaseCreator(ABC):
    @abstractmethod
    def create_connection(self) -> DatabaseConnection:
        pass

class MySQLCreator(DatabaseCreator):
    def create_connection(self) -> DatabaseConnection:
        return MySQLConnection()

class PostgreSQLCreator(DatabaseCreator):
    def create_connection(self) -> DatabaseConnection:
        return PostgreSQLConnection()

def client_code(creator: DatabaseCreator):
    connection = creator.create_connection()
    print(connection.connect())

print("Client: Connecting to MySQL database.")
client_code(MySQLCreator())

print("\nClient: Connecting to PostgreSQL database.")
client_code(PostgreSQLCreator())

通过使用工厂方法模式，我们将对象的创建过程与使用过程分离，使得代码更加灵活和可扩展。不同的具体创建者类实现不同的创建逻辑，使得系统可以方便地扩展和维护。