
Hello,我是小兔大白糖。 规则写在代码 if-else 里改不动,热更又怕误杀——规则引擎要的是可版本、可审计、可回滚的合同。写成这篇,给要做规则引擎选型与生命周期设计的同学。
风控规则引擎把事实、匹配与动作做成可版本、可审计、可回滚的合同,而不是散落 if-else。
估计阅读时间:25 分钟
只想先建立心智模型? 直接看 §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 还是自研,流程都是这三步:
| 步骤 | 谁做 | 做什么 |
|---|---|---|
| 1 | 你的 Java | 从 DB/请求里取出金额、用户等级、IP… 放进一个或多个 Fact 对象 |
| 2 | 规则引擎 | 用 when 和 Fact 比对;命中的规则执行 then(改 Fact、写结果对象) |
| 3 | 你的 Java | 读「决策结果」:通过 / 拒绝 / 打标 / 选哪个广告渠道 |
规则文件存在哪? 常见三种(选型讨论提一句即可):
- classpath 本地文件(
.drl)—— 学习、中小项目;改完要重启或做热加载。 - Git / 配置中心 —— 规则和代码一起版本管理。
- 数据库 + 后台编辑 —— 运营改规则;启动或定时拉取后编译进引擎(要自己实现)。
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: 决策 = 拒绝数据流(结合上图):
面试怎么说:
「我们把易变的拦截条件从代码抽到规则里;Java 负责接入和 Fact 组装,引擎负责匹配。规则变更可以走配置发布,不用每次改 Service 发版。」
0.5 案例二:启动页广告选网盟(真实项目,便于落地理解)
你在 某业务系统 某业务系统 里做过的改造,就是典型的 「决策表」型规则引擎,比风控简单,很适合讲清实现细节。
业务:App 打开时没有自家直客广告,要在穿山甲、优量汇、倍孜等网盟里选一个,并带上对应 广告位 ID。
原来:AdController 里两百行 if (ios && chuanShanJia) setAdType… setAdId… else if …。
现在:
| 部分 | 放哪 | 干什么 |
|---|---|---|
| 有没有直客广告、iPad 只出直客、审核期隐藏 | Java AdController | 流程控制 |
| 按配置比例 随机 选一家网盟 | Java getUsedAdProviderWithPercentage | 带随机,不适合写进 drl |
| 版本不够时 AdTroop 改穿山甲 | Java | 改的是「选谁」,不是映射表 |
| 网盟名 → adType + adId | Drools launch-ad-provider.drl | 纯映射规则 |
Fact 设计(面试加分):
- 输入
LaunchAdProviderContext:platform=ios/android、providerName=chuanshanjia、各渠道配置 ID… - 输出
LaunchAdProviderDecision:matched、adType、adId
数据流:
规则长什么样(节选):
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、和机器学习怎么区分?(简答)
- 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 规则引擎执行生命周期
执行循环(Match-Resolve-Act):
- Match:将 Working Memory 中的 Facts 与 Rule Base 中的 LHS 进行模式匹配
- Resolve:当多条规则同时匹配时,通过优先级、salience、最近使用等策略选择一条
- Act:执行选中规则的 RHS(可能修改 Working Memory,触发新的匹配)
2.2 Drools Rete 算法深度解析
Rete(拉丁语"网络")是 Charles Forgy 于 1974 年提出的模式匹配算法,核心思想是利用规则间的条件共享,避免重复计算。
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 默认策略:
- Salience(优先级):数值越高越先执行
- Recency(最近使用):最近加入 Working Memory 的 Fact 触发的规则优先
- Rule Order(规则顺序):加载顺序靠后的优先
- Complexity(复杂度):条件越复杂的规则优先(更具体)
2.4 规则热更新与版本控制架构
生产环境中规则必须支持热更新,核心架构:
关键技术点:
- 版本隔离:每个规则版本有独立 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"));
end3.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(异步):复杂关联分析(图计算)
- 规则冲突解决:引入了"规则域"概念,同一域内规则优先级由运营配置,跨域规则通过"决策融合器"加权
踩过的坑:
- 规则膨胀:双十一期间规则从 200 条膨胀到 2000 条,Rete 网络构建耗时从 50ms 增长到 2s。解决方案:规则分层 + 按需加载,只有命中前置条件的规则才加入当前网络
- 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)→ 上报 | < 200ms | Drools CEP |
| 营销反欺诈 | 同一设备注册 > 5 账号 → 拒绝 | < 100ms | Easy 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 快的原因:
- 节点共享:不同规则的前置条件共享 Alpha/Beta 节点,避免重复计算
- 状态缓存:Alpha Memory 缓存单条件结果,新 Fact 到达时只做增量更新
- 网络剪枝:Fact 从根节点流入,不满足的条件直接阻断,不会到达 Terminal Node
追问:Rete 的弱点是什么?
- 内存消耗大:需要维护大量 Partial Match(Beta Memory)
- 规则频繁变动时重建成本高:每次规则更新需重新构建网络
- 不适合事实频繁变动的场景:如果 Working Memory 中的 Fact 不断增删,维护索引的开销可能超过收益
Q2:Drools 和我们自研的规则引擎,怎么选?
答:看三个维度:规则复杂度、团队能力、性能要求。
| 维度 | 选 Drools | 选自研 |
|---|---|---|
| 规则复杂度 | 多事实关联、时间窗口、复杂模式匹配 | 单事实判断、简单条件组合 |
| 团队能力 | 有 Drools 专家,能处理调优 | 团队熟悉 Java,想完全掌控 |
| 性能要求 | 可接受 10-50ms 级延迟 | 要求 < 5ms 的极致延迟 |
| 规则数量 | > 1000 条 | < 500 条 |
大型加密货币交易所 风格建议:核心交易拦截链路用自研(极致性能),离线模型特征、复杂反洗钱规则用 Drools(表达能力)。
Q3:规则冲突消解的策略有哪些?风控场景下怎么选?
答:常见策略:
- Salience(优先级):数值高的先执行。适合风控的"硬规则优先"(如黑名单永远最高)
- Recency(最近事实优先):适合事件驱动的时序风控
- Specificity(特异性):条件越具体的规则越优先。适合"一般规则兜底,特殊规则优先"
- 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 回收关键点:
- RuleSet 不可变:一旦发布,内部规则集合不再修改,避免并发问题
- 请求绑定版本:而不是共享全局版本。即每个请求开始时获取当前
ruleSet引用,后续执行都基于这个引用 - 双缓冲策略:准备两套 RuleSet 内存,切换时只改指针,无锁
Q5:规则引擎和机器学习模型怎么协作?
答:三种协作模式:
-
前置过滤(规则先行)
请求 → 规则引擎(黑名单/硬规则)→ [REJECT] 直接拦截 ↓ [PASS] 模型打分(XGBoost/神经网络)→ 综合决策优点:规则拦截明确风险,减少模型计算量(可能过滤掉 80% 请求)
-
并行执行(规则 + 模型同时跑)
请求 ─┬─> 规则引擎 ─┐ └─> 模型打分 ─┴─> 决策融合层 → 最终决策优点:充分利用两者信息,适合复杂场景 缺点:延迟取两者最大值
-
规则后置(模型先行)
请求 → 模型打分 → 高风险 → 规则引擎精细化判断 → 决策 ↓ 低风险 直接放行优点:模型处理大部分简单请求,规则专注边界 case
大型加密货币交易所 实践建议:交易拦截用"规则先行"(低延迟),事后审计用"模型先行"(高召回)。
Q6:如何防止规则被绕过(Rule Evasion)?
答:这是风控规则引擎的独特挑战。攻击者会分析规则逻辑后针对性绕过:
防御策略:
- 规则混淆:生产环境不暴露规则细节,规则 ID 随机化
- 动态阈值:同一规则的实际阈值在一定范围内随机浮动(如
amount > 10000 ± 随机(0, 500)) - 多规则覆盖:同一风险点用多种规则从不同维度检测(金额、频率、设备、行为),绕过一条还有多条
- 蜜罐规则:插入无实际业务意义的规则,一旦被触发即标记攻击者在探测规则边界
- 模型兜底:规则被绕过还有模型作为第二道防线
7. 还要关联学什么?
| 文档 | 关联点 |
|---|---|
| E2 - 实时风控系统架构 | 规则引擎是风控决策层的核心组件,与特征层、执行层协同 |
| E4 - CEP 复杂事件处理 | 复杂时序规则(如"5 分钟内 3 次失败后成功")需要 CEP 补充 |
| B5 - 限流与熔断 | 规则引擎本身需要限流保护(如规则执行超时熔断) |
| C5 - Redis 缓存策略 | 规则条件中的特征数据(如用户历史行为)通常缓存于 Redis |
| S2 - 规则引擎服务设计 | 系统 design 层面的规则服务架构(DSL、编译、执行、监控) |
| A4 - CAS 与 LongAdder | 规则命中计数器的高并发实现 |
记忆口诀:
- Rete = 共享高速公路:Fact 上高速,相同检查不重复排队
- 冲突消解 = 急诊分诊:先救最危重的(Salience 最高),同等级按来的先后(Recency)
- 热更新 = 换轨不换车:新旧铁轨并行,火车瞬间切换,乘客无感知
系列:risk-systems #2