风控规则引擎:事实、匹配与可审计动作

风控规则引擎:事实、匹配与可审计动作

Hello,我是小兔大白糖。 规则写在代码 if-else 里改不动,热更又怕误杀——规则引擎要的是可版本、可审计、可回滚的合同。写成这篇,给要做规则引擎选型与生命周期设计的同学。

风控规则引擎把事实、匹配与动作做成可版本、可审计、可回滚的合同,而不是散落 if-else。

估计阅读时间:25 分钟

事实、规则匹配、动作与审计
事实、规则匹配、动作与审计 · 点击查看 SVG 原图

只想先建立心智模型? 直接看 §0 入门向:大白话 + 案例 + 数据流,够用。
下文 §1~§7 是深入版(Rete、Drools 语法、性能调优等),需要时再读。

专业版一句话:规则引擎把「如果…就…」从 Java 里拆出去,改成可配置规则;运行时把业务数据塞进去,引擎自动找匹配的规则并执行结果。


0. 入门:大白话与数据流是什么?

0.1 规则引擎到底是什么?(不用术语)

你可以把它想成 「可配置的一堆 if-else」,但:

  • 规则写在配置文件里(如 .drl、Excel、后台页面),改规则往往不用改 Java、不用发版。
  • Java 只负责:拿数据、调用引擎、把结果返回给业务。
  • 引擎负责:哪条「如果…就…」成立了,该执行哪条。

不适合用规则引擎的:逻辑就三五行、一年不变、没有「运营要改阈值」的需求 → 普通 if-else 更简单。

适合用的:规则多、变得勤、多人维护(风控、促销、路由、广告选渠道等)。


0.2 专业词 → 人话(文档/评审里能对上号)

面试/文档里常说的人话类比
Rule Base / 规则库所有「如果…就…」的集合一本菜谱
Fact / 事实这一次要用到的业务数据当前这桌客人的点单信息
Working Memory本次请求里放进引擎的那些 Fact配菜机器人面前的订单板
LHS(when)「如果」—— 条件菜谱里的「若点了牛排」
RHS(then)「就」—— 动作「则配烤土豆」
fireAllRules让引擎跑一遍,该执行的执行机器人按菜谱走一轮
Salience / 优先级多条规则都命中时谁先谁后VIP 菜先炒
Rete一种加速「找哪条规则命中」的算法后厨共享备料,别每道菜从头切菜
内嵌 Drools规则引擎和业务在同一个 Java 进程里规则装在自家服务器里
KIE Server规则引擎单独部署,业务 HTTP 调它规则放在中央厨房,各店打电话点菜

记不住 Rete 也没关系;对外可以说:「规则多时,引擎用 Rete 之类的方式少做重复判断,我们场景规则量不大时,更关心可维护性。」


0.3 一次请求的通用数据流(建议先记)

不管 Drools 还是自研,流程都是这三步:

risk rule engine design · 图 2
risk rule engine design · 图 2 · 点击查看 SVG 原图
步骤谁做做什么
1你的 Java从 DB/请求里取出金额、用户等级、IP… 放进一个或多个 Fact 对象
2规则引擎用 when 和 Fact 比对;命中的规则执行 then(改 Fact、写结果对象)
3你的 Java读「决策结果」:通过 / 拒绝 / 打标 / 选哪个广告渠道

规则文件存在哪? 常见三种(选型讨论提一句即可):

  1. classpath 本地文件(.drl)—— 学习、中小项目;改完要重启或做热加载。
  2. Git / 配置中心 —— 规则和代码一起版本管理。
  3. 数据库 + 后台编辑 —— 运营改规则;启动或定时拉取后编译进引擎(要自己实现)。

0.4 案例一:风控转账(常见教学例子)

业务:用户发起一笔转账,系统要决定:放行、人工审核、还是直接拒绝。

不用规则引擎的写法(全在 Service 里):

if (amount > 100_000) return REJECT;
if (blacklist.contains(userId)) return REJECT;
if (amount > 10_000 && country.equals("XX")) return REVIEW;
// … 几十条 continue 叠在一起

用规则引擎:Java 只组一个 Fact,规则写在文件里。

// 伪规则,表达意思即可
rule "大额拒绝"
  when:  金额 > 10万
  then:  决策 = 拒绝

rule "黑名单"
  when:  用户在黑名单
  then:  决策 = 拒绝

数据流(结合上图):

risk rule engine design · 图 3
risk rule engine design · 图 3 · 点击查看 SVG 原图

面试怎么说:
「我们把易变的拦截条件从代码抽到规则里;Java 负责接入和 Fact 组装,引擎负责匹配。规则变更可以走配置发布,不用每次改 Service 发版。」


0.5 案例二:启动页广告选网盟(真实项目,便于落地理解)

你在 某业务系统 某业务系统 里做过的改造,就是典型的 「决策表」型规则引擎,比风控简单,很适合讲清实现细节。

业务:App 打开时没有自家直客广告,要在穿山甲、优量汇、倍孜等网盟里选一个,并带上对应 广告位 ID。

原来:AdController 里两百行 if (ios && chuanShanJia) setAdType… setAdId… else if …。

现在:

部分放哪干什么
有没有直客广告、iPad 只出直客、审核期隐藏Java AdController流程控制
按配置比例 随机 选一家网盟Java getUsedAdProviderWithPercentage带随机,不适合写进 drl
版本不够时 AdTroop 改穿山甲Java改的是「选谁」,不是映射表
网盟名 → adType + adIdDrools launch-ad-provider.drl纯映射规则

Fact 设计(面试加分):

  • 输入 LaunchAdProviderContext:platform=ios/android、providerName=chuanshanjia、各渠道配置 ID…
  • 输出 LaunchAdProviderDecision:matched、adType、adId

数据流:

risk rule engine design · 图 4
risk rule engine design · 图 4 · 点击查看 SVG 原图

规则长什么样(节选):

rule "ios_chuanshanjia"
when
    ctx : LaunchAdProviderContext(platform == "ios", providerName == "chuanshanjia")
    decision : LaunchAdProviderDecision(matched == false)
then
    decision.setMatched(true);
    decision.setAdType("穿山甲");
    decision.setAdId( 配置ID 或 默认 "887628450" );
end

项目内详细文档(含 12 条规则对照表):
某业务系统.Service.Java.某业务系统/docs/drools-launch-ad/实现说明.md


0.6 内嵌还是单独部署?(面试常问)

方式什么意思什么时候选
内嵌Drools jar 和 Spring Boot 一起启动,KieContainer 在进程内单系统、延迟敏感、学习 demo(你的广告项目就是这种)
独立 KIE Server单独起一个规则服务,业务 HTTP/RPC 调多条业务线共用一套规则、运营统一控制台

广告改造选 内嵌 + classpath 的 .drl` 足够;不必为了面试硬上 KIE Server。


0.7 和 if-else、和机器学习怎么区分?(简答)

risk rule engine design · 图 5
risk rule engine design · 图 5 · 点击查看 SVG 原图
  • if-else:和规则引擎干的事一样,但规则写在代码里,难交给运营改。
  • 规则引擎:适合 可解释、可配置 的布尔逻辑(过线就拦)。
  • 模型:适合 模式难写清 的场景(规则补不住再用模型兜底)。

交易所常见说法:「硬规则拦截用引擎,可疑行为打分用模型,两者并行或规则在前。」


0.8 面试 6 问 6 答(白话版)

Q1:你们为什么用规则引擎?
A:网盟/风控规则经常改,不想每次改 Controller 发版;规则抽成 drl 或配置,Java 只编排流程。

Q2:一次调用规则引擎的步骤?
A:组 Fact → insert → fireAllRules → 读结果 Fact → dispose Session。

Q3:规则存在哪?
A:我们学习/项目里是 resources 下 .drl 文件;生产也可能是 DB 或规则平台,本质都是「规则文本 → 启动时编译进内存」。

Q4:Rete 了解吗?
A:知道是 Drools 用来加速匹配的;规则特别多时才关键。我们条数不多,更看重可读性和和 Java 分工。

Q5:规则引擎和 if-else 怎么选?
A:规则少、不变用 if-else;规则多、多人改、要带优先级用引擎。

Q6:做过相关项目吗?
A:可以把启动页广告为例:原 200 行 if-else 拆成 Java 选渠道 + Drools 做 provider 到 adId 映射,并写了 Fact 输入输出分离。


0.9 读完 §0 之后

你想…去看
面试能讲 + 结合自己项目§0 足够,再扫一眼 §5 业务场景
写 Drools drl / 看 Rete 图§2、§3
和 大型加密货币交易所 架构对标§4、§5
深挖 FAQ(热更新、和模型协作)§6

1. 这是什么?概念怎么定义

1.1 规则引擎的本质

规则引擎(Rule Engine)是一种将业务规则与应用程序代码分离的组件,允许业务分析师或运营人员通过外部配置(DSL、可视化界面、脚本)动态修改决策逻辑,无需重新发布应用。

核心三要素:

  • Rule Base(规则库):所有规则的集合,包含条件(LHS, Left-Hand Side)和动作(RHS, Right-Hand Side)
  • Working Memory(工作内存):当前待匹配的事实(Facts)集合,即业务数据对象
  • Inference Engine(推理机):负责模式匹配、冲突消解和规则执行的引擎核心

1.2 类比理解

类比:餐厅后厨的自动配菜系统

  • 规则库 = 菜谱(如果客人点了牛排且要求七分熟,则配菜为烤土豆和时蔬)
  • 工作内存 = 当前所有订单信息(桌号、菜品、口味偏好、过敏原)
  • 推理机 = 智能配菜机器人(扫描所有订单,匹配菜谱,决定先炒哪道菜)
  • Rete 算法 = 机器人脑子里的一张"共享备料清单"——如果 5 桌都点了牛排,机器人不会重复切 5 次肉,而是只切一次,共享给所有匹配的规则

1.3 为什么需要规则引擎

在风控系统中,规则的变更频率极高:

  • 新诈骗手法出现 → 需新增识别规则
  • 监管政策变化 → 需调整阈值
  • 大促期间 → 需临时放宽/收紧规则

如果没有规则引擎,这些变更需要走 发版 → 编译 → 测试 → 上线 的全流程,周期长、风险高。规则引擎实现了 Rule as Code → Rule as Configuration 的跃迁。


2. 核心原理是什么?

核心原理:事实进入匹配,命中后产可审计动作;规则要可版本、可热更、可回滚。

2.1 规则引擎执行生命周期

risk rule engine design · 图 6
risk rule engine design · 图 6 · 点击查看 SVG 原图

执行循环(Match-Resolve-Act):

  1. Match:将 Working Memory 中的 Facts 与 Rule Base 中的 LHS 进行模式匹配
  2. Resolve:当多条规则同时匹配时,通过优先级、salience、最近使用等策略选择一条
  3. Act:执行选中规则的 RHS(可能修改 Working Memory,触发新的匹配)

2.2 Drools Rete 算法深度解析

Rete(拉丁语"网络")是 Charles Forgy 于 1974 年提出的模式匹配算法,核心思想是利用规则间的条件共享,避免重复计算。

risk rule engine design · 图 7
risk rule engine design · 图 7 · 点击查看 SVG 原图

Rete 网络核心结构:

节点类型功能示例
Object Type Node按对象类型分流RiskEvent 走这条分支
Alpha Node单条件过滤,无状态amount > 10000
Beta Node多条件 Join,维护 Partial Match(amount>10000) AND (currency=='USDT')
Terminal Node规则触发点,指向 RHS执行拦截/告警

关键优化点:

  • 节点共享:如果 Rule A 和 Rule B 都有 amount > 10000 这个条件,Rete 网络中只会有一个 Alpha Node,两份规则共享匹配结果
  • Alpha Memory:缓存单条件过滤结果,Fact 未变时直接复用
  • Beta Memory:缓存 Join 结果,新 Fact 到达时只需增量计算

复杂度对比:

  • 朴素实现:每次插入 Fact 需要遍历所有规则的所有条件 → O(R × C)(R=规则数,C=每规则条件数)
  • Rete 算法:Fact 沿着网络流动,只经过相关节点 → 接近 O(C)(C=与该 Fact 相关的条件数)

2.3 冲突消解策略(Conflict Resolution)

当多个规则同时满足时,推理机需要决定执行哪一条。Drools 默认策略:

  1. Salience(优先级):数值越高越先执行
  2. Recency(最近使用):最近加入 Working Memory 的 Fact 触发的规则优先
  3. Rule Order(规则顺序):加载顺序靠后的优先
  4. Complexity(复杂度):条件越复杂的规则优先(更具体)
risk rule engine design · 图 8
risk rule engine design · 图 8 · 点击查看 SVG 原图

2.4 规则热更新与版本控制架构

生产环境中规则必须支持热更新,核心架构:

risk rule engine design · 图 9
risk rule engine design · 图 9 · 点击查看 SVG 原图

关键技术点:

  • 版本隔离:每个规则版本有独立 ID,新旧版本可同时存在于内存
  • 原子切换:使用 AtomicReference 切换规则集引用,保证无锁一致性
  • 灰度路由:基于用户 ID Hash 或业务标签决定使用哪个版本
  • 影子模式(Shadow Mode):新版本只执行但不影响决策,用于对比差异

3. 怎么用?关键代码与配置

3.1 轻量级自研规则引擎(基于注解 + 责任链)

对于规则数量 < 1000、复杂度不高的场景,自研轻量引擎比 Drools 更可控。以下是一个生产级的实现:

/**
 * 风控规则引擎核心接口
 * 设计哲学:轻量、可扩展、支持热更新
 */
public interface RiskRule {
    /** 规则名称 */
    String getName();
    /** 规则优先级,数值越大越优先 */
    int getPriority();
    /** 规则版本 */
    String getVersion();
    /** 评估条件 */
    boolean evaluate(RiskContext context);
    /** 执行动作 */
    RuleAction execute(RiskContext context);
}
 
/**
 * 规则执行结果
 */
public record RuleAction(
    Decision decision,      // PASS / REVIEW / REJECT
    String ruleId,
    String reasonCode,      // 标准化拒绝原因码
    Map<String, Object> metadata
) {}
 
/**
 * 规则上下文:包含所有需要被规则访问的数据
 */
public class RiskContext {
    private final RiskEvent event;
    private final UserProfile user;
    private final DeviceFingerprint device;
    private final List<HistoricalTransaction> history;
    private final Map<String, Object> features;  // 实时计算的特征
    // ... getters
}
 
/**
 * 规则引擎核心:责任链 + 优先级排序
 */
@Component
public class RiskRuleEngine {
 
    private volatile List<RiskRule> rules = new ArrayList<>();
    private final AtomicReference<Map<String, RiskRule>> ruleVersionMap = new AtomicReference<>();
    private final MeterRegistry meterRegistry;
 
    /**
     * 原子热更新规则集
     */
    public void refreshRules(List<RiskRule> newRules) {
        List<RiskRule> sorted = newRules.stream()
            .sorted(Comparator.comparingInt(RiskRule::getPriority).reversed())
            .toList();
 
        Map<String, RiskRule> versionMap = sorted.stream()
            .collect(Collectors.toMap(
                r -> r.getName() + ":" + r.getVersion(),
                Function.identity()
            ));
 
        this.rules = sorted;
        this.ruleVersionMap.set(versionMap);
 
        log.info("Rules refreshed, total={}, versions={}", sorted.size(), versionMap.keySet());
    }
 
    /**
     * 执行决策:短路求值 + 优先级排序
     */
    public RiskDecision evaluate(RiskContext context, String targetVersion) {
        long start = System.nanoTime();
        List<RuleAction> firedActions = new ArrayList<>();
        Decision finalDecision = Decision.PASS;
 
        for (RiskRule rule : rules) {
            // 版本过滤:灰度场景只执行指定版本的规则
            if (targetVersion != null && !rule.getVersion().equals(targetVersion)) {
                continue;
            }
 
            Timer.Sample sample = Timer.start(meterRegistry);
            try {
                if (rule.evaluate(context)) {
                    RuleAction action = rule.execute(context);
                    firedActions.add(action);
 
                    // 短路求值:一旦命中 REJECT,立即停止(最高优先级规则已排前面)
                    if (action.decision() == Decision.REJECT) {
                        finalDecision = Decision.REJECT;
                        break;
                    }
                    if (action.decision() == Decision.REVIEW && finalDecision == Decision.PASS) {
                        finalDecision = Decision.REVIEW;
                    }
                }
            } finally {
                sample.stop(meterRegistry.timer("rule.eval.duration",
                    "rule", rule.getName(),
                    "version", rule.getVersion()));
            }
        }
 
        meterRegistry.timer("rule.engine.duration").record(System.nanoTime() - start, TimeUnit.NANOSECONDS);
 
        return new RiskDecision(finalDecision, firedActions);
    }
}
 
/**
 * 具体规则实现示例:高频小额交易检测(盗刷/洗钱模式)
 */
@Component
public class HighFrequencySmallAmountRule implements RiskRule {
 
    @Autowired private RedisTemplate<String, String> redisTemplate;
    @Autowired private RuleConfigRepository configRepository;
 
    @Override
    public String getName() { return "HF_SMALL_AMOUNT"; }
 
    @Override
    public int getPriority() { return 900; }  // 高优先级
 
    @Override
    public String getVersion() { return "v2.1"; }
 
    @Override
    public boolean evaluate(RiskContext ctx) {
        RuleConfig config = configRepository.getConfig(getName());
 
        // 特征 1:最近 N 分钟交易笔数
        String countKey = "txn:count:" + ctx.getEvent().getUserId();
        String countStr = redisTemplate.opsForValue().get(countKey);
        int recentCount = countStr == null ? 0 : Integer.parseInt(countStr);
 
        // 特征 2:最近 N 分钟累计金额
        String amountKey = "txn:amount:" + ctx.getEvent().getUserId();
        String amountStr = redisTemplate.opsForValue().get(amountKey);
        BigDecimal recentAmount = amountStr == null ? BigDecimal.ZERO : new BigDecimal(amountStr);
 
        // 条件:高频(>10笔/5min)且小额(单笔<100)且累计>500
        return recentCount >= config.getInt("minCount", 10)
            && ctx.getEvent().getAmount().compareTo(config.getDecimal("maxSingleAmount", new BigDecimal("100"))) < 0
            && recentAmount.compareTo(config.getDecimal("minTotalAmount", new BigDecimal("500"))) >= 0;
    }
 
    @Override
    public RuleAction execute(RiskContext ctx) {
        return new RuleAction(
            Decision.REJECT,
            getName(),
            "RISK_HF_SMALL_AMOUNT_PATTERN",
            Map.of(
                "recentCount", redisTemplate.opsForValue().get("txn:count:" + ctx.getEvent().getUserId()),
                "suggestedAction", "BLOCK_24H",
                "escalationLevel", "HIGH"
            )
        );
    }
}
 
/**
 * 规则配置动态加载(支持热更新)
 */
@Component
public class RuleConfigRepository {
 
    private final ConcurrentHashMap<String, RuleConfig> cache = new ConcurrentHashMap<>();
    private final JdbcTemplate jdbcTemplate;
 
    @Scheduled(fixedDelay = 30000)  // 每 30s 刷新
    public void refresh() {
        List<RuleConfig> configs = jdbcTemplate.query(
            "SELECT rule_name, param_key, param_value, updated_at FROM risk_rule_config WHERE active = 1",
            (rs, rowNum) -> new RuleConfig(/* ... */)
        );
 
        configs.forEach(cfg -> cache.put(cfg.getRuleName(), cfg));
    }
 
    public RuleConfig getConfig(String ruleName) {
        return cache.getOrDefault(ruleName, RuleConfig.DEFAULT);
    }
}

3.2 Drools 规则文件示例(.drl)

对于规则数量 > 1000、需要复杂模式匹配(如多事实关联、时间窗口)的场景,Drools 是工业标准:

// ====== pom.xml ======
// <dependency>
//     <groupId>org.drools</groupId>
//     <artifactId>drools-core</artifactId>
//     <version>8.44.0.Final</version>
// </dependency>
 
// ====== RiskEvent.java ======
public class RiskEvent {
    private Long userId;
    private BigDecimal amount;
    private String currency;
    private String ipCountry;
    private String deviceId;
    private LocalDateTime timestamp;
    private TransactionType type;
    // getters...
}
 
// ====== risk-rules.drl ======
package com.大型加密货币交易所.risk.rules
 
dialect "java"
 
import com.大型加密货币交易所.risk.model.RiskEvent
import com.大型加密货币交易所.risk.model.Decision
import java.math.BigDecimal
import java.time.Duration
import java.time.LocalDateTime
 
// 全局变量:用于注入服务
// global com.大型加密货币交易所.risk.service.BlacklistService blacklistService;
// global com.大型加密货币交易所.risk.service.AlertService alertService;
 
// 规则 1:大额出金拦截(Salience=1000,最高优先级)
rule "LARGE_WITHDRAWAL_BLOCK"
    salience 1000
    no-loop true
    when
        $e : RiskEvent(
            type == TransactionType.WITHDRAWAL,
            amount >= 100000,
            currency == "USDT"
        )
    then
        insert(new Decision($e.getUserId(), "REJECT", "LARGE_WITHDRAWAL", "Large withdrawal blocked"));
        // alertService.sendAlert($e, "LARGE_WITHDRAWAL");
end
 
// 规则 2:黑名单国家 + 任何交易 = 直接拦截
rule "BLACKLIST_COUNTRY_BLOCK"
    salience 900
    no-loop true
    when
        $e : RiskEvent(
            ipCountry in ("XX", "YY", "ZZ")
        )
    then
        insert(new Decision($e.getUserId(), "REJECT", "BLACKLIST_COUNTRY", "Country in blacklist"));
end
 
// 规则 3:新设备 + 大额交易 = 强验证
rule "NEW_DEVICE_LARGE_TXN_REVIEW"
    salience 500
    when
        $e : RiskEvent(
            amount >= 10000,
            $deviceId : deviceId
        )
        // 这里可以关联另一个 Fact:DeviceTrustScore
        // $d : DeviceTrustScore(deviceId == $deviceId, score < 30)
    then
        insert(new Decision($e.getUserId(), "REVIEW", "NEW_DEVICE_RISK", "Require 2FA verification"));
end
 
// 规则 4:24h 内多笔小额后大额(盗刷模式)
rule "SMALL_THEN_LARGE_PATTERN"
    salience 800
    when
        $e : RiskEvent(amount >= 50000, $uid : userId)
        accumulate(
            RiskEvent(
                userId == $uid,
                amount < 1000,
                $ts : timestamp
            )
            over window:time(24h) from $e.timestamp,
            $count : count(),
            $total : sum(amount);
            $count >= 5, $total >= 2000
        )
    then
        insert(new Decision($uid, "REJECT", "SUSPICIOUS_PATTERN",
            "Rapid small transactions followed by large withdrawal"));
end

3.3 Easy Rules 轻量方案(适合简单场景)

/**
 * Easy Rules 适合规则简单、不想引入 Drools 依赖的场景
 * 核心:@Rule + @Condition + @Action 注解
 */
@Rule(name = "UnusualLoginLocation", description = "非常用登录地点检测")
public class UnusualLoginLocationRule {
 
    @Autowired private UserLocationService locationService;
 
    private RiskEvent event;
    private Decision decision;
 
    @Condition
    public boolean when() {
        String usualCountry = locationService.getUsualCountry(event.getUserId());
        return usualCountry != null && !usualCountry.equals(event.getIpCountry());
    }
 
    @Action
    public void then() throws Exception {
        decision = new Decision(event.getUserId(), "REVIEW", "UNUSUAL_LOCATION",
            "Login from unusual country: " + event.getIpCountry());
    }
 
    @Priority
    public int priority() { return 700; }
 
    // setter for event
}
 
// 使用方式
public class EasyRulesDemo {
    public static void main(String[] args) {
        RulesEngineParameters parameters = new RulesEngineParameters()
            .skipOnFirstAppliedRule(false)  // 不短路,执行所有匹配规则
            .skipOnFirstFailedRule(false);
 
        RulesEngine engine = new DefaultRulesEngine(parameters);
 
        Rules rules = new Rules();
        rules.register(new UnusualLoginLocationRule());
        rules.register(new HighFrequencyRule());
 
        Facts facts = new Facts();
        facts.put("event", riskEvent);
 
        engine.fire(rules, facts);
    }
}

3.4 规则版本控制与灰度发布组件

/**
 * 规则版本管理器:支持多版本共存、灰度发布、秒级回滚
 */
@Component
public class RuleVersionManager {
 
    // 主规则集(AtomicReference 保证可见性)
    private final AtomicReference<RuleSet> activeRuleSet = new AtomicReference<>();
 
    // 灰度规则集:version -> RuleSet
    private final ConcurrentHashMap<String, RuleSet> grayRuleSets = new ConcurrentHashMap<>();
 
    // 影子规则集:用于对比新旧版本决策差异
    private volatile RuleSet shadowRuleSet;
 
    @Autowired private RuleCompiler compiler;
    @Autowired private MetricCollector metrics;
 
    /**
     * 编译并发布新版本
     */
    public void publishVersion(String version, List<RuleDefinition> definitions, GrayConfig gray) {
        RuleSet compiled = compiler.compile(definitions);
 
        if (gray.isEnabled()) {
            // 灰度发布:先放入灰度集合
            grayRuleSets.put(version, compiled);
            log.info("Version {} published in GRAY mode: {}%", version, gray.getPercentage());
        } else {
            // 全量发布:直接替换主引用
            RuleSet old = activeRuleSet.getAndSet(compiled);
            log.info("Version {} published in FULL mode. Previous: {}",
                version, old != null ? old.getVersion() : "null");
        }
    }
 
    /**
     * 根据请求选择规则版本
     */
    public RuleSet resolveRuleSet(String userId, String requestVersion) {
        // 1. 强制指定版本(用于压测/调试)
        if (requestVersion != null && grayRuleSets.containsKey(requestVersion)) {
            return grayRuleSets.get(requestVersion);
        }
 
        // 2. 灰度命中判断
        for (Map.Entry<String, RuleSet> entry : grayRuleSets.entrySet()) {
            GrayConfig gray = entry.getValue().getGrayConfig();
            if (gray != null && gray.matches(userId)) {
                metrics.increment("rule.gray.hit", "version", entry.getKey());
                return entry.getValue();
            }
        }
 
        // 3. 默认返回主版本
        return activeRuleSet.get();
    }
 
    /**
     * 影子模式执行:同时跑新旧版本,对比决策差异
     */
    public ShadowResult evaluateWithShadow(RiskContext ctx) {
        RuleSet current = activeRuleSet.get();
        RuleSet shadow = shadowRuleSet;
 
        RiskDecision currentDecision = current.evaluate(ctx);
        RiskDecision shadowDecision = shadow != null ? shadow.evaluate(ctx) : null;
 
        if (shadowDecision != null && !currentDecision.equals(shadowDecision)) {
            metrics.increment("rule.shadow.mismatch");
            log.warn("Shadow mismatch! current={}, shadow={}", currentDecision, shadowDecision);
        }
 
        return new ShadowResult(currentDecision, shadowDecision);
    }
 
    /**
     * 紧急回滚:秒级切换
     */
    public void rollback(String targetVersion) {
        RuleSet target = grayRuleSets.get(targetVersion);
        if (target == null) {
            throw new RuleException("Rollback target not found: " + targetVersion);
        }
        activeRuleSet.set(target);
        grayRuleSets.clear();  // 清空灰度
        log.info("ROLLED BACK to version {}", targetVersion);
        metrics.increment("rule.rollback", "target", targetVersion);
    }
}
 
/**
 * 灰度配置:支持用户 ID Hash、白名单、百分比
 */
public class GrayConfig {
    private boolean enabled;
    private int percentage;        // 0-100
    private Set<String> whitelist; // 强制命中用户
    private String hashSeed;       // 哈希种子
 
    public boolean matches(String userId) {
        if (whitelist != null && whitelist.contains(userId)) return true;
        if (percentage <= 0) return false;
        if (percentage >= 100) return true;
 
        int hash = Math.abs((userId + hashSeed).hashCode());
        return hash % 100 < percentage;
    }
}

4. 业界怎么做?

4.1 阿里巴巴风控规则引擎(Ant Shield / 蚁盾)

阿里巴巴的风控体系经历了三代演进:

阶段架构规则引擎
1.0 硬编码if-else 堆砌在业务代码中无
2.0 脚本化Groovy 脚本动态加载轻量 Groovy Engine
3.0 标准化可视化规则编排 + 规则市场自研 Rete-like 引擎

关键设计:

  • 规则市场:将风控规则抽象为可复用的"规则模板",不同业务线(淘宝、支付宝、菜鸟)可直接订阅
  • 分层决策:
    • L1(< 10ms):本地缓存的硬规则(黑名单、简单频控)
    • L2(< 50ms):规则引擎执行(Rete 网络匹配)
    • L3(< 200ms):模型打分(XGBoost/LightGBM)
    • L4(异步):复杂关联分析(图计算)
  • 规则冲突解决:引入了"规则域"概念,同一域内规则优先级由运营配置,跨域规则通过"决策融合器"加权

踩过的坑:

  1. 规则膨胀:双十一期间规则从 200 条膨胀到 2000 条,Rete 网络构建耗时从 50ms 增长到 2s。解决方案:规则分层 + 按需加载,只有命中前置条件的规则才加入当前网络
  2. Groovy 内存泄漏:动态编译的 Groovy Class 无法卸载,导致 Metaspace OOM。解决方案:规则预编译为 Java Class,使用独立 ClassLoader,热更新时销毁旧 Loader

4.2 美团外卖营销反作弊规则引擎

美团外卖的营销预算高达数十亿,羊毛党攻击猖獗。其规则引擎的特点:

业务场景:

  • 新用户首单立减被批量注册账号薅羊毛
  • 满减券被灰产集中倒卖
  • 骑手/商家合谋刷单骗补贴

技术架构:

  • 规则编排平台:运营通过拖拽方式组合规则节点(条件判断、特征计算、决策输出)
  • 规则 DSL:自研类 SQL 语法,例如:
    RULE "新用户异常检测" {
        WHEN user.register_time < NOW() - 7d
         AND device.fingerprint_similarity > 0.85
         AND order.amount < 5
        THEN decision = "REJECT",
             reason = "SUSPECTED_SHEEP_PARTY"
    }
  • 执行优化:将高频规则编译为 Java Bytecode(通过 Janino 编译器),执行性能接近原生 Java

核心经验:

  • 规则与模型融合:简单规则(明确红线)走规则引擎,模糊边界(行为异常度)走模型,两者通过决策矩阵融合
  • 规则效果量化:每条规则上线后必须绑定 A/B 测试,观测拦截率、误杀率、漏放率,ROI 为负的规则自动下线

4.3 LinkedIn 的 PiNG 风控规则系统

LinkedIn 使用 Apache Flink CEP 处理实时风控规则,核心场景是检测账号盗用和爬虫:

  • 时序模式规则:在 5 分钟内,如果同一账号先后在 3 个不同国家登录,且第 3 次登录后 10 秒内发送了 20+ 消息,则判定为盗号
  • CEP 模式:
    Pattern<LoginEvent, ?> pattern = Pattern.<LoginEvent>begin("first")
        .followedBy("second")
        .where(new SimpleCondition<LoginEvent>() {
            public boolean filter(LoginEvent evt) {
                return !evt.getCountry().equals(firstCountry);
            }
        })
        .followedBy("third")
        .within(Time.minutes(5));
  • 规则状态管理:Flink 的 Keyed State 存储每个用户的登录历史,支持 exactly-once 语义

5. 业务场景怎么对照?

场景对照:硬合规规则优先,模型分辅助;冲突用优先级与审计轨迹仲裁。

5.1 风控场景下的规则引擎应用

风控场景规则示例执行延迟要求引擎选型
登录风控异地登录 + 新设备 → 强制 MFA< 50ms自研轻量 + Redis
交易拦截大额出金 + 黑名单地址 → 阻断< 30ms自研/Drools
反洗钱结构化存款(10笔×9990)→ 上报< 200msDrools CEP
营销反欺诈同一设备注册 > 5 账号 → 拒绝< 100msEasy Rules
内容风控消息含敏感词 → 拦截/人工审核< 20ms自研 + AC 自动机

5.2 选型建议

方案规则数量复杂度性能维护成本适用场景
自研轻量< 500低极高低高频简单规则(如登录/频控)
Easy Rules< 200低高低中小型项目,快速上线
Drools> 1000高中高高复杂风控决策、多事实关联
Flink CEP< 100高(时序)高中实时流式模式检测

5.3 常见误区 vs 正确做法

❌ 误区 1:规则越多越好
    - 认为规则越多覆盖越全,实则规则膨胀会导致匹配性能指数下降
✅ 正确做法:定期清理无效规则,保持规则集在可控规模;规则上线必须有 A/B 测试验证 ROI
 
❌ 误区 2:规则引擎万能论
    - 试图用规则引擎解决所有风控问题,忽视模型能力
✅ 正确做法:规则负责"明确红线"(如黑名单、硬阈值),模型负责"模糊识别"(如行为异常度),两者互补
 
❌ 误区 3:规则更新无版本控制
    - 直接在数据库 UPDATE 规则,出错后无法回滚
✅ 正确做法:规则即代码,走 Git 版本控制;生产环境支持多版本并存 + 灰度 + 秒级回滚
 
❌ 误区 4:忽视规则执行性能监控
    - 规则执行时间黑盒,直到超时才发现问题
✅ 正确做法:每条规则必须上报执行耗时(P50/P99),设置超时熔断(如单规则 > 10ms 直接跳过)
 
❌ 误区 5:规则之间无隔离
    - Rule A 修改了全局状态,导致 Rule B 行为异常
✅ 正确做法:规则执行无副作用(或严格控制副作用),状态变更通过 Working Memory 统一协调

6. 高频问题怎么答?

Q1:Rete 算法的时间复杂度是多少?为什么比暴力匹配快?

答:Rete 算法的摊还时间复杂度接近 O(F + R),其中 F 是 Fact 数量,R 是被触发的规则数。

暴力匹配需要每个 Fact 与每条规则的每个条件比较 → O(F × R × C)。

Rete 快的原因:

  1. 节点共享:不同规则的前置条件共享 Alpha/Beta 节点,避免重复计算
  2. 状态缓存:Alpha Memory 缓存单条件结果,新 Fact 到达时只做增量更新
  3. 网络剪枝:Fact 从根节点流入,不满足的条件直接阻断,不会到达 Terminal Node

追问:Rete 的弱点是什么?

  • 内存消耗大:需要维护大量 Partial Match(Beta Memory)
  • 规则频繁变动时重建成本高:每次规则更新需重新构建网络
  • 不适合事实频繁变动的场景:如果 Working Memory 中的 Fact 不断增删,维护索引的开销可能超过收益

Q2:Drools 和我们自研的规则引擎,怎么选?

答:看三个维度:规则复杂度、团队能力、性能要求。

维度选 Drools选自研
规则复杂度多事实关联、时间窗口、复杂模式匹配单事实判断、简单条件组合
团队能力有 Drools 专家,能处理调优团队熟悉 Java,想完全掌控
性能要求可接受 10-50ms 级延迟要求 < 5ms 的极致延迟
规则数量> 1000 条< 500 条

大型加密货币交易所 风格建议:核心交易拦截链路用自研(极致性能),离线模型特征、复杂反洗钱规则用 Drools(表达能力)。

Q3:规则冲突消解的策略有哪些?风控场景下怎么选?

答:常见策略:

  1. Salience(优先级):数值高的先执行。适合风控的"硬规则优先"(如黑名单永远最高)
  2. Recency(最近事实优先):适合事件驱动的时序风控
  3. Specificity(特异性):条件越具体的规则越优先。适合"一般规则兜底,特殊规则优先"
  4. First/Last(加载顺序):简单粗暴,不推荐生产使用

风控最佳实践:

  • 第一层:绝对规则(黑名单、监管红线)→ Salience = 10000
  • 第二层:强规则(大额拦截、异常模式)→ Salience = 1000
  • 第三层:弱规则(可疑行为标记)→ Salience = 100
  • 第四层:兜底规则 → Salience = 0

追问:如果两条同优先级规则冲突怎么办?

  • 引入决策融合层:不是"非此即彼",而是收集所有规则输出,通过加权投票或决策矩阵得出最终结论

Q4:规则热更新怎么保证线程安全?更新过程中正在执行的请求怎么办?

答:核心方案是 Copy-on-Write + 原子切换:

// 旧引用继续服务正在执行的请求
private volatile RuleSet ruleSet = v1;
 
// 后台线程构建新版本
RuleSet v2 = compile(newDefinitions);
 
// 原子切换:volatile 保证后续请求立即看到新引用
ruleSet = v2;
 
// 旧版本 v1 的引用计数归零后 GC 回收

关键点:

  1. RuleSet 不可变:一旦发布,内部规则集合不再修改,避免并发问题
  2. 请求绑定版本:而不是共享全局版本。即每个请求开始时获取当前 ruleSet 引用,后续执行都基于这个引用
  3. 双缓冲策略:准备两套 RuleSet 内存,切换时只改指针,无锁

Q5:规则引擎和机器学习模型怎么协作?

答:三种协作模式:

  1. 前置过滤(规则先行)

    请求 → 规则引擎(黑名单/硬规则)→ [REJECT] 直接拦截
                           ↓ [PASS]
                    模型打分(XGBoost/神经网络)→ 综合决策
    

    优点:规则拦截明确风险,减少模型计算量(可能过滤掉 80% 请求)

  2. 并行执行(规则 + 模型同时跑)

    请求 ─┬─> 规则引擎 ─┐
          └─> 模型打分 ─┴─> 决策融合层 → 最终决策
    

    优点:充分利用两者信息,适合复杂场景 缺点:延迟取两者最大值

  3. 规则后置(模型先行)

    请求 → 模型打分 → 高风险 → 规则引擎精细化判断 → 决策
             ↓ 低风险
          直接放行
    

    优点:模型处理大部分简单请求,规则专注边界 case

大型加密货币交易所 实践建议:交易拦截用"规则先行"(低延迟),事后审计用"模型先行"(高召回)。

Q6:如何防止规则被绕过(Rule Evasion)?

答:这是风控规则引擎的独特挑战。攻击者会分析规则逻辑后针对性绕过:

防御策略:

  1. 规则混淆:生产环境不暴露规则细节,规则 ID 随机化
  2. 动态阈值:同一规则的实际阈值在一定范围内随机浮动(如 amount > 10000 ± 随机(0, 500))
  3. 多规则覆盖:同一风险点用多种规则从不同维度检测(金额、频率、设备、行为),绕过一条还有多条
  4. 蜜罐规则:插入无实际业务意义的规则,一旦被触发即标记攻击者在探测规则边界
  5. 模型兜底:规则被绕过还有模型作为第二道防线

7. 还要关联学什么?

文档关联点
E2 - 实时风控系统架构规则引擎是风控决策层的核心组件,与特征层、执行层协同
E4 - CEP 复杂事件处理复杂时序规则(如"5 分钟内 3 次失败后成功")需要 CEP 补充
B5 - 限流与熔断规则引擎本身需要限流保护(如规则执行超时熔断)
C5 - Redis 缓存策略规则条件中的特征数据(如用户历史行为)通常缓存于 Redis
S2 - 规则引擎服务设计系统 design 层面的规则服务架构(DSL、编译、执行、监控)
A4 - CAS 与 LongAdder规则命中计数器的高并发实现

记忆口诀:

  • Rete = 共享高速公路:Fact 上高速,相同检查不重复排队
  • 冲突消解 = 急诊分诊:先救最危重的(Salience 最高),同等级按来的先后(Recency)
  • 热更新 = 换轨不换车:新旧铁轨并行,火车瞬间切换,乘客无感知

系列:risk-systems #2