=~
、三元运算符】,并且支持操作符的优先级和括号强制优先级语法受限,不是一门完整的语言,只是语言的一小部分集合。
<dependency>
<groupId>com.googlecode.aviator</groupId>
<artifactId>aviator</artifactId>
<version>2.3.3</version>
</dependency>
public static void main(String[] args) {
Long execute = (Long) AviatorEvaluator.execute("1+2+3");
System.out.println(execute);
}
这里的结果类型为long,而不是integer。因为aviator支持的数值类型仅有Long和Double
public static void main(String[] args) {
String name = "aaa";
Map<String, Object> env = new HashMap<String, Object>(10);
env.put("name", name);
String execute = (String) AviatorEvaluator.execute("'hello '+ name", env);
System.out.println(execute);
}
结果:hello aaa
上述,name为一个变量,默认为null,通过传入env的变量绑定环境,将name设置为输入的名称。
env的key为变量名,value是变量的值。
\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
Aviator2.2开始新增了exec
方法,可以更加方便的传入变量并执行,而不需要构造env
这个Map了
public static void main(String[] args) {
String name = "aaa";
String exec = (String) AviatorEvaluator.exec("'hello ' + name", name);
System.out.println(exec);
}
只需要在exec方法中按照变量在表达式中的出现顺序传入变量值就可执行,不需要构建map了
Aviator支持函数调用,函数调用的风格类似lua
public static void main(String[] args) {
Long execute = (Long) AviatorEvaluator.execute("string.length('hello')");
System.out.println(execute);
}
执行结果:5
string.length(hello)
:获取字符串长度
string.substring(字符串,index,end)
:截取字符串
string.contains()
:是否包含
自定义函数需要实现com.googlecode.aviator.runtime.type.AviatorFunction
接口,并注册到AviatorEvaluator
即可使用
package com.ly;
import com.googlecode.aviator.AviatorEvaluator;
import com.googlecode.aviator.runtime.function.AbstractFunction;
import com.googlecode.aviator.runtime.function.FunctionUtils;
import com.googlecode.aviator.runtime.type.AviatorDouble;
import com.googlecode.aviator.runtime.type.AviatorObject;
import java.util.Map;
/**
* @author LY
* @Description 自定义函数
*/
public class demo05 {
public static void main(String[] args) {
// 注册函数
AviatorEvaluator.addFunction(new AddFunction());
System.out.println(AviatorEvaluator.execute("add(1, 2)"));
System.out.println(AviatorEvaluator.execute("add(add(1, 2), 100)"));
}
}
/**
* 自定义函数
*/
class AddFunction extends AbstractFunction{
@Override
public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
Number number1 = FunctionUtils.getNumberValue(arg1, env);
Number number2 = FunctionUtils.getNumberValue(arg2, env);
return new AviatorDouble(number1.doubleValue() + number2.doubleValue());
}
public String getName() {
return "add";
}
}
执行结果:
3.0
103.0
public static void main(String[] args) {
String expression = "a - b + c * d";
Expression compile = AviatorEvaluator.compile(expression);
Map<String, Object> env = new HashMap<String, Object>();
env.put("a", 1);
env.put("b", 2);
env.put("c", 3);
env.put("d", 4);
Long execute = (Long) compile.execute(env);
System.out.println(execute);
}
通过compile方法将表达式编译成Expression中的中间对象,当要执行表达式时传入env并调用Expression的execute方法即可。
表达式中可使用括号来强制优先级
表达式编译后的结果可以自己缓存,也可交给Aviator来帮助缓存。AviatorExecutor
内部有一个全局的缓存池。
通过: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
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
}
Aviator中没有if else语句
public static void main(String[] args) {
System.out.println(AviatorEvaluator.exec("a>1?'yes':'no'", 2));
}
yes和no为字符串,需要加引号
public static void main(String[] args) {
System.out.println(AviatorEvaluator.exec("a>1?a * 2:a - 1", 2));
}
结果可进行运算
两分支结果可以是不同类型的
支持Ruby和Perl风格的表达式匹配运算,通过=~
操作符
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
}
Aviator的正则表达式规则跟Java完全一样,其内部使用的就是java.util.regex.Pattern
做编译
当要访问变量a中的某个属性b时,可以通过使用a.b访问到。更深:a.b.c
即Aviator可以将变量声明为嵌套访问的形式
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
}
}
nil是Aviator内置的常量,表示空的值。类似Java的null。
跟null不同点:
==、!=
的比较运算符。>、>=、<、<=
等比较运算符除了nil本身,任何对象都比bil大
nil与String相加时,跟java一样显示为null
Aviator不支持日期类型,若要比较日期,需要将日期写成字符串的形式,且要求是如“yyy-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和Date对象比较。
从2.3.0版本开始,aviator支持大数字计算和特定精度的计算
本质就是支持java.math.BigInteger
和java.math.BigDecimal
两种类型,这两种类型在aviator中简称为big int和decimal。
public static void main(String[] args) {
System.out.println(AviatorEvaluator.exec("99999999999999999999999999999999 + 99999999999999999999999999999999"));
}
结果为类型big int
的: 199999999999999999999999999999998
big int和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
}
当big int或decimal和其他类型的数字做运算时,按照long < big int < decimal < double
的规则做提升。即运算的数字若剋新不一致,结果类型为两者之间更“高”的类型
Java的java.math.BigDecimal
通过java.math.MathContext
支持特定精度的计算,任何涉及到金额的计算都应使用decimal类型。
默认Aviator的计算精度为MathContext.DECIMAL128
。可通过AviatorEvaluator.setMathContext(MathContext.DECIMAL64);
自定义精度。
aviator拥有强大的操作集合和数组的seq库。
整个库的风格类似函数式编程中的高阶函数。
在aviator中,数组以及java.util.Collection
下的子类都称为seq,可以直接利用seq库进行遍历、过滤、聚合等操作。
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
打印每个元素AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);
AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);
从2.1.1版本开始,Aviator允许设置输出每个表达式生成的字节码
AviatorEvaluator.setTrace(true);
方便用户做跟踪和调试。默认时输出带标准输出,可该百年输出指向:
AviatorEvaluator.setTraceOutputStream(new FileOutputStream(new File("aviator.log")));
函数名称 | 说明 |
---|---|
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 的谓词 |