表达式引擎Aviator实战_aviatorevaluator

概述

Aviator是一门高性能、轻量级的Java语言实现的表达式动态求值引擎。其设计目标是轻量级和高性能，相对于Groovy、JRuby的笨重，Aviator非常小，不过Aviator的语法受限，它并不是一门完整的语言，只是语言的一小部分集合。定位是介于Groovy这样重量级脚本语言和IKExpression这样轻量级表达式引擎之间。

Aviator的实现思路与其它轻量级的求值器不同，其它求值器是通过解释的方式运行，而Aviator是直接将表达式编译成Java字节码，交给JVM去执行。

功能

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

限制：没有if else、do while等语句，没有赋值语句，没有位运算符；

使用场景

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

实战

pom文件引入：

<dependency>
	<groupId>com.googlecode.aviator</groupId>
	<artifactId>aviator</artifactId>
</dependency>
1
2
3
4

入门

Aviator的数值类型只支持Long和Double，任何整数都将会转换成Long，任何浮点数都会转换成Double，包括用户传入的变量数值。不支持科学计数法，仅支持十进制。

nil对象
nil是Aviator内置的常量，类似Java中的null，空值。nil跟null不同在于，Java中null只能使用在==、!=的比较运算符，而nil还可以使用>、>=、<、<=等比较运算符。Aviator规定，任何对象都比nil大，除nil本身。用户传入的变量如果为null，将自动以nil替代。nil与String相加时，跟Java一样显示为null。

Aviator并不支持日期类型，如果要比较日期，你需要将日期写字符串的形式，并且要求是形如yyyy-MM-dd HH:mm:ss:SS的字符串，否则都将报错。字符串跟java.util.Date比较时将自动转换为Date对象进行比较。

要访问变量a中的某个属性b，可通过a.b访问到，即Aviator支持变量的嵌套访问。

Aviator在表达式级别支持正则表达式，通过//括起来的字符序列构成一个正则表达式，可用于匹配（作为=~操作符的右操作数)、比较大小，匹配仅能与字符串进行匹配。匹配成功后，Aviator会自动将匹配成功的分组放入$num的变量中，$0指代整个匹配的字符串，$1表示第一个分组，以此类推。正则表达式规则跟Java完全一样，内部使用java.util.regex.Pattern编译。

类型转换规则

• Java的byte，short，int，long都转化为Long类型，Java的float，double都将转化为Double类型。Java的char String都将转化为String。Java的null都将转为nil
• 当两个操作符都是Double或Long时，各自按照Double或Long的类型执行
• 当两个操作符中某一个是Double时，另一个操作数也将转换成Double，按照Double类型执行
• 任何类型与String相加，结果为String
• 任何类型都比nil大，除了nil本身
• nil在打印或与字符串相加时，显示为null
• 形如yyyy-MM-dd HH:mm:ss:SS的字符串，在与java.util.Date做比较时将尝试转换成java.util.Date对象比较
• 没有规定的类型转换操作，除了未知的变量类型之间，都将抛出异常

访问数组和集合
可以通过中括号去访问数组和java.util.List对象，可以通过map.key访问java.util.Map中key对应的value。

两种模式

• 默认AviatorEvaluator以编译速度优先：
  AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);
• 修改为运行速度优先，这会做更多的编译优化：
  AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);

@Test
public void testAviator() {
    log.info(AviatorEvaluator.execute("1 + 2 + 3") + "");
    log.info(AviatorEvaluator.execute("3 > 1 && 2 != 4 || true") + "");
    log.info((String) AviatorEvaluator.execute("3 > 0 ? 'yes': no"));// 三元表达式对于两个分支的结果类型并不要求一致，可以是任何类型

    // 以下5个皆为true
    AviatorEvaluator.execute("nil == nil");
    AviatorEvaluator.execute("3 > nil");
    AviatorEvaluator.execute("true != nil");
    AviatorEvaluator.execute("' ' > nil");
    AviatorEvaluator.execute("a == nil");

    // 内置函数
    log.info("string.length('hello') = " + AviatorEvaluator.execute("string.length('hello')"));
    log.info("string.contains('hello', 'h') = " + AviatorEvaluator.execute("string.contains('hello', 'h')"));
    log.info("math.pow(-3, 2) = " + AviatorEvaluator.execute("math.pow(-3, 2)"));
    log.info("math.sqrt(9.0) = " + AviatorEvaluator.execute("math.sqrt(9.0)"));

    final List<String> list = new ArrayList<String>();
    list.add("hello");
    list.add(" world");

    final int[] array = new int[3];
    array[0] = 0;
    array[1] = 1;
    array[2] = 3;

    final Map<String, Date> map = new HashMap<>();
    map.put("date", new Date());


    Map<String, Object> env = new HashMap<>();
    env.put("name", "johnny");
    String str = "'hello ' + name";
    log.info((String) AviatorEvaluator.execute(str, env));
    // 对比, 被@Deprecated的方法
    log.info((String) AviatorEvaluator.exec(str, "johnny"));
    env.put("date", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(new Date()));
    env.put("foo", new Foo(100, new Date()));
    env.put("email", "killmesoftly2022@gmail.com");
    env.put("list", list);
    env.put("array", array);
    env.put("map", map);
    // 正则
    log.info((String) AviatorEvaluator.execute("email=~/\\w[-\\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\\.)+[A-Za-z]{2,14}/ ? $0:'unknow'", env));
    // 嵌套引用
    log.info((String) AviatorEvaluator.execute("'[foo i='+ foo.i + ' year='+(foo.date.year+1900)+ ' month='+foo.date.month +']' ", env));
    // 日期对比
    log.info(AviatorEvaluator.execute("date > '2009-12-20 00:00:00:00' ", env) + "");
    // 数组和列表
    log.info(AviatorEvaluator.execute("list[0]+list[1]+'\nsum of array='+(array[0]+array[1]+array[2]) +'\ntoday is '+map.date ", env) + "");

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

依赖的实体Bean类为：

@Data
@AllArgsConstructor
private static class Foo { 
    int i;
    Date date;
}
1
2
3
4
5
6

运算符

• 算术运算符：包括+ - * / %五个二元运算符，和一元运算符-。其中- * / %和一元的-仅能作用于Number类型。"+"不仅能用于Number类型，还可以用于String的相加，或字符串与其他对象的相加。任何类型与String相加，结果为String。
• 逻辑运算符：一元否定运算符!，逻辑与&&，逻辑或||。逻辑运算符的操作数只能为Boolean。&&和||都执行短路规则
• 关系运算符：也叫比较运算符，包括<,<=,>,>=,==,!=，不仅可以用于数值，也可以用于Number、String、Pattern、Boolean等，甚至是用户传入的任何两个都实现java.lang.Comparable接口的对象之间。变量之间以及其他类型与nil之间的关系比较，不同类型除了nil之外不能相互比较。任何对象都比nil大，除nil之外。
• 匹配运算符：匹配运算符"=~"用于String和Pattern的匹配，它的左操作数必须为String，右操作数必须为Pattern。匹配成功后，Pattern的分组将存于变量$num，num为分组索引。

内置函数

自定义函数

实现com.googlecode.aviator.runtime.function.AbstractFunction接口，并注册到AviatorEvaluator即可使用

public class UserDefinedFunction extends AbstractFunction {
    /**
     * 自定义函数名称
     */
    @Override
    public String getName() {
        return "add";
    }

    @Override
    public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
        Number num1 = FunctionUtils.getNumberValue(arg1, env);
        Number num2 = FunctionUtils.getNumberValue(arg2, env);
        return new AviatorDouble(num1.doubleValue() + num2.doubleValue());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

使用自定义函数之前需要通过addFunction()方式注册，否则报错com.googlecode.aviator.exception.FunctionNotFoundException: Function not found: add。

// 注册函数
AviatorEvaluator.addFunction(new UserDefinedFunction());
log.info("add(1, 1) = " + AviatorEvaluator.execute("add(1, 1)"));
AviatorEvaluator.removeFunction("add");
// log.info("add(1, 1) = " + AviatorEvaluator.execute("add(1, 1)"));
1
2
3
4
5

编译表达式

每次执行Aviator.execute()时，背后都经过编译和执行的操作。那可以先编译表达式，拿到编译后结果，然后传入不同的env来重复使用编译结果，提高性能。

/**
 * 编译表达式和未编译表达式性能测试
 */
@Test
public void testCompile() {
    String expression = "a * (b - c)";
    Map<String, Object> env = new HashMap<>();
    env.put("a", 3.3);
    env.put("b", 2.2);
    env.put("c", 1.1);
    int num = 10000;
    // 编译表达式
	Expression compliedExp = AviatorEvaluator.compile(expression);
    Stopwatch watch = Stopwatch.createStarted();
    for (int i = 0; i < num; i++) {
        compliedExp.execute(env);
    }
    log.info(String.format("预编译耗时为%dms", watch.elapsed(TimeUnit.MILLISECONDS)));
    watch.stop().start();
    for (int i = 0; i < num; i++) {
        AviatorEvaluator.execute(expression, env);
    }
    log.info(String.format("无编译耗时为%dms", watch.elapsed(TimeUnit.MILLISECONDS)));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出：

ExpressionTest [testCompile:65] 预编译耗时为13ms
ExpressionTest [testCompile:70] 无编译耗时为2435ms
1
2

通过complie方法可以将表达式编译成Expression的中间对象，当要执行表达式时传入Map对象直接调用Expression的execute方法即可。

编译后结果可以自己缓存，也可以交给Aviator缓存，AviatorEvaluator内部维护有一个全局缓存池：

/**
 * 预编译缓存举例
 */
@Test
public void testCompileCache() {
    String expression1 = "a + b + c";
	Expression exp1 = AviatorEvaluator.compile(expression1, true);
    Expression exp2 = AviatorEvaluator.compile(expression1, true);
    Expression exp3 = AviatorEvaluator.compile(expression1, false);
    log.info("exp1 == exp2 : " + (exp1 == exp2));
    log.info("exp1 == exp3 : " + (exp1 == exp3));
}
1
2
3
4
5
6
7
8
9
10
11
12

输出：

ExpressionTest [testCompileCache:79] exp1 == exp2: true
ExpressionTest [testCompileCache:80] exp1 == exp3: false
1
2

将cached设置为true时，那下次编译同一个表达式时将直接返回上一次编译结果。使缓存失效：public static void invalidateCache(String expression)。

规则引擎

没有规则引擎时，有些逻辑复杂的业务代码，只能通过不断的增添if - else来满足复杂的业务场景，当if - else过多时，会导致代码极难阅读，虽然能通过策略模式来优化if - else，但依旧存在开发周期缓慢、发布上线的问题。

所以需要规则引擎，尤其是风控系统。

规则引擎的优势：

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

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

public class AviatorRuleEngine {
	// 规则可以保存在MySQL或Redis中
    Map<Integer, String> ruleMap = new HashMap<>();
	public AviatorRuleEngine() {
		// 判断是不是资深顾客
        ruleMap.put(1, "age >= 18 && sumConsume > 2000 && vip");
		// 资深顾客要求修改
        ruleMap.put(2, "age > 10 && sumConsume >= 8000 && vip && avgYearConsume >= 1000");
    }
	
	public static void main(String[] args) {
        AviatorRuleEngine aviator = new AviatorRuleEngine();
		// 选择规则，传入规则所需要的参数
        log.info("公式1：" + aviator.getResult(1, 20, 3000, false));
        log.info("公式2：" + aviator.getResult(2, 23, 8000, true, 2000));
    }
	
	public Object getResult(int ruleId, Object... args) {
        String rule = ruleMap.get(ruleId);
		return AviatorEvaluator.exec(rule, args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出：

公式1：false
公式2：true
1
2

参考