简介

Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎,主要用于各种表达式的动态求值。现在已经有很多开源可用的java表达式求值引擎,为什么还需要Avaitor呢?

Aviator的设计目标是轻量级和高性能 ,相比于Groovy、JRuby的笨重,Aviator非常小,加上依赖包也才450K,不算依赖包的话只有70K;当然,Aviator的语法是受限的,它不是一门完整的语言,而只是语言的一小部分集合。

其次,Aviator的实现思路与其他轻量级的求值器很不相同,其他求值器一般都是通过解释的方式运行,而Aviator则是直接将表达式编译成Java字节码,交给JVM去执行。简单来说,Aviator的定位是介于Groovy这样的重量级脚本语言和IKExpression这样的轻量级表达式引擎之间。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RylaCldK-1654075386060)(imgs/avitor01.png)]


Aviator的特性

支持大部分运算操作符,包括算术操作符、关系运算符、逻辑操作符、位运算符、正则匹配操作符(=~)、三元表达式?: ,并且支持操作符的优先级和括号强制优先级,具体请看后面的操作符列表。

支持大整数和精度运算(2.3.0版本引入)

支持函数调用和自定义函数

内置支持正则表达式匹配,类似Ruby、Perl的匹配语法,并且支持类Ruby的$digit指向匹配分组。

自动类型转换,当执行操作的时候,会自动判断操作数类型并做相应转换,无法转换即抛异常。

支持传入变量,支持类似a.b.c的嵌套变量访问。

函数式风格的seq库,操作集合和数组

性能优秀

Aviator的限制:

没有if else、do while等语句,没有赋值语句,仅支持逻辑表达式、算术表达式、三元表达式和正则匹配。

不支持八进制数字字面量,仅支持十进制和十六进制数字字面量。


JAR包引入

<dependency>
  <groupId>com.googlecode.aviator</groupId>
  <artifactId>aviator</artifactId>
  <version>5.2.4</version></dependency>12345

让AVIATOR动起来

既然Google帮我们做了那么多工作,那么怎么让他动起来呢?

Aviator有一个统一执行的入口 AviatorEvaluator 类。

他有一系列的静态方法提供给我们使用。

我们主要用到的两种方法为

AviatorEvaluator.compile
AviatorEvaluator.execute12

EXECUTE用法

先来看一个execute的最简单示例

import com.googlecode.aviator.AviatorEvaluator;public class AviatorSimpleExample {
    public static void main(String[] args) {
        Long result = (Long) AviatorEvaluator.execute("1+2+3");
        System.out.println(result);
    }}12345678

这里要注意一个问题,为什么我们的 1+2+3计算过后,要强制转换成Long类型?
因为Aviator只支持四种数字类型(2.3.0之后的版本):Long、Double、big int、decimal
理论上任何整数都将转换成Long(超过Long范围的,将自动转换为big int),任何浮点数都将转换为Double
以大写字母N为后缀的整数都被认为是big int,如1N,2N,9999999999999999999999N等,都是big int类型。
以大写字母M为后缀的数字都被认为是decimal,如1M,2.222M, 100000.9999M等等,都是decimal类型。

如果都是上图中,最基础的这种数字计算,肯定不可能满足各种业务场景。
下面介绍一下传入变量

import com.googlecode.aviator.AviatorEvaluator;
 import java.util.HashMap;import java.util.Map;
 public class AviatorSimpleExample {
    public static void main(String[] args) {
        String name = "唐简";
        Map<String,Object> env = new HashMap<>();
        env.put("name", name);
        String result = (String) AviatorEvaluator.execute(" 'Hello ' + name ", env);
        System.out.println(result);
    }}1234567891011121314
输出结果: Hello 唐简1

介绍一下Aviator的内置函数用法,其实特别简单,只要按照函数列表中(最下方有函数列表)定义的内容,直接使用就可以

import com.googlecode.aviator.AviatorEvaluator;
 import java.util.HashMap;import java.util.Map;
 public class AviatorSimpleExample {
    public static void main(String[] args) {
        String str = "小哥哥带你使用Aviator";
        Map<String,Object> env = new HashMap<>();
        env.put("str",str);
        Long length = (Long)AviatorEvaluator.execute("string.length(str)",env);
        System.out.println(length);
    }}1234567891011121314
输出结果 : 141

COMPILE用法

import com.googlecode.aviator.AviatorEvaluator;import com.googlecode.aviator.Expression;
 import java.util.HashMap;import java.util.Map;
 public class AviatorSimpleExample {
    public static void main(String[] args) {
        String expression = "a-(b-c)>100";
        Expression compiledExp = AviatorEvaluator.compile(expression);
        Map<String, Object> env = new HashMap<>();
        env.put("a", 100.3);
        env.put("b", 45);
        env.put("c", -199.100);
        Boolean result = (Boolean) compiledExp.execute(env);
        System.out.println(result);
    }}123456789101112131415161718
输出结果 false1

通过上面的代码片段可以看到
使用compile方法,先生成了 Expression 最后再由
Expression.execute,然后传入参数 map,进行计算
这么做的目的是,在我们实际使用过程中
很多情况下,我们要计算的公式都是一样的,只是每次的参数有所区别。
我们可以把一个编译好的Expression 缓存起来。
这样每次可以直接获取我们之前编译的结果直接进行计算,避免Perm区OutOfMemory

Aviator本身自带一个全局缓存
如果决定缓存本次的编译结果,只需要

Expression compiledExp = AviatorEvaluator.compile(expression,true);1

这样设置后,下一次编译同样的表达式,Aviator会自从从全局缓存中,拿出已经编译好的结果,不需要动态编译。如果需要使缓存失效,可以使用

AviatorEvaluator.invalidateCache(String expression);1

自定义函数的使用

import com.googlecode.aviator.AviatorEvaluator;import com.googlecode.aviator.Expression;import com.googlecode.aviator.runtime.function.AbstractFunction;import com.googlecode.aviator.runtime.function.FunctionUtils;import com.googlecode.aviator.runtime.type.AviatorBigInt;import com.googlecode.aviator.runtime.type.AviatorObject;
 import java.util.HashMap;import java.util.Map;
 public class AviatorSimpleExample {
    public static void main(String[] args) {
        AviatorEvaluator.addFunction(new MinFunction());
        String expression = "min(a,b)";
        Expression compiledExp = AviatorEvaluator.compile(expression, true);
        Map<String, Object> env = new HashMap<>();
        env.put("a", 100.3);
        env.put("b", 45);
        Double result = (Double) compiledExp.execute(env);
        System.out.println(result);
    }
 
    static class MinFunction 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 AviatorBigInt(Math.min(left.doubleValue(), right.doubleValue()));
        }
 
        public String getName() {
            return "min";
        }
    }}12345678910111213141516171819202122232425262728293031323334

从实际业务中使用的自定义函数来举例
我们需要对比两个数字的大小
(因为实际业务中,这两个数字为多个表达式计算的结果,如果不写自定函数,只能使用?:表达式来进行计算,会显得异常凌乱)
我们定义了一个 MinFunction 继承自 AbstractFunction
实现具体的方法,返回我们想要的结果。
务必要实现 getName这个方法,用于定义我们函数在Aviator中使用的名字。
在执行compile之前,先把我们的函数Add到Aviator函数列表中,后就可以使用了。
此处输出结果为

45.01

访问数组和集合

可以通过中括号去访问数组和java.util.List对象, 可以通过map.key访问java.util.Map中key对应的value, 一个例子:

public static void main(String[] args) {
    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}123456789101112131415161718

三元操作符

viator 不提供if else语句, 但是提供了三元操作符?:用于条件判断,使用上与 java 没有什么不同:

AviatorEvaluator.exec("a>0? 'yes':'no'", 1);  // yes1

Aviator 的三元表达式对于两个分支的结果类型并不要求一致,可以是任何类型,这一点与 java 不同。


正则表达式匹配

Aviator 支持类 Ruby 和 Perl 风格的表达式匹配运算,通过=~操作符, 如下面这个例子匹配 email 并提取用户名返回:

public static void main(String[] args) {
    String email = "killme2008@gmail.com";
    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}1234567

email与正则表达式/([\w0-8]+@\w+[.\w+]+)/通过=~操作符来匹配,结果为一个 Boolean 类 型, 因此可以用于三元表达式判断,匹配成功的时候返回$1,指代正则表达式的分组 1,也就是用户名,否则返回unknown。

Aviator 在表达式级别支持正则表达式,通过//括起来的字符序列构成一个正则表达式,正则表 达式可以用于匹配(作为=~的右操作数)、比较大小,匹配仅能与字符串进行匹配。匹配成功后, Aviator 会自动将匹配成功的分组放入$num的变量中,其中$0 指代整个匹配的字符串,而$1表示第一个分组,以此类推。

Aviator 的正则表达式规则跟 Java 完全一样,因为内部其实就是使用java.util.regex.Pattern做编译的。


变量的语法糖

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
    }}123456789101112131415161718192021

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 是 null12345

nil与String相加的时候,跟 java 一样显示为 null


日期比较

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
}123456789101112131415

也就是说String除了能跟String比较之外,还能跟nil和java.util.Date对象比较。


大数计算和精度

从 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"));
}123

结果为类型big int的: 199999999999999999999999999999998


字面量表示

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.execute("9223372036854775807100.356M * 2");
        System.out.println(rt + " " + rt.getClass());  // 18446744073709551614200.712 class java.math.BigDecimal
        rt = AviatorEvaluator.execute("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");
        Map<String, Object> map = new HashMap<>();
        map.put("a",a);
        rt = AviatorEvaluator.execute("a+10000000000000000000", map);
        System.out.println(rt + " " + rt.getClass());  // 92233720368547758089223372036854775807 class java.math.BigInteger
        map.clear();
        map.put("b",b);
        map.put("c",c);
        rt = AviatorEvaluator.execute("b+c*2", map);
        System.out.println(rt + " " + rt.getClass());  // 20003.19998 class java.math.BigDecimal
        map.clear();
        map.put("a",a);
        map.put("b",b);
        map.put("c",c);
        rt = AviatorEvaluator.execute("a*b/c", map);
        System.out.println(rt + " " + rt.getClass());  // 2.951479054745007313280155218459508E+34 class java.math.BigDecimal
    }123456789101112131415161718192021222324

类型转换和提升

当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.112345

DECIMAL 的计算精度

Java 的java.math.BigDecimal通过java.math.MathContext支持特定精度的计算,任何涉及到金额的计算都应该使用decimal类型。

默认 Aviator 的计算精度为MathContext.DECIMAL128,你可以自定义精度, 通过:

AviatorEvaluator.setOption(Options.MATH_CONTEXT, MathContext.DECIMAL64);1

即可设置,更多关于decimal的精度问题请看java.math.BigDecimal的 javadoc 文档。

强大的 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);}12345678910111213141516171819

我们可以:

  • 求长度: 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打印每个元素

两种运行模式

默认 AviatorEvaluator 以执行速度优先:

AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);

你可以修改为编译速度优先,这样不会做编译优化:

AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);

调试信息

从 2.1.1.版本开始,Aviator允许设置输出每个表达式生成的字节码,只要设置trace为true即可:

AviatorEvaluator.setTrace(true);

方便用户做跟踪和调试。默认是输出到标准输出,你可以改变输出指向:

AviatorEvaluator.setTraceOutputStream(new FileOutputStream(new File("aviator.log")));

参考资料

  • https://www.freesion.com/article/8180976491/

  • https://www.freesion.com/article/5591986400/
    EVAL);“`

你可以修改为编译速度优先,这样不会做编译优化:

AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);

调试信息

从 2.1.1.版本开始,Aviator允许设置输出每个表达式生成的字节码,只要设置trace为true即可:

AviatorEvaluator.setTrace(true);

方便用户做跟踪和调试。默认是输出到标准输出,你可以改变输出指向:

AviatorEvaluator.setTraceOutputStream(new FileOutputStream(new File("aviator.log")));

参考资料

  • https://www.freesion.com/article/8180976491/

  • https://www.freesion.com/article/5591986400/

  • https://code.google.com/archive/p/aviator/wikis/User_Guide_zh.wiki