Java 中执行动态表达式语句前中后缀Ognl、SpEL、Groovy、Jexl3

• ognl、spel、groovy、jexl3
• 二、ognl
• 三、spel
• 四、jexl/jexl3
• 五、groovy

ognl、spel、groovy、jexl3

  在一些规则集或者工作流项目中，经常会遇到动态解析表达式并执行得出结果的功能。

规则引擎是一种嵌入在应用程序中的组件，它可以将业务规则从业务代码中剥离出来，使用预先定义好的语义规范来实现这些剥离出来的业务规则；规则引擎通过接受输入的数据，进行业务规则的评估，并做出业务决策。

工作流（workflow），是对工作流程及其各操作步骤之间业务规则的抽象、概括描述。 工作流建模，即将工作流程中的工作如何前后组织在一起的逻辑和规则，在计算机中以恰当的模型表達并对其实施计算。 工作流要解决的主要问题是：为实现某个业务目标，利用计算机在多个参与者之间按某种预定规则自动传递文档、信息或者任务。

一、前中后缀简单描述

1、前缀、中缀、后缀表达式(逆波兰表达式)

最早接触的表达式解析是在上数据结构的时候，当时课设作业是 “ 做一个简单的四则混合运算语句解析并计算结果 ”，简单说就是计算器。

2、中缀表达式

将运算符写在两个操作数中间的表达式，称作中缀表达式。

中缀表达式是我们最熟悉和阅读最容易的表达式

比如：12 + 34 + 5 * 6 - 30 / 5

也就是我们常用的数学算式就是用中缀表达式表示的

3、后缀表达式

将运算符写在两个操作数之后的表达式称作后缀表达式。

12 34 + 5 6 * + 30 5 / -

前缀表达式需要从左往右读，遇到一个运算法，则从左边取 2 个操作数进行运算

从左到右读则可分为（（12 34 + ）（5 6 * ）+ ）（30 / 5） -

注：括号只是辅助，实际上没有

4、前缀表达式

前缀表达式是将运算符写在两个操作数之前的表达式。

前缀表达式需要从右往左读，遇到一个运算法，则从右边取 2 个操作数进行运算

12 + 34 + 5 * 6 - 30 / 5

- + + 12 34 * 5 6 / 30 5

中缀：12 + 34 + 5 * 6 - 30 / 5
后缀：12 34 + 5 6 * + 30 5 / -
前缀：- + + 12 34 * 5 6 / 30 5

二、ognl

ognl（object-graph navigation language的简称），对象图导航语言，它是一门表达式语言，除了用来设置和获取java对象的属性之外，另外提供诸如集合的投影和过滤以及lambda表达式等。

引入依赖：

<!-- https://mvnrepository.com/artifact/ognl/ognl -->
<dependency>
    <groupid>ognl</groupid>
    <artifactid>ognl</artifactid>
    <version>3.2.18</version>
</dependency>

memberaccess memberaccess = new abstractmemberaccess() {
    @override
    public boolean isaccessible(map context, object target, member member, string propertyname) {
        int modifiers = member.getmodifiers();
        return modifier.ispublic(modifiers);
    }
};

ognlcontext context = (ognlcontext) ognl.createdefaultcontext(this,
    memberaccess,
    new defaultclassresolver(),
    new defaulttypeconverter());

context.put("verifystatus", 1);
object expression = ognl.parseexpression("#verifystatus == 1");
boolean result =(boolean) ognl.getvalue(expression, context, context.getroot());
assert.asserttrue(result);

三、spel

spel(spring expression language)，即spring表达式语言。它是一种类似jsp的el表达式、但又比后者更为强大有用的表达式语言。

expressionparser parser = new spelexpressionparser();
expression expression = parser.parseexpression("#verifystatus == 1");

evaluationcontext context = new standardevaluationcontext();
context.setvariable("verifystatus", 1);
boolean result = (boolean) expression.getvalue(context);
assert.asserttrue(result);

四、jexl/jexl3

引入依赖：

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-jexl3 -->
<dependency>
    <groupid>org.apache.commons</groupid>
    <artifactid>commons-jexl3</artifactid>
    <version>3.1</version>
</dependency>

执行简单的表达式：

jexlengine jexl = new jexlbuilder().create();
jexlcontext jc = new mapcontext();
jc.set("verifystatus", 1);
jexlexpression expression = jexl.createexpression("verifystatus == 1");
boolean result = (boolean) expression.evaluate(jc);
assert.asserttrue(result);

五、groovy

groovy 是一个很好的选择，其具备完备的 groovy 和 java 语法的解析执行功能。

引入依赖, 这个可以根据需要引入最新版本

<!-- https://mvnrepository.com/artifact/org.codehaus.groovy/groovy -->
<dependency>
    <groupid>org.codehaus.groovy</groupid>
    <artifactid>groovy</artifactid>
    <version>2.5.6</version>
</dependency>

执行表达式：

binding binding = new binding();
binding.setvariable("verifystatus", 1);
groovyshell shell = new groovyshell(binding);
boolean result = (boolean) shell.evaluate("verifystatus == 1");
assert.asserttrue(result);

六、扩展

经常用 mybatis 的一定用过动态语句

<select id="getlist" 
    resultmap="userbasemap"
    parametertype="com.xx.param">
    select
        id, invite_code, phone, name
    from user
    where status = 1
    <if test="_parameter != null">
        <if test="invitecode !=null and invitecode !='' ">
            and invite_code = #{invitecode}
        </if>
    </if>
</select>

这里我们简化一下

该示例主要为了讲解，不一定好用, 其中 @if 与上面的 <if> 等效

select id, invite_code, phone, name 
from user 
where status = 1 
@if(:invitecode != null) { and invite_code = :invitecode }

在处理这种 sql 中，我们可以先用正则，将 @if 与 正常语句分割开

list<string> results = stringutil.matches(sql, "@if([\\s\\s]*?)}");

通过这种方式匹配到 @if(:invitecode != null) { and invite_code = :invitecode }

然后将需要执行计算的表达式与要拼接的 sql 分离出

string text = "@if(:invitecode != null) { and invite_code = :invitecode }";

list<string> sqlfragment = stringutil.matches(text, "\\(([\\s\\s]*?)\\)|\\{([\\s\\s]*?)\\}");

分离出

• :invitecode != null
• and invite_code = :invitecode
  

其中 :invitecode != null 是需要动态处理的语句，对于 :invitecode != null 我们需要识别出，那些是需要进行复制的变量名称

list<string> sqlfragmentparam = stringutil.matches(":invitecode != null", "\\?\\d+(\\.[a-za-z]+)?|:[a-za-z0-9]+(\\.[a-za-z]+)?");

得到 invitecode，并通过某种方式找到对应的值，

具体代码，仅供参考：

jexlengine jexl = new jexlbuilder().create();
jexlcontext jc = new mapcontext();
jc.set(":invitecode", "ddddsdfa");
jexlexpression expression = jexl.createexpression(sqlexp);
boolean needappendsql = (boolean) expression.evaluate(jc);

通过 needappendsql 来决定是否拼接 sql, 这样一个简单的动态 sql 就实现了，上面用的 jexl 写的，你可以改成上面任意一种方案，这里只做演示

@test
public void testsql() {
  string sql = "select id, invite_code, phone, name \n"
  + "from user \n"
  + "where status = 1 \n"
  + "@if(:invitecode != null) { and invite_code = :invitecode }";

  map<string, object> params = new hashmap<string, object>();
params.put("invitecode", "dd");

  system.out.println(parsejexl(sql, params));
}

public string parsejexl(string jexlsql, map<string, object> params) {

  // 判断是否包含 @if
  list<string> results = stringutil.matches(jexlsql, "@if([\\s\\s]*?)}");
  if (results.isempty()) {
      return jexlsql;
  }

  jexlengine jexl = new jexlbuilder().create();
  jexlcontext jc = new mapcontext();

  for (string e : results) {
    list<string> sqlfragment = stringutil.matches(e, "\\(([\\s\\s]*?)\\)|\\{([\\s\\s]*?)\\}");
    string sqlexp = sqlfragment.get(0).trim().substring(1, sqlfragment.get(0).length() - 1);
    list<string> sqlfragmentparam = stringutil.matches(sqlexp, "\\?\\d+(\\.[a-za-z]+)?|:[a-za-z0-9]+(\\.[a-za-z]+)?");
    for (string param : sqlfragmentparam) {
      string newsqlexp = "_" + param.substring(1);
      sqlexp = sqlexp.replace(param, newsqlexp);
      jc.set(newsqlexp, params.get(param.substring(1)));
    }
    jexlexpression expression = jexl.createexpression(sqlexp);
    boolean needappendsql = (boolean) expression.evaluate(jc);
    if (needappendsql) {
      jexlsql = jexlsql.replace(e, sqlfragment.get(1).trim().substring(1, sqlfragment.get(1).length() - 1));
    } else {
      jexlsql = jexlsql.replace(e, "");
    }
  }
  return jexlsql;
}

以上就是java 中执行动态表达式语句前中后缀ognl、spel、groovy、jexl3的详细内容，更多关于java ognl spel groovy jexl3的资料请关注其它相关文章！