Java各种规则引擎

一. Drools规则引擎

1.简介：

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

2.特性：

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

3.原理:

4.使用方式：

 (1)Maven 依赖：

    
        org.kie
        kie-api
        6.5.0.Final
    
    
        org.drools
        drools-compiler
        6.5.0.Final
        runtime
    
    
        junit
        junit
        4.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(age60)     //规则的条件部分
    then
        System.out.println("年龄不符合要求！");
end

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

 测试用例：

/**
 * 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;
    @Test
    public 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这样的轻量级表达式引擎之间。

2.特性：

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

3.整体结构：

4.maven依赖：

    com.googlecode.aviator
    aviator
    ${aviator.version}

5.执行方式

执行表达式的方法有两个：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("'His age is '+ age +'!'", age));
        // execute执行方式，需传递Map格式
        Map map = new HashMap();
        map.put("age", "18");
        System.out.println(AviatorEvaluator.execute("'His age is '+ age +'!'", 
map));
    }
}

6.使用方式：

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

（1）内置函数

/**
 * 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());
        // 方式1
        System.out.println(AviatorEvaluator.execute("multiply(12.23, -2.3)"));
        // 方式2
        Map 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{
    @Override
    public 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);
    }
    @Override
    public String getName() {
        return "multiply";
    }
}

7.常用操作符的使用

（1）操作符列表

 （2）常量和变量

 （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]+':'+array[0]+':'+'today is '+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? 'yes':'no'", 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 : 'unknow' ", 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(" '[user id='+ user.id + ',name='+user.name + ',age=' +user.age +']' ", 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;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}

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

nil是Aviator内置的常量，类似java中的null，表示空的值。nil跟null不同的在
于，在java中null只能使用在==、!=的比较运算符，而nil还可以使用>、>=、
、>=、