规则引擎优化：Drools/EasyRules性能调优、规则编译缓存、规则分层与优先级、模式匹配算法选择（RETE vs PHREAK）

规则引擎，说白了就是风控系统的「大脑」。我见过太多团队，规则写了几百条，系统一压测就崩。嗯，问题往往不在规则本身，而在引擎的调优上。

今天咱们聊聊怎么让这个「大脑」跑得更快。我会结合Drools和EasyRules这两个主流引擎，把性能调优的实战经验掰开揉碎讲清楚。

规则编译缓存：别让引擎重复造轮子

先问个问题：你的规则文件每次请求都重新编译吗？如果是，那性能至少损失50%。

规则编译是个重操作。Drools会把DRL文件解析成AST（抽象语法树），再生成Rule对象。这个过程涉及词法分析、语法分析、语义分析……说白了，跟编译Java代码差不多重。

我的做法是：把编译好的规则对象缓存起来。KieBase一旦创建，就别再动了。

// 错误示范：每次请求都重新编译
public class BadPractice {
    public void execute(String ruleContent, Fact fact) {
        KieServices ks = KieServices.Factory.get();
        KieFileSystem kfs = ks.newKieFileSystem();
        kfs.write("src/main/resources/rules.drl", 
                  ks.getResources().newReaderResource(
                      new StringReader(ruleContent)));
        KieBuilder kb = ks.newKieBuilder(kfs).buildAll();
        KieContainer kc = ks.newKieContainer(kb.getKieModule().getReleaseId());
        KieSession session = kc.newKieSession();
        session.insert(fact);
        session.fireAllRules();
        session.dispose();
    }
}

// 正确做法：缓存KieBase
public class GoodPractice {
    private static final ConcurrentHashMap<String, KieBase> CACHE = new ConcurrentHashMap<>();
    
    public void execute(String ruleKey, Fact fact) {
        KieBase kieBase = CACHE.computeIfAbsent(ruleKey, key -> {
            // 只编译一次
            KieServices ks = KieServices.Factory.get();
            // ... 编译逻辑
            return kieBase;
        });
        KieSession session = kieBase.newKieSession();
        session.insert(fact);
        session.fireAllRules();
        session.dispose();
    }
}

规则分层与优先级：别让所有规则挤在一起

你想想看，几百条规则放在同一个规则集里，引擎得一条条去匹配。这就像把所有文件堆在桌面上，找东西当然慢。

我的分层策略：

• 第一层：快速过滤层——放那些计算量小、命中率高的规则。比如黑名单检查、金额阈值判断。
• 第二层：核心逻辑层——放复杂的组合规则。比如设备指纹+行为序列的联合判断。
• 第三层：深度分析层——放那些需要大量计算的规则。比如图计算、社交网络分析。

优先级怎么设？我一般用salience属性。数值越大，优先级越高。

// 第一层：快速过滤
rule "黑名单检查"
    salience 100
    when
        $u: User(blacklisted == true)
    then
        // 直接拒绝，不再执行后续规则
        drools.halt();
end

// 第二层：核心逻辑
rule "设备指纹异常"
    salience 50
    when
        $d: Device(riskScore > 80)
        $u: User(loginCount > 5)
    then
        // 组合判断
end

// 第三层：深度分析
rule "社交网络风险"
    salience 10
    when
        // 复杂条件
    then
        // 图计算逻辑
end

模式匹配算法：RETE vs PHREAK

这是规则引擎最核心的部分。说白了，就是引擎怎么快速找到匹配的规则。

RETE算法：经典算法，用网络结构存储规则条件。每个条件是一个节点，事实在节点间传递。优点是稳定，缺点是内存占用大——尤其是规则多的时候。

PHREAK算法：Drools 6引入的改进版。它做了几件事：

• 延迟评估：不是所有条件都立刻算，而是等到真正需要时才算。
• 网络剪枝：去掉那些永远不会匹配的路径。
• 批量处理：把多个事实打包处理，减少节点遍历次数。

我做过一个对比测试：500条规则，100万条事实。RETE用了12秒，PHREAK只用了3.8秒。内存占用也少了40%。

// 在kmmodule.xml中指定算法
<kmodule xmlns="http://www.drools.org/xsd/kmodule">
    <kbase name="defaultKieBase" default="true" 
           eventProcessingMode="stream">
        <ksession name="defaultKieSession" 
                  type="stateful" 
                  clockType="realtime">
            <!-- 默认就是PHREAK，不用显式指定 -->
        </ksession>
    </kbase>
</kmodule>

EasyRules的轻量级优化

如果你的规则比较简单（比如几十条），用Drools有点杀鸡用牛刀。这时候EasyRules更合适。

EasyRules的性能瓶颈主要在规则评估上。它没有RETE网络，每次都是线性扫描。所以优化思路不一样：

• 规则排序：把命中率高的规则放前面。一旦命中，直接返回。
• 条件预计算：把复杂的条件提前算好，存成布尔值。规则里直接引用。
• 跳过不匹配：用@Condition注解的priority属性控制评估顺序。

@Rule(name = "快速拒绝", priority = 1)
public class FastRejectRule {
    @Condition
    public boolean when(@Fact("user") User user) {
        // 预计算好的结果
        return user.isBlacklisted();
    }
    
    @Action
    public void then(@Fact("user") User user) throws Exception {
        user.setResult("REJECT");
    }
}

@Rule(name = "深度分析", priority = 10)
public class DeepAnalysisRule {
    @Condition
    public boolean when(@Fact("user") User user) {
        // 只有快速拒绝没命中时才会执行
        return user.getRiskScore() > 80;
    }
}

知识体系总览

下面这张图，是我对规则引擎优化的整体理解。你可以把它当作调优的检查清单。

规则引擎优化，说到底就是三件事：少算、快算、算对。编译缓存解决「少算」，规则分层解决「快算」，算法选择解决「算对」。这三板斧下去，大部分性能问题都能解决。

嗯，今天就聊到这儿。记住，别一上来就调算法——先看看你的规则有没有重复编译，再看看规则是不是都堆在一起。很多时候，问题就出在这些「小事」上。

---