表达式引擎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?

创建空的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