Jexl表达式引擎的学习-string语句转java可执行

最新推荐文章于 2024-05-24 17:41:11 发布
最新推荐文章于 2024-05-24 17:41:11 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chanyuanjian5703/article/details/107953144
版权

Java将字符串转换成可执行代码

commons-jexl3新版本

注意区分JexlScript和JexlExpression，

  • JexlExpression可以支持多条语句，并返回最后一句执行结果。
  • JexlExpression支持一条，返回当前条执行结果
  • JexlExpression set = JEXL_ENGINE.createExpression(“pub.aString = value;pub.aString = value;”);

在这里插入图片描述

		<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-jexl3 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-jexl3</artifactId>
			<version>3.1</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.13</version>
			<scope>test</scope>
		</dependency>

package com.example.demo1.test7;

import org.apache.commons.jexl3.JexlBuilder;
import org.apache.commons.jexl3.JexlContext;
import org.apache.commons.jexl3.JexlEngine;
import org.apache.commons.jexl3.JexlException;
import org.apache.commons.jexl3.JexlExpression;
import org.apache.commons.jexl3.JexlScript;
import org.apache.commons.jexl3.MapContext;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

/**
 * @author crwu
 */
public class Test2 {


    private static final JexlEngine JEXL_ENGINE = new JexlBuilder().strict(true).silent(false).cache(32).create();

    // some constants
    private static final String LOWER42 = "fourty-two";
    private static final String UPPER42 = "FOURTY-TWO";


    /**
     * An Inner class.
     */
    public static class Inner {
        public static double aDouble = 42.0;
        public static double NOT42 = -42.0;
    }


    /**
     * A Struct, all fields public
     */
    public static class Struct {
        public Inner inner = new Inner();
        public int anInt = 42;
        public String aString = LOWER42;
    }


    // a pub instance
    private Struct pub;
    // the JexlContext to use
    private JexlContext ctxt;

    @Before
    public void setUp() {
        pub = new Struct();
        ctxt = new MapContext();
        ctxt.set("pub", pub);
    }

    @Test
    public void testGetInt() throws Exception {
        JexlExpression get = JEXL_ENGINE.createExpression("pub.anInt");
        Assert.assertEquals(42, get.evaluate(ctxt));
        JEXL_ENGINE.setProperty(pub, "anInt", -42);
        Assert.assertEquals(-42, get.evaluate(ctxt));
    }

    @Test
    public void testSetInt() throws Exception {
        JexlExpression set = JEXL_ENGINE.createExpression("pub.anInt = value");
        ctxt.set("value", -42);
        Assert.assertEquals(-42, set.evaluate(ctxt));
        Assert.assertEquals(-42, JEXL_ENGINE.getProperty(pub, "anInt"));
        ctxt.set("value", 42);
        Assert.assertEquals(42, set.evaluate(ctxt));
        Assert.assertEquals(42, JEXL_ENGINE.getProperty(pub, "anInt"));
        try {
            ctxt.set("value", UPPER42);
            Assert.assertEquals(null, set.evaluate(ctxt));
            Assert.fail("should have thrown");
        } catch (JexlException xjexl) {
            xjexl.printStackTrace();
        }
    }

    @Test
    public void testGetString() throws Exception {
        JexlExpression get = JEXL_ENGINE.createExpression("pub.aString");
        Assert.assertEquals(LOWER42, get.evaluate(ctxt));
        JEXL_ENGINE.setProperty(pub, "aString", UPPER42);
        Assert.assertEquals(UPPER42, get.evaluate(ctxt));
    }

    @Test
    public void testSetString() throws Exception {
        JexlExpression set = JEXL_ENGINE.createExpression("pub.aString = value;");
        ctxt.set("value", UPPER42);
        Assert.assertEquals(UPPER42, set.evaluate(ctxt));
        Assert.assertEquals(UPPER42, JEXL_ENGINE.getProperty(pub, "aString"));
        ctxt.set("value", LOWER42);
        Assert.assertEquals(LOWER42, set.evaluate(ctxt));
        Assert.assertEquals(LOWER42, JEXL_ENGINE.getProperty(pub, "aString"));
    }

    @Test
    public void testGetInnerDouble() throws Exception {
        JexlExpression get = JEXL_ENGINE.createExpression("pub.inner.aDouble");
        Assert.assertEquals(42.0, get.evaluate(ctxt));
        JEXL_ENGINE.setProperty(pub, "inner.aDouble", -42);
        Assert.assertEquals(-42.0, get.evaluate(ctxt));
    }

    @Test
    public void testSetInnerDouble() throws Exception {
        JexlExpression set = JEXL_ENGINE.createExpression("pub.inner.aDouble = value");
        ctxt.set("value", -42.0);
        Assert.assertEquals(-42.0, set.evaluate(ctxt));
        Assert.assertEquals(-42.0, JEXL_ENGINE.getProperty(pub, "inner.aDouble"));
        ctxt.set("value", 42.0);
        Assert.assertEquals(42.0, set.evaluate(ctxt));
        Assert.assertEquals(42.0, JEXL_ENGINE.getProperty(pub, "inner.aDouble"));
        try {
            ctxt.set("value", UPPER42);
            Assert.assertEquals(null, set.evaluate(ctxt));
            Assert.fail("should have thrown");
        } catch (JexlException xjexl) {
        }
    }

    public enum Gender {MALE, FEMALE}


    @Test
    public void testGetEnum() throws Exception {
        ctxt.set("gender", Gender.class);
        String src = "x = gender.MALE;y = gender.FEMALE;";
        JexlScript script = JEXL_ENGINE.createScript(src);
        Object result = script.execute(ctxt);
        // 返回最后一个语句的结果
        System.out.println(result);
        Assert.assertEquals(Gender.MALE, ctxt.get("x"));
        Assert.assertEquals(Gender.FEMALE, ctxt.get("y"));
    }

    @Test
    public void testGetStaticField() throws Exception {
        ctxt.set("Inner", Inner.class);
        String src = "x = Inner.NOT42;y = Inner.aDouble;";
        JexlScript script = JEXL_ENGINE.createScript(src);
        Object result = script.execute(ctxt);
        // 返回最后一个语句的结果
        System.out.println(result);
        Assert.assertEquals(Inner.NOT42, ctxt.get("x"));
        Assert.assertEquals(Inner.aDouble, ctxt.get("y"));
    }
    @Test
    public void testWhile() throws Exception {
        JexlContext jc = new MapContext();
        jc.set("a", 1);
        jc.set("b", "0");
        jc.set("ans", new StringBuffer());
        JexlScript e = JEXL_ENGINE.createScript("while (a < 10) {a = a + 1;ans.append(b);}");
        e.execute(jc);
        System.out.println(jc.get("ans"));
    }

}

commons-jexl老版本

https://blog.csdn.net/weixin_38019299/article/details/85798768

		<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-jexl -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-jexl</artifactId>
			<version>2.1.1</version>
		</dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-collections4</artifactId>
			<version>4.4</version>
		</dependency>

package com.example.demo1.test7;

import org.apache.commons.collections4.MapUtils;
import org.apache.commons.jexl2.Expression;
import org.apache.commons.jexl2.JexlContext;
import org.apache.commons.jexl2.JexlEngine;
import org.apache.commons.jexl2.MapContext;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * @author crwu
 */
public class Test {
    public String getA() {
        return a;
    }
    public void setA(String a) {
        this.a = a;
    }
    private String a;
    private static JexlEngine jexlEngine = new JexlEngine();
    public static void main(String[] args) {
        // t1();
        // t2();
        // t3();
        // t4();
        // t5();
        // t6();
        t7();

    }
    public static void t7() {
        Test tmpTest = new Test();
        tmpTest.setA("1");
        JexlContext jc = new MapContext();
        jc.set("tmpTest", tmpTest);
        jc.set("ans", "");
        Expression e = jexlEngine.createExpression("ans = tmpTest.getA()");
        e.evaluate(jc);
        System.out.println(jc.get("ans"));
        System.out.println("============================");
        e = jexlEngine.createExpression("ans = tmpTest.setA(\"2\")");
        e.evaluate(jc);
        Test tmpTest1 = (Test) jc.get("tmpTest");
        System.out.println(tmpTest1.getA());
    }
    public static void t6() {
        JexlContext jc = new MapContext();
        String str = "一二三四五六七八九十";
        jc.set("Util", new Util());
        jc.set("str", str);
        jc.set("ans", "");
        String expression = "ans = Util.regMatch(\"[\u4e00-\u9fa5]{10,}\",str)";
        Expression e = new JexlEngine().createExpression(expression);
        e.evaluate(jc);
        System.out.println(jc.get("ans"));
    }
    private static void t5() {
        JexlContext jc = new MapContext();
        jc.set("a", 1);
        jc.set("b", "0");
        jc.set("ans", new StringBuffer());
        Expression e = jexlEngine.createExpression("while (a < 10) {a = a + 1;ans.append(b);}");
        e.evaluate(jc);
        System.out.println(jc.get("ans"));
    }
    private static void t4() {
        JexlContext context = new MapContext();//创建Context设值对象
        String expressionStr = "array.size()";//表达式，表达式可以是数组的属性，元素等
        List<Object> array = new ArrayList<Object>();//创建一个列表
        array.add("this is an array");
        array.add(new Integer(0));
        context.set("array", array);//使用context对象将表达式中用到的值设置进去，必须是所有用到的值
        Expression expression = jexlEngine.createExpression(expressionStr);//使用引擎创建表达式对象
        Object o = expression.evaluate(context);//使用表达式对象开始计算
        System.out.println(o);//输出：2
    }

    private static void t3() {
        JexlContext jc = new MapContext();
        jc.set("x", 10);
        jc.set("y", 20);
        Expression e = jexlEngine.createExpression("x - y");
        Object result = e.evaluate(jc);
        System.out.println(result);
    }
    private static void t2() {
        Expression e = jexlEngine.createExpression("10 > 5 && \"test jexl\".contains(\"test\")");
        Object result = e.evaluate(null);
        System.out.println(result);
    }
    private static void t1() {
        Map<String, Object> map = new HashMap<>();
        map.put("alive", "coding every day");
        map.put("err", System.err);
        String expression = "err.print(alive)";
        Test.executeExpression(expression, map);
    }

    public static Object executeExpression(String jexlExpression, Map<String, Object> map) {
        Expression expression = jexlEngine.createExpression(jexlExpression);
        JexlContext context = new MapContext();
        if (MapUtils.isNotEmpty(map)) {
            // map.forEach(context::set);
            map.forEach((s, o) -> context.set(s, o));
        }
        return expression.evaluate(context);
    }
    static class Util {
        public static boolean regMatch(String regEx, String str) {
            Pattern pattern = Pattern.compile(regEx);
            return pattern.matcher(str).matches();
        }
    }
}
wcr0537
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java解析表达式JEXL实现办法
04-06
NULL 博文链接：https://wuniu2010.iteye.com/blog/1544253
表达式引擎fel-0.9版本
12-29
6. **API集成**：Fel-all-0.9.tar.gz文件包含了一个完整的Fel引擎包，很可能提供了方便的Java API，使得开发者能够轻松地将Fel引擎集成到Java项目中，进行表达式的创建、编译和执行。 7. **扩展性**：Fel引擎可能...
commons-jexl3 用法示例
festone000的专栏
03-22 6118
这个库可以用来做强大无比的规则引擎，懂的都懂，不理解的多说也无用。 jexl版本信息： <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-jexl3</artifactId> <version>3.1</version> </depende
Java Apache Jexl规则引擎初体验
最新发布
weixin_44826433的博客
05-24 1185
Apache Jexl规则引擎
Java代码中执行字符串逻辑表达式，即将字符串转换成可执行代码
点点一哈的博客
02-04 992
最近遇到的需求，前端传来一系列数据，其中包括比较符，类似==、>=、!=等比较符号，由客户选择，由于不想使用繁琐的switch/case，以及不想日后需求变动导致的比较符增加而改动代码，便想办法将表达式拼接成字符串，再代码执行得到比较结果。 参考原博客：https://www.dazhuanlan.com/2020/05/30/5ed1dd2cd84cb/ 原博客的写法中，ScriptEngineManager构造参数不填，这种写法在main方法中执行没毛病，而在工程项目代码中有问题。 代码如下
JexlEngine和ScriptEngine 执行顺序问题
zjy660358的专栏
08-23 352
有着计算机基础的，应该心算一下，就知道的是false，可实际结果。JexlEngine一样存在这个问题。我开始怀疑我的计算机常识。怀疑&& 比 || 更早执行，做测试。再来简洁一点，找到问题所在。对的呀，并级，左结合。
使用commons-jexl把string解析为可执行的Java语句
北京第三区交通委的博客
03-23 883
使用commons-jexl把string解析为可执行的Java语句
JEXL 简介
Angellyouran的专栏
11-28 3494
JEXL 简介
Java 第三阶段增强分析需求，代码实现能力【正则表达式】---- 代码
08-28
Java 第三阶段增强分析需求，代码实现能力【正则表达式】---- 代码 Java 第三阶段增强分析需求，代码实现能力【正则表达式】---- 代码 Java 第三阶段增强分析需求，代码实现能力【正则表达式】---- 代码 Java 第三...
DFA-Regex:Java中的DFA正则表达式引擎
05-07
DFA正则表达式 Java中的DFA regex引擎。 Pom设定 < groupId>top.yatt.dfargx < artifactId>dfargx < version>0.2.1 介绍 这是Java DFA regex引擎的实现。 高兼容性-单个jar库，无第3个依赖项 高性能-O（n）...
Fel Javael表达式引擎
10-17
Fel轻量级的高效的表达式计算引擎。 Fel在源自于企业项目,设计目标是为了不断变化的功能需求和性能需求.文档中有个别错误，但不影响阅读
jexl实例下载
04-10
jexl实例下载
apache commons jexl 表达解析工具
08-03
apache commons jexl 表达解析工具
Java switch 语句如何使用 String 参数
08-25
但是，从 Java 7 开始，switch 语句也支持使用 String 类型作为条件表达式。 在 Java 7 之前，如果我们尝试使用 String 参数在 switch 语句中，编译器将报告错误，指出“Cannot switch on a value of type String ...
java字符串表达式转换成可执行代码
Talk is cheap. Show me the code.
02-20 3174
在很多编程语言中都有eval函数,将"字符串"转换成执行的代码，并执行。 java中想要做这样的事情，需要引入其他"动态语言"才能实现类似效果。 比如可以 java调用内置的 jsEngine或groovyEngine。 需求比较简单，只是把字符串的数学公式求值，也可以使用 apache的commons-jexl3。 commons-jexl3 Demo 依赖 <!-- 解析表达式 --...
Java执行脚本代码，Java将字符串转换为代码执行
二饭的博客
07-21 2670
Java执行脚本内容，支持将客户端用户输入的文字内容在JVM中实时执行，并返回结果；还可以设置变量进行格式化或赋值计算。
利用JEXL实现动态表达式编译
热门推荐
Narcssus的专栏
02-23 2万+
JEXL
Java8使用ScriptEngine动态执行js及规则引擎jexl3、groovy的使用
Jaemon
08-26 4968
Java8使用ScriptEngine动态执行js及规则引擎jexl3、groovy的使用
Java Expression Language (JEXL)
谨慎对事 低调行事 0与1的世界 浩瀚如海 学无止境
04-18 3072
Official Website JEXL is a library intended to facilitate the implementation of dynamic and scripting features in applications and frameworks written in Java. JEXL implements an Expression Language

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值