架构与系统设计 / 系统课时

设计插件式业务扩展机制

设计插件式业务扩展机制

当支付、通知、计价等业务分支不断增加时,最危险的做法是持续扩写核心流程里的 if 或 switch。本课把变化封装成可注册策略,让核心服务只负责稳定流程,新实现通过扩展点接入。

学习目标

  • 识别适合抽成插件扩展点的业务变化。
  • 用策略、工厂和依赖倒置组织可替换实现。
  • 判断新增实现是否真的避免修改核心流程。

先把变化点移出核心流程

插件式设计的关键不是“动态加载”四个字,而是先建立稳定边界。核心流程负责校验订单、选择能力、推进状态;支付渠道、通知方式或定价规则则通过统一接口变化。这样新增实现时,修改范围被限制在扩展实现与装配位置,而不是散落到业务主链路。

插件式业务扩展的依赖与调用关系

如果一个变化必须改动核心服务才能加入,它仍然只是“分支代码搬家”。真正的扩展点应让核心流程面对抽象,并把“有哪些实现”交给装配层管理。

用策略和工厂形成插件入口

下面的示例把支付渠道定义为策略接口,工厂负责按渠道查找实现,结算服务只依赖工厂。示例可直接保存为 PluginOrderDemo.java,再执行 javac PluginOrderDemo.java && java PluginOrderDemo。

java
import java.util.HashMap;
import java.util.List;
import java.util.Map;

interface PaymentStrategy {
    String channel();
    String pay(int cents);
}

final class CardPayment implements PaymentStrategy {
    public String channel() {
        return "card";
    }

    public String pay(int cents) {
        return "CARD paid " + cents + " cents";
    }
}

final class WalletPayment implements PaymentStrategy {
    public String channel() {
        return "wallet";
    }

    public String pay(int cents) {
        return "WALLET paid " + cents + " cents";
    }
}

final class PaymentStrategyFactory {
    private final Map<String, PaymentStrategy> strategies = new HashMap<>();

    PaymentStrategyFactory(List<PaymentStrategy> strategies) {
        for (PaymentStrategy strategy : strategies) {
            PaymentStrategy old = this.strategies.put(strategy.channel(), strategy);
            if (old != null) {
                throw new IllegalArgumentException("duplicate channel: " + strategy.channel());
            }
        }
    }

    PaymentStrategy get(String channel) {
        PaymentStrategy strategy = strategies.get(channel);
        if (strategy == null) {
            throw new IllegalArgumentException("unsupported channel: " + channel);
        }
        return strategy;
    }
}

final class CheckoutService {
    private final PaymentStrategyFactory factory;

    CheckoutService(PaymentStrategyFactory factory) {
        this.factory = factory;
    }

    String checkout(String channel, int cents) {
        if (cents <= 0) {
            throw new IllegalArgumentException("cents must be positive");
        }
        return factory.get(channel).pay(cents);
    }
}

public class PluginOrderDemo {
    public static void main(String[] args) {
        PaymentStrategyFactory factory = new PaymentStrategyFactory(
            List.of(new CardPayment(), new WalletPayment())
        );
        CheckoutService service = new CheckoutService(factory);

        System.out.println(service.checkout("card", 1200));
        System.out.println(service.checkout("wallet", 800));
    }
}

预期输出

text
CARD paid 1200 cents
WALLET paid 800 cents

这里的策略解决“行为可替换”,工厂解决“按业务标识选择哪个实现”,依赖倒置则保证 CheckoutService 不认识 CardPayment、WalletPayment 等具体类。三者组合后,扩展点才有稳定边界。

用装配层承担新增实现的变化

假设要增加银行转账渠道,新的类只需实现 PaymentStrategy 并声明自己的 channel()。核心的 CheckoutService 与 PaymentStrategyFactory 都不需要增加新的条件分支;变化只发生在新实现和应用启动时的注册位置。

在真实 Java 项目中,装配可以由 Spring 容器收集一组接口实现,也可以由 JDK ServiceLoader 从插件包发现实现。无论采用哪种机制,都应保持同一原则:发现实现属于装配层,业务决策属于策略,核心流程只消费抽象能力。

判断这个扩展点是否设计到位

检查插件式机制时,不要只看是否用了接口,可以直接做一次“新增实现演练”:加入一个新渠道,观察需要修改哪些文件。理想结果是只新增实现并调整装配,不改核心业务流程、不复制校验逻辑,也不让调用方感知具体类。

还要为扩展点保留边界控制,例如拒绝重复标识、对未知渠道快速失败,并把共享的前置校验放在核心流程中。这样扩展能力不会演变成每个插件各自维护一套业务规则,既能增加变化点,也能守住稳定核心。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

设计插件式业务扩展机制

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通