工厂方法模式 (Factory Method Pattern) 在Spring Boot 中的应用场景

在 Spring Boot 日常开发中，工厂方法模式（Factory Method Pattern）的应用场景非常多，它可以帮助我们优雅地创建对象，解耦对象创建逻辑，提高代码的可维护性和可扩展性。下面我将详细列举几个典型的应用场景，并提供具体的代码示例。

场景一： 创建不同类型的日志记录器 (Logger)

假设你的 Spring Boot 应用需要支持多种日志记录方式，例如：

• 控制台日志 (Console Logger)
• 文件日志 (File Logger)
• 数据库日志 (Database Logger)
• 远程日志 (Remote Logger，例如发送到 Logstash 或 Kafka)

你可以使用工厂方法模式来创建不同类型的 Logger 对象。

1. 定义 Logger 接口：

public interface Logger {void log(String message);
}

2. 创建具体的 Logger 实现类：

// 控制台日志
public class ConsoleLogger implements Logger {@Overridepublic void log(String message) {System.out.println("[Console] " + message);}
}// 文件日志
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;public class FileLogger implements Logger {private final String logFilePath;public FileLogger(String logFilePath) {this.logFilePath = logFilePath;}@Overridepublic void log(String message) {try (PrintWriter writer = new PrintWriter(new FileWriter(logFilePath, true))) {writer.println("[File] " + message);} catch (IOException e) {e.printStackTrace();}}
}// 数据库日志 (示例，省略具体数据库操作)
public class DatabaseLogger implements Logger {@Overridepublic void log(String message) {System.out.println("[Database] " + message); // 实际应用中会写入数据库// ... 数据库写入逻辑 ...}
}

3. 定义 Logger 工厂接口：

public interface LoggerFactory {Logger createLogger();
}

4. 创建具体的 Logger 工厂类：

// 控制台日志工厂
public class ConsoleLoggerFactory implements LoggerFactory {@Overridepublic Logger createLogger() {return new ConsoleLogger();}
}// 文件日志工厂
public class FileLoggerFactory implements LoggerFactory {private final String logFilePath;public FileLoggerFactory(String logFilePath) {this.logFilePath = logFilePath;}@Overridepublic Logger createLogger() {return new FileLogger(logFilePath);}
}// 数据库日志工厂
public class DatabaseLoggerFactory implements LoggerFactory {@Overridepublic Logger createLogger() {return new DatabaseLogger();}
}

5. 在 Spring Boot 中配置和使用：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@SpringBootApplication
public class LoggerFactoryExampleApplication implements CommandLineRunner {// 使用 @Qualifier 注解指定要注入的 LoggerFactory 实现@Autowired@Qualifier("fileLoggerFactory") // 或者 "consoleLoggerFactory", "databaseLoggerFactory"private LoggerFactory loggerFactory;public static void main(String[] args) {SpringApplication.run(LoggerFactoryExampleApplication.class, args);}@Overridepublic void run(String... args) throws Exception {Logger logger = loggerFactory.createLogger(); // 通过工厂创建 Loggerlogger.log("This is a log message.");}
}@Configuration
class AppConfig {// 将 LoggerFactory 的实现类注册为 Spring Bean@Beanpublic LoggerFactory fileLoggerFactory() {return new FileLoggerFactory("app.log"); // 指定日志文件路径}@Beanpublic LoggerFactory consoleLoggerFactory() {return new ConsoleLoggerFactory();}@Beanpublic LoggerFactory databaseLoggerFactory() {return new DatabaseLoggerFactory();}
}

解释：

• 我们定义了 Logger 接口和三个具体的 Logger 实现类。
• 我们定义了 LoggerFactory 接口和三个具体的 LoggerFactory 实现类，分别用于创建不同类型的 Logger。
• 在 Spring Boot 配置类 (AppConfig) 中，我们使用 @Bean 注解将 FileLoggerFactory 注册为 Spring Bean。
• 在 LoggerFactoryExampleApplication 中，我们通过 @Autowired 和 @Qualifier 注解注入 LoggerFactory 的实例（这里注入的是 FileLoggerFactory）。
• 在 run 方法中，我们通过 loggerFactory.createLogger() 方法创建 Logger 对象，并调用其 log() 方法。

好处：

• 解耦： 应用程序代码不依赖于具体的 Logger 实现类，而是依赖于 Logger 接口和 LoggerFactory 接口。
• 可扩展： 如果要添加新的日志记录方式（例如，发送到远程日志服务器），只需要创建一个新的 Logger 实现类和一个对应的 LoggerFactory 实现类，并在 Spring Boot 配置中注册新的 LoggerFactory Bean 即可，无需修改现有代码。
• 可配置： 可以通过配置文件或 @Qualifier 注解轻松切换不同的 Logger 实现。

场景二： 创建不同类型的支付方式 (Payment Method)

假设你的电商应用需要支持多种支付方式，例如：

• 支付宝支付 (Alipay)
• 微信支付 (WeChat Pay)
• 银联支付 (UnionPay)

你可以使用工厂方法模式来创建不同类型的 Payment 对象。

1. 定义 Payment 接口：

public interface Payment {void pay(double amount);
}

2. 创建具体的 Payment 实现类：

// 支付宝支付
public class Alipay implements Payment {@Overridepublic void pay(double amount) {System.out.println("Paying " + amount + " via Alipay...");// ... 支付宝支付的具体逻辑 ...}
}// 微信支付
public class WeChatPay implements Payment {@Overridepublic void pay(double amount) {System.out.println("Paying " + amount + " via WeChat Pay...");// ... 微信支付的具体逻辑 ...}
}

3. 定义 Payment 工厂接口：

public interface PaymentFactory {Payment createPayment();
}

4. 创建具体的 Payment 工厂类：

// 支付宝支付工厂
public class AlipayFactory implements PaymentFactory {@Overridepublic Payment createPayment() {return new Alipay();}
}// 微信支付工厂
public class WeChatPayFactory implements PaymentFactory {@Overridepublic Payment createPayment() {return new WeChatPay();}
}

5. 在 Spring Boot 中配置和使用：
类似于Logger的例子，此处省略。 只需把Logger替换成Payment即可。

场景三： 创建不同类型的数据库连接 (Database Connection)

• 定义 Connection 接口，表示数据库连接。
• 创建不同的 Connection 实现类，例如 MySQLConnection, PostgreSQLConnection, OracleConnection。
• 定义 ConnectionFactory 接口，包含 createConnection() 方法。
• 创建不同的 ConnectionFactory 实现类，例如 MySQLConnectionFactory, PostgreSQLConnectionFactory, OracleConnectionFactory，分别用于创建不同类型的数据库连接。
• 在Spring Boot中使用@Configuration和 @Bean将具体的ConnectionFactory注册为Bean.

场景四： 创建不同类型的消息发送器 (Message Sender)

• 定义 MessageSender 接口，表示消息发送器。
• 创建不同的 MessageSender 实现类，例如 EmailSender, SmsSender, WeChatSender。
• 定义 MessageSenderFactory 接口，包含 createSender() 方法。
• 创建不同的 MessageSenderFactory 实现类，例如 EmailSenderFactory, SmsSenderFactory, WeChatSenderFactory，分别用于创建不同类型的消息发送器。
• 在Spring Boot中使用@Configuration和 @Bean将具体的MessageSenderFactory注册为Bean.

总结

工厂方法模式在 Spring Boot 日常开发中非常有用，它可以应用于各种需要创建不同类型对象的场景。 通过使用工厂方法模式，你可以：

• 解耦对象的创建逻辑和使用逻辑。
• 提高代码的可维护性和可扩展性。
• 轻松地切换不同的对象实现。
• 符合开闭原则。

在 Spring Boot 中，我们可以结合 Spring 的依赖注入、@Configuration 和 @Bean 注解，更方便地使用工厂方法模式。