首先声明一下，这是一个不负责任的、不完全的Aviator介绍文章，只管撩，不管埋
简介
Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎，主要用于各种表达式的动态求值。现在已经有很多开源可用的java表达式求值引擎，为什么还需要Avaitor呢？
Aviator的设计目标是轻量级和高性能 ，相比于Groovy、JRuby的笨重，Aviator非常小，加上依赖包也才450K,不算依赖包的话只有70K；当然，Aviator的语法是受限的，它不是一门完整的语言，而只是语言的一小部分集合。
其次，Aviator的实现思路与其他轻量级的求值器很不相同，其他求值器一般都是通过解释的方式运行，而Aviator则是直接将表达式编译成Java字节码，交给JVM去执行。简单来说，Aviator的定位是介于Groovy这样的重量级脚本语言和IKExpression这样的轻量级表达式引擎之间。
特性
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>3.0.1</version>
</dependency>让Aviator动起来
既然Google帮我们做了那么多工作，那么怎么让他动起来呢？
Aviator有一个统一执行的入口 AviatorEvaluator 类。
他有一系列的静态方法提供给我们使用。
我们主要用到的两种方法为
AviatorEvaluator.compile
AviatorEvaluator.executeexecute用法
先来看一个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);
}
}
这里要注意一个问题，为什么我们的 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);
}
}
输出结果： Hello 唐简介绍一下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);
}
}
输出结果 ： 14compile用法
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);
}
}
输出结果 false通过上面的代码片段可以看到
使用compile方法，先生成了 Expression 最后再由
Expression.execute，然后传入参数 map，进行计算
这么做的目的是，在我们实际使用过程中
很多情况下，我们要计算的公式都是一样的，只是每次的参数有所区别。
我们可以把一个编译好的Expression 缓存起来。
这样每次可以直接获取我们之前编译的结果直接进行计算，避免Perm区OutOfMemory
Aviator本身自带一个全局缓存
如果决定缓存本次的编译结果，只需要
Expression compiledExp = AviatorEvaluator.compile(expression,true);这样设置后，下一次编译同样的表达式，Aviator会自从从全局缓存中，拿出已经编译好的结果，不需要动态编译。如果需要使缓存失效，可以使用
AviatorEvaluator.invalidateCache(String expression);自定义函数的使用
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);
}
<span class="hljs-keyword">static</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title" data-spm-anchor-id="a2c4e.11153940.0.i46.883e6bafs01dzK">MinFunction</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">AbstractFunction</span> </span>{
@Override public AviatorObject call(<span class="hljs-built_in">Map</span><<span class="hljs-built_in">String</span>, <span class="hljs-built_in">Object</span>> env, AviatorObject arg1, AviatorObject arg2) {
<span class="hljs-built_in">Number</span> left = FunctionUtils.getNumberValue(arg1, env);
<span class="hljs-built_in">Number</span> right = FunctionUtils.getNumberValue(arg2, env);
<span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> AviatorBigInt(<span class="hljs-built_in" data-spm-anchor-id="a2c4e.11153940.0.i48.883e6bafs01dzK">Math</span>.min(left.doubleValue(), right.doubleValue()));
}
public <span class="hljs-built_in">String</span> getName() {
<span class="hljs-keyword">return</span> <span class="hljs-string">"min"</span>;
}
}
}
从实际业务中使用的自定义函数来举例
我们需要对比两个数字的大小
（因为实际业务中，这两个数字为多个表达式计算的结果，如果不写自定函数，只能使用？：表达式来进行计算，会显得异常凌乱）
我们定义了一个 MinFunction 继承自 AbstractFunction
实现具体的方法，返回我们想要的结果。
务必要实现 getName这个方法，用于定义我们函数在Aviator中使用的名字。
在执行compile之前，先把我们的函数Add到Aviator函数列表中，后就可以使用了。
此处输出结果为
45.0内置函数列表
操作符列表
| 序号 | 操作符 | 结合性 | 操作数限制 |
|---|---|---|---|
| 0 | () [ ] | 从左到右 | ()用于函数调用，[ ]用于数组和java.util.List的元素访问，要求[indx]中的index必须为整型 |
| 1 | ! - ~ | 从右到左 | ! 能用于Boolean,- 仅能用于Number,~仅能用于整数 |
| 2 | * / % | 从左到右 | Number之间 |
| 3 | + - | 从左到右 | + - 都能用于Number之间, + 还能用于String之间，或者String和其他对象 |
| 4 | << >> >>> | 从左到右 | 仅能用于整数 |
| 5 | < <= > >= | 从左到右 | Number之间、String之间、Pattern之间、变量之间、其他类型与nil之间 |
| 6 | == != =~ | 从左到右 | ==和!=作用于Number之间、String之间、Pattern之间、变量之间、其他类型与nil之间以及String和java.util.Date之间，=~仅能作用于String和Pattern之间 |
| 7 | & | 从左到右 | 整数之间 |
| 8 | ^ | 从左到右 | 整数之间 |
| 9 | ¦ | 从左到右 | 整数之间 |
| 10 | && | 从左到右 | Boolean之间，短路 |
| 11 | ¦¦ | 从左到右 | Boolean之间，短路 |
| 12 | ? : | 从右到左 | 第一个操作数的结果必须为Boolean，第二和第三操作数结果无限制 |
内置函数
| 函数名称 | 说明 |
|---|---|
| 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的谓词 |
常量和变量
| 值 | 说明 |
|---|---|
| true | 真值 |
| false | 假值 |
| nil | 空值 |
$digit |
正则表达式匹配成功后的分组，$0表示匹配的字符串，$1表示第一个分组 etc. |
参考资料
https://code.google.com/archive/p/aviator/wikis/User_Guide_zh.wiki