设计模式(三):工厂方法模式——当 `new` 开始出现在 `if/else` 里

举报
小不点和猫 发表于 2026/11/08 08:48:29 2026/11/08
【摘要】 上篇回顾:单例的教训是“唯一性”这个约束一旦被写进代码,就必须同时想清楚它会被谁破坏。这一篇换个方向:不是控制“造几个”,而是控制“谁来造、怎么造”。工厂方法模式是创建型模式里最常被过度使用的一个,也是 AI 最容易生成“完整但没必要”的结构的一个。 一、先看一个真实痛点支付模块最初只接了一家渠道,代码很直白:PaymentService service = new AlipayServic...

上篇回顾:单例的教训是“唯一性”这个约束一旦被写进代码,就必须同时想清楚它会被谁破坏。这一篇换个方向:不是控制“造几个”,而是控制“谁来造、怎么造”。工厂方法模式是创建型模式里最常被过度使用的一个,也是 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 分不清这两者,因为它看不到“谁在未来会改这段代码”。

生成阶段,用意图约束替代结构描述。 与其说“用工厂方法”,不如说“把支付渠道的创建收敛到一个注册点,新增渠道时不修改使用方,也不修改已有的渠道实现”。这个描述会自然导向注册表,而不是继承体系。

审查阶段,工厂的检查清单和单例不同,盯的是“抽象是否真的被用上”:

  1. 使用方是否只依赖产品接口?有没有 instanceof / 类型断言 / 调用具体产品特有方法?
  2. 创建失败时异常语义是否统一?调用方能否用一套方式处理?
  3. 注册表版:重复注册、遗漏注册、拼写错误能否在启动期暴露,而不是等到线上第一次调用?
  4. 这个工厂是否只是把一处 if/else 包装成了一个类,而使用方数量只有一两个?(如果是,可能是过度设计)
  5. 新增一个产品,实际需要改几个文件?如果答案是“改工厂文件”,那它就是简单工厂,别声称它满足开闭原则。

一个务实判断:在 Java 里,DI 容器(Spring 的 @Bean、Map<String, PaymentService> 注入)已经吸收了大量工厂方法的职责——容器本身就是注册表,按类型/名称注入就是“使用方声明要什么”。在 Python 里,importlib.metadata 的 entry points、插件框架、以及上面那种 @register 装饰器,承担了同样的角色。手写工厂体系真正还合理的场景是:创建过程有复杂逻辑(多步初始化、依赖外部配置、需要缓存/池化),或需要把“注册能力”开放给第三方模块。

七、三十秒自测

  1. 简单工厂和工厂方法的核心区别是什么?各自在什么条件下是“足够好”的?
  2. 如果使用方代码里出现了 if (service instanceof AlipayService),说明工厂模式哪里出了问题?
  3. 在你的项目里找一处“创建逻辑散落在多个 if/else”的地方,判断它该收敛到简单工厂、注册表,还是暂时不动。
    、
【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

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

全部回复

上滑加载中

设置昵称

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

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

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