工厂方法模式简介
工厂方法模式(Factory Method Pattern)是一种创建型设计模式,它定义了一个用于创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法让一个类的实例化延迟到其子类。
工厂方法模式的组成部分
- 产品(Product):定义工厂方法所创建对象的接口。
- 具体产品(ConcreteProduct):实现产品接口的具体类。
- 创建者(Creator):声明工厂方法,该方法返回一个产品类型的对象。创建者的子类通常会提供这个工厂方法的实现。
- 具体创建者(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. 文档生成器
假设我们有一个文档生成系统,可以生成不同格式的文档,例如 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())
通过使用工厂方法模式,我们将对象的创建过程与使用过程分离,使得代码更加灵活和可扩展。不同的具体创建者类实现不同的创建逻辑,使得系统可以方便地扩展和维护。