设计模式(四):抽象工厂模式——当“一组产品必须配套使用”
上篇回顾:工厂方法解决的是“造一个产品时,使用方不该知道具体类”。这一篇处理更麻烦的情况:当你要造的不是一个产品,而是一族必须配套的产品时,“各自用工厂方法造”反而会制造出混搭事故。
一、先看一个真实痛点
团队要把数据访问层从单库 MySQL 迁移到支持多方言。每个 DAO 都有两套实现:MysqlUserDao / PgUserDao、MysqlOrderDao / PgOrderDao、MysqlLogDao / PgLogDao。
一开始各自用工厂方法造,代码跑得很欢。直到某天灰度环境出了事故:UserDao 注入的是 MySQL 版,OrderDao 注入的是 PostgreSQL 版——连接池是两套,事务跨不了库,LIMIT ? OFFSET ? 和 LIMIT ? OFFSET ? 在某个方言下的分页语义还不一样,一个下单事务里一半写进了 MySQL、一半写进了 PG。
问题不在任何一个 DAO 的实现。问题是:这三个 DAO 属于同一个产品族,必须来自同一个变体,而“各自独立创建”这件事本身允许了混搭。 工厂方法保证了“单个产品的创建被封装”,但它不保证“多个产品之间的一致性”。
抽象工厂模式回应的正是这个压力:提供一个接口,用来创建一族相关或相互依赖的对象,而不指定它们的具体类——同时保证这一族来自同一个变体。
二、一句话本质与结构速写
本质:把“一个变体下的整族产品”打包成一个创建单元,使用方选一次变体,整族配套拿到。
代价一句话:新增一个“产品族”(变体)很容易,新增一个“产品种类”很痛苦——所有具体工厂都要改。
结构和工厂方法的关系要一次说清,这是最容易混淆的地方:
- 工厂方法:一个产品等级结构(
PaymentService),靠子类/注册表决定造哪一个。扩展方向是纵向的——加产品。 - 抽象工厂:多个产品等级结构(
UserDao、OrderDao、LogDao),一个具体工厂负责这一族的创建。扩展方向是横向的——加变体。
参与者:
- 抽象工厂(AbstractFactory) :声明一族产品的创建方法;
- 具体工厂(ConcreteFactory) :每个变体一个,保证族内产品配套;
- 抽象产品族(AbstractProductA/B/C) :使用方只依赖这些接口;
- 使用方:只持有抽象工厂和抽象产品,永远不出现具体类名。
关键约束:使用方拿到工厂后,不应再能“单独换掉族内某个产品”。一旦允许混搭,抽象工厂的一致性保证就失效了。
三、Java 实现:一个变体一个具体工厂
// 抽象产品族
public interface UserDao { User findById(long id); }
public interface OrderDao { Order findById(long id); }
public interface LogDao { void append(LogEntry e); }
// 抽象工厂:声明整族的创建
public interface DaoFactory {
UserDao createUserDao();
OrderDao createOrderDao();
LogDao createLogDao();
}
// 具体工厂:MySQL 变体
public class MysqlDaoFactory implements DaoFactory {
private final DataSource ds;
public MysqlDaoFactory(DataSource ds) { this.ds = ds; }
public UserDao createUserDao() { return new MysqlUserDao(ds); }
public OrderDao createOrderDao() { return new MysqlOrderDao(ds); }
public LogDao createLogDao() { return new MysqlLogDao(ds); }
}
// 具体工厂:PostgreSQL 变体
public class PgDaoFactory implements DaoFactory {
private final DataSource ds;
public PgDaoFactory(DataSource ds) { this.ds = ds; }
public UserDao createUserDao() { return new PgUserDao(ds); }
public OrderDao createOrderDao() { return new PgOrderDao(ds); }
public LogDao createLogDao() { return new PgLogDao(ds); }
}
使用方只依赖抽象:
public class OrderService {
private final UserDao users;
private final OrderDao orders;
// 注意:两个 DAO 来自同一个 factory,一致性由构造参数保证
public OrderService(DaoFactory factory) {
this.users = factory.createUserDao();
this.orders = factory.createOrderDao();
}
}
一致性是被结构保证的:OrderService 的构造函数只接收一个 DaoFactory,两个 DAO 必然同源。谁想混搭,必须在构造前手动拼两个工厂,这属于显式破坏,审查时一眼能看出。
两个 Java 特有的细节:
- 具体工厂通常持有共享资源(如
DataSource),族内产品共用它——这也是“配套”的实际含义之一。如果每个产品各自持有连接池,即使同源也会出问题。 - 抽象工厂常和 DI 容器配合:Spring 里按 profile 绑定不同的
DaoFactorybean,业务代码完全不知道当前是哪套数据库。这其实是抽象工厂最常见的现代落点。
3.1 抽象工厂最著名的“斜向问题”
“新增产品族容易、新增产品种类难”值得展开一句:
- 加一个
SqliteDaoFactory:只写一个新类,其他不动,满足开闭原则; - 加一个
AuditDao:DaoFactory接口要改,所有具体工厂都要实现它,违反开闭原则。
这是抽象工厂的固有代价,不是实现缺陷。它优化的是“变体切换”,牺牲的是“产品种类的扩展” 。所以用之前要判断:这个系统未来更可能加数据库方言,还是更可能加新的 DAO 种类?如果是后者,抽象工厂可能不是好选择。
四、Python 实现:抽象工厂常常“退化”成模块或配置
4.1 最自然的形态:一个模块就是一个变体
Python 里不需要显式的 AbstractFactory 接口——一个模块本身就是一族产品的命名空间:
# daos/mysql.py
def create_user_dao(ds): return MysqlUserDao(ds)
def create_order_dao(ds): return MysqlOrderDao(ds)
def create_log_dao(ds): return MysqlLogDao(ds)
# daos/pg.py
def create_user_dao(ds): return PgUserDao(ds)
def create_order_dao(ds): return PgOrderDao(ds)
def create_log_dao(ds): return PgLogDao(ds)
使用方注入的是模块对象:
import importlib
def make_order_service(dialect: str, ds) -> OrderService:
factory = importlib.import_module(f"daos.{dialect}")
return OrderService(
users=factory.create_user_dao(ds),
orders=factory.create_order_dao(ds),
)
这里的一致性由“所有创建函数都从同一个模块取”保证。它没有 interface DaoFactory,也没有 class MysqlDaoFactory——模块即工厂,命名空间即产品族。这比 Java 版短了一个数量级,语义完全等价。
4.2 需要显式类型约束时:Protocol + 字典
如果团队希望有类型检查、且变体数量固定,可以写成:
from typing import Protocol
class DaoFactory(Protocol):
def create_user_dao(self, ds): ...
def create_order_dao(self, ds): ...
def create_log_dao(self, ds): ...
class MysqlDaoFactory:
def __init__(self, ds): self._ds = ds
def create_user_dao(self): return MysqlUserDao(self._ds)
def create_order_dao(self): return MysqlOrderDao(self._ds)
def create_log_dao(self): return MysqlLogDao(self._ds)
_FACTORIES = {
"mysql": MysqlDaoFactory,
"pg": PgDaoFactory,
}
def get_factory(dialect: str, ds) -> DaoFactory:
try:
return _FACTORIES[dialect](ds)
except KeyError:
raise ValueError(f"unsupported dialect: {dialect}") from None
这种写法和 Java 结构一一对应,但只有在“需要 Protocol 做静态检查”或“工厂本身有状态(持有 ds)”时才有必要。纯函数模块版通常更轻。
4.3 什么时候 Python 干脆不用抽象工厂
如果“族内产品”之间没有共享资源、变体又只有一个,那连工厂都不需要——直接依赖注入一组函数或一个配置对象即可。Python 的 functools.partial、依赖注入框架(如 dependency-injector、FastAPI 的 Depends)常把抽象工厂的职责吸收掉:按配置绑定一组 provider,本质上就是“选一次变体、整族配套” 。
五、双语言对照表
| 维度 | Java | Python |
|---|---|---|
| 典型实现 | AbstractFactory 接口 + 每个变体一个具体工厂类 |
一个变体一个模块;或 Protocol + 工厂类;或 DI 框架绑定 |
| 一致性由什么保证 | 使用方只持有一个工厂引用,构造期绑定 | 使用方只 import 一个模块 / 注入一个工厂对象 |
| 扩展新变体 | 新增一个具体工厂类,满足 OCP | 新增一个模块,满足 OCP |
| 扩展新产品种类 | 改接口 + 所有具体工厂,违反 OCP | 改所有模块的创建函数,同样违反 OCP |
| 样板代码量 | 高(接口 + N 个类) | 极低(模块版几乎无骨架) |
| 主要风险 | 产品种类扩展时的连锁修改、工厂类膨胀 | 隐式约定(模块函数名要对齐)、拼写/导入错误运行期才暴露 |
| 现代替代 | DI 容器按 profile 绑定整组 bean | 依赖注入框架、插件 entry points、配置驱动装配 |
记忆锚点:抽象工厂 = “选一次变体,整族配套”;它优化变体切换,牺牲产品种类扩展。
六、现代视角:AI 生成抽象工厂时,审查什么
抽象工厂是 AI 最容易“生成得漂亮但用错场景”的模式之一,因为它结构感强、演示性强。结合“诊断—生成—审查”链条:
诊断阶段,先问一句“这一族产品真的必须同源吗”。 如果 UserDao 和 LogDao 可以来自不同实现而不出问题,那它们就不构成一个必须配套的产品族,抽象工厂就是多余的。AI 不会问这个问题——它看到一个接口里有三个 createXxx 就会照着生成。 判断依据是:族内产品是否共享资源(连接池、配置、事务上下文)、是否在语义上必须来自同一变体(方言、主题、平台)。
生成阶段,用“一致性约束”而不是“结构”下指令。 “让这三个 DAO 必须来自同一个数据库方言,并且使用方无法单独替换其中任意一个”——这个描述会自然导向“使用方只接收一个工厂”的结构。如果只说“用抽象工厂”,AI 可能生成一个每个 DAO 都能单独 set 的类,一致性反而丢了。
审查阶段,抽象工厂的检查清单要盯“一致性是否真的被结构保证”:
- 使用方是否只持有一个工厂引用?有没有可能传入两个不同源的工厂?
- 族内产品是否共享同一份资源(连接池/配置),还是各自又造了一份?
- 新增一个产品种类,要改几个文件?如果超过 2 个,确认这个代价可接受吗?
- 是否只是把“一个工厂方法”拆成了三个方法?产品族只有一两个成员时,抽象工厂往往不划算。
- Python 版:模块内创建函数命名是否一致?有没有启动期校验,避免运行到一半才发现某个变体漏了函数?
一个务实判断:在 Java 里,抽象工厂的职责大量被 DI 容器的 profile/条件装配吸收(Spring 的 @Profile、@ConditionalOnProperty);在 Python 里被依赖注入框架和“模块即工厂”吸收。手写抽象工厂仍然合理的场景是:变体需要整体切换(多租户、多数据库方言、AB 两套 UI 主题)、族内产品必须共享资源、且团队需要类型层面的强制约束。
七、三十秒自测
- 抽象工厂和工厂方法,扩展方向各是什么?各自违反开闭原则的场景分别是什么?
- 如果使用方代码里出现
factoryA.createUserDao()和factoryB.createOrderDao()来自两个不同工厂,会造成什么后果?为什么结构上应该避免? - 在你的项目里找一处“一组对象必须配套使用”的地方(数据源、UI 主题、协议编解码器),判断它现在是靠约定还是靠结构保证一致的。
- 点赞
- 收藏
- 关注作者
评论(0)