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

设计可组合的规则执行引擎

设计可组合的规则执行引擎

当优惠、风控或资格校验不断增加时,把条件继续堆进一个方法会让复用、顺序调整和测试都变困难。本节用统一规则接口、组合规则与责任链分离“规则本身”和“执行结构”,最终得到可替换、可组合、可验证的规则引擎骨架。

学习目标

  • 设计稳定的规则协议,让单条规则可以独立复用和测试。
  • 用组合模式表达 AND/OR 等规则树,用责任链控制执行顺序与短路。
  • 判断规则组合、流程编排与业务副作用之间的边界。

先固定规则的最小协议

规则引擎最容易失控的地方,是把“判断条件”“执行顺序”“失败处理”写进同一个类。更稳妥的做法是先固定一个很小的协议:规则只接收上下文并返回判定结果,不关心自己位于树的哪一层,也不决定下一条规则是谁。

组合模式负责把叶子规则和组合规则统一成同一种 Rule<T>。这样“金额不超过上限”和“同时满足地区与金额条件”都可以被上层当成一条规则。责任链则放在组合结构之外,用来决定多个阶段按照什么顺序执行、是否遇到失败立即停止。

规则树与责任链的组合关系

用组合规则表达结构,用责任链表达顺序

下面的 Java 17 示例把两种职责分开:AllOf 只关心子规则是否全部通过;RuleChain 只关心按顺序执行以及失败后短路。叶子规则既能直接执行,也能被组合进更大的规则。

java
import java.util.List;

public class RuleEngineDemo {
    record Order(String country, int amount) {}

    interface Rule<T> {
        boolean test(T context);
    }

    static final class CountryRule implements Rule<Order> {
        private final String expected;

        CountryRule(String expected) {
            this.expected = expected;
        }

        public boolean test(Order order) {
            return expected.equals(order.country());
        }
    }

    static final class AmountRule implements Rule<Order> {
        private final int maxAmount;

        AmountRule(int maxAmount) {
            this.maxAmount = maxAmount;
        }

        public boolean test(Order order) {
            return order.amount() <= maxAmount;
        }
    }

    static final class AllOf<T> implements Rule<T> {
        private final List<Rule<T>> children;

        AllOf(List<Rule<T>> children) {
            this.children = List.copyOf(children);
        }

        public boolean test(T context) {
            return children.stream().allMatch(rule -> rule.test(context));
        }
    }

    static final class RuleChain<T> {
        private final List<Rule<T>> stages;

        RuleChain(List<Rule<T>> stages) {
            this.stages = List.copyOf(stages);
        }

        boolean execute(T context) {
            // 链负责执行顺序,并在第一个失败点停止。
            for (Rule<T> stage : stages) {
                if (!stage.test(context)) {
                    return false;
                }
            }
            return true;
        }
    }

    public static void main(String[] args) {
        Rule<Order> eligibility = new AllOf<>(List.of(
            new CountryRule("CN"),
            new AmountRule(1000)
        ));

        RuleChain<Order> chain = new RuleChain<>(List.of(eligibility));

        System.out.println(chain.execute(new Order("CN", 500)));
        System.out.println(chain.execute(new Order("CN", 1500)));
    }
}

预期输出

text
true
false

这里的关键不是类的数量,而是变化维度被拆开了:新增叶子规则通常不需要改执行器;把 AllOf 换成 AnyOf 只改变组合语义;调整责任链阶段顺序也不必改规则实现。

让规则复用而不是让规则知道流程

真实业务里可以把“资格校验”“库存限制”“风险限制”做成独立规则,再按场景组装。组合规则适合表达树形逻辑,例如 (A AND B) OR C;责任链适合表达阶段顺序,例如先资格、再风控、最后优惠。

如果需要解释失败原因,可以把 boolean 升级为包含 passed、code 和 message 的结果对象;如果需要收集全部失败项,就不要使用 allMatch 的短路语义,而要显式遍历所有子规则。关键是让返回模型服务于业务需求,而不是破坏规则接口的单一职责。

什么时候调整这套结构

当规则只有两三条且几乎不会复用时,直接条件判断反而更清楚;当规则数量增长、同一规则需要出现在多个场景,或执行顺序经常调整时,组合模式加责任链才开始体现价值。

如果不同业务需要完全不同的组合算法,可以再引入策略对象,例如“全部通过”“任一通过”“按权重通过”。此时策略负责“如何汇总子规则结果”,组合对象负责“持有哪些子规则”,责任链继续负责“这些阶段按什么顺序执行”。三者各自对应一个变化轴,后续修改才不会重新耦合到一个巨型执行器中。

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

目录与阅读设置

阅读设置

17

记录一个想法

设计可组合的规则执行引擎

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

登录哪都通