⚡ 工厂模式核心概念与设计哲学
工厂模式(Factory Pattern)属于创建型设计模式,其本质在于将对象的创建与使用解耦,通过定义一个用于创建对象的接口或类,让子类决定实例化哪一个类。该模式将实例化逻辑集中管理,从而提升系统灵活性、可维护性与可扩展性。
从设计原则视角审视,工厂模式深度践行了:
- 依赖倒置原则(DIP):高层模块不依赖具体实现,而依赖抽象接口
- 开闭原则(OCP):对扩展开放、对修改关闭——新增产品无需修改工厂核心逻辑
- 里氏替换原则(LSP):工厂返回的子类对象可安全替换父类引用
- 接口隔离原则(ISP):通过最小接口定义产品契约,避免污染客户端
在Java工程实践中,工厂模式绝非仅用于“new对象”的语法糖,而是应对复杂业务变化的核心防御机制。当业务需求迭代频繁、产品线快速扩张(如多支付渠道、多消息中间件、多数据库适配),工厂模式可显著降低模块间耦合度,避免“牵一发而动全身”的重构风险。
需特别指出:工厂模式并非银弹。若系统仅含1-2个简单对象且无扩展需求,过度使用工厂将引入冗余抽象,增加代码复杂度与调试成本。实践中应遵循“需求驱动抽象”原则,而非机械套用模式。
⚙️ 工厂模式三大变体对比与适用场景
〈工厂模式家族谱系〉
- 简单工厂(Simple Factory):非GOF23种模式之一,属工厂模式雏形;通过静态方法集中创建对象;适用:产品线稳定、无扩展需求的轻量场景
- 工厂方法(Factory Method):GOF23核心模式;定义创建对象的接口,子类决定实例化哪个类;适用:产品族固定但需扩展新产品的场景(如新增支付渠道)
- 抽象工厂(Abstract Factory):GOF23核心模式;提供创建一系列相关或依赖对象的接口;适用:多产品族协同场景(如UI主题:Windows/Linux/macOS)
〔工厂模式选择决策树〕
当面临对象创建需求时,按以下步骤决策:
- 产品是否仅1种?→ 是:直接new;否:进入下一步
- 未来是否可能新增产品?→ 否:简单工厂;是:进入下一步
- 产品间是否存在强关联(必须成套使用)?→ 是:抽象工厂;否:工厂方法
下文将逐层展开三种模式的代码实现与工程细节,所有示例均经JDK 17验证,可直接集成至Spring Boot项目。
⚡ 简单工厂模式:代码实现与反模式警示
简单工厂通过静态方法封装创建逻辑,典型结构如下:
【产品接口】
public interface PaymentProcessor {
String processPayment(double amount);
String getChannelName();
}
【具体产品】
public class WeChatPay implements PaymentProcessor {
@Override
public String processPayment(double amount) {
return "微信支付:¥" + amount;
}
@Override
public String getChannelName() {
return "WeChatPay";
}
}
public class Alipay implements PaymentProcessor {
@Override
public String processPayment(double amount) {
return "支付宝支付:¥" + amount;
}
@Override
public String getChannelName() {
return "AliPay";
}
}
【工厂类】
public class PaymentFactory {
public static PaymentProcessor createPayment(String type) {
switch (type.toLowerCase()) {
case "wechat":
return new WeChatPay();
case "alipay":
return new Alipay();
default:
throw new IllegalArgumentException("Unsupported payment type: " + type);
}
}
}
【客户端调用】
public class OrderService {
public void checkout(String channel, double amount) {
PaymentProcessor processor = PaymentFactory.createPayment(channel);
System.out.println(processor.processPayment(amount));
}
}
// 调用示例
OrderService service = new OrderService();
service.checkout("wechat", 199.99); // 输出:微信支付:¥199.99
⚠️ 简单工厂的三大致命缺陷
- 违反开闭原则:新增支付渠道需修改工厂switch语句,存在引入Bug风险
- 静态方法无法继承:限制工厂类扩展性,难以与Spring依赖注入集成
- 参数校验集中:所有校验逻辑集中于工厂,违反单一职责原则
因此,简单工厂仅适用于原型验证阶段或内部工具类。生产级系统推荐使用工厂方法模式替代。
⚙️ 工厂方法模式:企业级实践标准
工厂方法通过为每种产品定义专属工厂,实现创建逻辑的分布式管理:
【工厂接口】
public interface PaymentFactory {
PaymentProcessor createProcessor();
}
【具体工厂】
public class WeChatPayFactory implements PaymentFactory {
@Override
public PaymentProcessor createProcessor() {
return new WeChatPay();
}
}
public class AlipayFactory implements PaymentFactory {
@Override
public PaymentProcessor createProcessor() {
return new Alipay();
}
}
【客户端调用】
// 通过依赖注入获取工厂(Spring方式)
@Service
public class OrderService {
private final PaymentFactory factory;
public OrderService(PaymentFactory factory) {
this.factory = factory;
}
public void checkout(double amount) {
PaymentProcessor processor = factory.createProcessor();
System.out.println(processor.processPayment(amount));
}
}
// 动态切换支付渠道
OrderService wechatOrder = new OrderService(new WeChatPayFactory());
OrderService aliOrder = new OrderService(new AlipayFactory());
【与Spring集成】
@Configuration
public class PaymentConfig {
@Bean
@Qualifier("wechat")
public PaymentFactory wechatFactory() {
return new WeChatPayFactory();
}
@Bean
@Qualifier("alipay")
public PaymentFactory alipayFactory() {
return new AlipayFactory();
}
}
@Service
public class OrderService {
@Autowired
@Qualifier("wechat")
private PaymentFactory factory;
}
工厂方法模式的核心优势在于:新增支付渠道仅需新增产品类与工厂类,无需修改现有代码。此特性使系统具备“热插拔”能力,完美支持插件化架构。
〔抽象工厂模式〕:多产品族协同场景
当业务涉及多个产品族(如:Windows/Linux/macOS桌面主题,每个主题含按钮/文本框/菜单等组件),抽象工厂确保产品族内组件的兼容性:
【产品族接口】
public interface Button {
void render();
}
public interface TextField {
void display();
}
【具体产品】
public class WindowsButton implements Button {
public void render() { System.out.println("Windows按钮"); }
}
public class LinuxButton implements Button {
public void render() { System.out.println("Linux按钮"); }
}
public class WindowsTextField implements TextField {
public void display() { System.out.println("Windows文本框"); }
}
public class LinuxTextField implements TextField {
public void display() { System.out.println("Linux文本框"); }
}
【抽象工厂】
public interface GUIFactory {
Button createButton();
TextField createTextField();
}
【具体工厂】
public class WindowsFactory implements GUIFactory {
public Button createButton() { return new WindowsButton(); }
public TextField createTextField() { return new WindowsTextField(); }
}
public class LinuxFactory implements GUIFactory {
public Button createButton() { return new LinuxButton(); }
public TextField createTextField() { return new LinuxTextField(); }
}
【客户端使用】
public class Application {
private final Button button;
private final TextField field;
public Application(GUIFactory factory) {
this.button = factory.createButton();
this.field = factory.createTextField();
}
public void run() {
button.render();
field.display();
}
}
// 根据操作系统动态选择工厂
GUIFactory factory = isWindows() ? new WindowsFactory() : new LinuxFactory();
Application app = new Application(factory);
app.run();
💡 抽象工厂 vs 工厂方法关键差异
- 工厂方法:一个工厂生产一种产品(单产品族)
- 抽象工厂:一个工厂生产多种产品(多产品族)
- 抽象工厂的工厂接口需定义多个创建方法
【电商订单系统】工厂模式实战案例
以电商订单处理为例,展示工厂模式在真实业务中的落地价值:
【订单状态机设计】
public interface OrderState {
void next(OrderContext context);
void prev(OrderContext context);
String getStatus();
}
【具体状态】
public class PendingState implements OrderState {
public void next(OrderContext context) {
context.setState(new PaidState());
}
public String getStatus() { return "待支付"; }
}
public class PaidState implements OrderState {
public void next(OrderContext context) {
context.setState(new ShippedState());
}
public void prev(OrderContext context) {
context.setState(new PendingState());
}
public String getStatus() { return "已支付"; }
}
【状态工厂】
public class OrderStateFactory {
private static final Map states = new HashMap<>();
static {
states.put("pending", new PendingState());
states.put("paid", new PaidState());
states.put("shipped", new ShippedState());
states.put("delivered", new DeliveredState());
}
public static OrderState getState(String status) {
return states.get(status.toLowerCase());
}
}
【订单上下文】
public class OrderContext {
private OrderState state;
public OrderContext(String initialStatus) {
this.state = OrderStateFactory.getState(initialStatus);
}
public void setState(OrderState state) { this.state = state; }
public void next() { state.next(this); }
public void prev() { state.prev(this); }
public String getStatus() { return state.getStatus(); }
}
【实际业务流程】
// 订单创建时初始状态为待支付
OrderContext order = new OrderContext("pending");
// 用户支付后状态流转
order.next(); // → 已支付
System.out.println(order.getStatus()); // 输出:已支付
// 用户申请退款
order.prev(); // → 待支付
order.next(); // → 已支付(重新支付后)
order.next(); // → 已发货
通过工厂模式管理订单状态,系统可轻松扩展新状态(如“售后中”、“已取消”),且各状态逻辑完全解耦,符合单一职责原则。
⚠️ 工厂模式常见误区与反模式
〔误区1:过度设计陷阱〕
某团队将简单服务类也套用工厂模式:
// 反例:为UserService添加工厂
public interface UserServiceFactory {
UserService create();
}
// 实际调用:new UserServiceFactoryImpl().create().findAll();
问题:UserService无复杂创建逻辑,工厂模式引入冗余抽象,增加维护成本
〔误区2:工厂类膨胀问题〕
当产品数量达20+时,工厂类数量激增,可采用:
→ 注册表模式:用Map注册工厂实例
→ 反射+配置:通过配置文件动态加载工厂类
〔误区3:忽略线程安全〕
单例工厂在并发场景下可能创建重复对象:
// 危险实现
public class SingletonFactory {
private static PaymentProcessor processor;
public static PaymentProcessor getInstance() {
if (processor == null) processor = new WeChatPay();
return processor;
}
}
正确方案:使用双重检查锁定或静态内部类
〔误区4:违反迪米特法则〕
客户端直接依赖工厂类而非接口:
// 反例:OrderService直接依赖WeChatPayFactory
public class OrderService {
private final WeChatPayFactory factory;
}
应通过接口依赖(PaymentFactory),实现解耦
🚀 工厂模式性能优化与工程实践
〔缓存策略优化〕
对创建成本高的对象(如数据库连接池),在工厂中加入缓存:
public class ConnectionFactory {
private static final Map pool = new ConcurrentHashMap<>();
public static Connection getConnection(String dbType) {
return pool.computeIfAbsent(dbType, k -> createConnection(k));
}
private static Connection createConnection(String dbType) {
// 创建连接逻辑(如HikariCP初始化)
}
}
〔Spring工厂Bean集成〕
@Component
public class PaymentFactoryBean implements FactoryBean {
private final String channel;
public PaymentFactoryBean(String channel) {
this.channel = channel;
}
@Override
public PaymentProcessor getObject() {
return switch (channel) {
case "wechat" -> new WeChatPay();
case "alipay" -> new Alipay();
default -> throw new IllegalArgumentException();
};
}
@Override
public Class> getObjectType() {
return PaymentProcessor.class;
}
}
〔测试友好性优化〕
通过Mock工厂解耦单元测试:
@Test
void testCheckout() {
PaymentFactory mockFactory = Mockito.mock(PaymentFactory.class);
PaymentProcessor mockProcessor = Mockito.mock(PaymentProcessor.class);
when(mockFactory.createProcessor()).thenReturn(mockProcessor);
when(mockProcessor.processPayment(100.0)).thenReturn("Mocked payment");
OrderService service = new OrderService(mockFactory);
assertEquals("Mocked payment", service.checkout(100.0));
}
✅ 工程落地黄金准则
- 优先使用Spring依赖注入替代手动工厂
- 工厂类应保持无状态(避免成员变量)
- 创建逻辑复杂时,拆分到Builder模式
- 日志记录关键创建事件(便于追踪问题)
〔工厂模式学习路径图〕
- 掌握基本工厂模式实现(Java 8+语法)
- 理解SOLID原则在工厂模式中的体现
- 实战电商/支付/日志系统案例
- 集成Spring IoC容器实现企业级应用
- 探索工厂模式与响应式编程结合(Project Reactor)