零基础入门：手把手搭建简易规则引擎指南

2025年12月17日 互联网

一、规则引擎的核心价值与应用场景

规则引擎是一种将业务逻辑与程序代码解耦的技术框架，通过定义规则集合实现动态决策。典型应用场景包括：

  1. 风控系统：实时检测交易异常（如频繁登录、大额转账）
  2. 促销系统：根据用户行为自动匹配优惠券策略
  3. 工作流系统：动态调整审批流程节点
  4. 物联网设备：根据传感器数据触发告警规则

相较于硬编码的if-else判断，规则引擎的优势在于：

  • 业务规则可独立维护，无需重新部署系统
  • 支持规则的动态增删改查
  • 提升系统可测试性与可维护性

二、简易规则引擎架构设计

1. 核心组件划分

组件 功能描述 示例数据结构
规则存储 持久化规则集合 JSON数组或数据库表
规则解析器 将文本规则转换为可执行结构 AST抽象语法树
事实对象 待匹配的业务数据 Map 或POJO
执行引擎 执行规则匹配与结果聚合 责任链模式或策略模式

2. 数据流设计

  1. graph TD
  2.     A[事实对象输入] --> B[规则匹配器]
  3.     B --> C{匹配成功?}
  4.     C -->|是| D[执行动作]
  5.     C -->|否| E[跳过规则]
  6.     D --> F[聚合结果]
  7.     E --> F
  8.     F --> G[输出决策]

三、分步骤实现指南

步骤1：定义规则数据结构

采用JSON格式存储规则，示例如下：

  1. {
  2.   "rules": [
  3.     {
  4.       "id": "rule_001",
  5.       "condition": "user.age > 18 && user.vipLevel == 'GOLD'",
  6.       "action": "grantCoupon('VIP_DISCOUNT')"
  7.     },
  8.     {
  9.       "id": "rule_002",
  10.       "condition": "order.amount > 1000",
  11.       "action": "setShipping('FREE')"
  12.     }
  13.   ]
  14. }

步骤2：构建规则解析器

使用Java的ScriptEngine实现动态条件解析：

  1. public class RuleParser {
  2.     private ScriptEngine engine = new ScriptEngineManager().getEngineByName("js");
  4.     public boolean evaluate(String condition, Map<String, Object> facts) {
  5.         try {
  6.             // 将事实对象注入引擎上下文
  7.             facts.forEach((k, v) -> engine.put(k, v));
  8.             return (Boolean) engine.eval(condition);
  9.         } catch (Exception e) {
  10.             throw new RuleParseException("条件解析失败: " + condition, e);
  11.         }
  12.     }
  13. }

步骤3：实现执行引擎

采用责任链模式处理规则链：

  1. public interface RuleHandler {
  2.     void handle(Map<String, Object> facts, List<String> results);
  3.     RuleHandler setNext(RuleHandler next);
  4. }
  6. public class ConditionRuleHandler implements RuleHandler {
  7.     private Rule rule;
  8.     private RuleHandler next;
  10.     public ConditionRuleHandler(Rule rule) {
  11.         this.rule = rule;
  12.     }
  14.     @Override
  15.     public void handle(Map<String, Object> facts, List<String> results) {
  16.         RuleParser parser = new RuleParser();
  17.         if (parser.evaluate(rule.getCondition(), facts)) {
  18.             results.add(rule.getAction()); // 实际场景应执行具体动作
  19.         }
  20.         if (next != null) {
  21.             next.handle(facts, results);
  22.         }
  23.     }
  25.     @Override
  26.     public RuleHandler setNext(RuleHandler next) {
  27.         this.next = next;
  28.         return next;
  29.     }
  30. }

步骤4：构建规则链

  1. public class RuleEngine {
  2.     private RuleHandler head;
  4.     public void addRule(Rule rule) {
  5.         RuleHandler handler = new ConditionRuleHandler(rule);
  6.         if (head == null) {
  7.             head = handler;
  8.         } else {
  9.             RuleHandler current = head;
  10.             while (current.setNext(null) != null) {
  11.                 current = current.setNext(null);
  12.             }
  13.             current.setNext(handler);
  14.         }
  15.     }
  17.     public List<String> execute(Map<String, Object> facts) {
  18.         List<String> results = new ArrayList<>();
  19.         if (head != null) {
  20.             head.handle(facts, results);
  21.         }
  22.         return results;
  23.     }
  24. }

四、性能优化策略

  1. 规则索引优化：

    • 按条件字段建立倒排索引
    • 示例：为user.age字段建立数值范围索引

  2. 执行策略选择：

    • 顺序执行：适合规则数量<100的场景
    • RETE算法：适合复杂规则网络（可引入开源库实现）

  3. 缓存机制：

    1. public class RuleCache {
    2.     private Cache<String, Boolean> conditionCache = Caffeine.newBuilder()
    3.         .maximumSize(1000)
    4.         .expireAfterWrite(10, TimeUnit.MINUTES)
    5.         .build();
    7.     public boolean getCachedResult(String conditionHash, Map<String, Object> facts) {
    8.         return conditionCache.getIfPresent(conditionHash);
    9.     }
    10. }

五、最佳实践建议

  1. 规则管理规范：

    • 规则ID采用业务域_序号格式（如RISK_001）
    • 条件表达式限制在50字符以内

  2. 安全防护措施：

    • 对用户输入的规则进行语法校验
    • 限制脚本引擎的执行权限

  3. 监控指标设计：

    • 规则匹配成功率
    • 单条规则执行耗时
    • 规则变更频率

六、扩展方向

  1. 集成AI能力：

    • 使用自然语言处理解析规则描述
    • 示例：将”如果用户最近30天消费超过5次则标记为活跃”转换为结构化规则

  2. 分布式执行：

    • 采用消息队列拆分规则执行
    • 使用Redis实现分布式锁控制规则变更

  3. 可视化编辑：

    • 开发Web界面拖拽生成规则
    • 集成Blockly等图形化编程库

通过本文的实践，开发者可以快速构建一个基础规则引擎，后续可根据业务需求逐步扩展复杂功能。建议从风控场景或促销系统切入验证核心逻辑，再通过性能测试优化执行效率。

最新文章