Java 23 种设计模式：从踩坑到精通 | 番外：工厂方法 vs 抽象工厂 ------ 从单产品到产品族，架构如何演进？
摘要 ：工厂方法和抽象工厂都是创建型模式，都用于解耦对象的创建与使用。但它们的核心区别在于粒度------工厂方法解决单一产品类型的横向扩展，抽象工厂解决产品族的纵向创建。本文从支付渠道对接的真实场景出发，沿着"简单工厂 → 工厂方法 → 抽象工厂"的演进路线，结合代码对比、UML 分析和 Spring、MyBatis 源码，帮你彻底搞懂这对"创建型兄弟"的选型边界。
🗺️ 本文阅读地图（3 分钟速览）
- 为什么支付+收款必须成套创建？
- 简单工厂 → 工厂方法 → 抽象工厂：一张图看懂演进
- UML 对比：单一产品 vs 产品族，继承 vs 组合
- 手写代码对比：从一坨 if-else 到可插拔的工厂架构
- Spring
BeanFactoryvsFactoryBean，MyBatisSqlSessionFactory如何体现- 面试必问："工厂方法和抽象工厂怎么选？抽象工厂完全符合开闭原则吗？"
📖 《Java 23 种设计模式：从踩坑到精通》开篇：系列介绍与目录 ｜ 当前：番外 · 工厂方法 vs 抽象工厂
🔗 返回系列总目录
文章目录
- [Java 23 种设计模式：从踩坑到精通 | 番外：工厂方法 vs 抽象工厂 ------ 从单产品到产品族，架构如何演进？](#Java 23 种设计模式：从踩坑到精通 | 番外：工厂方法 vs 抽象工厂 —— 从单产品到产品族，架构如何演进？)
-
- [1. 从"支付渠道对接"的架构演进说起](#1. 从“支付渠道对接”的架构演进说起)
- [2. UML 对比：单一产品 vs 产品族](#2. UML 对比：单一产品 vs 产品族)
-
- [2.1 工厂方法 UML（一个工厂一个产品）](#2.1 工厂方法 UML（一个工厂一个产品）)
- [2.2 抽象工厂 UML（一个工厂一族产品）](#2.2 抽象工厂 UML（一个工厂一族产品）)
- [3. 三大核心区别](#3. 三大核心区别)
- [4. 代码演进：从简单工厂到抽象工厂](#4. 代码演进：从简单工厂到抽象工厂)
-
- [4.1 简单工厂（最简陋）](#4.1 简单工厂（最简陋）)
- [4.2 工厂方法（单产品扩展）](#4.2 工厂方法（单产品扩展）)
- [4.3 抽象工厂（产品族成套创建）](#4.3 抽象工厂（产品族成套创建）)
- [5. 框架中的体现](#5. 框架中的体现)
-
- [5.1 Spring：`BeanFactory` vs `FactoryBean`](#5.1 Spring：
BeanFactoryvsFactoryBean) - [5.2 MyBatis：`SqlSessionFactory`](#5.2 MyBatis：
SqlSessionFactory)
- [5.1 Spring：`BeanFactory` vs `FactoryBean`](#5.1 Spring：
- [6. 面试必问 + 追问连环炮](#6. 面试必问 + 追问连环炮)
- [🧭 《Java 23 种设计模式：从踩坑到精通》快速导航](#🧭 《Java 23 种设计模式：从踩坑到精通》快速导航)
1. 从"支付渠道对接"的架构演进说起
假设你正在开发一个电商平台的支付模块，最初只需要支持支付宝支付。你写了一个简单工厂，根据参数创建支付对象：
java
// 简单工厂：一个工厂创建多种产品
public class PayFactory {
public static IPay create(String channel) {
if ("alipay".equals(channel)) return new AliPay();
if ("wechat".equals(channel)) return new WxPay();
throw new IllegalArgumentException("不支持的支付渠道");
}
}后来业务发展，你发现支付和收款必须成套创建------用户用支付宝付了款，就必须用支付宝的收款接口去对账，否则出现"串渠道"的生产事故。这时候简单工厂的弊端暴露无遗：它无法保证"支付对象"和"收款对象"来自同一个渠道。
于是架构演进开始：先用工厂方法 让每个渠道有独立的工厂，再用抽象工厂为每个渠道提供一整套产品族（支付 + 收款）。
2. UML 对比：单一产品 vs 产品族
2.1 工厂方法 UML（一个工厂一个产品）
2.2 抽象工厂 UML（一个工厂一族产品）
UML 的关键差异：
- 工厂方法的抽象工厂接口只有一个
createProduct()方法，抽象工厂有多个 创建方法（createPay()+createCollect()）； - 工厂方法的一个具体工厂对应一个具体产品 ，抽象工厂的一个具体工厂对应一个产品族（一组关联产品）。
3. 三大核心区别
| 对比维度 | 工厂方法 | 抽象工厂 |
|---|---|---|
| 意图 | 定义创建对象的接口，让子类决定实例化哪个类 | 创建一系列相关或相互依赖的对象（产品族） |
| 工厂职责 | 一个工厂只创建一种产品 | 一个工厂创建一族产品 |
| 扩展方向 | 新增产品只需新加工厂类，完全符合开闭原则 | 新增产品族符合开闭原则；但新增产品类型（如新增退款功能）需要修改抽象工厂接口和所有具体工厂，违反开闭原则 |
| 典型应用 | Spring FactoryBean、简单支付扩展 |
MyBatis SqlSessionFactory、支付+收款成套创建 |
💡 简单记忆：工厂方法是"一个产品一条生产线"，抽象工厂是"一族产品一个集团"。工厂方法加产品 = 加一条线；抽象工厂加产品类型 = 整个集团都要改。
4. 代码演进：从简单工厂到抽象工厂
4.1 简单工厂（最简陋）
java
// 简单工厂：一个工厂，根据参数返回不同产品
public class SimplePayFactory {
public static IPay createPay(String channel) {
switch (channel) {
case "alipay": return new AliPay();
case "wechat": return new WxPay();
default: throw new IllegalArgumentException("不支持的渠道");
}
}
}⚠️ 问题：新增渠道需修改
switch，违反开闭原则；无法保证支付和收款配套。
4.2 工厂方法（单产品扩展）
java
// 工厂方法：每个渠道一个工厂，只创建支付对象
public interface PayFactory {
IPay createPay();
}
public class AliPayFactory implements PayFactory {
@Override
public IPay createPay() { return new AliPay(); }
}
public class WxPayFactory implements PayFactory {
@Override
public IPay createPay() { return new WxPay(); }
}✅ 优点：新增渠道只需加新工厂类。
⚠️ 问题：收款对象需要另外创建，无法保证支付和收款来自同一渠道。
4.3 抽象工厂（产品族成套创建）
java
// 抽象工厂：一个工厂同时创建支付和收款
public abstract class PaymentFactory {
public abstract IPay createPay();
public abstract ICollect createCollect();
}
public class AliPaymentFactory extends PaymentFactory {
@Override
public IPay createPay() { return new AliPay(); }
@Override
public ICollect createCollect() { return new AliCollect(); }
}
public class WxPaymentFactory extends PaymentFactory {
@Override
public IPay createPay() { return new WxPay(); }
@Override
public ICollect createCollect() { return new WxCollect(); }
}✅ 优点：支付和收款强制配套 ，杜绝"串渠道"；切换渠道只需替换工厂实例。
⚠️ 缺点：如果需要新增"退款"产品，必须修改
PaymentFactory抽象类和所有具体工厂。
演进总结：
简单工厂 工厂方法 抽象工厂
──────→ ──────→ ──────→
一个工厂，多种产品 每个产品一个工厂 一个工厂，一族产品
集中但违反OCP 扩展性强 保证产品族一致
支付场景起步 支付扩展 支付+收款配套5. 框架中的体现
5.1 Spring：BeanFactory vs FactoryBean
BeanFactory：IoC 容器的核心接口，负责管理和创建所有 Bean。它不关心具体产品，可以看作一个超级"抽象工厂"。FactoryBean<T>：一个专门用于创建复杂对象的工厂 Bean，每次getObject()返回一个特定类型的产品。这是典型的工厂方法模式 ------每个FactoryBean只创建一种产品。
java
// FactoryBean：工厂方法模式
@Component
public class MyServiceFactoryBean implements FactoryBean<MyService> {
@Override
public MyService getObject() { return new MyService(); } // 只创建一种产品
@Override
public Class<?> getObjectType() { return MyService.class; }
}5.2 MyBatis：SqlSessionFactory
SqlSessionFactory 是典型的抽象工厂模式 ------它创建 SqlSession 以及与当前数据库环境关联的 Configuration、Transaction 等对象，构成一个完整的产品族。切换数据库环境只需替换 SqlSessionFactory 的实现。
6. 面试必问 + 追问连环炮
基础必问
- 工厂方法和抽象工厂的区别？
👉 工厂方法解决单一产品扩展，抽象工厂解决产品族创建。工厂方法的抽象工厂只有一个create()方法，抽象工厂有多个。 - 抽象工厂完全符合开闭原则吗？
👉 不完全。新增产品族（新增一个支付渠道）符合 OCP；但新增产品类型（如新增退款功能）需要修改抽象工厂接口和所有具体工厂，违反 OCP。这是面试中经常考察的点。
面试官追问
- "什么时候该用抽象工厂而不是工厂方法？"
👉 当系统需要创建的对象之间存在"成套"或"风格统一"的强关联时。如支付+收款必须来自同一渠道、跨平台 UI 的按钮+文本框必须风格一致。 - "
BeanFactory和FactoryBean分别是什么模式？"
👉BeanFactory是抽象工厂模式（管理所有 Bean 的容器），FactoryBean是工厂方法模式（生产特定复杂对象的工厂）。 - "简单工厂、工厂方法、抽象工厂如何演进？"
👉 产品种类少且固定 → 简单工厂；产品种类多、频繁新增 → 工厂方法；产品成族出现、需整体切换 → 抽象工厂。三者是一个"从集中到分散、从单产品到产品族"的演进过程。
🎉 恭喜：如果你能立刻画出工厂方法和抽象工厂的 UML 对比图，并说出"新增产品类型时抽象工厂违反 OCP"，你已经掌握了创建型模式最核心的选型逻辑。
💡 延伸阅读 ：本文是工厂方法模式与抽象工厂模式的深度对比。如果你想先了解每种模式的完整原理、UML、代码实现和面试题，可以先阅读正篇------工厂模式：简单工厂→工厂方法→抽象工厂全演进 和 抽象工厂模式：产品族创建，如何避免"一锅粥"？，再回来看这篇对比，效果更佳。
🧭 《Java 23 种设计模式：从踩坑到精通》快速导航
- 开篇：系列介绍与目录
- 当前：番外 · 工厂方法 vs 抽象工厂 ------ 从单产品到产品族，架构如何演进？（你在这里）
- 📖 延伸阅读：工厂模式正篇 ｜ 抽象工厂模式正篇
- 创建型模式汇总
- 结构型模式汇总
- 行为型模式汇总
🔔 关注《Java 23 种设计模式：从踩坑到精通》，用 25 篇文章彻底吃透设计模式。
📦 福利预告：全系列代码及 UML 源码将在完结时统一打包开放，点击「关注」「收藏」第一时间获取。
📌 除了设计模式，我也在深挖智能物流实战 （WMS、托盘调度、机器学习落地）。欢迎点击头像，看看专栏 《出版社物流WMS智能调度实战》。技术相通，思路可鉴。