生动讲解工厂方法模式
想象你要开一家"日志打印店"：
1. 客户只需要说："我要打印日志"
2. 不用关心是用打印机（文件日志）还是刻石碑（数据库日志）
3. 你根据订单类型自动选择对应的生产工具
这就是工厂方法模式的核心：**让子类决定创建什么对象**，客户端只需面向接口编程。
---
### 一、工厂方法模式四大核心组件
#### 1. 抽象产品（Logger接口）
```java
// 相当于"印刷品标准"
public interface Logger {
void writeLog(); // 所有日志都必须支持打印功能
}
```
#### 2. ️ 具体产品（FileLogger/DataBaseLogger）
```java
// 文件日志 - 相当于"纸质印刷"
public class FileLogger implements Logger {
public void writeLog() {
System.out.println("正在使用文件日志记录器记录日志");
}
}
// 数据库日志 - 相当于"石碑雕刻"
public class DataBaseLogger implements Logger {
public void writeLog() {
System.out.println("正在使用数据库日志记录器记录日志");
}
}
```
#### 3. 抽象工厂（LoggerFactory接口）
```java
// 印刷厂生产标准
public interface LoggerFactory {
Logger createLogger(); // 所有工厂必须能生产日志产品
}
```
#### 4. 具体工厂（FileLoggerFactory/DataBaseLoggerFactory）
```java
// 文件日志工厂 - 专门生产纸质印刷品
public class FileLoggerFactory implements LoggerFactory {
public Logger createLogger(){
System.out.println("️ 启动文件印刷流水线");
return new FileLogger();
}
}
// 数据库日志工厂 - 专门生产石碑雕刻
public class DataBaseLoggerFactory implements LoggerFactory {
public Logger createLogger() {
System.out.println("⛏️ 启动石碑雕刻工坊");
return new DataBaseLogger();
}
}
```
---
### 二、工作流程（客户下单场景）
```java
public class Client {
public static void main(String[] args) {
// 1. 获取工厂配置（客户选择印刷方式）
LoggerFactory factory = XMLUtil.getBean();
// 2. 创建日志产品（工厂生产）
Logger logger = factory.createLogger();
// 3. 使用产品（客户收货使用）
logger.writeLog();
}
}
```
#### 配置文件（订单需求单）
```xml
创建者模式.工厂方法模式.具体工厂.FileLoggerFactory
```
#### 配置解析器（订单处理中心）
```java
public class XMLUtil {
public static LoggerFactory getBean() {
// 1. 读取配置文件（接收订单）
// 2. 解析XML获取类名（理解需求）
String className = "创建者模式.工厂方法模式.具体工厂.FileLoggerFactory";
// 3. 反射创建工厂（分配对应工厂）
Class clazz = Class.forName(className);
return (LoggerFactory) clazz.newInstance();
}
}
```
---
### 三、实际开发应用场景
#### 场景1：支付网关切换
```java
// 抽象产品
interface Payment {
void pay(double amount);
}
// 具体产品
class Alipay implements Payment { /* 支付宝实现 */ }
class WechatPay implements Payment { /* 微信支付实现 */ }
// 抽象工厂
interface PaymentFactory {
Payment create();
}
// 客户端
public class PaymentClient {
public void processOrder(String paymentType) {
PaymentFactory factory = PaymentConfig.getFactory(paymentType);
Payment payment = factory.create();
payment.pay(100.00);
}
}
```
#### 场景2：跨数据库支持
```java
// 抽象产品
interface DatabaseConnection {
void connect();
}
// 具体产品
class MySQLConnection implements DatabaseConnection { /* ... */ }
class OracleConnection implements DatabaseConnection { /* ... */ }
// 配置文件切换
MySQL
Oracle -->
```
#### 场景3：多格式导出功能
```java
class ExportFactory {
public static Exporter getExporter(String format) {
switch(format) {
case "PDF": return new PDFExporterFactory();
case "EXCEL": return new ExcelExporterFactory();
default: throw new IllegalArgumentException("不支持的格式");
}
}
}
```
---
### 四、六大核心优势
1. **解耦王者**：客户端只依赖抽象（Logger），不依赖具体实现
```mermaid
graph LR
Client-->|依赖|Logger
Client-->|依赖|LoggerFactory
LoggerFactory-->|生产|Logger
```
2. **开闭原则典范**：新增产品只需扩展，无需修改已有代码
```java
// 新增云日志产品
class CloudLogger implements Logger { /* ... */ }
class CloudLoggerFactory implements LoggerFactory { /* ... */ }
```
3. **可配置性**：通过配置文件实现零代码修改切换实现
```xml
com.example.CloudLoggerFactory
```
4. **职责清晰**：每个工厂只负责创建一种产品
5. **可测试性**：轻松Mock工厂进行单元测试
6. **可扩展性**：天然支持产品族扩展（结合抽象工厂模式）
---
### 五、五大避坑指南
1. **避免过度设计**
✅ 简单场景用简单工厂：
```java
class LoggerFactory {
public static Logger create(String type) {
switch(type) {
case "FILE": return new FileLogger();
case "DB": return new DataBaseLogger();
}
}
}
```
❌ 不要为只有1-2种实现的场景上完整工厂模式
2. **防止循环依赖**
工厂不应依赖具体产品，应依赖抽象产品
```java
// 正确示范 ✅
class FileLoggerFactory implements LoggerFactory {
public Logger createLogger() { // 返回接口
return new FileLogger();
}
}
```
3. **性能考量**
频繁创建对象时考虑对象池：
```java
class DatabaseLoggerFactory {
private static Queue pool = new ConcurrentLinkedQueue<>();
public Logger createLogger() {
Logger logger = pool.poll();
if(logger == null) {
logger = new DatabaseLogger();
}
return logger;
}
}
```
4. **异常处理**
工厂方法应明确处理创建失败：
```java
public Logger createLogger() throws CreateException {
try {
return new DatabaseLogger();
} catch (DBConnectionException e) {
throw new CreateException("数据库连接失败", e);
}
}
```
5. **避免反射滥用**
配置化创建时要防御非法类：
```java
// XMLUtil改进
if(!LoggerFactory.class.isAssignableFrom(clazz)) {
throw new IllegalArgumentException("非法工厂类");
}
```
---
### 六、三种演进形态
| 模式类型 | 适用场景 | 示例 |
|----------------|-----------------------------------|--------------------------|
| 简单工厂 | 产品类型固定且较少 | `LoggerFactory.create(type)` |
| **工厂方法** | 需要灵活扩展产品 | 本文示例 |
| 抽象工厂 | 创建相关产品族（如不同主题UI组件）| `ThemeFactory.createButton()/createMenu()` |
---
### 七、最佳实践总结
1. **识别变化点**：将易变的创建逻辑封装进工厂
2. **面向接口编程**：客户端代码只与抽象产品/工厂交互
3. **配置化创建**：对频繁切换的实现使用配置文件+反射
4. **工厂命名规范**：使用`XXXFactory`统一后缀
5. **结合单例模式**：工厂本身通常实现为单例
```java
// 典型应用框架
DatabaseConnection conn = ConnectionFactory.getFactory(DatabaseType.MYSQL)
.createConnection();
```
> **黄金法则**：
> 当你的代码中出现`new`关键字时，问问自己：
> "这个对象的创建逻辑未来会变化吗？"
> 如果答案是肯定的，就该请出工厂方法模式了！
工厂方法就像制造业的"标准化生产线"，让产品制造与使用分离。正确使用能让你的代码像乐高积木一样灵活组装，应对各种需求变化！
浙公网安备 33010602011771号