在Python项目开发中，对象创建是常见的操作，但当需要创建的对象类型较多、创建逻辑复杂时，直接在业务代码中调用构造方法会导致代码冗余、耦合度高的问题。工厂模式通过将对象创建的逻辑封装到独立的工厂类中，让调用方只需要传入对应的参数就能获取所需的对象，有效优化了对象创建的流程。
工厂模式的核心作用
工厂模式的核心价值在于将对象的创建和使用分离，主要能带来三个方面的优化：
- 降低代码耦合度：调用方不需要依赖具体对象的构造方法，只需要和工厂类交互
- 提升代码可维护性：对象创建逻辑集中管理，修改创建规则时不需要改动所有调用点
- 增强扩展性：新增对象类型时只需要新增对应的产品类和工厂逻辑，符合开闭原则
简单工厂模式实现
简单工厂模式是最基础的工厂实现形式，通过一个工厂类根据传入的参数判断需要创建的对象类型，适合对象类型较少、创建逻辑简单的场景。
实现示例
以创建不同类型的日志处理器为例，首先定义统一的日志处理器抽象基类：
from abc import ABC, abstractmethod
# 抽象产品类
class LogHandler(ABC):
@abstractmethod
def write_log(self, content):
pass
然后定义两种具体的日志处理器实现：
# 具体产品类：文件日志处理器
class FileLogHandler(LogHandler):
def write_log(self, content):
print(f"将日志内容写入文件：{content}")
# 具体产品类：控制台日志处理器
class ConsoleLogHandler(LogHandler):
def write_log(self, content):
print(f"向控制台输出日志：{content}")
接下来实现简单工厂类，根据传入的类型参数返回对应的日志处理器实例：
# 简单工厂类
class LogHandlerFactory:
@staticmethod
def create_handler(handler_type):
if handler_type == "file":
return FileLogHandler()
elif handler_type == "console":
return ConsoleLogHandler()
else:
raise ValueError(f"不支持的日志处理器类型：{handler_type}")
调用方使用工厂获取对象的代码如下：
# 调用示例
if __name__ == "__main__":
# 获取文件日志处理器
file_handler = LogHandlerFactory.create_handler("file")
file_handler.write_log("这是一条文件日志")
# 获取控制台日志处理器
console_handler = LogHandlerFactory.create_handler("console")
console_handler.write_log("这是一条控制台日志")
工厂方法模式实现
当对象类型较多、创建逻辑复杂时，简单工厂的工厂类会变得臃肿，不符合单一职责原则。工厂方法模式将每个产品对象的创建逻辑拆分到对应的子工厂中，每个子工厂只负责创建一种产品对象。
实现示例
同样以日志处理器为例，首先定义抽象工厂类：
# 抽象工厂类
class LogHandlerFactory(ABC):
@abstractmethod
def create_handler(self):
pass
然后为每个产品类实现对应的子工厂：
# 文件日志处理器工厂
class FileLogHandlerFactory(LogHandlerFactory):
def create_handler(self):
return FileLogHandler()
# 控制台日志处理器工厂
class ConsoleLogHandlerFactory(LogHandlerFactory):
def create_handler(self):
return ConsoleLogHandler()
调用方使用工厂的代码如下：
# 调用示例
if __name__ == "__main__":
# 使用文件日志工厂获取处理器
file_factory = FileLogHandlerFactory()
file_handler = file_factory.create_handler()
file_handler.write_log("工厂方法模式下的文件日志")
# 使用控制台日志工厂获取处理器
console_factory = ConsoleLogHandlerFactory()
console_handler = console_factory.create_handler()
console_handler.write_log("工厂方法模式下的控制台日志")
抽象工厂模式实现
如果需要创建一组相关的对象（比如不同数据库的连接器和操作器），抽象工厂模式可以定义创建一族产品对象的接口，让子工厂负责实现整族产品的创建逻辑。
实现示例
以创建不同数据库的组件为例，首先定义两族抽象产品：
# 抽象产品族：数据库连接
class DBConnection(ABC):
@abstractmethod
def connect(self):
pass
# 抽象产品族：数据库操作器
class DBOperator(ABC):
@abstractmethod
def query(self, sql):
pass
然后定义MySQL和PostgreSQL两种数据库的具体产品实现：
# MySQL相关产品
class MySQLConnection(DBConnection):
def connect(self):
print("建立MySQL数据库连接")
class MySQLOperator(DBOperator):
def query(self, sql):
print(f"执行MySQL查询：{sql}")
# PostgreSQL相关产品
class PostgreSQLConnection(DBConnection):
def connect(self):
print("建立PostgreSQL数据库连接")
class PostgreSQLOperator(DBOperator):
def query(self, sql):
print(f"执行PostgreSQL查询：{sql}")
定义抽象工厂类，包含创建整族产品的接口：
# 抽象工厂类
class DBFactory(ABC):
@abstractmethod
def create_connection(self):
pass
@abstractmethod
def create_operator(self):
pass
实现两种数据库的具体工厂：
# MySQL工厂
class MySQLFactory(DBFactory):
def create_connection(self):
return MySQLConnection()
def create_operator(self):
return MySQLOperator()
# PostgreSQL工厂
class PostgreSQLFactory(DBFactory):
def create_connection(self):
return PostgreSQLConnection()
def create_operator(self):
return PostgreSQLOperator()
调用方使用抽象工厂的代码如下：
# 调用示例
if __name__ == "__main__":
# 使用MySQL工厂创建整套组件
mysql_factory = MySQLFactory()
mysql_conn = mysql_factory.create_connection()
mysql_op = mysql_factory.create_operator()
mysql_conn.connect()
mysql_op.query("SELECT * FROM users")
# 使用PostgreSQL工厂创建整套组件
pg_factory = PostgreSQLFactory()
pg_conn = pg_factory.create_connection()
pg_op = pg_factory.create_operator()
pg_conn.connect()
pg_op.query("SELECT * FROM orders")
三种工厂模式的选择建议
实际开发中可以根据场景选择合适的工厂模式：
- 如果对象类型少、创建逻辑简单，优先选择简单工厂模式，实现成本低
- 如果对象类型多、后续可能频繁新增类型，选择工厂方法模式，扩展性更好
- 如果需要创建一组关联的对象，选择抽象工厂模式，保证产品族的兼容性
通过合理运用工厂模式，能够有效优化Python项目中的对象创建流程，让代码结构更清晰，后期维护成本更低。