工厂方法模式深度解析：将对象创建的复杂性封装起来
在软件开发中，我们经常需要创建各种对象。传统的做法是直接使用 new 关键字来实例化具体类，但这种方式往往会导致代码耦合度高、难以扩展和维护。工厂方法模式正是为了解决这一问题而诞生的。
什么是工厂方法模式
工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个创建对象的接口，但让子类决定要实例化哪一个类。工厂方法让类的实例化推迟到子类进行。
核心思想
工厂方法模式的核心思想是：将对象创建的职责封装起来，交由专门的工厂类负责。这样做的最大好处是，当需要添加新的产品类型时，不需要修改现有的客户端代码，只需要扩展新的工厂子类即可。
工厂方法模式的结构
工厂方法模式包含以下几个主要角色：
- 产品（Product）：定义产品的接口
- 具体产品（Concrete Product）：实现产品接口的具体类
- 创建者（Creator）：声明工厂方法，返回产品对象
- 具体创建者（Concrete Creator）：重写工厂方法，返回具体产品实例
UML类图
┌─────────────┐ ┌─────────────┐
│ Product │ │ Creator │
├─────────────┤ ├─────────────┤
│ +operation()│ │ +factoryMethod()│
└─────────────┘ │ +someOperation()│
△ └─────────────┘
│ △
┌─────────────┐ │
│ConcreteProduct│ ┌─────────────┐
├─────────────┤ │ConcreteCreator│
│ +operation()│ ├─────────────┤
└─────────────┘ │ +factoryMethod()│
└─────────────┘
实际应用场景
场景一：日志记录器
假设我们需要开发一个日志系统，支持多种日志输出方式（文件、数据库、控制台等）。使用工厂方法模式可以优雅地实现这一需求。
// 产品接口
public interface Logger {
void log(String message);
}
// 具体产品
public class FileLogger implements Logger {
@Override
public void log(String message) {
System.out.println("文件日志: " + message);
}
}
public class DatabaseLogger implements Logger {
@Override
public void log(String message) {
System.out.println("数据库日志: " + message);
}
}
public class ConsoleLogger implements Logger {
@Override
public void log(String message) {
System.out.println("控制台日志: " + message);
}
}
// 创建者抽象类
public abstract class LoggerFactory {
// 工厂方法
public abstract Logger createLogger();
// 业务方法
public void writeLog(String message) {
Logger logger = createLogger();
logger.log(message);
}
}
// 具体创建者
public class FileLoggerFactory extends LoggerFactory {
@Override
public Logger createLogger() {
return new FileLogger();
}
}
public class DatabaseLoggerFactory extends LoggerFactory {
@Override
public Logger createLogger() {
return new DatabaseLogger();
}
}
public class ConsoleLoggerFactory extends LoggerFactory {
@Override
public Logger createLogger() {
return new ConsoleLogger();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
LoggerFactory factory = new FileLoggerFactory();
factory.writeLog("这是一个测试日志");
// 切换日志类型只需要更换工厂类
factory = new DatabaseLoggerFactory();
factory.writeLog("这是另一个测试日志");
}
}
场景二：数据库连接工厂
在数据库操作中，我们经常需要连接不同类型的数据库。工厂方法模式可以帮助我们创建统一的数据库连接接口。
// 数据库连接接口
public interface Connection {
void connect();
void execute(String sql);
void disconnect();
}
// 具体数据库连接
public class MySQLConnection implements Connection {
@Override
public void connect() {
System.out.println("连接MySQL数据库");
}
@Override
public void execute(String sql) {
System.out.println("MySQL执行: " + sql);
}
@Override
public void disconnect() {
System.out.println("断开MySQL连接");
}
}
public class PostgreSQLConnection implements Connection {
@Override
public void connect() {
System.out.println("连接PostgreSQL数据库");
}
@Override
public void execute(String sql) {
System.out.println("PostgreSQL执行: " + sql);
}
@Override
public void disconnect() {
System.out.println("断开PostgreSQL连接");
}
}
// 数据库连接工厂
public abstract class ConnectionFactory {
public abstract Connection createConnection();
public void executeQuery(String sql) {
Connection connection = createConnection();
connection.connect();
connection.execute(sql);
connection.disconnect();
}
}
// 具体工厂
public class MySQLConnectionFactory extends ConnectionFactory {
@Override
public Connection createConnection() {
return new MySQLConnection();
}
}
public class PostgreSQLConnectionFactory extends ConnectionFactory {
@Override
public Connection createConnection() {
return new PostgreSQLConnection();
}
}
工厂方法模式的变体
参数化工厂方法
有时候，我们可以通过参数来决定创建哪种产品，这样可以减少工厂类的数量。
public class UniversalLoggerFactory extends LoggerFactory {
private String loggerType;
public UniversalLoggerFactory(String loggerType) {
this.loggerType = loggerType;
}
@Override
public Logger createLogger() {
switch (loggerType.toLowerCase()) {
case "file":
return new FileLogger();
case "database":
return new DatabaseLogger();
case "console":
return new ConsoleLogger();
default:
throw new IllegalArgumentException("不支持的日志类型: " + loggerType);
}
}
}
使用反射的工厂方法
在某些语言中，我们可以利用反射机制来进一步简化工厂方法的实现。
public class ReflectionLoggerFactory extends LoggerFactory {
private Class<? extends Logger> loggerClass;
public ReflectionLoggerFactory(Class<? extends Logger> loggerClass) {
this.loggerClass = loggerClass;
}
@Override
public Logger createLogger() {
try {
return loggerClass.newInstance();
} catch (Exception e) {
throw new RuntimeException("创建日志器失败", e);
}
}
}
工厂方法模式的优点
- 封装性好：客户端只需要关心产品接口，不需要知道具体实现类的细节
- 扩展性强：添加新的产品类型时，只需要添加新的工厂子类，符合开闭原则
- 解耦合：将产品类的实例化操作与使用操作分离，降低了系统的耦合度
- 符合单一职责原则：将创建逻辑集中在工厂类中，便于维护
工厂方法模式的缺点
- 类的数量增加：每增加一个产品，就需要增加一个对应的工厂类，增加了系统的复杂度
- 增加了系统的抽象性：理解和使用都需要一定的学习成本
- 抽象层设计困难：如果产品接口设计不合理，后续的扩展会变得困难
工厂方法模式与简单工厂模式的区别
很多初学者容易混淆工厂方法模式和简单工厂模式，它们的主要区别在于：
- 简单工厂模式：由一个工厂类根据传入的参数决定创建哪种产品
- 工厂方法模式：将创建逻辑交给子类，父类只定义创建接口
简单工厂模式违背了开闭原则，而工厂方法模式则很好地遵循了这一原则。
实际项目中的应用
在Spring框架中，工厂方法模式被广泛应用。最典型的就是 BeanFactory 和 ApplicationContext，它们使用工厂方法模式来创建和管理Bean对象。
// Spring中的工厂方法模式示例
@Configuration
public class AppConfig {
@Bean
public DataSource dataSource() {
// 返回具体的数据源实例
return new HikariDataSource();
}
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
// 使用工厂方法创建JdbcTemplate
return new JdbcTemplate(dataSource);
}
}
总结
工厂方法模式是一种非常实用的创建型设计模式，它通过将对象创建的职责委托给子类，实现了创建逻辑与使用逻辑的分离。这种模式特别适用于以下场景：
- 一个类无法预知它必须创建的对象的类
- 一个类希望由其子类来指定它所创建的对象
- 类将创建对象的职责委托给多个帮助子类中的某一个
掌握工厂方法模式，能够让你的代码更加灵活、可扩展，也更容易维护。在实际开发中，要根据具体需求合理选择使用简单工厂模式还是工厂方法模式，避免过度设计。
希望通过本文的介绍，你能对工厂方法模式有更深入的理解，并能在实际项目中灵活运用这一强大的设计模式。