设计模式(四):抽象工厂模式——当“一组产品必须配套使用”

举报
小不点和猫 发表于 2026/11/09 08:46:35 2026/11/09
【摘要】 上篇回顾:工厂方法解决的是“造一个产品时,使用方不该知道具体类”。这一篇处理更麻烦的情况:当你要造的不是一个产品,而是一族必须配套的产品时,“各自用工厂方法造”反而会制造出混搭事故。 一、先看一个真实痛点团队要把数据访问层从单库 MySQL 迁移到支持多方言。每个 DAO 都有两套实现:MysqlUserDao / PgUserDao、MysqlOrderDao / PgOrderDao、M...

上篇回顾:工厂方法解决的是“造一个产品时,使用方不该知道具体类”。这一篇处理更麻烦的情况:当你要造的不是一个产品,而是一族必须配套的产品时,“各自用工厂方法造”反而会制造出混搭事故。

一、先看一个真实痛点

团队要把数据访问层从单库 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 绑定不同的 DaoFactory bean,业务代码完全不知道当前是哪套数据库。这其实是抽象工厂最常见的现代落点。

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 的类,一致性反而丢了。

审查阶段,抽象工厂的检查清单要盯“一致性是否真的被结构保证”:

  1. 使用方是否只持有一个工厂引用?有没有可能传入两个不同源的工厂?
  2. 族内产品是否共享同一份资源(连接池/配置),还是各自又造了一份?
  3. 新增一个产品种类,要改几个文件?如果超过 2 个,确认这个代价可接受吗?
  4. 是否只是把“一个工厂方法”拆成了三个方法?产品族只有一两个成员时,抽象工厂往往不划算。
  5. Python 版:模块内创建函数命名是否一致?有没有启动期校验,避免运行到一半才发现某个变体漏了函数?

一个务实判断:在 Java 里,抽象工厂的职责大量被 DI 容器的 profile/条件装配吸收(Spring 的 @Profile、@ConditionalOnProperty);在 Python 里被依赖注入框架和“模块即工厂”吸收。手写抽象工厂仍然合理的场景是:变体需要整体切换(多租户、多数据库方言、AB 两套 UI 主题)、族内产品必须共享资源、且团队需要类型层面的强制约束。

七、三十秒自测

  1. 抽象工厂和工厂方法,扩展方向各是什么?各自违反开闭原则的场景分别是什么?
  2. 如果使用方代码里出现 factoryA.createUserDao() 和 factoryB.createOrderDao() 来自两个不同工厂,会造成什么后果?为什么结构上应该避免?
  3. 在你的项目里找一处“一组对象必须配套使用”的地方(数据源、UI 主题、协议编解码器),判断它现在是靠约定还是靠结构保证一致的。
【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。