easy-rule规则引擎使用

简介

        轻量级的规则引擎，易于学习的api

        简单来说，规则引擎就是一个函数：y=f(x1,x2,…,xn)

        将业务代码和业务规则分离，解耦业务决策和业务代码的绑定关系

入门示例

依赖引入

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

<!--规则定义文件格式，支持json,yaml等-->
<dependency>
  <groupId>org.jeasy</groupId>
  <artifactId>easy-rules-support</artifactId>
  <version>4.1.0</version>
</dependency>

<!--支持mvel规则语法库-->
<dependency>
  <groupId>org.jeasy</groupId>
  <artifactId>easy-rules-mvel</artifactId>
  <version>4.1.0</version>
</dependency>

<dependency>
  <groupId>org.jeasy</groupId>
  <artifactId>easy-rules-spel</artifactId>
  <version>4.1.0</version>
</dependency>

代码示例

public static void main(String[] args) {

        Rules rules = new Rules();

        Rule rule = new RuleBuilder()
                .name("test")
                .description("测试").priority(3)
                .when(facts -> facts.get("userName").equals("zhangsan"))
                .then(facts -> System.out.println("this is test action!"))
                .build();

        rules.register(rule);

        Facts facts = new Facts();
        facts.put("userName","zhangsan");

        DefaultRulesEngine defaultRulesEngine = new DefaultRulesEngine();
        defaultRulesEngine.fire(rules,facts);
    }

核心概念

规则(Rule)

        由条件和行动构成的推理语句，通俗的讲：当满足某个条件之后，需要做后续的动作(一个或多个动作)，一般表示为IF <conditions> THEN <actions>, Rule表达逻辑。一个规则的IF部分称为LHS，THEN部分称为RHS。

除了以上示例方式构建Rule，还可以通过注解构建Rule：

@Rule(name = "repeatRule",description = "重复规则对消息内容去重",priority = 100)
public class RepeatRule {

    @Condition
    public boolean evaluate(@Fact("sendMessages") Set<String> sendMessages, @Fact("message") String message) {
        return sendMessages.contains(message);
    }

    @Action(order =0)
    public void execute(Facts facts) {
        //
    }

    @Action(order = 1)
    public void breakRules(Facts facts) {
        facts.put("break",true);
        facts.put("reason","repeat limit");
    }

}

事实(Facts)

        一组用户的输入数据，规则将根据输入数据判断是否满足条件，从而触发规则actions

        Facts是一组Fact集合，源码示例如下：

而Fact是一个容器，可以简单的理解成一个Map对象：

执行引擎(RulesEngine)

        引擎执行器，一般为推理引擎。Rules使用LHS与事实进行模式匹配。当匹配被找到，Rules会执行RHS即执行逻辑，同时actions经常会改变facts的状态，来推理出期望的结果。

        常用的执行引擎即:DefaultRulesEngine

结合mvel使用示例

@Test
    public void mvelExecute() {
        MVELRule repeatRule = new MVELRule().name("repeat Rule")
                .priority(100)
                .when("!sendMessages.contains(msgId)")
                .then("result.put('break',true);result.put('reason','repeat limit')");

        Rules rules = new Rules(repeatRule);

        Facts facts = new Facts();

        facts.put("msgId","123456");
        facts.put("sendMessages",new TreeSet<>());
        facts.put("msgType","interaction");
        facts.put("message","hello world");
        facts.put("result",new HashMap<>());

        DefaultRulesEngine engine = new DefaultRulesEngine();
        //CustomRuleListener customRuleListener = new CustomRuleListener();
        //engine.registerRuleListener(customRuleListener);
        engine.fire(rules,facts);
        Map<String,Object> result = (Map<String,Object>)facts.get("result");

        log.info("执行结果是:{}", JSONUtil.toJsonStr(result));
    }

MVEL可以支持表达式支持常用的逻辑符：> = < && || 等，还支持java类型api的调用

最直观的使用MVEL表达是API如下：

 @Test
    public void mvelCompileTest(){
        MyTest obj = new MyTest();
        Map<String, Object> map = new HashMap<>();
        map.put("key1", 1);
        map.put("key2", 2);

        String expression = "func(map)";
        Map<String, Object> vars = new HashMap<>();
        vars.put("map", map);

        MVEL.executeExpression(MVEL.compileExpression(expression), obj, vars);
        System.out.println(map);

    }

    public void func(Map<String, Object> map) {
        map.put("test","lisi");
    }

详细的MVEL脚本语言的使用：http://mvel.documentnode.com/

结合spel使用示例

public static void main(String[] args) {

        Rules rules = new Rules();

        SpELRule spelRule = new SpELRule().name("1")
                .description("1")
                .priority(1)
                .when("#{ ['item'].price >= 100 }")
                .then("#{ ['item'].setExpression('折扣1折\n原价为:' + ['item'].price " +
                        "+ '\n折扣后的价格为：'" +
                        " + T(java.lang.Float).parseFloat(['item'].price * 0.1+'') )  }");

        rules.register(spelRule);
        Item item = new Item(500);
        Facts facts = new Facts();
        facts.put("item", item);

        DefaultRulesEngine defaultRulesEngine = new DefaultRulesEngine();
        // 触发引擎
        defaultRulesEngine.fire(rules, facts);
        System.out.println(item.getExpression());

    }

企业级应用

如果规则引擎的使用仅仅只如以上硬编码的使用方式，还不足以体现规则引擎的强大。试看以下代码：

@Test
    public void factoryTest() throws Exception {

        ClassPathResource classPathResource = new ClassPathResource("rule.yml");
        String absolutePath = classPathResource.getAbsolutePath();

        YamlRuleDefinitionReader ymlReader = new YamlRuleDefinitionReader();
        MVELRuleFactory mvelRuleFactory = new MVELRuleFactory(ymlReader);
        Rules rules = mvelRuleFactory.createRules(new FileReader(absolutePath));

        DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
        JSONObject entries = new JSONObject();
        entries.set("productId","1");
        entries.set("type","1");

        Facts facts = new Facts();
        facts.put("canteen", entries);

        rulesEngine.fire(rules, facts);
    }

yml内容如下：

---
name: "规则1"
description: "prouductId = 1 && type = 1 "
condition: "canteen.productId==1&&canteen.type==1"
priority: 1
actions:
  - "com.lyc.performance.easyruledemo.four.UserInfoService.getNowTime();"
---
name: "规则2"
description: "prouductId = 1 && type = 2"
condition: "canteen.productId == 2 && canteen.type == 1"
priority: 2
actions:
  - "System.out.println(2);"

以上通过配置文件定义规则，将规则的触发决策通过文本的方式表述，解耦了业务逻辑代码和规则决策，大大的提升了该引擎的实用性。试想如下业务场景：

公司为了对产品经销商加强管理，需要制定一系列的处罚措施，当触犯某条规则时，将受到相应的惩罚措施。如果采用代码实现决策过程，需要大量的if else来完成，且当需要改变处罚措施时，需要修改代码，重新发布。

如果把决策过程由以上配置文件完成(再配合规则变动刷新等措施或者直接把规则数据由数据库存储加载)，可以方便的支持需求变更(此处只是讨论决策的变动，如果需要新增加某种处罚措施也需要代码调整、发布)

源码浅析

easy-rule的源码较为简单(最主要是将触发规则(Condition)和执行逻辑(Action)解耦的思想)，以下以简单的示例做源码分析：

org.jeasy.rules.core.DefaultRulesEngine#doFire

可以看出执行引擎的核心逻辑逻辑清晰、简单--就是通过循环Rule，判断是否命中规则，然后执行规则逻辑即可

其中执行引擎有4个参数可设置，分别释义如下：

skipOnFirstAppliedRule：Parameter to skip next applicable rules when a rule is applied(当第一个被命中的规则执行后，是否不执行后续规则)代码line 115就是改功能的释义

skipOnFirstNonTriggeredRule：Parameter to skip next applicable rules when a rule is non triggered(当有规则的判断逻辑未命中或判断是否命中异常，是否跳过后续规则,代码line102,line130 是逻辑释义)

isSkipOnFirstFailedRule：Parameter to skip next applicable rules when a rule has failed(当执行某个规则逻辑异常时是否跳过后续规则)

priorityThreshold：规则优先级的阈值，超过该阈值的规则不被执行，默认值是Integer.MAX_VALUE

功能展望

在上面的企业级应用中有提到过，将规则决策由代码实现转而由配置文件(或者存储于数据库)中实现，解耦了规则和执行逻辑。(执行逻辑--知识库)知识库的更新需要走发布流程。如果实现以下功能是不是能更好的发挥该框架的功能

1  解藕知识库与业务逻辑的耦合性，维护知识库来进行知识与版本的管理

2  动态增加知识库，让JVM动态加载新的知识库

3 屏蔽语言壁垒，能够让运营、产品支持在线规则配置、发布是最终要实现的重要目标。做到无需研发接入，实时发布