Java MVEL.compileExpression方法代码示例

import org.mvel2.MVEL; //导入方法依赖的package包/类
public static void main(String[] args) {
    Foo foo = new Foo();
    foo.setName("test");
    Map context = new HashMap();
    String expression = "foo.name == 'test'";
    VariableResolverFactory functionFactory = new MapVariableResolverFactory(context);
    context.put("foo",foo);
    Boolean result = (Boolean) MVEL.eval(expression,functionFactory);
    System.out.println(result);


    Serializable compileExpression = MVEL.compileExpression(expression);
    result = (Boolean) MVEL.executeExpression(compileExpression, context, functionFactory);
    System.out.print(result);

}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
/**
 * Helpful method for processing a boolean MVEL expression and associated arguments.
 *
 * Caches the expression in an LRUCache.
 * @param expression
 * @param vars
 * @return the result of the expression
 */
protected Boolean executeExpression(String expression, Map<String, Object> vars) {
    Serializable exp = (Serializable) expressionCache.get(expression);
    vars.put("MVEL", MVEL.class);

    if (exp == null) {
        try {
            exp = MVEL.compileExpression(expression, getParserContext());
        } catch (CompileException ce) {
            LOG.warn("Compile exception processing phrase: " + expression,ce);
            return Boolean.FALSE;
        }
        expressionCache.put(expression, exp);
    }

    try {
        return (Boolean) MVEL.executeExpression(exp, vars);
    } catch (Exception e) {
        LOG.error(e);
    }

    return false;
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
public static void runMvel(int xmax, int ymax, int zmax) {
    Map context = new HashMap();
    String expression = "x + y*2 - z";
    Serializable compileExpression = MVEL.compileExpression(expression);
    Integer result = 0;
    Date start = new Date();
    for (int xval = 0; xval < xmax; xval++) {
        for (int yval = 0; yval < ymax; yval++) {
            for (int zval = 0; zval <= zmax; zval++) {
                context.put("x", xval);
                context.put("y", yval);
                context.put("z", zval);
                VariableResolverFactory functionFactory = new MapVariableResolverFactory(context);
                Integer cal = (Integer) MVEL.executeExpression(compileExpression, context, functionFactory);
                result += cal;
            }
        }
    }
    Date end = new Date();
    System.out.println("MVEL:time is : " + (end.getTime() - start.getTime()) + ",result is " + result);

}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
/**
 * If the SkuFee expression is null or empty, this method will always return true
 * 
 * @param fee
 * @param fulfillmentGroup
 * @return
 */
protected boolean shouldApplyFeeToFulfillmentGroup(SkuFee fee, FulfillmentGroup fulfillmentGroup) {
    boolean appliesToFulfillmentGroup = true;
    String feeExpression = fee.getExpression();
    
    if (!StringUtils.isEmpty(feeExpression)) {
        Serializable exp = (Serializable) EXPRESSION_CACHE.get(feeExpression);
        if (exp == null) {
            ParserContext mvelContext = new ParserContext();
            mvelContext.addImport("MVEL", MVEL.class);
            mvelContext.addImport("MvelHelper", MvelHelper.class);
            exp = MVEL.compileExpression(feeExpression, mvelContext);
        
            EXPRESSION_CACHE.put(feeExpression, exp);
        }
        HashMap<String, Object> vars = new HashMap<String, Object>();
        vars.put("fulfillmentGroup", fulfillmentGroup);
        return (Boolean)MVEL.executeExpression(feeExpression, vars);
    }
    
    return appliesToFulfillmentGroup;
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
public void start() {
    //Create two of the same expressions
    final String expression = "firstname";
    final String expression2 = "lastname";

    //Create a bean to run expressions against
    final Bean bean = new Bean();

    //Use reflection mode
    OptimizerFactory.setDefaultOptimizer(OptimizerFactory.SAFE_REFLECTIVE);

    //Compile the expressions
    Serializable mvelExp1 = MVEL.compileExpression(expression);
    Serializable mvelExp2 = MVEL.compileExpression(expression2);

    //run the threads
    runThreads(bean, mvelExp1, mvelExp2);
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
public void testJIRA164f() {
    Serializable s = MVEL.compileExpression("10 + 11 + 12 / (var1 + 1 + var1 + 51 + 71) * var1 + 13 + 14",
            ParserContext.create().stronglyTyped().withInput("var1", double.class));
    Map vars = new HashMap();

    double var1 = 1d;
    vars.put("var1", var1);

    OptimizerFactory.setDefaultOptimizer("reflective");
    assertEquals((float) (10 + 11 + 12 / (var1 + 1 + var1 + 51 + 71) * var1 + 13 + 14),
            ((Double) MVEL.executeExpression(s, vars)).floatValue());

    s = MVEL.compileExpression("10 + 11 + 12 / (var1 + 1 + var1 + 51 + 71) * var1 + 13 + 14",
            ParserContext.create().withInput("var1", double.class));
    OptimizerFactory.setDefaultOptimizer("ASM");
    assertEquals((float) (10 + 11 + 12 / (var1 + 1 + var1 + 51 + 71) * var1 + 13 + 14),
            ((Double) MVEL.executeExpression(s, vars)).floatValue());
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
public void testJIRA164() {
    Serializable s = MVEL.compileExpression("1 / (var1 + var1) * var1",
            ParserContext.create().stronglyTyped().withInput("var1", double.class));
    Map vars = new HashMap();
    double var1 = 1d;

    vars.put("var1", var1);

    OptimizerFactory.setDefaultOptimizer("reflective");
    assertEquals((1 / (var1 + var1) * var1), MVEL.executeExpression(s, vars));

    s = MVEL.compileExpression("1 / (var1 + var1) * var1", ParserContext.create().withInput("var1", double.class));
    OptimizerFactory.setDefaultOptimizer("ASM");
    assertEquals((1 / (var1 + var1) * var1), MVEL.executeExpression(s, vars));

}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
public void testJIRA210() {
    Map<String, Object> vars = new LinkedHashMap<String, Object>();
    vars.put("bal", new BigDecimal("999.99"));

    String[] testCases = {"bal - 1 + \"abc\"",};


    Object val1, val2;
    for (String expr : testCases) {
        System.out.println("Evaluating '" + expr + "': ......");
        val1 = MVEL.eval(expr, vars);
        //       System.out.println("'" + expr + " ' = " + ret.toString());
        assertNotNull(val1);
        Serializable compiled = MVEL.compileExpression(expr);
        val2 = executeExpression(compiled, vars);
        //     System.out.println("'" + expr + " ' = " + ret.toString());
        assertNotNull(val2);
        assertEquals("expression did not evaluate correctly: " + expr, val1, val2);
    }
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
public void testJIRA164c() {
    Serializable s = MVEL.compileExpression("1 + 1 / (var1 + var1 + 2 + 3) * var1",
            ParserContext.create().stronglyTyped().withInput("var1", double.class));
    Map vars = new HashMap();

    double var1 = 1d;
    vars.put("var1", var1);

    OptimizerFactory.setDefaultOptimizer("reflective");
    assertEquals((1 + 1 / (var1 + var1 + 2 + 3) * var1), MVEL.executeExpression(s, vars));

    s = MVEL.compileExpression("1 + 1 / (var1 + var1 + 2 + 3) * var1",
            ParserContext.create().withInput("var1", double.class));
    OptimizerFactory.setDefaultOptimizer("ASM");
    assertEquals((1 + 1 / (var1 + var1 + 2 + 3) * var1), MVEL.executeExpression(s, vars));
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
public void testMVEL226() {

        A226 a = new A226();
        Map m = Collections.singletonMap("a", a);
        Map<String, Object> nestMap = Collections.<String, Object>singletonMap("foo", "bar");
        String ex = "a.?map['foo']";
        Serializable s;

        assertNull(MVEL.getProperty(ex, m));

        OptimizerFactory.setDefaultOptimizer("ASM");
        s = MVEL.compileExpression(ex);
        assertNull(MVEL.executeExpression(s, m));
        a.map = nestMap;
        assertEquals("bar", MVEL.executeExpression(s, m));
        a.map = null;

        OptimizerFactory.setDefaultOptimizer(OptimizerFactory.DYNAMIC);

        s = MVEL.compileExpression(ex);
        assertNull(MVEL.executeExpression(s, m));
        a.map = nestMap;
        assertEquals("bar", MVEL.executeExpression(s, m));
    }
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
@Override
   protected Serializable cache() {
try {
    value = MVEL.compileExpression(content, context);
} catch (Exception e) {
    String message = MessageFormatter
	    .arrayFormat("无法将Id为[{}]的字符串[{}]转换为[{}]对象", new Object[] { id, content, clz}).getMessage();
    log.error(message, e);
    throw new IllegalArgumentException(message);
}
return value;
   }
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
@Override
protected Serializable cache() {
	try {
		value = MVEL.compileExpression(content, context);
	} catch (Exception e) {
		String message = MessageFormatter
				.arrayFormat("无法将Id为[{}]的字符串[{}]转换为[{}]对象", new Object[] { id, content, clz }).getMessage();
		log.error(message, e);
		throw new IllegalArgumentException(message);
	}
	return value;
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
protected static Serializable cache(String content) {
	Serializable value = null;
	try {
		value = MVEL.compileExpression(content, context);
	} catch (Exception e) {
		e.printStackTrace();
	}
	return value;
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
private List<Object> translate(String text, TemplateRenderer.OutputContext ctx) {
    if (text == null) return null;
    List<Object> list = new ArrayList<Object>();
    int lastend = 0;
    while (true) {
        int[] se = indexOfExp(text, lastend);
        if (se == null) {
            break;
        }
        if (se[0] > lastend) {
            list.add(text.substring(lastend, se[0]));
        }
        lastend = se[1];

        TemplateRenderer.Var var = new TemplateRenderer.Var();
        var.ctx = ctx;
        var.raw = text.charAt(se[0]) == '#';
        var.exp = MVEL.compileExpression(text.substring(se[0] + 2, se[1] - 1));
        if (ctx == TemplateRenderer.OutputContext.Javascript && se[0] > 0 && se[1] < text.length()) {
            if ((text.charAt(se[0] - 1) == '"' || text.charAt(se[0] - 1) == '\'') || (text.charAt(se[1]) == '"' || text.charAt(se[1]) == '\'')) {
                var.ctx = TemplateRenderer.OutputContext.JavascriptString;
            }
        }
        list.add(var);
    }
    if (lastend < text.length()) {
        list.add(text.substring(lastend));
    }
    return list;
}
 

import org.mvel2.MVEL; //导入方法依赖的package包/类
public CompiledIncludeNode(int begin, String name, char[] template, int start, int end) {
    this.begin = begin;
    this.name = name;
    this.contents = subset(template, this.cStart = start, (this.end = this.cEnd = end) - start - 1);

    int mark;
    cIncludeExpression = MVEL.compileExpression(this.includeExpression = subset(contents, 0, mark = captureToEOS(contents, 0)));
    if (mark != contents.length)
        cPreExpression = MVEL.compileExpression(this.preExpression = subset(contents, ++mark, contents.length - mark));
}