Aviator和MVEL实现Map过滤(通过动态表达式求值)—Java表达式引擎的使用

pom

<dependency>
    <groupId>com.googlecode.aviator</groupId>
    <artifactId>aviator</artifactId>
    <version>4.2.10</version>
</dependency>
<dependency>
    <groupId>org.mvel</groupId>
    <artifactId>mvel2</artifactId>
    <version>2.4.10.Final</version>
</dependency>
View Code

对单一map的简单操作

import java.util.HashMap;
import java.util.Map;
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.AviatorBigInt;
import com.googlecode.aviator.runtime.type.AviatorObject;

public class App 
{
    static{
        //注册函数
        AviatorEvaluator.addFunction(new MinFunction());
    }
    
    public static void main( String[] args )
    {
        Map<String, Object> sourceMapItem = new HashMap<String, Object>();
        sourceMapItem.put("pt", "mi");
        sourceMapItem.put("ab", "abc");
        sourceMapItem.put("xy", "xyz");
        sourceMapItem.put("int1", 135);
        sourceMapItem.put("int2", 68);
        sourceMapItem.put("decimal2", 19.83);
        sourceMapItem.put("mydate", "2020-10-10 28:35:00");
        sourceMapItem.put("value", 999);
        String expStr = "pt == 'mi'";
        Object result;       
        result =  AviatorEvaluator.execute(expStr, sourceMapItem);
        System.out.println(expStr+" ---  "+result);
        //逻辑与 + 简单表达式        
        expStr = "pt == 'mi' && ab == 'abc' && int1 > 100 && decimal2 < 20.50";
        result =  AviatorEvaluator.execute(expStr, sourceMapItem);
        System.out.println(expStr+" ---  "+result);
        //逻辑与或组合        
        expStr = "pt == 'mi1' || (decimal2 < 20.50 && xy+'X' == 'xyzX')";
        result =  AviatorEvaluator.execute(expStr, sourceMapItem);
        System.out.println(expStr+" ---  "+result);
        //三目运算        
        expStr = "pt == 'mi1' ? ab == 'ab' : ab == 'abc'";
        result =  AviatorEvaluator.execute(expStr, sourceMapItem);
        System.out.println(expStr+" ---  "+result);
        //函数
        expStr = "pt != 'mi1' && string.length(xy) >= 5 ";
        result =  AviatorEvaluator.execute(expStr, sourceMapItem);
        System.out.println(expStr+" ---  "+result);      
        //自定义函数
        expStr = "pt == 'mi1' || myMin(int2 , int1) > 10 ";
        result =  AviatorEvaluator.execute(expStr, sourceMapItem);
        System.out.println(expStr+" ---  "+result);
        

    }
    
    static class MinFunction 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 "myMin";
        }
    }
}
View Code

输出结果

pt == 'mi' ---  true
pt == 'mi' && ab == 'abc' && int1 > 100 && decimal2 < 20.50 ---  true
pt == 'mi1' || (decimal2 < 20.50 && xy+'X' == 'xyzX') ---  true
pt == 'mi1' ? ab == 'ab' : ab == 'abc' ---  true
pt != 'mi1' && string.length(xy) >= 5  ---  false
pt == 'mi1' || myMin(int2 , int1) > 10  ---  true

一个扩展的任务,Aviator对嵌套map进行stream过滤

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import com.googlecode.aviator.AviatorEvaluator;

public class MapForFilter {
    
    final static String EXPSTR = "(pt == 'mi' && ab == 'abc' && int1 > 100) || "
            + "(decimal2 < 20.50 && string.length(xy) >= 5)";
    
    public static void main( String[] args )
    {
        aviatorEvaluatorDemo();                  
    }

    private static void aviatorEvaluatorDemo() {
        Map<String, Map<String, Object>> sourceMap = fillData();
 
        Map<String, Map<String, Object>> resultdMap = parseMapForFilter(sourceMap,EXPSTR);
        
        System.out.println("过滤后:"+resultdMap);
    }

    private static Map<String, Map<String, Object>> fillData() {
        Map<String, Map<String, Object>> sourceMap = new HashMap<String, Map<String, Object>>();
        
        Map<String, Object> sourceMapItem1 = new HashMap<String, Object>();
        sourceMapItem1.put("pt", "mi");
        sourceMapItem1.put("ab", "abc");
        sourceMapItem1.put("xy", "xyz");
        sourceMapItem1.put("int1", 135);
        sourceMapItem1.put("int2", 68);
        sourceMapItem1.put("decimal2", 19.83);
        sourceMapItem1.put("mydate", "2020-10-10 28:35:00");
        sourceMapItem1.put("value", 999);
        
        Map<String, Object> sourceMapItem2 = new HashMap<String, Object>();
        sourceMapItem2.put("pt", "oppo");
        sourceMapItem2.put("ab", "ab");
        sourceMapItem2.put("xy", "xy");
        sourceMapItem2.put("int1", 24);
        sourceMapItem2.put("int2", 56);
        sourceMapItem2.put("decimal2", 519.83);
        sourceMapItem2.put("mydate", "2020-10-11 28:35:00");
        sourceMapItem2.put("value", 888);
        
        Map<String, Object> sourceMapItem3 = new HashMap<String, Object>();
        sourceMapItem3.put("pt", "oppo");
        sourceMapItem3.put("ab", "cde");
        sourceMapItem3.put("xy", "xy");
        sourceMapItem3.put("int1", 213);
        sourceMapItem3.put("int2", 473);
        sourceMapItem3.put("decimal2", 119.83);
        sourceMapItem3.put("mydate", "2020-10-12 28:35:00");
        sourceMapItem3.put("value", 777);
        
        Map<String, Object> sourceMapItem4 = new HashMap<String, Object>();
        sourceMapItem4.put("pt", "oppo");
        sourceMapItem4.put("ab", "fgh");
        sourceMapItem4.put("xy", "xyz123");
        sourceMapItem4.put("int1", 156);
        sourceMapItem4.put("int2", 215);
        sourceMapItem4.put("decimal2", 15.92);
        sourceMapItem4.put("mydate", "2020-10-13 28:35:00");
        sourceMapItem4.put("value", 666);
        
        sourceMap.put("2020-10-10",sourceMapItem1);
        sourceMap.put("2020-10-11",sourceMapItem2);
        sourceMap.put("2020-10-12",sourceMapItem3);
        sourceMap.put("2020-10-13",sourceMapItem4);
        return sourceMap;
    }
    
    public static Map<String, Map<String, Object>> parseMapForFilter(Map<String, Map<String, Object>> sourceMap,String exp) {
        
        return Optional.ofNullable(sourceMap).map(
                (v) -> {
                    Map<String, Map<String, Object>> params = v.entrySet().stream()
                            .filter(map -> checkItem(map.getValue(),exp)) 
                            .collect(Collectors.toMap(map -> map.getKey(), map -> map.getValue()));  

                    return params;
                }
        ).orElse(null);
    }

    private static boolean checkItem(Map<String, Object> itemMap,String exp) {

        Object result = AviatorEvaluator.execute(exp, itemMap);
        return (boolean) result;
    }
}

MVEL的实现同样的过滤任务

为了适应MVEL,注意表达式的字符有少许不同。

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import org.mvel2.MVEL;

public class MapForFilterMvel {

    final static String EXPSTR = "(m.pt == 'mi' && m.ab == 'abc' && m.int1 > 100) || "
            + "(m.decimal2 < 20.50 && m.xy.length()>5)"; 
    
    public static void main( String[] args )
    {
        mvelDemo();             
    }
    
    private static void mvelDemo() {
        Map<String, Map<String, Object>> sourceMap = fillData();
        
        Map<String, Map<String, Object>> resultdMap = parseMapForMvelFilter(sourceMap);
        
        System.out.println("过滤后:"+resultdMap);
    }

    private static Map<String, Map<String, Object>> parseMapForMvelFilter(Map<String, Map<String, Object>> sourceMap) {
        
        return Optional.ofNullable(sourceMap).map(
                (v) -> {
                    Map<String, Map<String, Object>> params = v.entrySet().stream()
                            .filter(map -> checkItemByMvel(map.getValue())) 
                            .collect(Collectors.toMap(map -> map.getKey(), map -> map.getValue()));  

                    return params;
                }
        ).orElse(null);
    }

    private static boolean checkItemByMvel(Map<String, Object> value) {
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("m", value);
        Object object = MVEL.eval(EXPSTR, paramMap);
        return (boolean)object;
    }
    
    private static Map<String, Map<String, Object>> fillData() {
        Map<String, Map<String, Object>> sourceMap = new HashMap<String, Map<String, Object>>();
        
        Map<String, Object> sourceMapItem1 = new HashMap<String, Object>();
        sourceMapItem1.put("pt", "mi");
        sourceMapItem1.put("ab", "abc");
        sourceMapItem1.put("xy", "xyz");
        sourceMapItem1.put("int1", 135);
        sourceMapItem1.put("int2", 68);
        sourceMapItem1.put("decimal2", 19.83);
        sourceMapItem1.put("mydate", "2020-10-10 28:35:00");
        sourceMapItem1.put("value", 999);
        
        Map<String, Object> sourceMapItem2 = new HashMap<String, Object>();
        sourceMapItem2.put("pt", "oppo");
        sourceMapItem2.put("ab", "ab");
        sourceMapItem2.put("xy", "xy");
        sourceMapItem2.put("int1", 24);
        sourceMapItem2.put("int2", 56);
        sourceMapItem2.put("decimal2", 519.83);
        sourceMapItem2.put("mydate", "2020-10-11 28:35:00");
        sourceMapItem2.put("value", 888);
        
        Map<String, Object> sourceMapItem3 = new HashMap<String, Object>();
        sourceMapItem3.put("pt", "oppo");
        sourceMapItem3.put("ab", "cde");
        sourceMapItem3.put("xy", "xy");
        sourceMapItem3.put("int1", 213);
        sourceMapItem3.put("int2", 473);
        sourceMapItem3.put("decimal2", 119.83);
        sourceMapItem3.put("mydate", "2020-10-12 28:35:00");
        sourceMapItem3.put("value", 777);
        
        Map<String, Object> sourceMapItem4 = new HashMap<String, Object>();
        sourceMapItem4.put("pt", "oppo");
        sourceMapItem4.put("ab", "fgh");
        sourceMapItem4.put("xy", "xyz123");
        sourceMapItem4.put("int1", 156);
        sourceMapItem4.put("int2", 215);
        sourceMapItem4.put("decimal2", 15.92);
        sourceMapItem4.put("mydate", "2020-10-13 28:35:00");
        sourceMapItem4.put("value", 666);
        
        sourceMap.put("2020-10-10",sourceMapItem1);
        sourceMap.put("2020-10-11",sourceMapItem2);
        sourceMap.put("2020-10-12",sourceMapItem3);
        sourceMap.put("2020-10-13",sourceMapItem4);
        return sourceMap;
    }

}

对map集合的过滤:结果:

过滤后:
{
2020-10-10={ab=abc, xy=xyz, int2=68, mydate=2020-10-10 28:35:00, int1=135, pt=mi, decimal2=19.83, value=999},
2020-10-13={ab=fgh, xy=xyz123, int2=215, mydate=2020-10-13 28:35:00, int1=156, pt=oppo, decimal2=15.92, value=666}
}

Aviator的优缺点

final static String EXPSTR = "(pt == 'mi' && ab == 'abc' && int1 > 100) || (decimal2 < 20.50 && string.length(xy) >= 5)";
  • 更轻量级。
  • 对map的支持非常好,可以说就是为了Map量身定做的,对key变量直接使用就可以了。
  • 函数只能使用内置函数或者自定义函数。
  • 不支持对象的属性和方法。
  • 不支持if else和for循环。

MVEL的优点

 final static String EXPSTR = "(m.pt == 'mi' && m.ab == 'abc' && m.int1 > 100) || (m.decimal2 < 20.50 && m.xy.length()>5)"; 
  • 功能更加强大。
  • 使用map需要再包一层,用于指示map的根。稍微有些限制,但也不影响使用,固定一个map变量名就好了。
  • 支持对象属性、方法,这就厉害了,可以复用全部的java内置class,也可以使用你自己写的class的属性和方法。也可以自定义方法。
  • 支持对象new操作,支持断言,支持对象赋值。
  • 支持if else流程,支持循环。

操作符列表

序号操作符结合性操作数限制
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.

参考资料

5.0版以后成为了aviatorscript

https://github.com/killme2008/aviatorscript

 

posted @ 2020-09-12 13:36  昕友软件开发  阅读(2112)  评论(0编辑  收藏  举报
欢迎访问我的开源项目:xyIM企业即时通讯