精华内容
下载资源
问答
  • 一个开源的Java表达式计算引擎 Java代码 /** * java 表达式计算引擎 * @author Michael sun */ public class TestExpr4j { /** * @param args */ public static void main(String[] args) { ...
  • Janino不仅可以将一组源文件编译为一组类文件(如JAVAC),还可以在内存中编译Java表达式,块,类主体或源文件,加载字节码并直接在同一JVM中执行。 JANINO与Apache Commons JCI(“Java编译器接口”)和JBoss Rules...


    在这里插入图片描述

    1.官方介绍

    Janino是一个超小型,超快的Java编译器。

    Janino不仅可以将一组源文件编译为一组类文件(如JAVAC),还可以在内存中编译Java表达式,块,类主体或源文件,加载字节码并直接在同一JVM中执行。

    JANINO与Apache Commons JCI(“Java编译器接口”)和JBoss Rules / Drools集成在一起。

    JANINO还可用于 静态代码分析 或 代码修改。

    2.代码示例

    修改了下官方的示例代码

     /**
         * 总耗时秒:2
         * 每秒处理条数:10000000
         * @throws Exception
         */
        @Test
        public void IETest2() th
    展开全文
  • Fel表达式计算引擎

    千次阅读 2018-10-27 15:12:24
    一、Fel表达式计算引擎介绍 Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。 Fel是开放的,引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel...

    一、Fel表达式计算引擎介绍

    Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。
    Fel是开放的,引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数),所有这些函数都是可以替换的,扩展函数也非常简单。
    Fel有双引擎,同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码(生成java代码和编译模块都是可以扩展和替换的)

    通常情况下,Fel-0.7每秒可以执行千万次表达式(不包含编译时间)。目前还没有发现开源的表达式引擎比Fel快。

     

    二、上代码,快速上手使用

    Fel表达式计算引擎很容易使用,看示例代码,学习时也不妨看看其类实现。

    示例代码如下:

    package com.cjh.test.Fel;
    
    import com.greenpineyu.fel.FelEngine;
    import com.greenpineyu.fel.FelEngineImpl;
    import com.greenpineyu.fel.context.FelContext;
    import com.greenpineyu.fel.context.MapContext;
    import com.greenpineyu.fel.function.CommonFunction;
    import com.greenpineyu.fel.function.Function;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Fel表达式引擎测试
     * @author chen jia hao
     */
    public class FelTest {
    
        public static void main(String[] args) {
    
            test1();
        }
    
        /**
         * 表达式计算
         */
        public static void test1(){
            FelEngine fel = new FelEngineImpl();
            FelContext ctx = fel.getContext();
            ctx.set("a", 1);
            ctx.set("b", 2);
            ctx.set("c", 3);
            Object result = fel.eval("a*b+c >0 && a<b");
            System.out.println(result);
        }
    
        /**
         * 访问对象属性,(同时指定特定上下文)
         */
        public static void test2(){
    
            FelEngine felEngine = new FelEngineImpl();
    
            Map<String, Object> params = new HashMap<>();
            params.put("name","陈嘉豪");
            FelContext mapContext = new MapContext();
            mapContext.set("obj",params);
    
            Object result = felEngine.eval("obj.name",mapContext);
            System.out.println(result);
        }
    
        /**
         * 调用静态方法
         * 格式:"$('class').method(var0,var1..,varn)"
         * class:类的全路径
         */
        public static void test3(){
            Object eval = FelEngine.instance.eval("$('Math').min(1,2)");
            System.out.println(eval);
        }
    
        /**
         * 自定义函数
         */
        public static void test4(){
    
            Function function = new CommonFunction() {
                /**
                 * 设置函数名称
                 * @return
                 */
                @Override
                public String getName() {
    
                    return "isEmpty";
                }
    
                /**
                 * 方法体
                 * @param objects
                 * @return
                 */
                @Override
                public Object call(Object[] objects) {
                    if(objects==null || objects.length<1){
                        return true;
                    }
                    Object object = objects[0];
                    if(object==null){
                        return true;
                    }
                    return false;
                }
            };
    
            FelEngineImpl felEngine = new FelEngineImpl();
            //添加自定义函数
            felEngine.addFun(function);
    
            felEngine.getContext().set("name","chenjiahao");
    
            Object eval = felEngine.eval("isEmpty(name)");
            System.out.println(eval);
    
            eval = felEngine.eval("isEmpty(age)");
            System.out.println(eval);
    
        }
    
    }
    



     

    展开全文
  • 表达式计算引擎

    千次阅读 2013-06-08 17:46:00
    Fel是轻量级的高效的表达式计算引擎 Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。 Fel是开放的,引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等...

    Fel是轻量级的高效的表达式计算引擎

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

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

    Fel有多快?

    通常情况下,Fel-0.7每秒可以执行千万次表达式(不包含编译时间)。速度是Jexl-2.0的20倍以上。

    目前还没有发现开源的表达式引擎比Fel快。

    具体的测试数据请参见http://code.google.com/p/fast-el/wiki/Performance


    为何要使用Fel?

    Fel语法和API非常简单,语法与Java基本相同,几乎没有学习成本。

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

    Fel整个包只有200多KB。

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

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

    Fel支持大数值高精度计算

    Fel有良好的安全管理功能

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

    Fel不能做什么?

    Fel只支持表达式,不支持脚本。

    Fel适用场景:

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

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


    安装

    1:获取Fel

    项目主页:http://code.google.com/p/fast-el/ 下载地址:http://code.google.com/p/fast-el/downloads/list


    Fel使用例子:

    1:算术表达式:

    FelEngine fel = new FelEngineImpl();    
    Object result = fel.eval("5000*12+7500");    
    System.out.println(result);   

    输出结果:67500

    2:变量

    使用变量,其代码如下所示:

    FelContext ctx = fel.getContext();    
    ctx.set("单价", 5000);    
    ctx.set("数量", 12);    
    ctx.set("运费", 7500);    
    Object result = fel.eval("单价*数量+运费");    
    System.out.println(result);   

    输出结果:67500

    3:访问对象属性

    在Fel中,可能非常方便的访问对象属性,示例代码如下所示

    FelEngine fel = new FelEngineImpl();
    FelContext ctx = fel.getContext();
    Foo foo = new Foo();
    ctx.set("foo", foo);
    Map<String,String> m = new HashMap<String,String>();
    m.put("ElName", "fel");
    ctx.set("m",m);
            
    //调用foo.getSize()方法。
    Object result = fel.eval("foo.size");
    
    //调用foo.isSample()方法。
    result = fel.eval("foo.sample");
                    
    //foo没有name、getName、isName方法
    //foo.name会调用foo.get("name")方法。
    result = fel.eval("foo.name");
                    
    //m.ElName会调用m.get("ElName");
    result = fel.eval("m.ElName");

    4:访问数组、集合、Map

    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方法

    FelEngine fel = new FelEngineImpl();   
    FelContext ctx = fel.getContext();   
    ctx.set("out", System.out);   
    fel.eval("out.println('Hello Everybody'.substring(6))");  

    输出结果:Everybody

    6:自定义上下文环境

    //负责提供气象服务的上下文环境   
    FelContext ctx = new AbstractConetxt() {   
        public Object get(Object name) {   
            if("天气".equals(name)){   
                return "晴";   
            }   
            if("温度".equals(name)){   
                return 25;   
            }   
            return null;   
        }   
    };   
    FelEngine fel = new FelEngineImpl(ctx);   
    Object eval = fel.eval("'天气:'+天气+';温度:'+温度");   
    System.out.println(eval);  

    输出结果:天气:晴;温度:25

    7:多层上下文环境(命名空间)

    FelEngine fel = new FelEngineImpl();   
    String costStr = "成本";   
    String priceStr="价格";   
    FelContext baseCtx = fel.getContext();   
    //父级上下文中设置成本和价格   
    baseCtx.set(costStr, 50);   
    baseCtx.set(priceStr,100);   
       
    String exp = priceStr+"-"+costStr;   
    Object baseCost = fel.eval(exp);   
    System.out.println("期望利润:" + baseCost);   
       
    FelContext ctx = new ContextChain(baseCtx, new MapContext());   
    //通货膨胀导致成本增加(子级上下文 中设置成本,会覆盖父级上下文中的成本)   
    ctx.set(costStr,50+20 );   
    Object allCost = fel.eval(exp, ctx);   
    System.out.println("实际利润:" + allCost);  

    输出结果:

    期望利润:50

    实际利润:30

    8:编译执行

    FelEngine fel = new FelEngineImpl();   
    FelContext ctx = fel.getContext();   
    ctx.set("单价", 5000);   
    ctx.set("数量", 12);   
    ctx.set("运费", 7500);   
    Expression exp = fel.compile("单价*数量+运费",ctx);   
    Object result = exp.eval(ctx);   
    System.out.println(result);  

    执行结果:67500

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

    9:自定义函数

        //定义hello函数   
        Function fun = new CommonFunction() {   
      
            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('fel')";   
        //解释执行   
        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);   
      

    执行结果:

    hello fel hello fel

    10:调用静态方法

    如果你觉得上面的自定义函数也麻烦,Fel提供的$函数可以方便的调用工具类的方法 熟悉jQuery的朋友肯定知道"$"函数的威力。Fel东施效颦,也实现了一个"$"函数,其作用是获取class和创建对象。结合点操作符,可以轻易的调用工具类或对象的方法。

      //调用Math.min(1,2)
      FelEngine.instance.eval("$('Math').min(1,2)");
      //调用new Foo().toString();
      FelEngine.instance.eval("$('com.greenpineyu.test.Foo.new').toString());

    通过"$('class').method"形式的语法,就可以调用任何等三方类包(commons lang等)及自定义工具类的方法,也可以创建对象,调用对象的方法。如果有需要,还可以直接注册Java Method到函数管理器中。

    11 大数值计算(始于0.9版本)

    Fel发布后,有些网友希望提供大数值计算功能,于是,大数值计算功能就有了。例子如下:

      FelEngine fel = FelBuilder.bigNumberEngine();
      String input = "111111111111111111111111111111+22222222222222222222222222222222";
      Object value = fel.eval(input);
      Object compileValue = fel.compile(input, fel.getContext()).eval(fel.getContext());
      System.out.println("大数值计算(解释执行):" + value);
      System.out.println("大数值计算(编译执行):" + compileValue);

    由上例子可以看出,大数值计算引擎和常规计算引擎在使用方法是相同的。如果表达式数值比较大,要求精度高,可使用大数值计算引擎。不足之处是效率没有常规计算引擎高。

    安全(始于0.8版本)

    为了防止出现“${'System'}.exit(1)”这样的表达式导致系统崩溃。Fel加入了安全管理器,主要是对方法访问进行控制。安全管理器中通过允许访问的方法列表(白名单)和禁止访问的方法列表(黑名单)来控制方法访问。将"java.lang.System. "加入到黑名单,表示System类的所有方法都不能访问。将"java.lang.Math. "加入白名单,表示只能访问Math类中的方法。如果你不喜欢这个安全管理器,可以自己开发一个,非常简单,只需要实现一个方法就可以了。



    展开全文
  • 载原文地址:Fel是轻量级的高效的表达式计算引擎 Fel的问题 Fel的问题 Fel是轻量级的高效的表达式计算引擎 Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。 Fel是开放的,引擎执行中...

    载原文地址:Fel是轻量级的高效的表达式计算引擎

    Fel的问题

    Fel的问题

    Fel是轻量级的高效的表达式计算引擎

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

    Fel是开放的,引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数),所有这些函数都是可以替换的,扩展函数也非常简单。

    Fel有双引擎,同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码(生成java代码和编译模块都是可以扩展和替换的)

    Fel有多快?

    通常情况下,Fel-0.7每秒可以执行千万次表达式(不包含编译时间)。速度是Jexl-2.0的20倍以上。
    目前还没有发现开源的表达式引擎比Fel快。
    具体的测试数据请参见http://code.google.com/p/fast-el/wiki/Performance。

    为何要使用Fel ?

    • Fel语法和API非常简单,语法与Java基本相同,几乎没有学习成本。
    • Fel非常快,上面已经做了简单说明。
    • Fel整个包只有200多KB。
    • Fel可以非常方便的访问数组、集合、Map的元素和对象的属性。
    • Fel可以非常方便的调用对象的方法和类方法(如果这些还不够,可以添加自定义函数)。
    • Fel支持大数值高精度计算
    • Fel有良好的安全管理功能
    • 如果Fel不能满足你的要求,扩展和修改Fel很简单。

    Fel不能做什么?

    Fel只支持表达式,不支持脚本。

    Fel适用场景:

    Fel适合处理海量数据,Fel良好的扩展性可以更好的帮助用户处理数据。
    Fel同样适用于其他需要使用表达式引擎的地方(如果工作流、公式计算、数据有效性校验等等)

    使用

    1. 项目主页:http://code.google.com/p/fast-el/
    2. 下载地址:http://code.google.com/p/fast-el/downloads/list
    3. Maven配置:
    <dependency>
        <groupId>org.eweb4j</groupId>
        <artifactId>fel</artifactId>
        <version>0.8</version>
    </dependency>

    Fel使用例子:

    • 算术表达式:
    FelEngine fel = new FelEngineImpl();    
    Object result = fel.eval("5000*12+7500");    
    System.out.println(result);   

    输出结果:67500

    • 变量
      使用变量,其代码如下所示:
    FelContext ctx = fel.getContext();    
    ctx.set("单价", 5000);    
    ctx.set("数量", 12);    
    ctx.set("运费", 7500);    
    Object result = fel.eval("单价*数量+运费");    
    System.out.println(result);   

    输出结果:67500

    • 访问对象属性
    FelEngine fel = new FelEngineImpl();
    FelContext ctx = fel.getContext();
    Foo foo = new Foo();
    ctx.set("foo", foo);
    Map<String,String> m = new HashMap<String,String>();
    m.put("ElName", "fel");
    ctx.set("m",m); 
    
    //调用foo.getSize()方法。
    Object result = fel.eval("foo.size");
    //调用foo.isSample()方法。
    result = fel.eval("foo.sample");         
    //foo没有name、getName、isName方法
    //foo.name会调用foo.get("name")方法。
    result = fel.eval("foo.name"); 
    //m.ElName会调用m.get("ElName");
    result = fel.eval("m.ElName");
    • 访问数组、集合、Map
    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));
    • 调用JAVA方法
    FelEngine fel = new FelEngineImpl();   
    FelContext ctx = fel.getContext();   
    ctx.set("out", System.out);   
    fel.eval("out.println('Hello Everybody'.substring(6))");  

    输出结果:Everybody

    • 自定义上下文环境
    //负责提供气象服务的上下文环境
    FelContext ctx = new AbstractContext() {
        public Object get(String name) {
            if("天气".equals(name)){
                return "晴";
            }
            if("温度".equals(name)){
                return 25;
            }
            return null;
        }
    };
    FelEngine fel = new FelEngineImpl(ctx);
    Object eval = fel.eval("'天气:'+天气+';温度:'+温度");
    System.out.println(eval);

    输出结果:天气:晴;温度:25

    • 多层上下文环境(命名空间)
    FelEngine fel = new FelEngineImpl();   
    String costStr = "成本";   
    String priceStr="价格";   
    FelContext baseCtx = fel.getContext();   
    //父级上下文中设置成本和价格   
    baseCtx.set(costStr, 50);   
    baseCtx.set(priceStr,100);   
       
    String exp = priceStr+"-"+costStr;   
    Object baseCost = fel.eval(exp);   
    System.out.println("期望利润:" + baseCost);   
       
    FelContext ctx = new ContextChain(baseCtx, new MapContext());   
    //通货膨胀导致成本增加(子级上下文 中设置成本,会覆盖父级上下文中的成本)   
    ctx.set(costStr,50+20 );   
    Object allCost = fel.eval(exp, ctx);   
    System.out.println("实际利润:" + allCost);  

    输出结果:
    期望利润:50
    实际利润:30

    • 编译执行
    FelEngine fel = new FelEngineImpl();   
    FelContext ctx = fel.getContext();   
    ctx.set("单价", 5000);   
    ctx.set("数量", 12);   
    ctx.set("运费", 7500);   
    Expression exp = fel.compile("单价*数量+运费",ctx);   
    Object result = exp.eval(ctx);   
    System.out.println(result);  

    执行结果:67500
    备注:适合处理海量数据,编译执行的速度基本与Java字节码执行速度一样快。

    • 自定义函数
    //定义hello函数   
    Function fun = new CommonFunction() {   
    
        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('fel')";   
    //解释执行   
    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);   

    执行结果:
    hello fel hello fel

    • 调用静态方法

    如果你觉得上面的自定义函数也麻烦,Fel提供的函数可以方便的调用工具类的方法熟悉jQuery的朋友肯定知道"函数可以方便的调用工具类的方法熟悉jQuery的朋友肯定知道""函数的威力。Fel东施效颦,也实现了一个"$"函数,其作用是获取class和创建对象。结合点操作符,可以轻易的调用工具类或对象的方法。

    //调用Math.min(1,2)
    FelEngine.instance.eval("$('Math').min(1,2)");
    //调用new Foo().toString();
    FelEngine.instance.eval("$('com.greenpineyu.test.Foo.new').toString());

    通过"$('class').method"形式的语法,就可以调用任何等三方类包(commons lang等)及自定义工具类的方法,也可以创建对象,调用对象的方法。如果有需要,还可以直接注册Java Method到函数管理器中。

    • 大数值计算(始于0.9版本)

    Fel发布后,有些网友希望提供大数值计算功能,于是,大数值计算功能就有了。例子如下:

    FelEngine fel = FelBuilder.bigNumberEngine();
    String input = "111111111111111111111111111111+22222222222222222222222222222222";
    Object value = fel.eval(input);
    Object compileValue = fel.compile(input, fel.getContext()).eval(fel.getContext());
    System.out.println("大数值计算(解释执行):" + value);
    System.out.println("大数值计算(编译执行):" + compileValue);

    由上例子可以看出,大数值计算引擎和常规计算引擎在使用方法是相同的。如果表达式数值比较大,要求精度高,可使用大数值计算引擎。不足之处是效率没有常规计算引擎高。

    • 安全(始于0.8版本)

    为了防止出现“${'System'}.exit(1)”这样的表达式导致系统崩溃。Fel加入了安全管理器,主要是对方法访问进行控制。安全管理器中通过允许访问的方法列表(白名单)和禁止访问的方法列表(黑名单)来控制方法访问。将"java.lang.System. * "加入到黑名单,表示System类的所有方法都不能访问。将"java.lang.Math. * "加入白名单,表示只能访问Math类中的方法。如果你不喜欢这个安全管理器,可以自己开发一个,非常简单,只需要实现一个方法就可以了。

    展开全文
  • 表达式计算引擎-JEP

    2019-10-10 13:07:52
    最近调整了原先的一个中间件的功能,把之前被产品去掉的规则表达式计算又重新添了回去. 这个中间件的基本功能是使用预定义的关键字和数值比对进行判断,从大量的数据中生成告警,主要是用于服务器监控. 这里的表达式...
  • 独立表达式计算引擎

    千次阅读 2007-04-09 09:11:00
    .NET里边有的用CodeDom, 有的用DataTable的计算列,还有用Com下的Script引擎,但没找到一个轻量级的独立表达式计算引擎。哎,DotNet的东东是不多,牛人也不屑做这玩意。不过我觉得这表达式引擎用到的地方还是挺多的...
  • Fel是轻量级的高效的表达式计算引擎。 Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。 Fel是开放的,引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都...
  • Fel轻量高效的表达式计算引擎

    千次阅读 2018-06-10 10:41:12
    Fel是轻量级的高效的表达式计算引擎Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。Fel是开放的,引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是...
  • Fel在源自于企业项目,设计目标是为了...编译执行就是将表达式编译成字节码(生成java代码和编译模块都是可以扩展和替换的) Fel基于Java1.5开发,适用于Java1.5及以上版本。 表达式引擎QQ群:75055831,欢迎交流。
  • Fel Javael表达式引擎

    2017-10-17 15:07:43
    Fel轻量级的高效的表达式计算引擎。 Fel在源自于企业项目,设计目标是为了不断变化的功能需求和性能需求.文档中有个别错误,但不影响阅读
  • Java表达式引擎aviator

    千次阅读 2020-02-28 09:52:09
    Aviator是一个高性能、轻量级的 java 语言实现的表达式求值引擎, 主要用于各种表达式的动态求值。 2、特性 设计目标是轻量级和高性能,相比于Groovy、JRuby的笨重, Aviator非常小, 加上依赖包也才450K,不算依赖包的...
  • java表达式引擎

    2016-09-26 13:14:00
    以前一直想自己写个简单的支持加减乘除简单的表达式引擎,今天闲逛居然发现一个现成的。特此记录已备研究。 https://github.com/killme2008/aviator/wiki#%E6%89%A7%E8%A1%8C%E8%A1%A8%E8%BE%BE%E5%BC%8F ...
  • 轻量级Java表达式引擎Aviator

    千次阅读 2019-03-21 16:20:06
    Aviator是一个高性能、轻量级的 java 语言实现的表达式求值引擎, 主要用于各种表达式的动态求值。现在已经有很多开源可用的 java 表达式求值引擎,为什么还需要 Avaitor 呢? Aviator的设计目标是轻量级和高性能,相比...
  • 我的美梦就这样破碎了 ヽ`、 、ヽ`、还没到三伏天的大雨ヽ`、ヽ、ヽ`ヽヽ、 ヽ`、ヽ ヽ烦人逗比经理电话来了 、 ヽ`、ヽ、ヽ`、ヽ、ヽ`、 ヽ、ヽ 、ヽ`、ヽ、ヽ`、ヽ Fel是轻量级的高效的表达式计算引擎 ...
  • 选用了一些常用的表达式引擎计算方案,包含:java脚本引擎(javax/script)、groovy脚本引擎、Expression4j、Fel表达式引擎。 其中java脚本引擎使用了解释执行和编译执行两种方式、groovy脚本只采用了编译执行(解释...
  • Aviator——轻量级Java表达式求值引擎

    千次阅读 2019-09-11 21:17:06
    首先声明一下,这是一个不负责任的、不完全的Aviator介绍文章,只管撩,不管埋 ...现在已经有很多开源可用的java表达式求值引擎,为什么还需要Avaitor呢? Aviator的设计目标是轻量级和高性能 ...
  • expr4j 表达式计算

    千次阅读 2018-04-04 15:45:01
    1 expr4j 简介Expression Calculation Engine for Java :java表达式计算引擎2 expr4j 下载地址...
  • Fel是轻量级的高效的表达式计算引擎 Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。 Fel是开放的,引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等...
  • Fel详情参考: ... 这里写的这个Fel计算器其实算不上是计算器,因为没有提供数字键,只能通过键盘输入,并且最重要的一点是,这个计算器的主要方法只是调用下面的代码: FelEngine fel = new FelEngineImpl();...
  • .net里有的用codedom,有的用datatable的计算列,还有用Com下的Script引擎,愣没找到一个轻量级的独立表达式计算引擎。哎,dotnet的东东是不多,牛人也不屑做这玩意。不过我觉得这表达式引擎用到的地方还是挺多的呀.....
  • Java动态脚本实现、规则引擎计算/表达式引擎 动态执行用户自定义规则及脚本、摆脱频繁变更的业务规则

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,029
精华内容 19,611
关键字:

java表达式计算引擎

java 订阅