表达式引擎Aviator实战

概述

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

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

功能

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

限制:没有if else、do while等语句,没有赋值语句,没有位运算符;

使用场景

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

实战

pom文件引入:

<dependency>
	<groupId>com.googlecode.aviatorgroupId>
	<artifactId>aviatorartifactId>
dependency>

入门

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", "[email protected]");
    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) + "");

}

依赖的实体Bean类为:

@Data
@AllArgsConstructor
private static class Foo { 
    int i;
    Date date;
}

运算符

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

内置函数

函数名称 说明
sysdate() 返回当前日期对象java.util.Date
rand() 返回一个介于0-1的随机数,double类型
print([out],obj) 打印对象,如果指定out,向out打印,否则输出到控制台
now() 返回System.currentTimeMillis
string.substring(s,begin[,end]) 截取字符串s,从begin到end,end如果忽略的话,将从begin到结尾,与java.util.String.substring一样。
math.log(d) 求d的自然对数
math.log10(d) 求d以10为底的对数
map(seq,fun) 将函数fun作用到集合seq每个元素上,返回新元素组成的集合
filter(seq,predicate) 将谓词predicate作用在集合的每个元素上,返回谓词为true的元素组成的集合
include(seq,element) 判断element是否在集合seq中,返回boolean值
sort(seq) 排序集合,仅对数组和List有效,返回排序后的新集合
reduce(seq,fun,init) fun接收两个参数,集合元素,累积init,用于将fun作用在集合每个元素和初始值上面,返回最终的init值
seq.eq(value) 返回一个谓词,用来判断传入的参数是否跟value相等,一般用于filter函数,如filter(seq,seq.eq(3)) 过滤返回等于3的元素组成的集合
seq.exists() 返回判断存在,即不为nil的谓词

自定义函数

实现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());
    }
}

使用自定义函数之前需要通过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)"));

编译表达式

每次执行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)));
}

输出:

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

通过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));
}

输出:

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

将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:false
公式2:true

参考

你可能感兴趣的:(Java,java)