easy-rule 初窥

文章目录

前言
一、easy-rule简介
二、使用步骤
- 1.引入库
- 2.定义规则
- - 2.1 使用声明式方式
  - 2.2 使用流程API的方式
  - 2.3 使用表达式
  - 2.4 使用配置文件
- 3. 触发规则
项目demo
- 1 校验对象定义
- 2. 多个分组条件定义
- 3. 测试用例
- - 4. 调整后的DEMO

前言

最近，公司有个项目，需要根据不同的规则来检验是否满足条件，由于条件可以配置，所以需要在开发的时候考虑条件的可拓展性，不能因为新增了规则，就需要修改规则，所以决定在使用规则引擎来处理条件校验。

一、easy-rule简介

Easy Rules是一个简单而强大的Java规则引擎，具有轻量级框架和易于学习的API，基于POJO的开发与注解的编程模型，定义抽象的业务规则并轻松应用它们，支持从简单规则创建组合规则的能力，支持使用表达式语言（如MVEL和SpEL）定义规则的能力。
正是因为Easy Rule的简单轻量级，不需要引入额外的资源，此外是Java技术栈，方便学习等因素，所以才选择Easy Rule。Easy Rule中使用MVEL进行表达式解析，详细用法见 Mvel2.0使用指南一基础

二、使用步骤

Easy Rule的使用方法，可以参考Github

1.引入库



    org.jeasy
    easy-rules-core
    4.1.0




    org.jeasy
    easy-rules-support
    4.1.0




    org.jeasy
    easy-rules-mvel
    4.1.0

2.定义规则 2.1 使用声明式方式

@Rule(name = "weather rule", description = "if it rains then take an umbrella")
public class WeatherRule {

    @Condition
    public boolean itRains(@Fact("rain") boolean rain) {
        return rain;
    }
    
    @Action
    public void takeAnUmbrella() {
        System.out.println("It rains, take an umbrella!");
    }
}

2.2 使用流程API的方式

Rule weatherRule = new RuleBuilder()
        .name("weather rule")
        .description("if it rains then take an umbrella")
        .when(facts -> facts.get("rain").equals(true))
        .then(facts -> System.out.println("It rains, take an umbrella!"))
        .build();

2.3 使用表达式

Rule weatherRule = new RuleBuilder()
        .name("weather rule")
        .description("if it rains then take an umbrella")
        .when(facts -> facts.get("rain").equals(true))
        .then(facts -> System.out.println("It rains, take an umbrella!"))
        .build();

2.4 使用配置文件

name: "weather rule"
description: "if it rains then take an umbrella"
condition: "rain == true"
actions:
  - "System.out.println("It rains, take an umbrella!");"

MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
Rule weatherRule = ruleFactory.createRule(new FileReader("weather-rule.yml"));

3. 触发规则

public class Test {
    public static void main(String[] args) {
        // define facts
        Facts facts = new Facts();
        facts.put("rain", true);

        // define rules
        Rule weatherRule = ...
        Rules rules = new Rules();
        rules.register(weatherRule);

        // fire rules on known facts
        RulesEngine rulesEngine = new DefaultRulesEngine();
        rulesEngine.fire(rules, facts);
    }
}

项目demo

由于公司项目条件是有分组的概念，一个分组内的条件是且的关系，多个分组之间的条件是或的关系，而且只需要校验条件是否成立即可，所以和上面的使用步骤还是有点区别。我本地测试的demo如下：

1 校验对象定义

@Data
public class Person {
    
    private int age;
    
    private String name;
    
    private boolean adult;
    
    private int sex;
    
    private int height;
}

2. 多个分组条件定义

先采用yml文件配置的方式，name 相同则为同一个分组。

---
name: "rule1"
description: "nameRule"
priority: 1
condition: "person.name == '张三'"
actions:
  - "System.out.println("success!!!");"

---
name: "rule1"
description: "ageRule"
priority: 2
condition: "person.age > 18"
actions:
  - "person.setAdult(true);"

---
name: "rule2"
description: "sexRule"
priority: 1
condition: "person.sex == 1"
actions:
  - "System.out.println("I am a boy!!!");"

---
name: "rule3"
description: "heightRule"
priority: 1
condition: "person.height > 170"
actions:
  - "System.out.println("I am a boy!!!");"

3. 测试用例

public static void main(String[] args) throws Exception {
        MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
        Rules rules = ruleFactory.createRules(new FileReader("E:\Java\workspace\spring-demo\easy-rule-test\src\main\resources\testRule.yml"));

        Person person = new Person();
        person.setAge(19);
        person.setName("张三");
        person.setSex(1);
        person.setHeight(180);

        Facts facts = new Facts();
        facts.put("person", person);

        RulesEngine rulesEngine = new DefaultRulesEngine();
        Map result = rulesEngine.check(rules, facts);
        System.out.println("检测对象：" + person);
        System.out.println("检测结果：" + result);

        person.setAge(17);
        person.setSex(2);
        person.setHeight(166);
        result = rulesEngine.check(rules, facts);
        System.out.println("检测对象：" + person);
        System.out.println("检测结果：" + result);
    }

检验结果：

13:41:57.199 [main] DEBUG org.jeasy.rules.core.DefaultRulesEngine - Checking rules
检测对象：Person(age=19, name=张三, adult=false, sex=1, height=180)
检测结果：{rule1=true, rule3=true, rule1=true, rule2=true}
13:41:57.230 [main] DEBUG org.jeasy.rules.core.DefaultRulesEngine - Checking rules
检测对象：Person(age=17, name=张三, adult=false, sex=2, height=166)
检测结果：{rule1=false, rule3=false, rule1=true, rule2=false}

从返回的结果，rule1的结果返回了两个，不符合当前的需求，所以进行调整了一下，如下所示：

4. 调整后的DEMO

public static void main(String[] args) throws Exception {
        MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
        Rules rules = ruleFactory.createRules(new FileReader("E:\Java\workspace\spring-demo\easy-rule-test\src\main\resources\testRule.yml"));

        Person person = new Person();
        person.setAge(19);
        person.setName("张三");
        person.setSex(1);
        person.setHeight(180);

        Facts facts = new Facts();
        facts.put("person", person);

        RulesEngine rulesEngine = new DefaultRulesEngine();
        Map result = groupCheck(rules, facts);
        System.out.println("检测对象：" + person);
        System.out.println("检测结果：" + result);

        person.setAge(17);
        person.setSex(2);
        person.setHeight(166);
        result = groupCheck(rules, facts);
        System.out.println("检测对象：" + person);
        System.out.println("检测结果：" + result);
    }

    public static Map> convertGroupRule(Rules rules){
        Map> ruleMap = new HashMap<>();
        for (Rule rule : rules) {
            List ruleList = ruleMap.getOrDefault(rule.getName(), new ArrayList<>());
            ruleList.add(rule);
            ruleMap.put(rule.getName(), ruleList);
        }

        return ruleMap;
    }

    public static Map groupCheck(Rules rules, Facts facts){
        Map result = new HashMap<>();
        Map> ruleMap = convertGroupRule(rules);
        for (Map.Entry> entry : ruleMap.entrySet()){
            List ruleList = entry.getValue();
            Boolean ok = null;
            for (Rule rule: ruleList){
                if (!rule.evaluate(facts)){
                    ok = Boolean.FALSE;
                    break;
                } else {
                    ok = Boolean.TRUE;
                }
            }

            result.put(entry.getKey(), ok);
        }

        return result;
    }

检测对象：Person(age=19, name=张三, adult=false, sex=1, height=180)
检测结果：{rule1=true, rule3=true, rule2=true}
检测对象：Person(age=17, name=张三, adult=false, sex=2, height=166)
检测结果：{rule1=false, rule3=false, rule2=false}

easy-rule 初窥

Java相关栏目本月热门文章