Java MapVariableResolverFactory类代码示例

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的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.integration.impl.MapVariableResolverFactory; //导入依赖的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.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public static void initGlobalContext(Configuration configuration) {
    if(configuration.getGlobalContext()!=null && configuration.getGlobalResolver()==null) {
        synchronized (Configuration.class) {
            if(configuration.getGlobalResolver()==null) {
                MavenLoader.prefetch(configuration.getArtifacts());
                GlobalContext globalContext = configuration.getGlobalContext();
                MapVariableResolverFactory globalResolver = new MapVariableResolverFactory(new HashMap<String, Object>());
                globalResolver.createVariable(VARIABLE_RESOLVER, globalResolver);
                MavenLoader.loadArtifact(globalContext.getArtifacts(), globalResolver);
                Utils.executeExpression(globalContext.getInit(), globalResolver);
                Utils.registerDisposeExpression(globalContext.getDispose(), globalResolver);
                initTimers(globalContext, globalResolver);
                configuration.setGlobalResolver(globalResolver);
            }
        }
    }
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
private static void initTimers(GlobalContext globalContext, MapVariableResolverFactory globalResolver) {
    TimerTask[] timerTasks = globalContext.getTimerTasks();
    if(timerTasks!=null && timerTasks.length>0){
        Timer timer = new Timer();
        globalResolver.createVariable(VARIABLE_GLOBAL_TIMER, timer);
        for(TimerTask timerTask: timerTasks){
            MvelTimerTask mvelTimerTask = new MvelTimerTask(timerTask.getJobExpression(), globalResolver);
            if(timerTask.getFirstTime()!=null && timerTask.getPeriod()!=null){
                timer.schedule(mvelTimerTask, timerTask.getFirstTime(), timerTask.getPeriod());
            } else if(timerTask.getFirstTime()!=null && timerTask.getPeriod()==null){
                timer.schedule(mvelTimerTask, timerTask.getFirstTime());
            } else if(timerTask.getDelay()!=null && timerTask.getPeriod()!=null){
                timer.schedule(mvelTimerTask, timerTask.getDelay(), timerTask.getPeriod());
            } else if(timerTask.getDelay()!=null){
                timer.schedule(mvelTimerTask, timerTask.getDelay());
            }
        }
    }
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
@org.junit.Test
public void mvelScheduler() throws Exception{
    Timer timer = new Timer();
    MapVariableResolverFactory variableResolverFactory = new MapVariableResolverFactory();
    ClassRef[] classRefs = {new ClassRef("org.github.suhorukov.SigarCollect", "SigarCollect")};
    ResourceRef[] resourceRefs = new ResourceRef[0];
    Artifact[] artifacts = {new Artifact("com.github.igor-suhorukov:jvm-metrics:1.1", classRefs, resourceRefs)};
    MavenLoader.loadArtifact(artifacts, variableResolverFactory);
    String mvelScript = "java.lang.String metrics = new SigarCollect().getJsonFullInfo();" +
                        "org.aspectj.aspect.ExecuteTimerTaskTest.setJsonResult(metrics);";
    timer.schedule(new MvelTimerTask(mvelScript, variableResolverFactory), TIMER_DELAY);
    Thread.sleep(TIMER_DELAY*5);
    HashMap metrics = new GsonBuilder().create().fromJson(jsonResult, HashMap.class);
    assertNotNull(jsonResult);
    assertTrue(metrics.containsKey("ProcCpu"));
    assertTrue(metrics.containsKey("Pid"));
    assertTrue(metrics.containsKey("Mem"));
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public void testThisReferenceMapVirtualObjects1() {
    // Create our root Map object
    Map<String, String> map = new HashMap<String, String>();
    map.put("foo", "bar");

    VariableResolverFactory factory = new MapVariableResolverFactory(new HashMap<String, Object>());
    factory.createVariable("this", map);

    OptimizerFactory.setDefaultOptimizer("reflective");

    // Run test
    assertEquals(true,
            executeExpression(compileExpression("this.foo == 'bar'"),
                    map,
                    factory));
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public void testThisReferenceMapVirtualObjects2() {
    // Create our root Map object
    Map<String, String> map = new HashMap<String, String>();
    map.put("foo",
            "bar");

    VariableResolverFactory factory = new MapVariableResolverFactory(new HashMap<String, Object>());
    factory.createVariable("this",
            map);

    // I think we can all figure this one out.

    if (!Boolean.getBoolean("mvel2.disable.jit")) OptimizerFactory.setDefaultOptimizer("ASM");

    // Run test
    assertEquals(true,
            executeExpression(compileExpression("this.foo == 'bar'"),
                    map,
                    factory));
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public void testSataticClassImportViaFactoryAndWithModification() {
    OptimizerFactory.setDefaultOptimizer("ASM");
    MapVariableResolverFactory mvf = new MapVariableResolverFactory(createTestMap());
    ClassImportResolverFactory classes = new ClassImportResolverFactory();
    classes.addClass(Person.class);

    ResolverTools.appendFactory(mvf,
            classes);

    assertEquals(21,
            executeExpression(
                    compileExpression("p = new Person('tom'); p.age = 20; " +
                            "with( p ) { age = p.age + 1 }; return p.age;",
                            classes.getImportedClasses()),
                    mvf));
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public void testTestIntToLong() {
    //System.out.println( int.class.isAssignableFrom( Integer.class ) );
    //Number n = new Integer ( 3 )

    String s = "1+(long)a";

    ParserContext pc = new ParserContext();
    pc.addInput("a", Integer.class);

    ExpressionCompiler compiler = new ExpressionCompiler(s, pc);
    CompiledExpression expr = compiler.compile();

    Map vars = new HashMap();
    vars.put("a", 1);

    Object r = ((ExecutableStatement) expr).getValue(null, new MapVariableResolverFactory(vars));
    assertEquals(new Long(2), r);
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public void testMVEL190() {
    ParserContext context = new ParserContext();
    context.addImport(Ship.class);
    context.addImport(MapObject.class);

    context.addInput("obj", MapObject.class);

    Object compiled = MVEL.compileExpression(
            "((Ship) obj).getName()", context);

    Map<String, Object> vars = new HashMap<String, Object>();
    vars.put("obj", new Ship());

    VariableResolverFactory varsResolver
            = new MapVariableResolverFactory(vars);

    System.out.println(
            executeExpression(compiled, varsResolver));

}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public void testBreakpoints() {
    ExpressionCompiler compiler = new ExpressionCompiler("a = 5;\nb = 5;\n\nif (a == b) {\n\nSystem.out.println('Good');\nreturn a + b;\n}\n");
    System.out.println("-------\n" + compiler.getExpression() + "\n-------\n");

    ParserContext ctx = new ParserContext();
    ctx.setSourceFile("test.mv");
    ctx.setDebugSymbols(true);

    CompiledExpression compiled = compiler.compile(ctx);

    MVELRuntime.registerBreakpoint("test.mv", 7);

    Debugger testDebugger = new Debugger() {
        public int onBreak(Frame frame) {
            System.out.println("Breakpoint [source:" + frame.getSourceName() + "; line:" + frame.getLineNumber() + "]");

            return 0;
        }
    };

    MVELRuntime.setThreadDebugger(testDebugger);

    assertEquals(10, MVEL.executeDebugger(compiled, null, new MapVariableResolverFactory(createTestMap())));
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public boolean isDefinedAt(IBatisRoutingFact routingFact) {
    Validate.notNull(routingFact);
    String namespace = StringUtils.substringBeforeLast(routingFact.getAction(), ".");
    boolean matches = StringUtils.equals(namespace, getTypePattern());
    if (matches) {
        try {
            Map<String, Object> vrs = new HashMap<String, Object>();
            vrs.putAll(getFunctionMap());
            vrs.put("$ROOT", routingFact.getArgument()); // add top object reference for expression
            VariableResolverFactory vrfactory = new MapVariableResolverFactory(vrs);
            if (MVEL.evalToBoolean(getAttributePattern(), routingFact.getArgument(), vrfactory)) {
                return true;
            }
        } catch (Throwable t) {
            logger
                    .info(
                            "failed to evaluate attribute expression:'{}' with context object:'{}'\n{}",
                            new Object[] { getAttributePattern(), routingFact.getArgument(), t });
        }
    }
    return false;
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public boolean isDefinedAt(IBatisRoutingFact routingFact) {
    Validate.notNull(routingFact);
    boolean matches = StringUtils.equals(getTypePattern(), routingFact.getAction());
    if (matches) {
        try {
            Map<String, Object> vrs = new HashMap<String, Object>();
            vrs.putAll(getFunctionMap());
            vrs.put("$ROOT", routingFact.getArgument()); // add top object reference for expression
            VariableResolverFactory vrfactory = new MapVariableResolverFactory(vrs);
            if (MVEL.evalToBoolean(getAttributePattern(), routingFact.getArgument(), vrfactory)) {
                return true;
            }
        } catch (Throwable t) {
            logger
                    .info(
                            "failed to evaluate attribute expression:'{}' with context object:'{}'\n{}",
                            new Object[] { getAttributePattern(), routingFact.getArgument(), t });
        }
    }

    return false;
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
public Integer execute(String columnValue, Map<String, Object> extension) {
    Map<String, Object> vrs = new HashMap<String, Object>();
    //, Map<String, ElFunction<?,?>> functionMap
    //vrs.putAll(functionMap);// 拓展函数
    Map<String, Object> params = new HashMap<String, Object>();
    params.put("value", columnValue);
    vrs.put("$ROOT", params);
    VariableResolverFactory vrfactory = new MapVariableResolverFactory(vrs);
    return MVEL.eval(expression, params, vrfactory, Integer.class);
}
 

import org.mvel2.integration.impl.MapVariableResolverFactory; //导入依赖的package包/类
private VariableResolverFactory createProcessVariableResolver(JoinPoint pjp) {
    VariableResolverFactory variableResolverFactory = new MapVariableResolverFactory();
    Utils.fillResolveParams(aspect.getProcess().getResultParams(), variableResolverFactory);
    variableResolverFactory.createVariable(JOIN_POINT_VARIABLE, pjp);
    variableResolverFactory.createVariable(ContextUtils.VARIABLE_RESOLVER, variableResolverFactory);
    variableResolverFactory.setNextFactory(resolverFactory);
    return variableResolverFactory;
}