表达式引擎 google aviator
1.美图
2.概述
Aviator是一个高性能、轻量级的 java 语言实现的表达式求值引擎, 主要用于各种表达式的动态求值。现在已经有很多开源可用的 java 表达式求值引擎,为什么还需要 Avaitor 呢?
Aviator的设计目标是轻量级和高性能,相比于Groovy、JRuby的笨重, Aviator非常小, 加上依赖包也才450K,不算依赖包的话只有 70K; 当然, Aviator的语法是受限的, 它不是一门完整的语言, 而只是语言的一小部分集合。
其次, Aviator的实现思路与其他轻量级的求值器很不相同, 其他求值器一般都是通过解释的方式运行, 而Aviator则是直接将表达式编译成Java 字节码, 交给JVM去执行。简单来说, Aviator的定位是介于Groovy这样的重量级脚本语言和IKExpression这样的轻量级表达式引擎 之间。
Aviator支持大部分运算操作符, 包括算术操作符、关系运算符、逻辑操作符、位运算符、正则匹配操作符(=~)、三元表达式(?:), 并且支持操作符的优先级和括号强制优先级, 具体请看后面的操作符列表, 支持自定义函数.
3.包依赖
Aviator依赖了commons-beanutils, 使用Aviator可以添加下面的maven依赖:
<dependency>
<groupId>com.googlecode.aviatorgroupId>
<artifactId>aviatorartifactId>
<version>2.3.3version>
dependency>
4.使用手册
4.1 执行表达式
Aviator的使用都是集中通过com.googlecode.aviator.AviatorEvaluator这个入口类来处理, 最简单的例子, 执行一个计算1+2+3的表达式:
/**
* 测试点：测试表达式求值
* 测试结果：6
*
*/
@Test
public void expersionTest() {
Long result = (Long) AviatorEvaluator.execute("1+2+3");
System.out.println(result);
}
细心的朋友肯定注意到结果是Long,而不是Integer。这是因为Aviator的数值类型仅支持Long和Double, 任何整数都将转换成Long, 任何浮点数都将转换为Double, 包括用户传入的变量数值。这个例子的打印结果将是正确答案6。
4.2 使用变量
想让Aviator对你say hello吗? 很简单, 传入你的名字, 让Aviator负责字符串的相加:
/**
* 测试点：测试 变量求值
* 测试结果：hello Michael
*/
@Test
public void varTest() {
String yourName = "Michael";
Map<String, Object> env = new HashMap<String, Object>();
env.put("yourName", yourName);
String result = (String) AviatorEvaluator.execute(" 'hello ' + yourName ", env);
System.out.println(result); // hello Michael
}
上面的例子演示了怎么向表达式传入变量值, 表达式中的yourName是一个变量, 默认为null, 通过传入Map的变量绑定环境, 将yourName设置为你输入的名称。 env 的key是变量名, value是变量的值。
上面例子中的’hello '是一个Aviator的String, Aviator的String是任何用单引号或者双引号括起来的字符序列, String可以比较大小(基于unicode顺序), 可以参与正则匹配, 可以与任何对象相加, 任何对象与String相加结果为String。 String中也可以有转义字符,如\n、\\、\' 等。
/**
* 测试点：测试 特殊符号 求值
* 测试结果：
*/
@Test
public void varTest1() {
String yourName = "Michael";
Map<String, Object> env = new HashMap<String, Object>();
env.put("yourName", yourName);
System.out.println((String) AviatorEvaluator.execute(" 'a\"b' ")); // 字符串 a"b
System.out.println((String) AviatorEvaluator.execute(" \"a\'b\" ")); // 字符串 a'b
System.out.println((String) AviatorEvaluator.execute(" 'hello ' + 3 ")); // 字符串 hello 3
System.out.println((String) AviatorEvaluator.execute(" 'hello '+ unknow ")); // 字符串 hello null
}
4.3 exec 方法
Aviator 2.2 开始新增加一个exec方法, 可以更方便地传入变量并执行, 而不需要构造env这个map了:
String name = "dennis";
AviatorEvaluator.exec(" 'hello ' + yourName ", name); // hello dennis
只要在exec中按照变量在表达式中的出现顺序传入变量值就可以执行, 不需要构建Map了。
4.4 调用函数
Aviator 支持函数调用, 函数调用的风格类似 lua, 下面的例子获取字符串的长度:
AviatorEvaluator.execute("string.length('hello')"); // 5
string.length(‘hello’)是一个函数调用, string.length是一个函数, 'hello’是调用的参数。
再用string.substring来截取字符串:
AviatorEvaluator.execute("string.contains(\"test\", string.substring('hello', 1, 2))"); // true
通过string.substring(‘hello’, 1, 2)获取字符串’e’, 然后通过函数string.contains判断e是否在’test’中。可以看到, 函数可以嵌套调用。
Aviator 的内置函数列表请看后面。
4.5 自定义函数
Aviator 除了内置的函数之外,还允许用户自定义函数,只要实现com.googlecode.aviator.runtime.type.AviatorFunction接口, 并注册到AviatorEvaluator即可使用. AviatorFunction接口十分庞大, 通常来说你并不需要实现所有的方法, 只要根据你的方法的参 数个数, 继承AbstractFunction类并override相应方法即可。
可以看一个例子,我们实现一个add函数来做数值的相加:
public class AddFunction extends AbstractFunction {
@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());
}
public String getName() {
return "add";
}
}
测试类
/**
* 测试点：测试 自定义函数 求值
* 测试结果：
*/
@Test
public void selfFunctionTest() {
//注册函数
AviatorEvaluator.addFunction(new AddFunction());
System.out.println(AviatorEvaluator.execute("add(1, 2)")); // 3.0
System.out.println(AviatorEvaluator.execute("add(add(1, 2), 100)")); // 103.0
}
注册函数通过AviatorEvaluator.addFunction方法, 移除可以通过removeFunction。
4.6 编译表达式
上面提到的例子都是直接执行表达式, 事实上 Aviator 背后都帮你做了编译并执行的工作。 你可以自己先编译表达式, 返回一个编译的结果, 然后传入不同的env来复用编译结果, 提高性能, 这是更推荐的使用方式:
/**
* 测试点：测试 编译表达式 求值
* 测试结果：false
*/
@Test
public void compileExpressionTest() {
String expression = "a-(b-c)>100";
// 编译表达式
Expression compiledExp = AviatorEvaluator.compile(expression);
Map<String, Object> env = new HashMap<String, Object>();
env.put("a", 100.3);
env.put("b", 45);
env.put("c", -199.100);
// 执行表达式
Boolean result = (Boolean) compiledExp.execute(env);
System.out.println(result); // false
}
通过compile方法可以将表达式编译成Expression的中间对象, 当要执行表达式的时候传入env并调用Expression的execute方法即可。 表达式中使用了括号来强制优先级, 这个例子还使用了>用于比较数值大小, 比较运算符!=、==、>、>=、<、<=不仅可以用于数值, 也可以用于String、Pattern、Boolean等等, 甚至是任何用户传入的两个都实现了java.lang.Comparable接口的对象之间。
编译后的结果你可以自己缓存, 也可以交给 Aviator 帮你缓存, AviatorEvaluator内部有一个全局的缓存池, 如果你决定缓存编译结果, 可以通过:
public static Expression compile(String expression, boolean cached)
将cached设置为true即可, 那么下次编译同一个表达式的时候将直接返回上一次编译的结果。
使缓存失效通过:
public static void invalidateCache(String expression)
4.7 访问数组和集合
可以通过中括号去访问数组和java.util.List对象, 可以通过map.key访问java.util.Map中key对应的value, 一个例子:
/**
* 测试点：测试 数组和集合 求值
* 测试结果：
*/
@Test
public void arrayTest() {
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<String, Date>();
map.put("date", new Date());
Map<String, Object> env = new HashMap<String, Object>();
env.put("list", list);
env.put("array", array);
env.put("mmap", map);
System.out.println(AviatorEvaluator.execute("list[0]+list[1]", env)); // hello world
System.out.println(AviatorEvaluator.execute("'array[0]+array[1]+array[2]=' + (array[0]+array[1]+array[2])", env)); // array[0]+array[1]+array[2]=4
System.out.println(AviatorEvaluator.execute("'today is ' + mmap.date ", env)); // today is Wed Feb 24 17:31:45 CST 2016
}
4.8 三元操作符
Aviator 不提供if else语句, 但是提供了三元操作符?:用于条件判断,使用上与 java 没有什么不同:
AviatorEvaluator.exec("a>0? 'yes':'no'", 1); // yes
Aviator 的三元表达式对于两个分支的结果类型并不要求一致,可以是任何类型,这一点与 java 不同。
4.9 正则表达式匹配
Aviator 支持类 Ruby 和 Perl 风格的表达式匹配运算,通过=~操作符, 如下面这个例子匹配 email 并提取用户名返回:
/**
* 测试点：测试 正则表达式 求值
* 测试结果：
*/
@Test
public void repxTest() {
String email = "[email protected]";
Map<String, Object> env = new HashMap<String, Object>();
env.put("email", email);
String username = (String) AviatorEvaluator.execute("email=~/([\\w0-8]+)@\\w+[\\.\\w+]+/ ? $1 : 'unknow' ", env);
System.out.println(username); // killme2008
}
email与正则表达式/([\\w0-8]+@\\w+[\\.\\w+]+)/通过=~操作符来匹配,结果为一个 Boolean 类 型, 因此可以用于三元表达式判断,匹配成功的时候返回$1,指代正则表达式的分组 1,也就是用户名,否则返回unknown。
Aviator 在表达式级别支持正则表达式,通过//括起来的字符序列构成一个正则表达式,正则表 达式可以用于匹配(作为=~的右操作数)、比较大小,匹配仅能与字符串进行匹配。匹配成功后, Aviator 会自动将匹配成功的分组放入$num的变量中,其中$0 指代整个匹配的字符串,而$1表示第一个分组,以此类推。
Aviator 的正则表达式规则跟 Java 完全一样,因为内部其实就是使用java.util.regex.Pattern做编译的。
4.10 变量的语法糖
Aviator 有个方便用户使用变量的语法糖, 当你要访问变量a中的某个属性b, 那么你可以通过a.b访问到, 更进一步, a.b.c将访问变量a的b属性中的c属性值, 推广开来也就是说 Aviator 可以将变量声明为嵌套访问的形式。
TestAviator类符合JavaBean规范, 并且是 public 的，我们就可以使用语法糖:
public class TestAviator {
int i;
float f;
Date date;
// 构造方法
public TestAviator(int i, float f, Date date) {
this.i = i;
this.f = f;
this.date = date;
}
// getter and setter
public static void main(String[] args) {
TestAviator foo = new TestAviator(100, 3.14f, new Date());
Map<String, Object> env = new HashMap<String, Object>();
env.put("foo", foo);
System.out.println(AviatorEvaluator.execute("'foo.i = '+foo.i", env)); // foo.i = 100
System.out.println(AviatorEvaluator.execute("'foo.f = '+foo.f", env)); // foo.f = 3.14
System.out.println(AviatorEvaluator.execute("'foo.date.year = '+(foo.date.year+1990)", env)); // foo.date.year = 2106
}
}
4.11 nil 对象
nil是 Aviator 内置的常量,类似 java 中的null,表示空的值。nil跟null不同的在于,在 java 中null只能使用在==、!=的比较运算符,而nil还可以使用>、>=、<、<=等比较运算符。 Aviator 规定,任何对象都比nil大除了nil本身。用户传入的变量如果为null,将自动以nil替代。
AviatorEvaluator.execute("nil == nil"); //true
AviatorEvaluator.execute(" 3> nil"); //true
AviatorEvaluator.execute(" true!= nil"); //true
AviatorEvaluator.execute(" ' '>nil "); //true
AviatorEvaluator.execute(" a==nil "); //true, a 是 nul
nil与String相加的时候,跟 java 一样显示为 null
4.12 日期比较
Aviator 并不支持日期类型,如果要比较日期,你需要将日期写字符串的形式,并且要求是形如 “yyyy-MM-dd HH:mm:ss:SS”的字符串,否则都将报错。 字符串跟java.util.Date比较的时候将自动转换为Date对象进行比较:
public static void main(String[] args) {
Map<String, Object> env = new HashMap<String, Object>();
final Date date = new Date();
String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date);
env.put("date", date);
env.put("dateStr", dateStr);
Boolean result = (Boolean) AviatorEvaluator.execute("date==dateStr", env);
System.out.println(result); // true
result = (Boolean) AviatorEvaluator.execute("date > '2010-12-20 00:00:00:00' ", env);
System.out.println(result); // true
result = (Boolean) AviatorEvaluator.execute("date < '2200-12-20 00:00:00:00' ", env);
System.out.println(result); // true
result = (Boolean) AviatorEvaluator.execute("date==date ", env);
System.out.println(result); // true
}
也就是说String除了能跟String比较之外,还能跟nil和java.util.Date对象比较。
4.13 大数计算和精度
从 2.3.0 版本开始,aviator 开始支持大数字计算和特定精度的计算, 本质上就是支持java.math.BigInteger和java.math.BigDecimal两种类型, 这两种类型在 aviator 中简称 为big int和decimal类型。 类似99999999999999999999999999999999这样的数字在 Java 语言里是没办法编译通过 的, 因为它超过了Long类型的范围, 只能用BigInteger来封装。但是 aviator 通过包装,可 以直接支持这种大整数的计算,例如:
public static void main(String[] args) {
System.out.println(AviatorEvaluator.exec("99999999999999999999999999999999 + 99999999999999999999999999999999"));
}
结果为类型big int的: 199999999999999999999999999999998
4.14 字面量表示
big int和decimal的表示与其他数字不同,两条规则:
- 以大写字母N为后缀的整数都被认为是big int,如1N,2N,9999999999999999999999N等, 都是big int类型。
- 超过long范围的整数字面量都将自动转换为big int类型。
- 以大写字母M为后缀的数字都被认为是decimal, 如1M,2.222M, 100000.9999M等, 都是decimal类型。
用户也可以通过变量传入这两种类型来参与计算。
运算
big int和decimal的运算,跟其他数字类型long,double没有什么区别,操作符仍然是一样的。 aviator重载了基本算术操作符来支持这两种新类型:
public static void main(String[] args) {
Object rt = AviatorEvaluator.exec("9223372036854775807100.356M * 2");
System.out.println(rt + " " + rt.getClass()); // 18446744073709551614200.712 class java.math.BigDecimal
rt = AviatorEvaluator.exec("92233720368547758074+1000");
System.out.println(rt + " " + rt.getClass()); // 92233720368547759074 class java.math.BigInteger
BigInteger a = new BigInteger(String.valueOf(Long.MAX_VALUE) + String.valueOf(Long.MAX_VALUE));
BigDecimal b = new BigDecimal("3.2");
BigDecimal c = new BigDecimal("9999.99999");
rt = AviatorEvaluator.exec("a+10000000000000000000", a);
System.out.println(rt + " " + rt.getClass()); // 92233720368547758089223372036854775807 class java.math.BigInteger
rt = AviatorEvaluator.exec("b+c*2", b, c);
System.out.println(rt + " " + rt.getClass()); // 20003.19998 class java.math.BigDecimal
rt = AviatorEvaluator.exec("a*b/c", a, b, c);
System.out.println(rt + " " + rt.getClass()); // 2.951479054745007313280155218459508E+34 class java.math.BigDecimal
}
4.14 类型转换和提升
当big int或者decimal和其他类型的数字做运算的时候,按照long < big int < decimal < double的规则做提升, 也就是说运算的数字如果类型不一致, 结果的类型为两者之间更“高”的类型。例如:
1 + 3N, 结果为big int的4N
1 + 3.1M,结果为decimal的4.1M
1N + 3.1M,结果为decimal的 4.1M
1.0 + 3N,结果为double的4.0
1.0 + 3.1M,结果为double的4.1
4.15 decimal 的计算精度
Java 的java.math.BigDecimal通过java.math.MathContext支持特定精度的计算,任何涉及到金额的计算都应该使用decimal类型。
默认 Aviator 的计算精度为MathContext.DECIMAL128,你可以自定义精度, 通过:
AviatorEvaluator.setMathContext(MathContext.DECIMAL64);
即可设置,更多关于decimal的精度问题请看java.math.BigDecimal的 javadoc 文档。
4.16 强大的 seq 库
aviator 拥有强大的操作集合和数组的 seq 库。整个库风格类似函数式编程中的高阶函数。在 aviator 中, 数组以及java.util.Collection下的子类都称为seq,可以直接利用 seq 库进行遍历、过滤和聚合等操作。
例如,假设我有个 list:
public static void main(String[] args) {
Map<String, Object> env = new HashMap<String, Object>();
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(20);
list.add(10);
env.put("list", list);
Object result = AviatorEvaluator.execute("count(list)", env);
System.out.println(result); // 3
result = AviatorEvaluator.execute("reduce(list,+,0)", env);
System.out.println(result); // 33
result = AviatorEvaluator.execute("filter(list,seq.gt(9))", env);
System.out.println(result); // [10, 20]
result = AviatorEvaluator.execute("include(list,10)", env);
System.out.println(result); // true
result = AviatorEvaluator.execute("sort(list)", env);
System.out.println(result); // [3, 10, 20]
AviatorEvaluator.execute("map(list,println)", env);
}
我们可以:
- 求长度: count(list)
- 求和: reduce(list,+,0), reduce函数接收三个参数,第一个是seq,第二个是聚合的函数,如+等,第三个是聚合的初始值
- 过滤: filter(list,seq.gt(9)), 过滤出list中所有大于9的元素并返回集合; seq.gt函数用于生成一个谓词,表示大于某个值
- 判断元素在不在集合里: include(list,10)
- 排序: sort(list)
- 遍历整个集合: map(list,println), map接受的第二个函数将作用于集合中的每个元素,这里简单地调用println打印每个元素
4.17 两种运行模式
默认 AviatorEvaluator 以执行速度优先:
AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);
你可以修改为编译速度优先,这样不会做编译优化:
AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);
4.18 调试信息
从 2.1.1.版本开始,Aviator允许设置输出每个表达式生成的字节码,只要设置trace为true即可:
AviatorEvaluator.setTrace(true);
方便用户做跟踪和调试。默认是输出到标准输出,你可以改变输出指向:
AviatorEvaluator.setTraceOutputStream(new FileOutputStream(new File("aviator.log")));
参考：https://blog.csdn.net/keda8997110/article/details/50782848