表达式引擎Aviator基本介绍及使用以及基于Aviator的规则引擎（附代码详细介绍）

1. Aviator

1.1 什么是Aviator?

Aviator是一门高性能、轻量级的Java语言实现的表达式求值引擎，主要用于表达式的动态求值。

1.2 为什么需要Aviator?

Aviator的设计目标是 轻量级 和 高性能 ，相对于Groovy、JRuby的笨重，Aviator非常小，加上依赖包就450K，不算依赖包就70K，不过Aviator的语法受限，它并不是一门完整的语言，只是语言的一小部分集合。

1.3 Aviator的特点

Aviator的实现思路与其它轻量级的求值器不同，其它求值器是通过解释的方式运行，而Aviator是直接将表达式编译成Java字节码，交给JVM去执行。
Aviator的定位是介于Groovy这样重量级脚本语言和IKExpression这样轻量级表达式引擎之间。

1.4 Aviator的功能

• 支持大部分运算操作符，包括算数运算符、关系运算符、逻辑操作符、正则匹配操作符、三元表达式，并且还致辞操作符的优先级以及括号的强制优先级。
• 支持函数调用和自定义函数
• 支持正则表达式匹配
• 自动类型转换，当执行操作的时候，会自动判断操作数类型并做相应的转换，无法转换就抛异常
• 支持传入变量，支持类似a.b.c的嵌套变量访问。
• 性能优秀

1.5 使用场景

• 规则判断以及规则引擎
• 公式计算
• 动态脚本控制
等等…

1.6 怎么使用Aviator?

AviatorScript使用文档：AviatorScript语法文档
创建空的Maven项目，导入如下的依赖

<dependency>
    <groupId>com.googlecode.aviator</groupId>
    <artifactId>aviator</artifactId>
    <version>5.1.4</version>
</dependency>

一个简单的例子:

//Aviator的使用都是集中通过com.googlecode.aviator.AviatorEvaluator这个入口类来处理
public void test1() {
    Long sum = (Long)AviatorEvaluator.execute("1 + 2 + 3");
    System.out.println(sum);
}
//结果为： 6

注意点： Aviator的数值类型只支持Long和Double，任何整数都将会转换成Long，任何浮点数都会转换成Double，包括用户传入的变量数值。
其它例子：

public class AviatorSimpleTest {
    /**
     * 算数表达式
     */
    @Test
    public void test1() {
        Long sum = (Long)AviatorEvaluator.execute("1 + 2 + 3");
        System.out.println(sum);
    }
    /**
     * 逻辑表达式
     */
    @Test
    public void test2() {
        Boolean result = (Boolean)AviatorEvaluator.execute("3 > 1 && 2 != 4 || true");
        System.out.println(result);
    }
    /**
     * 往表达式传入值
     */
    @Test
    public void test3() {
        Map<String, Object> env = new HashMap<>();
        env.put("name", "ruilin.shao");
        String str = "'hello ' + name";
        String result = (String) AviatorEvaluator.execute(str, env);
        System.out.println(result);
        //写法二
        String result2 = (String)AviatorEvaluator.exec(str, "便利蜂");
        System.out.println(result2);
    }
    /**
     * 三元表达式
     */
    @Test
    public void test4() {
        String result = (String)AviatorEvaluator.execute("3 > 0 ? yes : no");
        System.out.println(result);
    }
    /**
     * 函数调用
     */
    @Test
    public void test5() {
        System.out.println("string.length('hello') = " + AviatorEvaluator.execute("string.length('hello')"));//求字符串长度,不能用String.length();
        System.out.println("string.contains('hello', 'h') = " + AviatorEvaluator.execute("string.contains('hello', 'h')"));//判断字符串中是否包含某个字符串
        System.out.println("math.pow(-3, 2) = " + AviatorEvaluator.execute("math.pow(-3, 2)"));
        System.out.println("math.sqrt(9.0) = " + AviatorEvaluator.execute("math.sqrt(9.0)"));
    }
}

1.7 Aviator自定义函数

Aviator除了自己内部定义了一些函数外，还支持自定义函数，只需要实现com.googlecode.aviator.runtime.type.AviatorFunction接口，并注册到AviatorEvaluator即可使用
创建自定义函数：

public class UserDefinedFunction extends AbstractFunction {
    //自定义功能的名字
    @Override
    public String getName() {
        return "multi";
    }
    @Override
    public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
        Number left = FunctionUtils.getNumberValue(arg1, env);
        Number right = FunctionUtils.getNumberValue(arg2, env);
        return new AviatorDouble(left.doubleValue() * right.doubleValue());
    }
}

使用自定义函数

@Test
public void test6() {
    //注册函数
    AviatorEvaluator.addFunction(new UserDefinedFunction());
    System.out.println("multi(2, 3) = " + AviatorEvaluator.execute("multi(2, 3)"));
    //移除函数
    AviatorEvaluator.removeFunction("multi");
    //移除后再执行如下语句会报错
    //System.out.println("multi(2, 3) = " + AviatorEvaluator.execute("multi(2, 3)"));
}

1.8 编译表达式

其实每次执行Aviator.execute()时，背后都经过了编译和执行的操作。
那么我们可以先编译表达式，返回一个编译后的结果，然后传入不同的env来重复使用编译的结果，这样可以提高性能。

/**
 * 编译表达式和未编译表达式性能测试
 */
@Test
public void test8() {
    String expression = "a * (b + c)";
    Map<String, Object> env = new HashMap<>();
    env.put("a", 3.32);
    env.put("b", 234);
    env.put("c", 324.2);
    //编译表达式
    Expression compliedExp = AviatorEvaluator.compile(expression);
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
        Double result = (Double) compliedExp.execute(env);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("预编译的耗时为：" + (endTime - startTime));
    long startTime2 = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
        Double result = (Double) AviatorEvaluator.execute(expression, env);
    }
    long endTime2 = System.currentTimeMillis();
    System.out.println("无编译的耗时为：" + (endTime2 - startTime2));
}

通过complie方法可以将表达式编译成Expression的中间对象，当要执行表达式的时候传入Map对象直接调用Expression的execute方法即可。
编译后的结果可以自己缓存，也可以交给Aviator来帮你缓存，AviatorEvaluator内部又一个全局的缓存池，如果想通过Aviator来帮你缓存，可以通过如下方法：

public static Expression complie(String expression, boolean cached);

举例：

/**
 * 预编译缓存举例
 */
@Test
public void test9() {
    String expression1 = "a + b + c";
    Expression compiledExp1 = AviatorEvaluator.compile(expression1, true);
    Expression compiledExp2 = AviatorEvaluator.compile(expression1, true);
    Expression compiledExp3 = AviatorEvaluator.compile(expression1, false);
    System.out.println("compiledExp1 == compiledExp2 : " + (compiledExp1 == compiledExp2));
    System.out.println("compiledExp1 == compiledExp3 : " + (compiledExp1 == compiledExp3));
}
//compiledExp1 == compiledExp2 : true
//compiledExp1 == compiledExp3 : false

2. 规则引擎

2.1 为什么需要规则引擎？

没有规则引擎的情况下，有些逻辑复杂的业务代码，只能不断的去增添if - else来满足复杂的业务场景，当if - else过多时，会导致代码极难阅读，虽然能通过策略模式来优化if - else，但是依旧无法解决开发缓慢、需要上线的问题。
在风控系统中，风控的逻辑在不断的发生一个变化，如果在代码中写死，逻辑一发生变化，我们就需要改一下代码，再上线一次，在频繁变更逻辑的情况下，这种做法显然无法接收，所以我们需要规则引擎来改变这个现状，通过高效可靠的方式去做这些业务规则的改变。

2.2 规则引擎的好处

• 降低开发成本
• 业务人员独立配置业务规则，开发人员无需理解，以往需要业务人员告诉开发人员，开发人员需要理解才能开发，并且还需要大量的测试来确定是否正确，而且开发结果还容易和提出的业务有偏差，种种都导致开发成本上升
• 增加业务的透明度，业务人员配置之后其它人业务人员也能看到，
• 提高了规则改动的效率和上线的速度

2.3 基于Aviator的规则引擎

通过规则引擎，我们只需要将业务人员配置的规则转换成一个规则字符串，然后将该规则字符串保存进数据库中，当使用该规则时，只传递该规则所需要的参数，便可以直接计算出结果，我们开发人员无需再为这些规则编写任何代码。

public class AviatorExampleTwo {
    //规则可以保存在数据库中，mysql或者redis等等
    Map<Integer, String> ruleMap = new HashMap<>();
    public AviatorExampleTwo() {
        //秒数计算公式
        ruleMap.put(1, "hour * 3600 + minute * 60 + second");
        //正方体体积计算公式
        ruleMap.put(2, "height * width * length");
        //判断一个人是不是资深顾客
        ruleMap.put(3, "age >= 18 && sumConsume > 2000 && vip");
        //资深顾客要求修改
        ruleMap.put(4, "age > 10 && sumConsume >= 8000 && vip && avgYearConsume >= 1000");
        //判断一个人的年龄是不是大于等于18岁
        ruleMap.put(5, "age  >= 18 ? 'yes' : 'no'");
    }
    public static void main(String[] args) {
        AviatorExampleTwo aviatorExample = new AviatorExampleTwo();
        //选择规则，传入规则所需要的参数
        System.out.println("公式1：" + aviatorExample.getResult(1, 1, 1, 1));
        System.out.println("公式2：" + aviatorExample.getResult(2, 3, 3, 3));
        System.out.println("公式3：" + aviatorExample.getResult(3, 20, 3000, false));
        System.out.println("公式4：" + aviatorExample.getResult(4, 23, 8000, true, 2000));
        System.out.println("公式5：" + aviatorExample.getResult(5, 12));
    }
    public Object getResult(int ruleId, Object... args) {
        String rule = ruleMap.get(ruleId);
        return AviatorEvaluator.exec(rule, args);
    }
}
//公式1：3661
//公式2：27
//公式3：false
//公式4：true
//公式5：no