Java在Java中执⾏动态表达式语句：前中后缀、Ognl、SpEL、
Groovy、Jexl3
在⼀些规则集或者⼯作流项⽬中，经常会遇到动态解析表达式并执⾏得出结果的功能。
规则引擎是⼀种嵌⼊在应⽤程序中的组件，它可以将业务规则从业务代码中剥离出来，使⽤预先定义好的语义规范来实现这些剥离出来的业务规则；规则引擎通过接受输⼊的数据，进⾏业务规则的评估，并做出业务决策。
⼯作流（Workflow），是对⼯作流程及其各操作步骤之间业务规则的抽象、概括描述。⼯作流建模，即将⼯作流程中的⼯作如何前后组织在⼀起的逻辑和规则，在计算机中以恰当的模型表達并对其实施计算。⼯作流要解决的主要问题是：为实现某个业务⽬标，利⽤计算机在多个参与者之间按某种预定规则⾃动传递⽂档、信息或者任务。
Table of Contents
⽬录
前缀、中缀、后缀表达式(逆波兰表达式)
最早接触的表达式解析是在上数据结构的时候，当时课设作业是 “ 做⼀个简单的四则混合运算语句解析并计算结果 ”，简单说就是计算器。
中缀表达式
将运算符写在两个操作数中间的表达式，称作中缀表达式。
中缀表达式是我们最熟悉和阅读最容易的表达式
⽐如：12 + 34 + 5 * 6 - 30 / 5
也就是我们常⽤的数学算式就是⽤中缀表达式表⽰的
后缀表达式
将运算符写在两个操作数之后的表达式称作后缀表达式。
12 34 + 5 6 * + 30 5 / -
前缀表达式需要从左往右读，遇到⼀个运算法，则从左边取 2 个操作数进⾏运算
从左到右读则可分为
（（12 34 + ）（5 6 * ）+ ）（30 / 5） -
括号只是辅助，实际上没有
前缀表达式
前缀表达式是将运算符写在两个操作数之前的表达式。
前缀表达式需要从右往左读，遇到⼀个运算法，则从右边取 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表达式等。
引⼊依赖
<!-- mvnrepository/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 = Modifiers();
return Modifier.isPublic(modifiers);
}
};
OgnlContext context = (OgnlContext) ateDefaultContext(this,
memberAccess,
new DefaultClassResolver(),
new DefaultTypeConverter());
context.put("verifyStatus", 1);
Object expression = Ognl.parseExpression("#verifyStatus == 1");
boolean result =(boolean) Value(expression, context, Root());
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) Value(context);
Assert.assertTrue(result);
Jexl/Jexl3
引⼊依赖
<!-- mvnrepository/artifact/org.apachemons/commons-jexl3 -->
<dependency>
<groupId>org.apachemons</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 = ateExpression("verifyStatus == 1");
boolean result = (boolean) expression.evaluate(jc);
Assert.assertTrue(result);
Groovy
Groovy 是⼀个很好的选择，其具备完备的 Groovy 和 Java 语法的解析执⾏功能。
引⼊依赖, 这个可以根据需要引⼊最新版本
<!-- mvnrepository/vy/groovy -->
<dependency>
<groupId&vy</groupId>
<artifactId>groovy</artifactId>
<version>2.5.6</version>
</dependency>
执⾏表达式
Binding binding = new Binding();
binding.setVariable("verifyStatus", 1);
用java编写一个简单的计算器GroovyShell shell = new GroovyShell(binding);
boolean result = (boolean) shell.evaluate("verifyStatus == 1");
Assert.assertTrue(result);
扩展
经常⽤ MyBatis 的⼀定⽤过动态语句
<select id="getList"
resultMap="UserBaseMap"
parameterType="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 = ateExpression(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 = (0).trim().substring(1, (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 = place(param, newSQLExp);
jc.set(newSQLExp, (param.substring(1)));
}
JexlExpression expression = ateExpression(sqlExp);
Boolean needAppendSQL = (Boolean) expression.evaluate(jc);
if (needAppendSQL) {
jexlSql = place(e, (1).trim().substring(1, (1).length() - 1));    } else {
jexlSql = place(e, "");
}
}
return jexlSql;
}
参考
关于 OGNL、SpEL、Jexl3 和 Groovy 的具体⽤法可以参考⽂档