规则引擎之 Easy Rules 详解

Easy Rules 简介

Easy Rules 是一个轻量级的 Java 规则引擎框架，专注于简化规则引擎的开发和使用。它基于 POJO（Plain Old Java Object）和 Java 8 的流式 API，使开发者能够以简单的方式定义和管理规则。

---

Easy Rules 的主要特点

1. 轻量级：依赖少，配置简单。
2. 规则即代码：通过 POJO 定义规则，无需复杂的 DSL（领域特定语言）。
3. 灵活的规则管理：支持规则优先级、动态加载规则等功能。
4. 易于扩展：支持自定义规则执行器、规则监听器等。

---

核心概念

1. 规则（Rule）

   • 每个规则包含两个部分：
     • 条件：决定规则是否应该执行。
     • 动作：当条件为真时执行的逻辑。
   • 使用 @Rule 注解或者实现 Rule 接口。

2. 规则引擎（RulesEngine）

   • 用于执行一组规则。框架内置了一些规则引擎，例如 DefaultRulesEngine。

3. 规则容器（Rules）

   • 一个集合，用于存储多个规则。

4. 规则监听器（RuleListener）

   • 监听规则的执行过程，可以在规则执行前、执行后或跳过时触发操作。

---

依赖引入

在 pom.xml 中引入 Easy Rules：

<dependency>
    <groupId>org.jeasy</groupId>
    <artifactId>easy-rules-core</artifactId>
    <version>4.4.0</version>
</dependency>

---

示例开发：Easy Rules 使用入门

1. 定义规则

规则可以通过以下两种方式定义：

方式 1：基于注解的规则

import org.jeasy.rules.annotation.Action;
import org.jeasy.rules.annotation.Condition;
import org.jeasy.rules.annotation.Priority;
import org.jeasy.rules.annotation.Rule;

@Rule(name = "Weather Rule", description = "If it rains, take an umbrella")
public class WeatherRule {

    @Condition
    public boolean itRains() {
        // 定义规则的条件逻辑
        return true; // 假设下雨
    }

    @Action
    public void takeUmbrella() {
        // 定义规则触发的动作
        System.out.println("It rains, take an umbrella!");
    }

    @Priority
    public int getPriority() {
        // 定义规则优先级，值越小优先级越高
        return 1;
    }
}

方式 2：基于接口的规则

import org.jeasy.rules.api.Rule;
import org.jeasy.rules.api.Facts;

public class WeatherRuleInterface implements Rule {

    @Override
    public boolean evaluate(Facts facts) {
        // 判断规则条件
        return facts.get("weather").equals("rainy");
    }

    @Override
    public void execute(Facts facts) throws Exception {
        // 执行规则逻辑
        System.out.println("It rains, take an umbrella!");
    }
}

---

2. 创建规则引擎

将规则加载到规则引擎中并执行：

import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rules;
import org.jeasy.rules.core.DefaultRulesEngine;

public class EasyRulesExample {
    public static void main(String[] args) {
        // 定义事实
        Facts facts = new Facts();
        facts.put("weather", "rainy");

        // 定义规则
        Rules rules = new Rules();
        rules.register(new WeatherRule()); // 使用注解定义的规则

        // 创建规则引擎
        DefaultRulesEngine rulesEngine = new DefaultRulesEngine();

        // 执行规则
        rulesEngine.fire(rules, facts);
    }
}

输出结果：

It rains, take an umbrella!

---

进阶功能

1. 规则优先级

• 通过 @Priority 注解或 Rule 的 getPriority 方法定义规则的执行顺序。
• 默认优先级为 Integer.MAX_VALUE，值越小，优先级越高。

2. 动态规则加载

Easy Rules 支持从外部动态加载规则，例如 JSON 文件或其他数据源。

示例：从 JSON 加载规则

引入 JSON 模块：

<dependency>
    <groupId>org.jeasy</groupId>
    <artifactId>easy-rules-mvel</artifactId>
    <version>4.4.0</version>
</dependency>

定义 JSON 规则文件（rules.json）：

[
  {
    "name": "Weather Rule",
    "description": "If it rains, take an umbrella",
    "priority": 1,
    "condition": "facts['weather'] == 'rainy'",
    "actions": [
      "System.out.println('It rains, take an umbrella!')"
    ]
  }
]

加载和执行规则：

import org.jeasy.rules.api.Facts;
import org.jeasy.rules.core.DefaultRulesEngine;
import org.jeasy.rules.mvel.MVELRule;
import org.jeasy.rules.support.reader.JsonRuleDefinitionReader;
import org.jeasy.rules.support.reader.RuleDefinitionReader;

import java.io.FileReader;
import java.util.List;

public class DynamicRuleExample {
    public static void main(String[] args) throws Exception {
        // 读取 JSON 文件
        RuleDefinitionReader reader = new JsonRuleDefinitionReader();
        List<MVELRule> rules = reader.read(new FileReader("rules.json"));

        // 定义事实
        Facts facts = new Facts();
        facts.put("weather", "rainy");

        // 加载规则并执行
        DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
        rulesEngine.fire(new org.jeasy.rules.api.Rules(rules), facts);
    }
}

---

3. 规则监听器

通过监听器捕获规则的执行流程，适用于日志记录或扩展逻辑。

import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rule;
import org.jeasy.rules.core.RuleListener;

public class CustomRuleListener implements RuleListener {

    @Override
    public boolean beforeEvaluate(Rule rule, Facts facts) {
        System.out.println("Evaluating rule: " + rule.getName());
        return true;
    }

    @Override
    public void afterEvaluate(Rule rule, Facts facts, boolean evaluationResult) {
        System.out.println("Rule evaluated: " + rule.getName() + " - " + evaluationResult);
    }

    @Override
    public void onSuccess(Rule rule, Facts facts) {
        System.out.println("Rule executed successfully: " + rule.getName());
    }

    @Override
    public void onFailure(Rule rule, Facts facts, Exception exception) {
        System.out.println("Rule execution failed: " + rule.getName());
    }
}

注册监听器：

DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.registerRuleListener(new CustomRuleListener());

---

典型应用场景

1. 业务规则引擎
   例如电商促销规则、积分规则。

2. 告警处理
   根据监控数据动态触发告警。

3. 审批工作流
   判断是否满足审批条件并执行相应操作。

4. 动态策略引擎
   支持从数据库或文件加载规则，实现动态变更业务逻辑。

---

Easy Rules 优缺点

优点

• 简单易用：无需复杂配置。
• 轻量级：适合中小型项目。
• 灵活扩展：支持自定义监听器、动态规则加载等。

缺点

• 功能较少：不支持复杂规则编排。
• 性能有限：对于规则较多或执行频繁的场景，可能需要更高性能的框架（如 Drools）。

---

总结

Easy Rules 非常适合需要快速实现业务规则引擎的场景。对于中小型项目，Easy Rules 的简单性和灵活性是一大优势。如果项目规则复杂或者性能要求较高，可以考虑结合 Drools 等更强大的规则引擎使用。