canal 中使用到的Aviator

在canal的源码模块中有子模块canal.filter。其中都是基于aviator的各种filter

canal.filter中基于aviator的filter

Aviator的简介

Aviator是一个高性能、轻量级的 java 语言实现的表达式求值引擎, 主要用于各种表达式的动态求值。现在已经有很多开源可用的 java 表达式求值引擎,为什么还需要 Avaitor 呢?Aviator的设计目标是轻量级和高性能,相比于Groovy、JRuby的笨重, Aviator非常小, 加上依赖包也才450K,不算依赖包的话只有 70K; 当然, Aviator的语法是受限的, 它不是一门完整的语言, 而只是语言的一小部分集合。其次, Aviator的实现思路与其他轻量级的求值器很不相同, 其他求值器一般都是通过解释的方式运行, 而Aviator则是直接将表达式编译成Java 字节码, 交给JVM去执行。简单来说, Aviator的定位是介于Groovy这样的重量级脚本语言和IKExpression这样的轻量级表达式引擎 之间。Aviator支持大部分运算操作符, 包括算术操作符、关系运算符、逻辑操作符、位运算符、正则匹配操作符(=~)、三元表达式(?:), 并且支持操作符的优先级和括号强制优先级, 具体请看后面的操作符列表, 支持自定义函数.

####依赖加入
<dependency>
  <groupId>com.googlecode.aviator</groupId>
  <artifactId>aviator</artifactId>
  <version>2.2.1</version>
</dependency>

使用

Aviator的使用都是集中通过com.googlecode.aviator.AviatorEvaluator
这个入口类来处理, 最简单的例子, 执行一个计算1+2+3的表达式:

package com.alibaba.otter.canal.filter;
import com.googlecode.aviator.AviatorEvaluator;

public class TestAviator {

    @Test
    public void test_simple() {
        Long result = (Long) AviatorEvaluator.execute("1+2+3");
        System.out.println(result);
    }
}

运行结果

细心的朋友肯定注意到结果是Long,而不是Integer。这是因为Aviator的数值类型仅支持Long和Double, 任何整数都将转换成Long, 任何浮点数都将转换为Double, 包括用户传入的变量数值。这个例子的打印结果将是正确答案6。

使用变量

想让Aviator对你say hello吗? 很简单, 传入你的名字, 让Aviator负责字符串的相加:

    @Test
    public void test_string() {
        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<String,Object>的变量绑定环境, 将yourName
设置为你输入的名称。 env 的key是变量名, value是变量的值。上面例子中的'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 "); // 字符串 hello3
AviatorEvaluator.execute(" 'hello '+ unknow "); // 字符串 hello null

exec 方法

Aviator 2.2 开始新增加一个exec
方法, 可以更方便地传入变量并执行, 而不需要构造env这个map了:

 @Test
    public void test_exec() {
         @Test
    public void test_exec() {
        String name = "dennis";
        System.out.println(AviatorEvaluator.exec(" 'hello ' + yourName ", name)); // hello dennis
    }
    }

调用函数

Aviator 支持函数调用, 函数调用的风格类似 lua, 下面的例子获取字符串的长度:
string.length('hello')是一个函数调用, string.length是一个函数, 'hello'是调用的参数。再用string.substring来截取字符串:

   @Test
    public void test_substring() {
        System.out.println(AviatorEvaluator.execute("string.contains(\"test\", string.substring('hello', 1, 2))"));
    }

自定义函数

Aviator 除了内置的函数之外,还允许用户自定义函数,只要实现com.googlecode.aviator.runtime.type.AviatorFunction接口, 并注册到AviatorEvaluator即可使用. AviatorFunction接口十分庞大, 通常来说你并不需要实现所有的方法, 只要根据你的方法的参 数个数, 继承AbstractFunction类并override相应方法即可。可以看一个例子,我们实现一个add函数来做数值的相加:

@Test
    public void test_user_function() {
        //注册函数
        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
        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";
        }
    }

注册函数通过AviatorEvaluator.addFunction方法, 移除可以通过removeFunction。

编译表达式

上面提到的例子都是直接执行表达式, 事实上 Aviator 背后都帮你做了编译并执行的工作。 你可以自己先编译表达式, 返回一个编译的结果, 然后传入不同的env来复用编译结果, 提高性能, 这是更推荐的使用方式:

 @Test
    public void test_user_compile() {
        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)

方法。

访问数组和集合

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

@Test
    public void test_map_list() {
        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
    }

debug日志，可以看一下转换过程

hello world
array[0]+array[1]+array[2]=4
10:34:57.264 [main] DEBUG o.a.c.b.converters.BooleanConverter - Setting default value: false
10:34:57.272 [main] DEBUG o.a.c.b.converters.BooleanConverter - Converting 'Boolean' value 'false' to type 'Boolean'
10:34:57.273 [main] DEBUG o.a.c.b.converters.BooleanConverter -     No conversion required, value is already a Boolean
10:34:57.280 [main] DEBUG o.a.c.b.converters.ByteConverter - Setting default value: 0
10:34:57.280 [main] DEBUG o.a.c.b.converters.ByteConverter - Converting 'Integer' value '0' to type 'Byte'
10:34:57.280 [main] DEBUG o.a.c.b.converters.ByteConverter -     Converted to Byte value '0'
10:34:57.282 [main] DEBUG o.a.c.b.c.CharacterConverter - Setting default value:  
10:34:57.282 [main] DEBUG o.a.c.b.c.CharacterConverter - Converting 'Character' value ' ' to type 'Character'
10:34:57.282 [main] DEBUG o.a.c.b.c.CharacterConverter -     No conversion required, value is already a Character
10:34:57.284 [main] DEBUG o.a.c.b.converters.DoubleConverter - Setting default value: 0
10:34:57.284 [main] DEBUG o.a.c.b.converters.DoubleConverter - Converting 'Integer' value '0' to type 'Double'
10:34:57.284 [main] DEBUG o.a.c.b.converters.DoubleConverter -     Converted to Double value '0.0'
10:34:57.287 [main] DEBUG o.a.c.b.converters.FloatConverter - Setting default value: 0
10:34:57.288 [main] DEBUG o.a.c.b.converters.FloatConverter - Converting 'Integer' value '0' to type 'Float'
10:34:57.288 [main] DEBUG o.a.c.b.converters.FloatConverter -     Converted to Float value '0.0'
10:34:57.290 [main] DEBUG o.a.c.b.converters.IntegerConverter - Setting default value: 0
10:34:57.291 [main] DEBUG o.a.c.b.converters.IntegerConverter - Converting 'Integer' value '0' to type 'Integer'
10:34:57.291 [main] DEBUG o.a.c.b.converters.IntegerConverter -     No conversion required, value is already a Integer
10:34:57.292 [main] DEBUG o.a.c.b.converters.LongConverter - Setting default value: 0
10:34:57.292 [main] DEBUG o.a.c.b.converters.LongConverter - Converting 'Integer' value '0' to type 'Long'
10:34:57.292 [main] DEBUG o.a.c.b.converters.LongConverter -     Converted to Long value '0'
10:34:57.294 [main] DEBUG o.a.c.b.converters.ShortConverter - Setting default value: 0
10:34:57.294 [main] DEBUG o.a.c.b.converters.ShortConverter - Converting 'Integer' value '0' to type 'Short'
10:34:57.294 [main] DEBUG o.a.c.b.converters.ShortConverter -     Converted to Short value '0'
10:34:57.297 [main] DEBUG o.a.c.b.c.BigDecimalConverter - Setting default value: 0.0
10:34:57.297 [main] DEBUG o.a.c.b.c.BigDecimalConverter - Converting 'BigDecimal' value '0.0' to type 'BigDecimal'
10:34:57.297 [main] DEBUG o.a.c.b.c.BigDecimalConverter -     No conversion required, value is already a BigDecimal
10:34:57.298 [main] DEBUG o.a.c.b.c.BigIntegerConverter - Setting default value: 0
10:34:57.298 [main] DEBUG o.a.c.b.c.BigIntegerConverter - Converting 'BigInteger' value '0' to type 'BigInteger'
10:34:57.298 [main] DEBUG o.a.c.b.c.BigIntegerConverter -     No conversion required, value is already a BigInteger
10:34:57.298 [main] DEBUG o.a.c.b.converters.BooleanConverter - Setting default value: false
10:34:57.298 [main] DEBUG o.a.c.b.converters.BooleanConverter - Converting 'Boolean' value 'false' to type 'Boolean'
10:34:57.298 [main] DEBUG o.a.c.b.converters.BooleanConverter -     No conversion required, value is already a Boolean
10:34:57.299 [main] DEBUG o.a.c.b.converters.ByteConverter - Setting default value: 0
10:34:57.299 [main] DEBUG o.a.c.b.converters.ByteConverter - Converting 'Integer' value '0' to type 'Byte'
10:34:57.299 [main] DEBUG o.a.c.b.converters.ByteConverter -     Converted to Byte value '0'
10:34:57.299 [main] DEBUG o.a.c.b.c.CharacterConverter - Setting default value:  
10:34:57.299 [main] DEBUG o.a.c.b.c.CharacterConverter - Converting 'Character' value ' ' to type 'Character'
10:34:57.299 [main] DEBUG o.a.c.b.c.CharacterConverter -     No conversion required, value is already a Character
10:34:57.299 [main] DEBUG o.a.c.b.converters.DoubleConverter - Setting default value: 0
10:34:57.300 [main] DEBUG o.a.c.b.converters.DoubleConverter - Converting 'Integer' value '0' to type 'Double'
10:34:57.300 [main] DEBUG o.a.c.b.converters.DoubleConverter -     Converted to Double value '0.0'
10:34:57.303 [main] DEBUG o.a.c.b.converters.FloatConverter - Setting default value: 0
10:34:57.303 [main] DEBUG o.a.c.b.converters.FloatConverter - Converting 'Integer' value '0' to type 'Float'
10:34:57.303 [main] DEBUG o.a.c.b.converters.FloatConverter -     Converted to Float value '0.0'
10:34:57.303 [main] DEBUG o.a.c.b.converters.IntegerConverter - Setting default value: 0
10:34:57.304 [main] DEBUG o.a.c.b.converters.IntegerConverter - Converting 'Integer' value '0' to type 'Integer'
10:34:57.304 [main] DEBUG o.a.c.b.converters.IntegerConverter -     No conversion required, value is already a Integer
10:34:57.304 [main] DEBUG o.a.c.b.converters.LongConverter - Setting default value: 0
10:34:57.304 [main] DEBUG o.a.c.b.converters.LongConverter - Converting 'Integer' value '0' to type 'Long'
10:34:57.304 [main] DEBUG o.a.c.b.converters.LongConverter -     Converted to Long value '0'
10:34:57.304 [main] DEBUG o.a.c.b.converters.ShortConverter - Setting default value: 0
10:34:57.304 [main] DEBUG o.a.c.b.converters.ShortConverter - Converting 'Integer' value '0' to type 'Short'
10:34:57.304 [main] DEBUG o.a.c.b.converters.ShortConverter -     Converted to Short value '0'
10:34:57.305 [main] DEBUG o.a.c.b.converters.StringConverter - Setting default value: 
10:34:57.305 [main] DEBUG o.a.c.b.converters.StringConverter - Converting 'String' value '' to type 'String'
10:34:57.324 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Z@7b09a4dc
10:34:57.324 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'boolean[]' value '[Z@7b09a4dc' to type 'boolean[]'
10:34:57.324 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a boolean[]
10:34:57.324 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [B@3626a69f
10:34:57.325 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'byte[]' value '[B@3626a69f' to type 'byte[]'
10:34:57.325 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a byte[]
10:34:57.325 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [C@23852c7f
10:34:57.325 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'char[]' value '[C@23852c7f' to type 'char[]'
10:34:57.325 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a char[]
10:34:57.325 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [D@7c2c5810
10:34:57.326 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'double[]' value '[D@7c2c5810' to type 'double[]'
10:34:57.326 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a double[]
10:34:57.326 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [F@4349c220
10:34:57.326 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'float[]' value '[F@4349c220' to type 'float[]'
10:34:57.326 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a float[]
10:34:57.326 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [I@1f67e563
10:34:57.338 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'int[]' value '[I@1f67e563' to type 'int[]'
10:34:57.338 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a int[]
10:34:57.338 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [J@5e04d6b0
10:34:57.338 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'long[]' value '[J@5e04d6b0' to type 'long[]'
10:34:57.338 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a long[]
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [S@faaed09
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'short[]' value '[S@faaed09' to type 'short[]'
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a short[]
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.math.BigDecimal;@1eaff1e8
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'BigDecimal[]' value '[Ljava.math.BigDecimal;@1eaff1e8' to type 'BigDecimal[]'
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a BigDecimal[]
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.math.BigInteger;@7c6aa5ee
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'BigInteger[]' value '[Ljava.math.BigInteger;@7c6aa5ee' to type 'BigInteger[]'
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a BigInteger[]
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Boolean;@590713ac
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Boolean[]' value '[Ljava.lang.Boolean;@590713ac' to type 'Boolean[]'
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Boolean[]
10:34:57.339 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Byte;@279c6035
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Byte[]' value '[Ljava.lang.Byte;@279c6035' to type 'Byte[]'
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Byte[]
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Character;@79866b99
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Character[]' value '[Ljava.lang.Character;@79866b99' to type 'Character[]'
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Character[]
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Double;@796e33ac
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Double[]' value '[Ljava.lang.Double;@796e33ac' to type 'Double[]'
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Double[]
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Float;@44d64315
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Float[]' value '[Ljava.lang.Float;@44d64315' to type 'Float[]'
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Float[]
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Integer;@4583e712
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Integer[]' value '[Ljava.lang.Integer;@4583e712' to type 'Integer[]'
10:34:57.340 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Integer[]
10:34:57.341 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Long;@25b7715d
10:34:57.341 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Long[]' value '[Ljava.lang.Long;@25b7715d' to type 'Long[]'
10:34:57.343 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Long[]
10:34:57.343 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Short;@2a14d8c8
10:34:57.343 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Short[]' value '[Ljava.lang.Short;@2a14d8c8' to type 'Short[]'
10:34:57.343 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Short[]
10:34:57.343 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.String;@13766d9c
10:34:57.343 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'String[]' value '[Ljava.lang.String;@13766d9c' to type 'String[]'
10:34:57.343 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a String[]
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.lang.Class;@441626bf
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Class[]' value '[Ljava.lang.Class;@441626bf' to type 'Class[]'
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Class[]
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.util.Date;@7a407909
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Date[]' value '[Ljava.util.Date;@7a407909' to type 'Date[]'
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Date[]
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.util.Calendar;@33c76cab
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'Calendar[]' value '[Ljava.util.Calendar;@33c76cab' to type 'Calendar[]'
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a Calendar[]
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.io.File;@7b1da1d1
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'java.io.File[]' value '[Ljava.io.File;@7b1da1d1' to type 'java.io.File[]'
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a java.io.File[]
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.sql.Date;@2767237
10:34:57.344 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'java.sql.Date[]' value '[Ljava.sql.Date;@2767237' to type 'java.sql.Date[]'
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a java.sql.Date[]
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.sql.Time;@725122f2
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'java.sql.Time[]' value '[Ljava.sql.Time;@725122f2' to type 'java.sql.Time[]'
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a java.sql.Time[]
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.sql.Timestamp;@7ba01bb6
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'java.sql.Timestamp[]' value '[Ljava.sql.Timestamp;@7ba01bb6' to type 'java.sql.Timestamp[]'
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a java.sql.Timestamp[]
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter - Setting default value: [Ljava.net.URL;@42683e68
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter - Converting 'java.net.URL[]' value '[Ljava.net.URL;@42683e68' to type 'java.net.URL[]'
10:34:57.345 [main] DEBUG o.a.c.b.converters.ArrayConverter -     No conversion required, value is already a java.net.URL[]
today is Mon Dec 12 10:34:56 CST 2016

三元操作符

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

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

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

正则表达式匹配

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

        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

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 的，我们就可以使用语法糖:

 
    int i;
    float f;
    Date date;
  
    public TestAviator(int i, float f, Date date) {
        this.i = i;
        this.f = f;
        this.date = date;
    }

    public int getI() {
        return i;
    }


    public void setI(int i) {
        this.i = i;
    }


    public float getF() {
        return f;
    }


    public void setF(float f) {
        this.f = f;
    }


    public Date getDate() {
        return date;
    }


    public void setDate(Date date) {
        this.date = date;
    }


    @Test
    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
    }

nil 对象

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

  @Test
    public void test_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 是 null
    }

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

日期比较

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

   @Test
    public void test_date() {
        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对象比较。

大数计算和精度

从 2.3.0 版本开始,aviator 开始支持大数字计算和特定精度的计算, 本质上就是支持java.math.BigInteger和java.math.BigDecimal两种类型, 这两种类型在 aviator 中简称 为big int和decimal类型。 类似99999999999999999999999999999999这样的数字在 Java 语言里是没办法编译通过 的, 因为它超过了Long
类型的范围, 只能用BigInteger来封装。但是 aviator 通过包装,可 以直接支持这种大整数的计算,例如:

  @Test
    public void test_bigdecimal() {
        System.out.println(AviatorEvaluator.exec("99999999999999999999999999999999N + 99999999999999999999999999999999N"));
    }

结果为类型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重载了基本算术操作符来支持这两种新类型

    @Test
    public void test_bigdecimal_operate() {
        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.BigDecima
    }

输出结果

18446744073709551614200.712 class java.math.BigDecimal
92233720368547759074 class java.math.BigInteger
92233720368547758089223372036854775807 class java.math.BigInteger
20003.19998 class java.math.BigDecimal
2.951479054745007313280155218459508E+34 class java.math.BigDecimal

类型转换和提升

当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
decimal 的计算精度

Java 的java.math.BigDecimal通过java.math.MathContext支持特定精度的计算,任何涉及到金额的计算都应该使用decimal类型。默认 Aviator 的计算精度为MathContext.DECIMAL128,你可以自定义精度, 通过:

AviatorEvaluator.setMathContext(MathContext.DECIMAL64);

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

强大的 seq 库

aviator 拥有强大的操作集合和数组的 seq 库。整个库风格类似函数式编程中的高阶函数。在 aviator 中, 数组以及java.util.Collection下的子类都称为seq,可以直接利用 seq 库进行遍历、过滤和聚合等操作。
例如,假设我有个 list:

    @Test
    public void test_seq() {
        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打印每个元素
两种运行模式

默认 AviatorEvaluator 以执行速度优先:

AviatorEvaluator.setTrace(true);

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

AviatorEvaluator.setTraceOutputStream(new FileOutputStream(new File("aviator.log")))
语法手册

下面是 Aviator 详细的语法规则定义。

  1. 数据类型

  • Number类型: 数字类型,支持四种类型,分别是long,double,java.math.BigInteger(简称 big int)和java.math.BigDecimal(简 称 decimal),规则如下:

    • 任何以大写字母 N 结尾的整数都被认为是 big int
    • 任何以大写字母 M 结尾的数字都被认为是 decimal
    • 其他的任何整数都将被转换为 Long
    • 其他任何浮点数都将被转换为 Double
    • 超过 long 范围的整数字面量都将自动转换为 big int 类型
    • 其中 big int 和 decimal 是 2.3.0 版本开始引入的。数字还支持十六进制(以0x或者0X开头的数字), 以及科学计数法,如1e-3等。 不支持其他进制。

  • String类型: 字符串类型,单引号或者双引号括起来的文本串,如'hello world', 变量如果传入的是String或者Character也将转为String类型

  • Bool类型: 常量true和false,表示真值和假值,与 java 的Boolean.TRUE和Boolean.False对应

  • Pattern类型: 正则表达式, 以//括起来的字符串,如/\d+/,内部 实现为java.util.Pattern

  • 变量类型: 与 Java 的变量命名规则相同,变量的值由用户传入

  • nil类型: 常量nil,类似 java 中的null,但是nil比较特殊,nil不仅可以参与==、!=的比较, 也可以参与>、>=、<、<=的比较,Aviator 规定任何类型都大于nil除了nil本身,nil==nil返回true。 用户传入的变量值如果为null,那么也将作为nil处理,nil打印为null

  1. 操作符
  • 算术运算符
    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返回的结果类型一致。

内置函数

函数名称 说明
sysdate() 返回当前日期对象java.util.Date
rand() 返回一个介于 0-1 的随机数,double 类型
print([out],obj) 打印对象,如果指定 out,向 out 打印, 否则输出到控制台
println([out],obj) 与 print 类似,但是在输出后换行
now() 返回 System.currentTimeMillis
long(v) 将值的类型转为 long
double(v) 将值的类型转为 double
str(v) 将值的类型转为 string
date_to_string(date,format) 将 Date 对象转化化特定格式的字符串,2.1.1 新增
string_to_date(source,format) 将特定格式的字符串转化为 Date 对 象,2.1.1 新增
string.contains(s1,s2) 判断 s1 是否包含 s2,返回 Boolean
string.length(s) 求字符串长度,返回 Long
string.startsWith(s1,s2) s1 是否以 s2 开始,返回 Boolean
string.endsWith(s1,s2) s1 是否以 s2 结尾,返回 Boolean
string.substring(s,begin[,end]) 截取字符串 s,从 begin 到 end,如果忽略 end 的话,将从 begin 到结尾,与 java.util.String.substring 一样。
string.indexOf(s1,s2) java 中的 s1.indexOf(s2),求 s2 在 s1 中 的起始索引位置,如果不存在为-1
string.split(target,regex,[limit]) Java 里的 String.split 方法一致,2.1.1 新增函数
string.join(seq,seperator) 将集合 seq 里的元素以 seperator 为间隔 连接起来形成字符串,2.1.1 新增函数
string.replace_first(s,regex,replacement) Java 里的 String.replaceFirst 方法, 2.1.1 新增
string.replace_all(s,regex,replacement) Java 里的 String.replaceAll 方法 , 2.1.1 新增
math.abs(d) 求 d 的绝对值
math.sqrt(d) 求 d 的平方根
math.pow(d1,d2) 求 d1 的 d2 次方
math.log(d) 求 d 的自然对数
math.log10(d) 求 d 以 10 为底的对数
math.sin(d) 正弦函数
math.cos(d) 余弦函数
math.tan(d) 正切函数
map(seq,fun) 将函数 fun 作用到集合 seq 每个元素上, 返回新元素组成的集合
filter(seq,predicate) 将谓词 predicate 作用在集合的每个元素 上,返回谓词为 true 的元素组成的集合
count(seq) 返回集合大小
include(seq,element) 判断 element 是否在集合 seq 中,返回 boolean 值
sort(seq) 排序集合,仅对数组和 List 有效,返回排 序后的新集合
reduce(seq,fun,init) fun 接收两个参数,第一个是集合元素, 第二个是累积的函数,本函数用于将 fun 作用在集合每个元素和初始值上面,返回 最终的 init 值
seq.eq(value) 返回一个谓词,用来判断传入的参数是否跟 value 相等,用于 filter 函数,如filter(seq,seq.eq(3)) 过滤返回等于3 的元素组成的集合
seq.neq(value) 与 seq.eq 类似,返回判断不等于的谓词
seq.gt(value) 返回判断大于 value 的谓词
seq.ge(value) 返回判断大于等于 value 的谓词
seq.lt(value) 返回判断小于 value 的谓词
seq.le(value) 返回判断小于等于 value 的谓词
seq.nil() 返回判断是否为 nil 的谓词
seq.exists() 返回判断不为 nil 的谓词

github地址 包括文档

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 159,117评论 4赞 362
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,328评论 1赞 293
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,839评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,007评论 0赞 206
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,384评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,629评论 1赞 219
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,880评论 2赞 313
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,593评论 0赞 198
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,313评论 1赞 243
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,575评论 2赞 246
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,066评论 1赞 260
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,392评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,052评论 3赞 236
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,082评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,844评论 0赞 195
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,662评论 2赞 274
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,575评论 2赞 270

推荐阅读更多精彩内容

  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,295评论 18赞 399
  • 所思
    觉得自己变成一条咸鱼咸鱼咸鱼！
    取名字好烦啊阅读 209评论 0赞 0
  • 我只能一再地让你相信，那个永远爱你的人是我
    老狼的《流浪歌手的情人》里的一句歌词是这么唱的：我只能一再地让你相信，那个永远爱你的人是我。 听到这句时，我在想作...
    迦南知识铺阅读 837评论 0赞 8
  • 梦醒时分--继续前行
    本文是当我知道我的本科留学梦想破灭之后的些许感悟，整理于此，也包括最近发生的一些事情分析。条条干货啊。 1.选择不...
    华尔腾云阅读 307评论 0赞 0
  • 印
    我把月亮戳到天上 天就是我的 我把脚踩入地里 地就是我的 我亲吻你 你就是我的
    无赖蘑菇阅读 235评论 0赞 3