Java表达式引擎Aviator

叁歲伎倆 2023-10-06 23:01 33阅读 0赞

java表达式引擎有很多，最后选择了Aviator。原因是：高性能、轻量级。  
Aviator 是将表达式直接翻译成对应的 java 字节码执行，除了依赖 commons-beanutils 这个库之外（用于做反射）不依赖任何第三方库，因此整体非常轻量级，整个 jar 包大小哪怕发展到现在 5.3 这个版本，也才 620K。

<dependency>
        <groupId>com.googlecode.aviator</groupId>
        <artifactId>aviator</artifactId>
        <version>5.3.1</version>
    </dependency>

假如有这样一个if else判断

String result;
            int score = 95;
            if (score > 90) {
                result = "优";
            } else if (score > 80) {
                result = "良";
            } else if (score > 60) {
                result = "及格";
            } else {
                result = "不及格";
            }

if else可以使用三元运算来实现

int score = 95;
            String s = score > 90 ? "优" : score > 80 ? "良" : score > 60 ? "及格" : "不及格";
            System.out.println(score + s);

使用Aviator的三元表达式引擎计算：

Map<String, Object> params = new HashMap<>();
            params.put("score", 85);
            //表达式
            String expression = "score > 90 ? \"优\" : score > 80 ? \"良\" : score > 60 ? \"及格\" : \"不及格\"";
            Object result = AviatorEvaluator.execute(expression, params);
            System.out.println(result);

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

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

Expression compiledExp = AviatorEvaluator.compile(expression,true);  
这样设置后，下一次编译同样的表达式，Aviator会自从从全局缓存中，拿出已经编译好的结果，不需要动态编译。如果需要使缓存失效，可以使用

AviatorEvaluator.invalidateCache(String expression);

Map<String, Object> params = new HashMap<>();
            params.put("score", 85);
            //表达式
            String expression = "score > 90 ? \"优\" : score > 80 ? \"良\" : score > 60 ? \"及格\" : \"不及格\"";
            String result = (String) AviatorEvaluator.compile(expression, true).execute(params);
            System.out.println(result);

当然还支持常见的字符串函数，与java语法有点区别。

Map<String, Object> params = new HashMap<>();
            params.put("s1", "abc123");
            params.put("s2", "abc");
            params.put("s3", "男");
            params.put("s4", "男");
            //表达式
            //等价于s1.contains(s2) && s3.equals(s4)
            String expression = "string.contains(s1,s2) && s3==s4";
            Object result = AviatorEvaluator.compile(expression, true).execute(params);
            System.out.println(result);//结果：true

支持单引号

//表达式
            //等价于s1.contains(s2) && s3.equals(s4)
            String expression = "string.contains('abc123','abc') && '男'=='男'";
            Object result = AviatorEvaluator.compile(expression, true).execute();
            System.out.println(result);//结果：true

具体语法参考下面文档

#### 操作符列表 ####

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>操作符</th> 
   <th>结合性</th> 
   <th>操作数限制</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>0</td> 
   <td>() [ ]</td> 
   <td>从左到右</td> 
   <td>()用于函数调用，[ ]用于数组和java.util.List的元素访问，要求[indx]中的index必须为整型</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>! - ~</td> 
   <td>从右到左</td> 
   <td>! 能用于Boolean,- 仅能用于Number,~仅能用于整数</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>* / %</td> 
   <td>从左到右</td> 
   <td>Number之间</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>+ -</td> 
   <td>从左到右</td> 
   <td>+ - 都能用于Number之间, + 还能用于String之间，或者String和其他对象</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>&lt;&lt; &gt;&gt; &gt;&gt;&gt;</td> 
   <td>从左到右</td> 
   <td>仅能用于整数</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>&lt; &lt;= &gt; &gt;=</td> 
   <td>从左到右</td> 
   <td>Number之间、String之间、Pattern之间、变量之间、其他类型与nil之间</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>== != =~</td> 
   <td>从左到右</td> 
   <td>==和!=作用于Number之间、String之间、Pattern之间、变量之间、其他类型与nil之间以及String和java.util.Date之间，=~仅能作用于String和Pattern之间</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>&amp;</td> 
   <td>从左到右</td> 
   <td>整数之间</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>^</td> 
   <td>从左到右</td> 
   <td>整数之间</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>¦</td> 
   <td>从左到右</td> 
   <td>整数之间</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>&amp;&amp;</td> 
   <td>从左到右</td> 
   <td>Boolean之间，短路</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>¦¦</td> 
   <td>从左到右</td> 
   <td>Boolean之间，短路</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>? :</td> 
   <td>从右到左</td> 
   <td>第一个操作数的结果必须为Boolean，第二和第三操作数结果无限制</td> 
  </tr> 
 </tbody> 
</table>

#### 内置函数 ####

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

#### 常量和变量 ####

<table> 
 <thead> 
  <tr> 
   <th>值</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>true</td> 
   <td>真值</td> 
  </tr> 
  <tr> 
   <td>false</td> 
   <td>假值</td> 
  </tr> 
  <tr> 
   <td>nil</td> 
   <td>空值</td> 
  </tr> 
  <tr> 
   <td><code>$digit</code></td> 
   <td>正则表达式匹配成功后的分组，<code>$0</code>表示匹配的字符串，<code>$1</code>表示第一个分组 etc.</td> 
  </tr> 
 </tbody> 
</table>