Aviator是一个高性能、轻量级的 java 语言实现的表达式求值引擎, 主要用于各种表达式的动态求值。现在已经有很多开源可用的 java 表达式求值引擎,为什么还需要 Avaitor 呢?
Aviator的设计目标是轻量级和高性能,相比于Groovy、JRuby的笨重, Aviator非常小, 加上依赖包也才 537K,不算依赖包的话只有 70K; 当然, Aviator的语法是受限的, 它不是一门完整的语言, 而只是语言的一小部分集合。
其次, Aviator的实现思路与其他轻量级的求值器很不相同, 其他求值器一般都是通过解释的方式运行, 而Aviator则是直接将表达式编译成 JVM 字节码, 交给 JVM 去执行。简单来说, Aviator的定位是介于 Groovy 这样的重量级脚本语言和 IKExpression 这样的轻量级表达式引擎之间。
Aviator的特性:
Aviator的限制:
Aviator依赖了commons-beanutils, 使用Aviator可以添加下面的maven依赖:
com.googlecode.aviator
aviator
{version}
从 3.2.0 版本开始, Aviator 仅支持 JDK 7 及其以上版本。 JDK 6 请使用 3.1.1 这个稳定版本。
val result = AviatorEvaluator.execute("1+2+3")
println(result) //6
如果开启了 ALWAYS_PARSE_FLOATING_POINT_NUMBER_INTO_DECIMAL 选项,那么在表达式中出现的浮点数都将解析为 BigDecimal,这是为了方便一些用户要求高精度的计算,又不想额外地给浮点数加上 M 后缀标记为 BigDecimal:
AviatorEvaluator.setOption(Options.ALWAYS_PARSE_FLOATING_POINT_NUMBER_INTO_DECIMAL, true)
val result = AviatorEvaluator.execute("println('hello world'); 1+2+3 ; 100-1")
println(result)
//输出结果:
//hello world
//99
表达式的结果将是最后一个表达式 100-1,也就是 99,但是中间的表达式也将执行,包括打印 hello world。通过在表达式求值过程中加入 println打印,可以方便调试,也可以通过 Options.TRACE_EVAL来跟踪执行过程,参见后续章节。
val instance = AviatorEvaluator.newInstance
//接下来使用 instance,几乎跟 AviatorEvaluator 没有不同,只是换成了实例方法
val world = "world"
val env = new util.HashMap[String,Object]()
env.put("world",world)
val result =AviatorEvaluator.execute(" 'hello ' + world ",env)
println(result) // hello world
'hello ‘是一个Aviator的String, Aviator的String是任何用单引号或者双引号括起来的字符序列, String可以比较大小(基于unicode顺序), 可以参与正则匹配, 可以与任何对象相加, 任何对象与String相加结果为String。 String中也可以有转义字符,如\n、\、’ 等。
AviatorEvaluator.execute(" 'a\"b' ") // 字符串 a"b
AviatorEvaluator.execute(" \"a\'b\" ") // 字符串 a'b
AviatorEvaluator.execute(" 'hello ' + 3 ") // 字符串 hello 3
AviatorEvaluator.execute(" 'hello '+ unknow ") // 字符串 hello null
val value = "world"
AviatorEvaluator.exec("'hello' + value",value) // hello world
AviatorEvaluator.execute("string.length('hello')")
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’中。可以看到, 函数可以嵌套调用。
object test {
def main(args: Array[String]): Unit = {
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
}
}
class AddFunction extends AbstractFunction{
override def call(env: java.util.Map[String, Object], arg1: AviatorObject, arg2: AviatorObject): AviatorObject = {
val left = FunctionUtils.getNumberValue(arg1, env)
val right = FunctionUtils.getNumberValue(arg2, env)
new AviatorDouble(left.doubleValue + right.doubleValue)
}
def getName = "add"
}
注册函数通过AviatorEvaluator.addFunction方法, 移除可以通过removeFunction。另外, FunctionUtils 提供了一些方便参数类型转换的方法。
如果你的参数个数不确定,可以继承 AbstractVariadicFunction 类,只要实现其中的 variadicCall 方法即可,比如我们实现一个找到第一个参数不为 null 的函数:
object test {
def main(args: Array[String]): Unit = {
AviatorEvaluator.addFunction(new GetFirstNonNullFunction)
System.out.println(AviatorEvaluator.execute("getFirstNonNull(1)")) // 1
System.out.println(AviatorEvaluator.execute("getFirstNonNull(1,2,3,4,nil,5)")) // 1
System.out.println(AviatorEvaluator.execute("getFirstNonNull(a,b,c,d)")) // null
}
}
class GetFirstNonNullFunction extends AbstractVariadicFunction {
override def variadicCall(env: util.Map[String, AnyRef], args: AviatorObject*): AviatorObject = {
if (args != null) for (arg <- args) {
if (arg.getValue(env) != null) return arg
}
new AviatorString(null)
}
override def getName = "getFirstNonNull"
}
当然,同时你仍然覆写特定的 call 方法来自定义实现。
自定义函数在 4.0.0 之后也可以通过 lambda 来定义:
AviatorEvaluator.defineFunction("add", "lambda (x,y) -> x + y end")
AviatorEvaluator.exec("add(1,2)") //3
class function extends FunctionLoader{
/**
* Invoked when function not found
*
* @param name function name
*/
override def onFunctionNotFound(name: String): AviatorFunction = ???
}
用户可以自主实现函数加载器,当函数不能从当前求值器中找到的时候,将调用 loader 的onFunctionNotFound 方法进行查找。自定义的加载器,通过 AviatorEvaluator.addFunctionLoader(loader)注册,可以注册多个加载器,加载顺序将按照添加顺序进行查找,其中任何一个找到,都将中断查找过程。
AviatorEvaluator.addOpFunction(OperatorType.BIT_AND, new AbstractFunction() {
override def call(env: util.Map[String, Object], arg1: AviatorObject, arg2: AviatorObject) = new AviatorString(arg1.getValue(env).toString + arg2.getValue(env).toString)
override def getName = "&"
})
AviatorEvaluator.addOpFunction(opType, func) 就可以重载指定的运算符,重载后运行即可看到:
val map = new util.HashMap[String,Object]()
map.put("a","4")
val result = AviatorEvaluator.execute("a&3", map)
println(result) //43
val map1 = new util.HashMap[String,Object]()
map1.put("a","hello")
val result1 = AviatorEvaluator.execute("a&' world'", map1)
println(result1) //hello world
请注意,运算符重载使用不当,一定程度上会带来混乱,并且有一定的性能损失,请慎重使用。
val expression = "a-(b-c)>100"
// 编译表达式
val compiledExp = AviatorEvaluator.compile(expression)
val env = new util.HashMap[String,Object]()
env.put("a", 100.3.asInstanceOf[Object])
env.put("b", new Integer(45))
env.put("c", (-199.100).asInstanceOf[Object])
// 执行表达式
val result = compiledExp.execute(env).asInstanceOf[Boolean]
println(result) // false
通过compile方法可以将表达式编译成Expression的中间对象, 当要执行表达式的时候传入env并调用Expression的execute方法即可。 表达式中使用了括号来强制优先级, 这个例子还使用了>用于比较数值大小, 比较运算符!=、==、>、>=、<、<=不仅可以用于数值, 也可以用于String、Pattern、Boolean等等, 甚至是任何用户传入的两个都实现了java.lang.Comparable接口的对象之间。
编译后的结果你可以自己缓存, 也可以交给 Aviator 帮你缓存, AviatorEvaluator内部有一个全局的缓存池, 如果你决定缓存编译结果, 可以通过:
public static Expression compile(final String expression, final boolean cached)
将cached设置为true即可, 那么下次编译同一个表达式的时候将直接返回上一次编译的结果。
使缓存失效通过:
public static void invalidateCache(String expression)
val list = new util.ArrayList[String]
list.add("hello")
list.add(" world")
val array = new Array[Int](3)
array(0) = 0
array(1) = 1
array(2) = 3
val map = new util.HashMap[String,Object]()
map.put("date", new Date())
val env = new util.HashMap[String,Object]()
env.put("list", list)
env.put("array", array)
env.put("mmap", map)
println(AviatorEvaluator.execute("list[0]+list[1]", env)) // hello world
println(AviatorEvaluator.execute("'array[0]+array[1]+array[2]=' + (array[0]+array[1]+array[2])", env)) // array[0]+array[1]+array[2]=4
println(AviatorEvaluator.execute("'today is ' + mmap.date ", env)) // today is Tue Mar 19 11:42:51 CST 2019
如果函数调用或者括号表达式结果是一个数组或者List,你同样可以可以通过 [index] 访问:
println(AviatorEvaluator.exec("string.split(s,',')[0]", "a,b,c,d")) //a
println(AviatorEvaluator.exec("a>0? 'yes':'no'", new Integer(1))) // yes
Aviator 的三元表达式对于两个分支的结果类型并不要求一致,可以是任何类型,这一点与 java 不同。
val email = "[email protected]"
val env = new util.HashMap[String,Object]()
env.put("email", email)
val username = AviatorEvaluator.execute("email=~/([\\w0-8]+)@\\w+[\\.\\w+]+/ ? $1 : 'unknow' ", env).asInstanceOf[String]
println(username) // killme2008
email与正则表达式/([\w0-8]+@\w+[\.\w+]+)/通过=~操作符来匹配,结果为一个 Boolean 类 型, 因此可以用于三元表达式判断,匹配成功的时候返回$1,指代正则表达式的分组 1,也就是用户名,否则返回unknown。
Aviator 在表达式级别支持正则表达式,通过//括起来的字符序列构成一个正则表达式,正则表达式可以用于匹配(作为=~的右操作数)、比较大小。但是匹配仅能与字符串进行匹配。匹配成功后, Aviator 会自动将匹配成功的捕获分组(capturing groups) 放入 env ${num}的变量中,其中$0 指代整个匹配的字符串,而$1表示第一个分组,$2表示第二个分组以此类推。
请注意,分组捕获放入 env 是默认开启的,因此如果传入的 env 不是线程安全并且被并发使用,可能存在线程安全的隐患。关闭分组匹配,可以通过 AviatorEvaluator.setOption(Options.PUT_CAPTURING_GROUPS_INTO_ENV, false); 来关闭,对性能有稍许好处。
Aviator 的正则表达式规则跟 Java 完全一样,因为内部其实就是使用java.util.regex.Pattern做编译的。
object test {
def main(args: Array[String]): Unit = {
val foo = new Foo(100, 3.14f, new Date())
val env = new util.HashMap[String,Object]()
env.put("foo", foo)
println(AviatorEvaluator.execute("'foo.i = '+foo.i", env)) // foo.i = 100
println(AviatorEvaluator.execute("'foo.f = '+foo.f", env)) // foo.f = 3.14
println(AviatorEvaluator.execute("'foo.date.year = '+(foo.date.year+1900)", env)) // foo.date.year = 2019
}
}
class Foo(var i: Int, var f: Float, var date: Date) {
def getI: Int = i
def setI(i: Int): Unit = {
this.i = i
}
def getF: Float = f
def setF(f: Float): Unit = {
this.f = f
}
def getDate: Date = date
def setDate(date: Date): Unit = {
this.date = date
}
}
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 是 null
nil与String相加的时候,跟 java 一样显示为 null
val env = new util.HashMap[String,Object]()
val date = new Date()
val dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date)
env.put("date", date)
env.put("dateStr", dateStr)
var result = AviatorEvaluator.execute("date==dateStr", env).asInstanceOf[Boolean]
println(result) // true
result = AviatorEvaluator.execute("date > '2010-12-20 00:00:00:00' ", env).asInstanceOf[Boolean]
println(result)// true
result = AviatorEvaluator.execute("date < '2200-12-20 00:00:00:00' ", env).asInstanceOf[Boolean]
println(result)// true
result = AviatorEvaluator.execute("date==date ", env).asInstanceOf[Boolean]
println(result)// true
也就是说String除了能跟String比较之外,还能跟nil和java.util.Date对象比较。
println(AviatorEvaluator.execute("99999999999999999999999999999999 + 99999999999999999999999999999999"))
//结果:199999999999999999999999999999998
AviatorEvaluator.setOption(Options.ALWAYS_PARSE_FLOATING_POINT_NUMBER_INTO_DECIMAL, true)
var rt = AviatorEvaluator.exec("9223372036854775807100.356M * 2")
println(rt + " " + rt.getClass) // 18446744073709551614200.712 class java.math.BigDecimal
rt = AviatorEvaluator.exec("92233720368547758074+1000")
println(rt + " " + rt.getClass) // 92233720368547759074 class java.math.BigInteger
val a = new BigInteger(String.valueOf(Long.MaxValue) + String.valueOf(Long.MaxValue))
val b = new java.math.BigDecimal("3.2")
val c = new java.math.BigDecimal("9999.99999")
rt = AviatorEvaluator.exec("a+10000000000000000000", a)
println(rt + " " + rt.getClass) // 92233720368547758089223372036854775807 class java.math.BigInteger
rt = AviatorEvaluator.exec("b+c*2", b, c)
println(rt + " " + rt.getClass) // 20003.19998 class java.math.BigDecimal
rt = AviatorEvaluator.exec("a*b/c", a, b, c)
println(rt + " " + rt.getClass) // 2.951479054745007313280155218459508E+34 class java.math.BigDecimal
AviatorEvaluator.setOption(Options.MATH_CONTEXT, MathContext.DECIMAL64)
即可设置,更多关于decimal的精度问题请看java.math.BigDecimal的 javadoc 文档。
val env = new util.HashMap[String,Object]()
val list = new util.ArrayList[Integer]
list.add(3)
list.add(20)
list.add(10)
env.put("list", list)
var result = AviatorEvaluator.execute("count(list)", env)
println(result) // 3
result = AviatorEvaluator.execute("reduce(list,+,0)", env)
println(result) // 33
result = AviatorEvaluator.execute("filter(list,seq.gt(9))", env)
println(result) // [20, 10]
result = AviatorEvaluator.execute("include(list,10)", env)
println(result) // true
result = AviatorEvaluator.execute("sort(list)", env)
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打印每个元素
其他还有:
seq.some(list, pred) 当集合中只要有一个元素满足谓词函数 pred 返回 true,立即返回 true,否则为 false。
seq.every(list, pred) 当集合里的每个元素都满足谓词函数 pred 返回 true,则结果为 true,否则返回 false。
seq.not_any(list, pred),当集合里的每个元素都满足谓词函数 pred 返回 false,则结果为 true,否则返回 false。
以及 seq.or(p1, p2, …) 和 seq.and(p1, p2, …) 用于组合 seq.gt、seq.lt 等谓词函数。
AviatorEvaluator.setOption(Options.OPTIMIZE_LEVEL, AviatorEvaluator.EVAL)
你可以修改为编译速度优先,这样不会做编译优化:
AviatorEvaluator.setOption(Options.OPTIMIZE_LEVEL, AviatorEvaluator.COMPILE)
AviatorEvaluator.setOption(Options.TRACE, true)
默认是打印到标准输出,你可以改变输出指向:
AviatorEvaluator.setTraceOutputStream(new FileOutputStream(new File("aviator.log")))
下面是 Aviator 详细的语法规则定义。
其中 big int 和 decimal 是 2.3.0 版本开始引入的。数字还支持十六进制(以0x或者0X开头的数字), 以及科学计数法,如1e-3等。 不支持其他进制。
算术运算符
Aviator 支持常见的算术运算符,包括+ - * / %五个二元运算符,和一元运算符-(负)。其中- * / %和一元的-仅能作用于Number类型。
+不仅能用于Number类型,还可以用于String的相加,或者字符串与其他对象的相加。
Aviator 规定,任何类型与String相加,结果为String。
逻辑运算符
Avaitor 的支持的逻辑运算符包括,一元否定运算符!,以及逻辑与的&&,逻辑或的||。逻辑运算符的操作数只能为Boolean。
&&和||都执行短路规则。
关系运算符
Aviator 支持的关系运算符包括<, <=, >, >=以及==和!= 。
关系运算符可以作用于Number之间、String之间、Pattern之间、Boolean之间、变量之间以及其他类型与nil之间的关系比较, 不同类型除了nil之外不能相互比较。
位运算符
Aviator 支持所有的 Java 位运算符,包括&, |, ^, ~, >>, <<, >>>。
匹配运算符
匹配运算符=~用于String和Pattern的匹配,它的左操作数必须为String,右操作数必须为Pattern。 匹配成功后,Pattern的分组将存于变量$num,num为分组索引。
三元运算符
Aviator 没有提供if else语句,但是提供了三元运算符?:,形式为bool ? exp1: exp2。 其中bool必须为Boolean类型的表达式, 而exp1和exp2可以为任何合法的 Aviator 表达式,并且不要求exp1和exp2返回的结果类型一致。
完整的内置函数列表参见内置函数。
点击此处
AviatorEvaluator.setOption(opt, val) 支持定义求值器的行为,完整的 Options 枚举选项参见完整选项说明
点击此处
点击此处
点击此处
主页
示例
官方指南