【java表达式引擎】四、高性能、轻量级的AviatorScript

一、Aviator 介绍

github：(https://github.com/killme2008/aviatorscript%60)
参考文档1：https://www.yuque.com/boyan-avfmj/aviatorscript
参考博客2：https://blog.csdn.net/ZhangQingmu/article/details/125087255

Aviator起源于2011年，由国内的开发者开源的，表达式引擎
表达式引擎当时国内开源的已经有 IKExpression，可惜是纯解释执行的，效率很一般，Groovy 刚开始流行，性能不错，但是整体很重量级，更重要的原因是我们希望控制用户能使用的语法和函数，需要一个定制的“子集”，因此 Aviator 就诞生了。

原理和特点

Aviator 的基本过程是将表达式直接翻译成对应的 java 字节码执行，整个过程最多扫两趟（开启执行优先模式，如果是编译优先模式下就一趟），这样就保证了它的性能超越绝大部分解释性的表达式引擎，测试也证明如此；其次，除了依赖 commons-beanutils 这个库之外（用于做反射）不依赖任何第三方库，因此整体非常轻量级，整个 jar 包大小哪怕发展到现在 5.0 这个大版本，也才 430K。同时， Aviator 内置的函数库非常“节制”，除了必须的字符串处理、数学函数和集合处理之外，类似文件 IO、网络等等你都是没法使用的，这样能保证运行期的安全，如果你需要这些高阶能力，可以通过开放的自定义函数来接入。因此总结它的特点是：

● 高性能
● 轻量级
● 一些比较有特色的特点：
○ 支持运算符重载
○ 原生支持大整数和 BigDecimal 类型及运算，并且通过运算符重载和一般数字类型保持一致的运算方式。
○ 原生支持正则表达式类型及匹配运算符 =~
○ 类 clojure 的 seq 库及 lambda 支持，可以灵活地处理各种集合
● 开放能力：包括自定义函数接入以及各种定制选项
● Java Scripting API 支持
● 数组的 支持

二、依赖

目前github上的最新版本是5.3.2
大家可以依赖以下版本，也可以下载源码直接在源码中测试

<dependency>
  <groupId>com.googlecode.aviator</groupId>
  <artifactId>aviator</artifactId>
  <version>5.3.2</version>
</dependency>
1
2
3
4
5

三、样例使用

1、需求

这次现提出一些需求看是否都可以满足

• 常规的 加减乘除
  1+1+3+5-6=4
  (9.88+12.24)-5.88/(5.88+6.14)* (9.88+12.24)= 11.299234608985

• 逻辑判断
  if(3<6,1,0)
  IFERROR((MIN(5/0,3)),0) = 0

2、上手使用

我们主要使用这两个方法就可以满足上述需求

 AviatorEvaluator.compile
AviatorEvaluator.execute
1
2

3、加减乘除

   @Test
   public void test1() {
      Expression exp1 = AviatorEvaluator.compile("1+1+3+5-6");
      Expression exp2 = AviatorEvaluator.compile(" (9.88+12.24)-5.88/(5.88+6.14)* (9.88+12.24)");
      Object execute = exp1.execute();
      Object execute2 = exp2.execute();
      assertEquals(4,execute);
      System.out.println( execute);//4
      System.out.println(execute2);//11.299234608985023
   }
1
2
3
4
5
6
7
8
9
10

4、逻辑判断

执行test2报错了不支持excel格式的逻辑判断

   @Test
   public void test2() {
      Expression exp1 = AviatorEvaluator.compile("if(3<6,1,0)");
      Expression exp2 = AviatorEvaluator.compile("IFERROR((MIN(5/0,3)),0)");
      Object execute = exp1.execute();
      Object execute2 = exp2.execute();
      System.out.println( execute);//
      System.out.println(execute2);//
   }
1
2
3
4
5
6
7
8
9

支持if else 和三母运算

   /**
    * if else
    */
   @Test
   public void test3() {
      Expression exp1 = AviatorEvaluator.compile("if(1<2) { 3 } else { 4}");
      Expression exp2 = AviatorEvaluator.compile("1<2?  3 : 4 ");
      Object execute = exp1.execute();
      System.out.println( execute);//3
      Object execute2 = exp2.execute();
      System.out.println( execute2);//3
   }

1
2
3
4
5
6
7
8
9
10
11
12
13

max和min

   /**
    * max和min函数
    */
   @Test
   public void test4() {
      Expression exp1 = AviatorEvaluator.compile("min(3,4)");
      Expression exp2 = AviatorEvaluator.compile("max(3,4)");
      Object execute = exp1.execute();
      System.out.println( execute);//3
      Object execute2 = exp2.execute();
      System.out.println( execute2);//4
   }
1
2
3
4
5
6
7
8
9
10
11
12

小编的一些常见的需求基本可以满足，下面就看一下还支持那些吧。

四、其余介绍

1、基本数据类型

AviatorScript 支持常见的类型，如数字、布尔值、字符串等等，同时将大整数、BigDecimal、正则表达式也作为一种基本类型来支持。

加减乘除对应的运算符就是 +,-,*,/ 这都比较好理解，取模运算符就是 % ，规则和语法和 java 是一样的。

• 整数
  整数例如 -99、0、1、2、100……等等，对应的类型是 java 中的 long 类型。AviatorScript 中并没有 byte/short/int 等类型，统一整数类型都为 long，支持的范围也跟 java 语言一样：-9223372036854774808~9223372036854774807。

• 浮点数
  仅支持 double 类型
  浮点数和浮点数的算术运算结果为浮点数，浮点数和整数的运算结果仍然为浮点数。

• 高精度计算(Decimal)
  浮点数是无法用于需要精确运算的场景，比如货币运算或者物理公式运算等，这种情况下如果在 Java 里一般推荐使用 BigDecimal 类型，调用它的 add/sub 等方法来做算术运算。
  AviatorScript 将 BigDecimal 作为基本类型来支持（下文简称 decimal 类型），只要浮点数以 M 结尾就会识别类型为 deicmal，例如 1.34M 、 0.333M 或者科学计数法 2e-3M 等等。
  如果你觉的为浮点数添加 M 后缀比较麻烦，希望所有浮点数都解析为 decimal ，可以开启 Options.ALWAYS_PARSE_FLOATING_POINT_NUMBER_INTO_DECIMAL

• 字符串
  在任何语言中，字符串都是最基本的类型，比如 java 里就是 String 类型。AviatorScript 中同样支持字符串，只要以单引号或者双引号括起来的连续字符就是一个完整的字符串对象，例如：

"a"  或者 'a' 
1

2、逻辑判断

支持if esle elseif 等连续判断

3、循环语句

支持 for 和 while 两种循环语句

五、函数列表

只要是下方的函数，都是可以直接使用的
例如

   /**
    * 使用系统函数
    */
   @Test
   public void test6() {
      Expression exp1 = AviatorEvaluator.compile("min(3,4)");
      Expression exp2 = AviatorEvaluator.compile("rand(100)");
      Object execute = exp1.execute();
      System.out.println( execute);//3
      Object execute2 = exp2.execute();
      System.out.println( execute2);//59
   }

   /**
    * 日期函数
    */
   @Test
   public void test8() {
      Expression exp1 = AviatorEvaluator.compile("date_to_string(date,format)");
      Map<String, Object> env = new HashMap<>();
      env.put("date", new Date());
      env.put("format", "yyyy-MM-dd");
      Object result =  exp1.execute(env);
      System.out.println( result);//2022-09-12


      Expression exp2 = AviatorEvaluator.compile("string_to_date(source,format)");
      Map<String, Object> env2 = new HashMap<>();
      env2.put("source", "2022-01-04");
      env2.put("format", "yyyy-MM-dd");
      Object result2 =  exp2.execute(env2);
      System.out.println( result2);//Tue Jan 04 00:00:00 CST 2022
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

1、系统函数

2、数学函数

3、字符串函数

4、集合函数

5、自定义函数的使用

   /**
    * 自定义函数minn
    */
   @Test
   public void test7() {
      AviatorEvaluator.addFunction(new MinnFunction());
      String expression = "minn(a,b)";
      Expression compiledExp = AviatorEvaluator.compile(expression);
      Map<String, Object> env = new HashMap<>();
      env.put("a", 5.5);
      env.put("b", 55);
      Double result = (Double) compiledExp.execute(env);
      System.out.println(result);//5.5
   }

   static class MinnFunction 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 "minn";
      }
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

六、对象中的属性引用

你要访问变量a中的某个属性b, 那么你可以通过a.b访问到, 更进一步, a.b.c将访问变量a的b属性中的c属性值, 推广开来也就是说 Aviator 可以将变量声明为嵌套访问的形式。

  /**
   * 类型转换,及对象中的属性引用
   */
  @Test
  public void testTypeConversation() {
    Map<String, Object> env = new HashMap<String, Object>();
    env.put("foo", new Foo(100));
    env.put("bar", new Bar(99, 999));
    env.put("date", new Date());

    Map<String, Object> map = new HashMap<String, Object>();
    map.put("key", "aviator");
    env.put("tmap", map);
    env.put("bool", Boolean.FALSE);

    // long op long=long
    System.out.println(this.instance.execute("3+3") instanceof Long);
    System.out.println(this.instance.execute("3+3/2") instanceof Long);
    System.out.println(this.instance.execute("foo.a+bar.a", env) instanceof Long);
    System.out.println(this.instance.execute("bar.a+bar.b", env));

    // double op double=double
    System.out.println(this.instance.execute("3.2+3.3") instanceof Double);
    System.out.println(this.instance.execute("3.01+3.1/2.1") instanceof Double);
    System.out.println(this.instance.execute("3.19+3.1/2.9-1.0/(6.0002*7.7+8.9)") instanceof Double);

    // double + long=double
     System.out.println(this.instance.execute("3+0.02") instanceof Double);
     System.out.println(this.instance.execute("3+0.02-100") instanceof Double);
     System.out.println(this.instance.execute("3+3/2-1/(6*7+8.0)") instanceof Double);
     System.out.println(this.instance.execute("foo.a+3.2-1000", env) instanceof Double);

    // object + string =string
    System.out.println( this.instance.execute("'hello '+ 'world'"));
    System.out.println( this.instance.execute("'hello '+tmap.key", env));
    System.out.println(this.instance.execute("true+' '+tmap.key", env));
    System.out.println( this.instance.execute("foo.a+tmap.key", env));
    System.out.println( this.instance.execute("/\\d+/+'hello'"));
    System.out.println( this.instance.execute("3.2+tmap.key", env));
    System.out.println( this.instance.execute("bool+' is false'", env));

}
public class Foo {
    int a;
    public Foo() {
    }
    public Foo(final int a) {
      super();
      this.a = a;
    }
    public int getA() {
      return this.a;
    }
    public void setA(final int a) {
      this.a = a;
    }
  }
  public class Bar extends Foo {
    int b;
    public Bar() {
    }
    public Bar(final int a, final int b) {
      super(a);
      this.b = b;
    }
    public int getB() {
      return this.b;
    }
    public void setB(final int b) {
      this.b = b;
    }

  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73