Java各种规则引擎

https://www.jianshu.com/p/41ea7a43093c

https://segmentfault.com/a/1190000020330741?utm_source=tag-newesthttps://baike.baidu.com/item/%E8%A7%84%E5%88%99%E5%BC%95%E6%93%8E/3076955?fr=aladdin

一、规则引擎使用场景：

1. 用于页面，流程，扩展点实现的选择；输出结果：实现的位置；
2. 编排无数的条件积木和行为积木，达到业务逻辑计算，券库存消减的目的；输出结果：商品重计算后的价格；
3. 通过订单，售后单，会员等信息编排和判断，达到多因子决策给出最佳答案的效果；输出结果：响应式回答/营销推荐，也或分步骤完成某类表单（售后申请，或工单提交）；
4. 过订单消息的触发，和商业化协议的元数据输入，形成结构化的计费记录；输出结果：计费凭证；

业务配置-条件积木，以及应用的授权逻辑，都有非常多的规则管理，由于业务的变化大，需求迭代快，需要不断的嵌套规则，硬编码开发。基于业务需要，希望能建立规则引擎，将规则代码从业务中抽离出来，降低规则迭代成本，降低if else等的规则嵌套，增强代码的维护性和复用性。开发人员不用过多的关注逻辑判断，可以专注与逻辑处理。

有很多规则，如校验是通过if else逻辑硬编码完成，商品目前支持电商、零售等业务部门，无非就是两种情况：一种是商品领域模型的变更，还有一种是规则的变更。可以说，支撑上层业务，业务规则占了需求的半边天。

通用的业务规则引擎，不和自己的业务藕合，提供一个通用的规则引擎是可行的。

二、什么是规则引擎

规则引擎是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。接受数据输入，解释业务规则，并根据业务规则做出业务决策。

规则本质上是一个函数，如y=f(x1,x2,..,xn)

规则引擎由三部分

• 事实（Fact）：就是用户输入的已经事实，可以理解为推理前的已知对象。
• LHS(Left Hand Side)：可以理解为规则执行需要满足的条件。
• RHS(Right Hand Sike)：可以理解为规则执行后的返回对象。

两个重要模块：

• 规则管理：可以理解为逻辑上管理规则，主要涉及规则、事实对象和规则集三个实体。涉及到规则变更时，最好对规则加个版本，可通过规则版本控制，可以平滑灰度地方式改变规则，也便于更有信心在测试规则正确性。
• 规则执行：通过规则库数据，通过规则引擎的规则解析、规则编译将可执行代码缓存起来，避免每次和DB交互，然后每次规则的变更也通过ZK或者DCC实时通知给规则执行器。规则执行器的实现方式，可以多种多样，不依赖于规则库的存储方式，可以根据需求，选用Drools、Aviator等第三方引擎，甚至可以基于ANTLR定制。

三、实践总结

实践出真理。调研了一些 Java 的规则引擎框架：

• drools比较重，适合风控金融，反欺诈。Avator、Fel、QLExpress 等不太适合搜索路由场景
• 用基于 Apollo 或者 grovvy脚本等实现引擎，配置路由规则到 apollo 或者 脚本即可。

如果是简单的场景，我们只要定义好关键条件 key ，命中 key ，返回 key 对应的 result 即可。

如果复杂金融场景，drools 比较合适。

比如一个搜索场景，按照优先级由上到下：

1. 如果带了某个店铺ID，路由到店铺分片的搜索索引
2. 如果带了某个买家ID，路由到买家分片的搜索索引
3. 如果状态是热状态，路由到热状态索引
4. 如果...

这种简单的，就用 apollo 定义好关键条件 json ，匹配即可。

一. Drools规则引擎

1. 简介：

Drools就是为了解决业务代码和业务规则分离的引擎。
Drools 规则是在 Java 应用程序上运行的，其要执行的步骤顺序由代码确定
，为了实现这一点，Drools 规则引擎将业务规则转换成执行树。


1. 特性：

优点：1、简化系统架构，优化应用2、提高系统的可维护性和维护成本3、方便系统的整合4、减少编写“硬代码”业务规则的成本和风险


3.原理：

 

Drools.png

1. 使用方式：

(1)Maven 依赖：

org.kiekie-api6.5.0.Finalorg.droolsdrools-compiler6.5.0.Finalruntimejunitjunit4.12



（2）新建配置文件/src/resources/META-INF/kmodule.xml






（3）新建drools规则文件/src/resources/rules/age.drl

import com.lrq.wechatDemo.domain.User // 导入类dialect "mvel"rule "age" // 规则名，唯一when$user : User(age<15 || age>60) //规则的条件部分thenSystem.out.println("年龄不符合要求！");
end


工程搭建完毕，效果如图：

 

项目结构.png

测试用例：


/*** CreateBy: haleyliu* CreateDate: 2018/12/26*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locatiOns= {"classpath*:applicationContext.xml"})
public class TestUser {private static KieContainer cOntainer= null;private KieSession statefulKieSession = null;@Testpublic void test(){KieServices kieServices = KieServices.Factory.get();cOntainer= kieServices.getKieClasspathContainer();statefulKieSession = container.newKieSession("myAgeSession");User user = new User("duval yang",12);statefulKieSession.insert(user);statefulKieSession.fireAllRules();statefulKieSession.dispose();}}

---

二.Aviator表达式求值引擎

1. 简介：

Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎，主要用于各
种表达式的动态求值。现在已经有很多开源可用的java表达式求值引擎，为什
么还需要Avaitor呢？Aviator的设计目标是轻量级和高性能 ，相比于Groovy、JRuby的笨重，Aviator
非常小，加上依赖包也才450K,不算依赖包的话只有70K；当然，Aviator的语法
是受限的，它不是一门完整的语言，而只是语言的一小部分集合。其次，Aviator的实现思路与其他轻量级的求值器很不相同，其他求值器一般都
是通过解释的方式运行，而Aviator则是直接将表达式编译成Java字节码，交给
JVM去执行。简单来说，Aviator的定位是介于Groovy这样的重量级脚本语言和
IKExpression这样的轻量级表达式引擎之间。


1. 特性：

（1）支持大部分运算操作符，包括算术操作符、关系运算符、逻辑操作符、
正则匹配操作符(=~)、三元表达式?: ，并且支持操作符的优先级和括号强制优
先级，具体请看后面的操作符列表。
（2）支持函数调用和自定义函数。
（3）支持正则表达式匹配，类似Ruby、Perl的匹配语法，并且支持类Ruby的
$digit指向匹配分组。自动类型转换，当执行操作的时候，会自动判断操作数类
型并做相应转换，无法转换即抛异常。
（4）支持传入变量，支持类似a.b.c的嵌套变量访问。
（5）性能优秀。
（6）Aviator的限制，没有if else、do while等语句，没有赋值语句，仅支持逻
辑表达式、算术表达式、三元表达式和正则匹配。没有位运算符

1. 整体结构：

   

   整体结构.png

2. maven依赖：

 

com.googlecode.aviatoraviator${aviator.version}



1. 执行方式
   执行表达式的方法有两个：execute()、exec();
   execute()，需要传递Map格式参数
   exec(),不需要传递Map
   示例：


/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class Test {public static void main(String[] args) {// exec执行方式，无需传递Map格式String age = "18";System.out.println(AviatorEvaluator.exec("&＃39;His age is &＃39;+ age +&＃39;!&＃39;", age));// execute执行方式，需传递Map格式Map map = new HashMap();map.put("age", "18");System.out.println(AviatorEvaluator.execute("&＃39;His age is &＃39;+ age +&＃39;!&＃39;",
map));}
}


1. 使用函数
   Aviator可以使用两种函数：内置函数、自定义函数
   （1）内置函数

   

   Aviator内置函数.png

 

 

Aviator内置函数.png


/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class Test {public static void main(String[] args) {Map map = new HashMap<>();map.put("s1","123qwer");map.put("s2","123");System.out.println(AviatorEvaluator.execute("string.startsWith(s1,s2)",map));}
}

（2）自定义函数

自定义函数要继承AbstractFunction类，重写目标方法。


/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class Test {public static void main(String[] args) {// 注册自定义函数AviatorEvaluator.addFunction(new MultiplyFunction());// 方式1System.out.println(AviatorEvaluator.execute("multiply(12.23, -2.3)"));// 方式2Map params = new HashMap<>();params.put("a", 12.23);params.put("b", -2.3);System.out.println(AviatorEvaluator.execute("multiply(a, b)", params));}}class MultiplyFunction extends AbstractFunction{@Overridepublic AviatorObject call(Map env, AviatorObject arg1, AviatorObject arg2) {double num1 = FunctionUtils.getNumberValue(arg1, env).doubleValue();double num2 = FunctionUtils.getNumberValue(arg2, env).doubleValue();return new AviatorDouble(num1 * num2);}@Overridepublic String getName() {return "multiply";}}


1. 常用操作符的使用
   （1）操作符列表

   

   操作符列表.png

 

（2）常量和变量

 

常量和变量.png

（3）编译表达式


/**
* CreateBy: haleyliu
* CreateDate: 2018/12/25
*/
public class Test {public static void main(String[] args) {String expression = "a+(b-c)>100";// 编译表达式Expression compiledExp = AviatorEvaluator.compile(expression);Map env = new HashMap<>();env.put("a", 100.3);env.put("b", 45);env.put("c", -199.100);// 执行表达式Boolean result = (Boolean) compiledExp.execute(env);System.out.println(result);}
}

(4) 访问数组和集合
List和数组用list[0]和array[0]，Map用map.date

/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class Test {public static void main(String[] args) {final List list = new ArrayList<>();list.add("hello");list.add(" world");final int[] array = new int[3];array[0] = 0;array[1] = 1;array[2] = 3;final Map map = new HashMap<>();map.put("date", new Date());Map env = new HashMap<>();env.put("list", list);env.put("array", array);env.put("map", map);System.out.println(AviatorEvaluator.execute("list[0]+&＃39;:&＃39;+array[0]+&＃39;:&＃39;+&＃39;today is &＃39;+map.date", env));}}


（5） 三元比较符

/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class Test {public static void main(String[] args) {Map env = new HashMap();env.put("a", -5);String result = (String) AviatorEvaluator.execute("a>0? &＃39;yes&＃39;:&＃39;no&＃39;", env);System.out.println(result);}}


(6) 正则表达式匹配


/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class Test {public static void main(String[] args) {String email = "hello2018@gmail.com";Map env = new HashMap();env.put("email", email);String username = (String) AviatorEvaluator.execute("email=~/([\\w0-8]+)@\\w+[\\.\\w+]+/ ? $1 : &＃39;unknow&＃39; ", env);System.out.println(username);}
}


(7) 变量的语法糖衣


/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class Test {public static void main(String[] args) {User user = new User(1,"jack","18");Map env = new HashMap<>();env.put("user", user);String result = (String) AviatorEvaluator.execute(" &＃39;[user id=&＃39;+ user.id + &＃39;,name=&＃39;+user.name + &＃39;,age=&＃39; +user.age +&＃39;]&＃39; ", env);System.out.println(result);}
}/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class User {private int id;private String name;private String age;public User() {}public User(int id, String name, String age) {this.id = id;this.name = name;this.age = age;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}@Overridepublic String toString() {return "User{" +"id=" + id +", name=&＃39;" + name + &＃39;\&＃39;&＃39; +", age=&＃39;" + age + &＃39;\&＃39;&＃39; +&＃39;}&＃39;;}}


(8) nil对象[任何对象都比nil大除了nil本身]

nil是Aviator内置的常量，类似java中的null，表示空的值。nil跟null不同的在
于，在java中null只能使用在==、!=的比较运算符，而nil还可以使用>、>=、
<、<=等比较运算符。Aviator规定，[任何对象都比nil大除了nil本身]。用户传入
的变量如果为null，将自动以nil替代。AviatorEvaluator.execute("nil == nil"); //true AviatorEvaluator.execute(" 3> nil"); //true AviatorEvaluator.execute(" true!= nil"); //true AviatorEvaluator.execute(" &＃39; &＃39;>nil "); //true AviatorEvaluator.execute(" a==nil "); //true,a is null
nil与String相加的时候，跟java一样显示为null

(9) 日期比较


/*** CreateBy: haleyliu* CreateDate: 2018/12/25*/
public class Test {public static void main(String[] args) {Map env = new HashMap();final Date date = new Date();String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date);env.put("date", date);env.put("dateStr", dateStr);Boolean result = (Boolean) AviatorEvaluator.execute("date==dateStr",env);System.out.println(result);result = (Boolean) AviatorEvaluator.execute("date > &＃39;2009-12-20
00:00:00:00&＃39; ", env);System.out.println(result);result = (Boolean) AviatorEvaluator.execute("date <&＃39;2200-12-20
00:00:00:00&＃39; ", env);System.out.println(result);result = (Boolean) AviatorEvaluator.execute("date ==date ", env);System.out.println(result);}
}


(10) 语法手册

数据类型

• Number类型：数字类型，支持两种类型，分别对应Java的Long和Double，也就是说任何整数都将被转换为Long，而任何浮点数都将被转换为Double，包括用户传入的数值也是如此转换。不支持科学计数法，仅支持十进制。如-1、100、2.3等。

• String类型： 字符串类型，单引号或者双引号括起来的文本串，如&＃39;hello world&＃39;，变量如果传入的是String或者Character也将转为String类型。

• Bool类型： 常量true和false，表示真值和假值，与java的Boolean.TRUE和Boolean.False对应。

• Pattern类型： 类似Ruby、perl的正则表达式，以//括起来的字符串，如//d+/，内部实现为java.util.Pattern。

• 变量类型： 与Java的变量命名规则相同，变量的值由用户传入，如"a"、"b"等

• nil类型: 常量nil,类似java中的null，但是nil比较特殊，nil不仅可以参与==、!=的比较，也可以参与>、>=、<、<=的比较，Aviator规定任何类型都n大于nil除了nil本身，nil==nil返回true。用户传入的变量值如果为null，那么也将作为nil处理，nil打印为null。

算术运算符

Aviator支持常见的算术运算符，包括+ - / % 五个二元运算符，和一元运算符"-"。其中 - / %和一元的"-"仅能作用于Number类型。

"+"不仅能用于Number类型，还可以用于String的相加，或者字符串与其他对象的相加。Aviator规定，任何类型与String相加，结果为String。

逻辑运算符

Avaitor的支持的逻辑运算符包括，一元否定运算符"!"，以及逻辑与的"&&"，逻辑或的"||"。逻辑运算符的操作数只能为Boolean。

关系运算符

Aviator支持的关系运算符包括"<" "<=" ">" ">=" 以及"=="和"!=" 。
&&和||都执行短路规则。

关系运算符可以作用于Number之间、String之间、Pattern之间、Boolean之间、变量之间以及其他类型与nil之间的关系比较，不同类型除了nil之外不能相互比较。

Aviator规定任何对象都比nil大除了nil之外。

匹配运算符

匹配运算符"=~"用于String和Pattern的匹配，它的左操作数必须为String，右操作数必须为Pattern。匹配成功后，Pattern的分组将存于变量$num，num为分组索引。

三元运算符

Aviator没有提供if else语句，但是提供了三元运算符 "?:"，形式为 bool ? exp1: exp2。 其中bool必须为结果为Boolean类型的表达式，而exp1和exp2可以为任何合法的Aviator表达式，并且不要求exp1和exp2返回的结果类型一致。

1. 两种模式
   默认AviatorEvaluator以编译速度优先：
   AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);
   你可以修改为运行速度优先，这会做更多的编译优化：
   AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);

---

三.MVEL表达式解析器

1.简介 ：

MVEL在很大程度上受到Java语法的启发，作为一个表达式语言，也有一些根本
的区别，旨在更高的效率，例如：直接支持集合、数组和字符串匹配等操作以
及正则表达式。 MVEL用于执行使用Java语法编写的表达式。


2.特性：

MVEL是一个功能强大的基于Java应用程序的表达式语言。
目前最新的版本是2.0，具有以下特性：
(1). 动态JIT优化器。当负载超过一个确保代码产生的阈值时，选择性地产生字
节代码,这大大减少了内存的使用量。新的静态类型检查和属性支持，允许集成
类型安全表达。
(2). 错误报告的改善。包括行和列的错误信息。
(3). 新的脚本语言特征。MVEL2.0 包含函数定义，如：闭包，lambda定义，
标准循环构造(for, while, do-while, do-until…)，空值安全导航操作，内联with
-context运营 ，易变的（isdef）的测试运营等等。
(4). 改进的集成功能。迎合主流的需求，MVEL2.0支持基础类型的个性化属性处理器，集成到JIT中。
(5). 更快的模板引擎，支持线性模板定义，宏定义和个性化标记定义。
(6). 新的交互式shell（MVELSH）。(7). 缺少可选类型安全
(8). 集成不良，通常通过映射填入内容。没有字节码不能运作用字节码生成编
译时间慢，还增加了可扩展性问题；不用字节码生成运行时执行非常慢
(9). 内存消耗过大
(10). Jar巨大/依赖规模


3.原理：

与java不同，MVEL是动态类型（带有可选分类），也就是说在源文件中是没有
类型限制的。一条MVEL表达式，简单的可以是单个标识符，复杂的则可能是
一个充满了方法调用和内部集合创建的庞大的布尔表达式。


4.使用方式：
maven引入jar：

org.mvelmvel22.3.1.Final

测试：

package com.lrq.wechatdemo.utils;import com.google.common.collect.Maps;
import org.mvel2.MVEL;import java.util.Map;/*** CreateBy: haleyliu* CreateDate: 2018/12/26*/
public class MvelUtils {public static void main(String[] args) {String expression = "a == null && b == nil ";Map map = Maps.newHashMap();map.put("a",null);map.put("b",null);Object object = MVEL.eval(expression,map);System.out.println(object);}}


---

四.EasyRules规则引擎

1.简介：

easy-rules首先集成了mvel表达式，后续可能集成SpEL的一款轻量
级规则引擎


2.特性：

easy rules是一个简单而强大的java规则引擎，它有以下特性：轻量级框架，学习成本低
基于POJO
为定义业务引擎提供有用的抽象和简便的应用
从原始的规则组合成复杂的规则
它主要包括几个主要的类或接口：Rule,RulesEngine,RuleListener,Facts
还有几个主要的注解：@Action,@Condition,@Fact,@Priority,@Rule


3.使用方式：

@Rule可以标注name和description属性，每个rule的name要唯一，
如果没有指定，则RuleProxy则默认取类名
@Condition是条件判断，要求返回boolean值，表示是否满足条件@Action标注条件成立之后触发的方法@Priority标注该rule的优先级，默认是Integer.MAX_VALUE - 1，值
越小越优先@Fact 我们要注意Facts的使用。Facts的用法很像Map，它是客户
端和规则文件之间通信的桥梁。在客户端使用put方法向Facts中添
加数据，在规则文件中通过key来得到相应的数据。


有两种使用方式：

1. java方式
   首先先创建规则并标注属性

package com.lrq.wechatdemo.rules;import org.jeasy.rules.annotation.Action;
import org.jeasy.rules.annotation.Condition;
import org.jeasy.rules.annotation.Fact;
import org.jeasy.rules.annotation.Rule;
import org.jeasy.rules.support.UnitRuleGroup;/*** CreateBy: haleyliu* CreateDate: 2018/12/26*/
public class RuleClass {@Rule(priority = 1) //规则设定优先级public static class FizzRule {@Conditionpublic boolean isFizz(@Fact("number") Integer number) {return number % 5 == 0;}@Actionpublic void printFizz() {System.out.print("fizz\n");}}@Rule(priority = 2)public static class BuzzRule {@Conditionpublic boolean isBuzz(@Fact("number") Integer number) {return number % 7 == 0;}@Actionpublic void printBuzz() {System.out.print("buzz\n");}}public static class FizzBuzzRule extends UnitRuleGroup {public FizzBuzzRule(Object... rules) {for (Object rule : rules) {addRule(rule);}}@Overridepublic int getPriority() {return 0;}}@Rule(priority = 3)public static class NonFizzBuzzRule {@Conditionpublic boolean isNotFizzNorBuzz(@Fact("number") Integer number) {// can return true, because this is the latest rule to trigger according to// assigned priorities// and in which case, the number is not fizz nor buzzreturn number % 5 != 0 || number % 7 != 0;}@Actionpublic void printInput(@Fact("number") Integer number) {System.out.print(number+"\n");}}}


然后客户端调用

package com.lrq.wechatdemo.rules;import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rules;
import org.jeasy.rules.api.RulesEngine;
import org.jeasy.rules.core.DefaultRulesEngine;
import org.jeasy.rules.core.RulesEngineParameters;/*** CreateBy: haleyliu* CreateDate: 2018/12/26*/
public class RuleJavaClient {public static void main(String[] args) {// 创建规则引擎RulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);// 创建规则集并注册规则Rules rules = new Rules();rules.register(new RuleClass.FizzRule());rules.register(new RuleClass.BuzzRule());rules.register(new RuleClass.FizzBuzzRule(new RuleClass.FizzRule(), new RuleClass.BuzzRule()));rules.register(new RuleClass.NonFizzBuzzRule());// 执行规则Facts facts = new Facts();for (int i = 1; i <= 100; i++) {facts.put("number", i);fizzBuzzEngine.fire(rules, facts);System.out.println();}}}

2.yml方式

resources目录下新建fizzbuzz.yml

---
name: "fizz rule"
description: "print fizz if the number is multiple of 5"
priority: 1
condition: "number % 5 == 0"
actions:
- "System.out.println(\"fizz\")"---
name: "buzz rule"
description: "print buzz if the number is multiple of 7"
priority: 2
condition: "number % 7 == 0"
actions:
- "System.out.println(\"buzz\")"---
name: "fizzbuzz rule"
description: "print fizzbuzz if the number is multiple of 5 and 7"
priority: 0
condition: "number % 5 == 0 && number % 7 == 0"
actions:
- "System.out.println(\"fizzbuzz\")"---
name: "non fizzbuzz rule"
description: "print the number itself otherwise"
priority: 3
condition: "number % 5 != 0 || number % 7 != 0"
actions:
- "System.out.println(number)"


客户端调用：

package com.lrq.wechatdemo.rules;import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rules;
import org.jeasy.rules.api.RulesEngine;
import org.jeasy.rules.core.DefaultRulesEngine;
import org.jeasy.rules.core.RulesEngineParameters;
import org.jeasy.rules.mvel.MVELRuleFactory;import java.io.FileNotFoundException;
import java.io.FileReader;/*** CreateBy: haleyliu* CreateDate: 2018/12/26*/
public class RuleYmlClient {public static void main(String[] args) throws FileNotFoundException {// create a rules engineRulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);// create rulesRules rules = MVELRuleFactory.createRulesFrom(new FileReader("fizzbuzz.yml"));// fire rulesFacts facts = new Facts();for (int i = 1; i <= 100; i++) {facts.put("number", i);fizzBuzzEngine.fire(rules, facts);System.out.println();}}
}

作者：HaleyLiu
链接：https://www.jianshu.com/p/41ea7a43093c
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。