设计模式(三):工厂方法模式——当 `new` 开始出现在 `if/else` 里
上篇回顾:单例的教训是“唯一性”这个约束一旦被写进代码,就必须同时想清楚它会被谁破坏。这一篇换个方向:不是控制“造几个”,而是控制“谁来造、怎么造”。工厂方法模式是创建型模式里最常被过度使用的一个,也是 AI 最容易生成“完整但没必要”的结构的一个。
一、先看一个真实痛点
支付模块最初只接了一家渠道,代码很直白:
PaymentService service = new AlipayService(config);
三个月后接了微信,代码变成:
PaymentService service;
if ("alipay".equals(channel)) {
service = new AlipayService(config);
} else if ("wechat".equals(channel)) {
service = new WechatService(config);
} else if ("unionpay".equals(channel)) {
service = new UnionPayService(config);
}
问题不是这个 if/else 本身难看。问题是这段分支逻辑在系统里出现了七次:下单、退款、对账、回调验签、定时补单……每接一家新渠道,七个地方都要改,漏掉一个就是线上事故。更隐蔽的是,每个分支里还夹着该渠道特有的初始化参数——有的要证书路径,有的要商户号,有的要预加载 SDK。
这就是“创建逻辑散落”的设计压力。工厂方法模式回应的核心问题是:把“用哪个具体类、怎么初始化它”这件事,从使用方收拢到一个专门的位置。 使用方只声明“我要一个 PaymentService”,不再知道也不需要知道它是怎么被造出来的。
二、一句话本质与结构速写
本质:定义一个用于创建对象的接口,让子类(或注册表)决定实例化哪一个具体类,把“要什么”和“怎么造”分离。
代价一句话:你换来的是“新增产品时使用方不用改”,付出的是“每新增一个产品,创建侧要多一个类/一条注册”。 开闭原则不是免费的,它把修改从 N 个使用点挪到了 1 个创建点,但创建点本身仍然在增长。
结构上有两个层次要分清,这是初学者最容易混淆的地方:
- 产品(Product) :抽象接口,使用方只依赖它;
- 具体产品(ConcreteProduct) :真正被创建的类;
- 创建者(Creator) :声明工厂方法,返回产品;
- 具体创建者(ConcreteCreator) :决定实例化哪个具体产品。
关键约束是:使用方只持有 Product 类型的引用。一旦使用方 instanceof 具体产品、或调用产品接口之外的方法,工厂就白建了——这是审查时第一条要看的。
三、Java 实现:抽象 Creator + 子类决定产品
3.1 标准形态
// 产品
public interface PaymentService {
PaymentResult pay(Order order);
RefundResult refund(RefundRequest req);
}
// 具体产品
public class AlipayService implements PaymentService {
private final AlipayConfig config;
AlipayService(AlipayConfig config) { this.config = config; }
public PaymentResult pay(Order order) { /* ... */ return null; }
public RefundResult refund(RefundRequest req) { /* ... */ return null; }
}
// 创建者:声明工厂方法,本身不决定具体类型
public abstract class PaymentServiceFactory {
public abstract PaymentService create(PaymentContext ctx);
// 模板方法:使用方调这个,而不是直接调 create
public PaymentResult payWith(Order order, PaymentContext ctx) {
PaymentService service = create(ctx); // 子类决定造什么
return service.pay(order);
}
}
// 具体创建者
public class AlipayServiceFactory extends PaymentServiceFactory {
public PaymentService create(PaymentContext ctx) {
return new AlipayService(loadAlipayConfig(ctx));
}
}
使用方代码从“七个 if/else”变成“持有某个 PaymentServiceFactory,调 payWith”。新增渠道 = 新增一个具体产品 + 一个具体创建者,使用方一行不改。
3.2 但真实项目里,往往先落到“简单工厂”
上面是 GoF 的工厂方法。实践中更常见的是简单工厂——用一个方法/类集中分支,不引入 Creator 继承体系:
public final class PaymentServiceFactory {
private static final Map<String, Function<PaymentContext, PaymentService>> REGISTRY =
new HashMap<>();
static {
REGISTRY.put("alipay", ctx -> new AlipayService(loadAlipayConfig(ctx)));
REGISTRY.put("wechat", ctx -> new WechatService(loadWechatConfig(ctx)));
}
public static PaymentService create(String channel, PaymentContext ctx) {
var creator = REGISTRY.get(channel);
if (creator == null) throw new IllegalArgumentException("unsupported channel: " + channel);
return creator.apply(ctx);
}
}
它违反了开闭原则(新增渠道要改 static 块),但把“七处分支”收敛成了“一处注册”,这已经解决了 90% 的痛点。这是一个重要的判断点:当变化的频率不高、产品族不大时,简单工厂 + 注册表比完整的工厂方法体系更诚实。 完整工厂方法的代价是类数量随产品线性增长,收益是“创建侧也不需要修改”——只有在创建逻辑本身频繁变化、或需要让不同模块各自扩展产品时,这个收益才成立。
3.3 Java 特有的约束
- 工厂方法天然适合模板方法:
payWith就是骨架,create是可变步骤。这也是很多框架的写法(Spring 的FactoryBean、各种AbstractXxxFactory)。 - 产品接口必须是使用方能完整使用的。如果使用方需要调
AlipayService特有的方法,要么把该方法提到接口里,要么说明“这里不该用工厂”。 - 异常语义要统一:
create失败时抛什么?注册表版通常抛IllegalArgumentException,继承版可能在子类里抛不同异常,使用方无法统一处理。这是工厂模式常见的“漏掉后果”。
四、Python 实现:注册表比继承体系更自然
4.1 注册表装饰器
from typing import Callable, Protocol
class PaymentService(Protocol):
def pay(self, order) -> dict: ...
def refund(self, req) -> dict: ...
_REGISTRY: dict[str, Callable[..., PaymentService]] = {}
def register(channel: str):
def deco(factory: Callable[..., PaymentService]):
_REGISTRY[channel] = factory
return factory
return deco
def create_payment_service(channel: str, **ctx) -> PaymentService:
if channel not in _REGISTRY:
raise ValueError(f"unsupported channel: {channel}")
return _REGISTRY[channel](**ctx)
# 使用方:定义即注册,不需要单独的 Factory 类
@register("alipay")
def _alipay(**ctx) -> PaymentService:
return AlipayService(config=load_alipay_config(ctx))
这是 Python 里最主流的“工厂方法”形态。注意它没有 Factory 类——注册表本身就是工厂,装饰器负责把新产品的创建逻辑挂进去。新增渠道只需要在渠道模块里加一个 @register 函数,创建点不需要改动,这反而比 Java 的继承版更接近“对扩展开放”的本意。
4.2 更轻的形态:字典映射
_FACTORIES = {
"alipay": lambda **ctx: AlipayService(load_alipay_config(ctx)),
"wechat": lambda **ctx: WechatService(load_wechat_config(ctx)),
}
def create_payment_service(channel: str, **ctx) -> PaymentService:
try:
return _FACTORIES[channel](**ctx)
except KeyError:
raise ValueError(f"unsupported channel: {channel}") from None
什么时候用字典、什么时候用装饰器注册?字典要求所有创建逻辑集中在一处,适合产品少、且希望“一眼看全”的场景;装饰器注册把创建逻辑分散到各产品模块,适合产品多、且希望“新增产品不碰工厂文件”的场景。这和 Java 里“简单工厂 vs 工厂方法”的取舍本质是同一个,只是 Python 用更轻的机制表达了它。
4.3 类体系版:只在确实需要时写
from abc import ABC, abstractmethod
class PaymentServiceFactory(ABC):
@abstractmethod
def create(self, ctx: dict) -> PaymentService: ...
def pay_with(self, order, ctx):
return self.create(ctx).pay(order)
class AlipayServiceFactory(PaymentServiceFactory):
def create(self, ctx): return AlipayService(load_alipay_config(ctx))
它和 Java 版结构一一对应,但在 Python 里通常不是首选——因为它把“用函数就能表达的事”升级成了类层级,而 Python 的模块、函数、装饰器已经能承担同样的职责。这也正好说明:工厂方法模式的类结构,有一部分是在弥补“没有一等函数”的语言限制。
五、双语言对照表
| 维度 | Java | Python |
|---|---|---|
| 典型实现 | 抽象 Creator + 具体 Creator 子类;简单工厂 + 注册表 | 注册表装饰器、字典映射、可调用对象;ABC 版只在需要时用 |
| 约束来源 | 编译期类型 + 接口/抽象类强制 | 运行期约定;Protocol/ABC 可选校验 |
| 扩展新产品的代价 | 工厂方法版:新增 2 个类;简单工厂版:改 1 处注册 | 装饰器版:新增 1 个被注册函数;字典版:改 1 处 |
| 样板代码量 | 较高 | 极低 |
| 使用方依赖什么 | Product 接口 |
Protocol 或鸭子类型 |
| 主要风险 | 类数量膨胀、异常语义不统一、使用方泄漏具体类型 | 注册遗漏/重复注册、隐式约定、运行期才发现拼写错误 |
| 现代替代 | DI 容器 + Supplier / Function |
注册表、functools.partial、插件机制(entry points) |
记忆锚点:工厂方法 = 使用方说“我要一个 X”,创建方决定“给你哪个 X、怎么造”;代价是创建侧多了一个需要维护的地方。
六、现代视角:AI 生成工厂时,最该审查什么
工厂方法在 AI 辅助流程里的位置,和单例刚好相反:单例的问题是“AI 容易漏掉后果”,工厂方法的问题是“AI 太容易给你一个完整的工厂体系” 。一句“用工厂模式重构这段创建逻辑”,AI 大概率会生成抽象类 + 子类 + 接口三件套,而不会先问你“产品会频繁增加吗、创建逻辑会变化吗”。
结合总览篇的“诊断—生成—审查”链条:
诊断阶段,先区分两种压力。 一种是“分支散落”——同一组 if/else 在多个地方重复,这时收敛到一处注册就够了,简单工厂通常是最优解。另一种是“创建逻辑本身需要按模块扩展”——比如各业务线各自负责自己的支付渠道初始化,这时才值得上工厂方法/注册表扩展点。AI 分不清这两者,因为它看不到“谁在未来会改这段代码”。
生成阶段,用意图约束替代结构描述。 与其说“用工厂方法”,不如说“把支付渠道的创建收敛到一个注册点,新增渠道时不修改使用方,也不修改已有的渠道实现”。这个描述会自然导向注册表,而不是继承体系。
审查阶段,工厂的检查清单和单例不同,盯的是“抽象是否真的被用上”:
- 使用方是否只依赖产品接口?有没有
instanceof/ 类型断言 / 调用具体产品特有方法? - 创建失败时异常语义是否统一?调用方能否用一套方式处理?
- 注册表版:重复注册、遗漏注册、拼写错误能否在启动期暴露,而不是等到线上第一次调用?
- 这个工厂是否只是把一处
if/else包装成了一个类,而使用方数量只有一两个?(如果是,可能是过度设计) - 新增一个产品,实际需要改几个文件?如果答案是“改工厂文件”,那它就是简单工厂,别声称它满足开闭原则。
一个务实判断:在 Java 里,DI 容器(Spring 的 @Bean、Map<String, PaymentService> 注入)已经吸收了大量工厂方法的职责——容器本身就是注册表,按类型/名称注入就是“使用方声明要什么”。在 Python 里,importlib.metadata 的 entry points、插件框架、以及上面那种 @register 装饰器,承担了同样的角色。手写工厂体系真正还合理的场景是:创建过程有复杂逻辑(多步初始化、依赖外部配置、需要缓存/池化),或需要把“注册能力”开放给第三方模块。
七、三十秒自测
- 简单工厂和工厂方法的核心区别是什么?各自在什么条件下是“足够好”的?
- 如果使用方代码里出现了
if (service instanceof AlipayService),说明工厂模式哪里出了问题? - 在你的项目里找一处“创建逻辑散落在多个
if/else”的地方,判断它该收敛到简单工厂、注册表,还是暂时不动。
、
- 点赞
- 收藏
- 关注作者
评论(0)