fel的简单使用及介绍

Fel介绍

Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。

Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。
Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换的）

Fel有多快？
通常情况下，Fel-0.7每秒可以执行千万次表达式（不包含编译时间）。速度是Jexl-2.0的20倍以上。目前还没有发现开源的表达式引擎比Fel快。

 

为何要使用Fel?
Fel语法和API非常简单，语法与Java基本相同，几乎没有学习成本。

Fel非常快，上面已经做了简单说明。

Fel整个包只有200多KB。

Fel可以非常方便的访问数组、集合、Map的元素和对象的属性。

Fel可以非常方便的调用对象的方法和类方法（如果这些还不够，可以添加自定义函数）。

Fel支持大数值高精度计算

Fel有良好的安全管理功能

如果Fel不能满足你的要求，扩展和修改Fel很简单。

Fel不能做什么？
Fel只支持表达式，不支持脚本。

Fel适用场景：
Fel适合处理海量数据，Fel良好的扩展性可以更好的帮助用户处理数据。

Fel同样适用于其他需要使用表达式引擎的地方（如果工作流、公式计算、数据有效性校验等等）

创建项目引入依赖

<!-- https://mvnrepository.com/artifact/org.eweb4j/fel -->
<dependency>
    <groupId>org.eweb4j</groupId>
    <artifactId>fel</artifactId>
    <version>0.8</version>
</dependency>

使用方式

1、算术方程式

    public static void main(String[] args){
        arithmetic();// 算术方程式
    }

    private static void arithmetic(){
        FelEngine fel = new FelEngineImpl();
        Object result = fel.eval("(6552*365+12000)/12");
        System.out.println(result);
    }

2、变量方式

  获取变量进行计算表达

    public static void main(String[] args){
        arithmetic();// 算术方程式
        System.err.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
        variable();// 变量法
    }

    private static void arithmetic(){
        FelEngine fel = new FelEngineImpl();
        Object result = fel.eval("(6552*365+12000)/12");
        System.out.println(result);
    }

    private static void variable(){
        FelEngine fel = new FelEngineImpl();
        FelContext ctx = fel.getContext();
        ctx.set("日计数", 6552);
        ctx.set("天数", 365);
        ctx.set("基础费用", 12000);
        ctx.set("月份",12);
        Object result = fel.eval("(日计数*天数+基础费用)/月份");
        System.out.println(result);
    }

3、可以使用对象属性进行计算

    public static void main(String[] args){
        objectDetil();
    }

    private static void objectDetil(){
        FelEngine fel = new FelEngineImpl();
        FelContext ctx = fel.getContext();
        Map<String,String> m = new HashMap<String,String>();
        m.put("ElName", "我是map的value");
        ctx.set("m",m);

        // 调用m.get('ElName')方法。
        Object result = fel.eval("m.get('ElName')");
        // 调用m.size()方法。
        Object size = fel.eval("m.size()");
        System.out.println(result+"     size = "+size);
    }

4、获取数组，集合，map

跟上面一样使用的 fel.eval(“xxx”)来获取对象内容

    private static void array(){
        FelEngine fel = new FelEngineImpl();
        FelContext ctx = fel.getContext();

        //数组
        int[] intArray = {1,2,3};
        ctx.set("intArray",intArray);
        //获取intArray[0]
        String exp = "intArray[0]";
        System.out.println(exp+"->"+fel.eval(exp));

        //List
        List<Integer> list = Arrays.asList(1,2,3);
        ctx.set("list",list);
        //获取list.get(0)
        exp = "list[0]";
        System.out.println(exp+"->"+fel.eval(exp));

        //集合
        Collection<String> coll = Arrays.asList("a","b","c");
        ctx.set("coll",coll);
        //获取集合最前面的元素。执行结果为"a"
        exp = "coll[0]";
        System.out.println(exp+"->"+fel.eval(exp));

        //迭代器
        Iterator<String> iterator = coll.iterator();
        ctx.set("iterator", iterator);
        //获取迭代器最前面的元素。执行结果为"a"
        exp = "iterator[0]";
        System.out.println(exp+"->"+fel.eval(exp));

        //Map
        Map<String,String> m = new HashMap<String, String>();
        m.put("name", "HashMap");
        ctx.set("map",m);
        exp = "map.name";
        System.out.println(exp+"->"+fel.eval(exp));

        //多维数组
        int[][] intArrays= {{11,12},{21,22}};
        ctx.set("intArrays",intArrays);
        exp = "intArrays[0][0]";
        System.out.println(exp+"->"+fel.eval(exp));

        //多维综合体，支持数组、集合的任意组合。
        List<int[]> listArray = new ArrayList<int[]>();
        listArray.add(new int[]{1,2,3});
        listArray.add(new int[]{4,5,6});
        ctx.set("listArray",listArray);
        exp = "listArray[0][0]";
        System.out.println(exp+"->"+fel.eval(exp));
    }

5、调用java方法

    private static void java(){
        FelEngine fel = new FelEngineImpl();
        FelContext ctx = fel.getContext();
        ctx.set("out", System.out);
        fel.eval("out.println('Hello Word'.substring(6))");
    }

6、编译执行

    private static void install(){
        FelEngine fel = new FelEngineImpl();
        FelContext ctx = fel.getContext();
        ctx.set("日计数", 6552);
        ctx.set("天数", 365);
        ctx.set("基础费用", 12000);
        ctx.set("月份",12);
        Expression exp = fel.compile("(日计数*天数+基础费用)/月份",ctx);
        Object result = exp.eval(ctx);
        System.out.println(result);
    }

适合处理海量数据，编译执行的速度基本与Java字节码执行速度一样快。

7、自定义函数

    private static void custom(){
        //定义hello函数
        Function fun = new CommonFunction() {

            @Override
            public String getName() {
                return "hello";
            }

            /*
             * 调用hello("xxx")时执行的代码
             */
            @Override
            public Object call(Object[] arguments) {
                Object msg = null;
                if(arguments!= null && arguments.length>0){
                    msg = arguments[0];
                }
                return ObjectUtils.toString(msg);
            }

        };
        FelEngine e = new FelEngineImpl();
        //添加函数到引擎中。
        e.addFun(fun);
        String exp = "hello('test')";
        //解释执行
        Object eval = e.eval(exp);
        System.out.println("hello "+eval);
        //编译执行
        Expression compile = e.compile(exp, null);
        eval = compile.eval(null);
        System.out.println("hello "+eval);
    }

参考博客：Fel是轻量级的高效的表达式计算引擎学习（一）

 

 

-------------------------IDEA引入本地jar包

选择jar包确定即可