Java | 在 Java 中执行动态表达式语句: 前中后缀、SpEL、OGNL、Groovy、Jexl3

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《Java | 在 Java 中执行动态表达式语句: 前中后缀、SpEL、OGNL、Groovy、Jexl3》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下MySQL、Java、groovy，希望所有认真读完的童鞋们，都有实质性的提高。

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

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

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

Table of Contents

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

  • 中缀表达式
  • 后缀表达式
  • 前缀表达式
• OGNL
• SpEL
• Jexl/Jexl3
• 执行简单的表达式

• Groovy

  • 执行表达式
• 扩展
• 参考

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

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

中缀表达式

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

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

比如：

ognlognl3.2.18

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

引入依赖

org.apache.commonscommons-jexl33.1

执行简单的表达式

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 语法的解析执行功能。

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

org.codehaus.groovygroovy2.5.6

执行表达式

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, invite_code, phone, name
    from user
    where status = 1
    
            and invite_code = #{inviteCode}
        

这里我们简化一下

该示例主要为了讲解，不一定好用, 其中

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

在处理这种 SQL 中，我们可以先用正则，将

List results = StringUtil.matches(sql, "@if([\\s\\S]*?)}");

通过这种方式匹配到

String text = "@if(:inviteCode != null) { and invite_code = :inviteCode }";

List sqlFragment = StringUtil.matches(text, "\\(([\\s\\S]*?)\\)|\\{([\\s\\S]*?)\\}");

分离出

• :inviteCode != null
• and invite_code = :inviteCode

其中

List 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 params = new HashMap();
params.put("inviteCode", "dd");

  System.out.println(parseJexl(sql, params));
}

public String parseJexl(String jexlSql, Map params) {

  // 判断是否包含 @if
  List 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 sqlFragment = StringUtil.matches(e, "\\(([\\s\\S]*?)\\)|\\{([\\s\\S]*?)\\}");
    String sqlExp = sqlFragment.get(0).trim().substring(1, sqlFragment.get(0).length() - 1);
    List 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;
}

参考

关于 OGNL、SpEL、Jexl3 和 Groovy 的具体用法可以参考文档

• http://commons.apache.org/pro...
• https://docs.spring.io/spring...
• http://groovy-lang.org/syntax...
• http://commons.apache.org/pro...

今天关于《Java | 在 Java 中执行动态表达式语句: 前中后缀、SpEL、OGNL、Groovy、Jexl3》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！