首页｜我的编程技术分享 | Java表达式引擎解析与实用工具

Java表达式引擎解析与实用工具

37 次阅读，发布于 : 2024-12-27

Java表达式引擎解析与实用工具
================

在开发涉及表单或流程的系统时，设计高效的表达式和规则引擎至关重要。这些工具能简化业务逻辑处理，并增强流程的动态性。本文将梳理几种主流的表达式引擎，帮助开发者在选型时更有针对性。

以下内容既适合初次接触的开发者，也能为熟悉相关技术的读者提供新的视角。

Spring EL
---------

### 资源链接

*   [Spring EL 官方文档](https://docs.spring.io/spring-framework/reference/core/expressions.html)
    
*   [Spring EL 示例代码](https://github.com/spring-projects/spring-framework/tree/master/spring-expression)

### 特点概述

Spring Expression Language (SpEL) 是 Spring 框架内置的表达式语言，支持丰富的功能：

*   **灵活性强：** 动态操作对象属性、方法调用、运算逻辑均可实现。
    
*   **深度集成：** 可与 Spring Security、Spring Data 等模块无缝协作。
    
*   **语法便捷：** 使用 `#{}` 包裹表达式，支持复杂逻辑计算。
    
*   **类型转换：** 内置强大的类型转换机制。
    
*   **安全管控：** 通过定制 ExpressionParser 限制表达式行为范围。

### 示例用法

#### 属性访问
```
#{bean.property}
```
#### 方法调用
```
#{bean.method(param)}
```
#### 条件运算
```
#{condition ? trueValue : falseValue}
```
### 实用工具类
```
public class SpringELUtil {
    private static final SpelExpressionParser PARSER = new SpelExpressionParser();

private SpringELUtil() {}

public static <T> T evaluate(Map<String, Object> variables, String expression, Class<T> returnType) {
        StandardEvaluationContext context = new StandardEvaluationContext(variables);
        variables.forEach(context::setVariable);
        return PARSER.parseExpression(expression).getValue(context, returnType);
    }

public static void main(String[] args) {
        Map<String, Object> vars = new HashMap<>();
        vars.put("name", "example");
        System.out.println(evaluate(vars, "#root.get('name')", String.class));
    }
}
```
OGNL
----

### 资源链接

*   [OGNL 官方文档](https://ognl.orphan.software/language-guide)
    
*   [OGNL 示例代码](https://github.com/orphan-oss/ognl)

### 特点概述

OGNL (Object-Graph Navigation Language) 是一种表达式语言，适合操作复杂对象图。常用于 Apache Struts2 等框架。主要特点包括：

*   **语法清晰：** 支持 `object.property` 形式的属性访问。
    
*   **链式调用：** 可深入对象层级操作。
    
*   **集合处理：** 提供集合过滤与映射功能。
    
*   **方法调用：** 允许创建新对象并调用其方法。

### 实用工具类
```
public class OGNLUtil {
    private OGNLUtil() {}

public static <T> T evaluate(Map<String, Object> context, String expression, Class<T> returnType) {
        Object result = OgnlCache.getValue(expression, context);
        if (result != null && returnType.isAssignableFrom(result.getClass())) {
            return returnType.cast(result);
        }
        return null;
    }

public static void main(String[] args) {
        Map<String, Object> vars = new HashMap<>();
        vars.put("name", "example");
        System.out.println(evaluate(vars, "#root.name", String.class));
    }
}
```
Aviator
-------

### 资源链接

*   [Aviator 官方文档](http://fnil.net/aviator/)
    
*   [Aviator 示例代码](https://github.com/killme2008/aviatorscript)

### 特点概述

Aviator 是高性能表达式引擎，特别适合对性能敏感的场景。

*   **速度快：** 内置 JIT 编译优化。
    
*   **易用性高：** API 简洁明了。
    
*   **安全性强：** 提供沙箱机制。
    
*   **可扩展性：** 支持自定义函数。

### 实用工具类
```
public class AviatorUtil {
    private AviatorUtil() {}

public static <T> T evaluate(Map<String, Object> env, String expression, Class<T> returnType) {
        Object result = AviatorEvaluator.execute(expression, env);
        if (result != null && returnType.isAssignableFrom(result.getClass())) {
            return returnType.cast(result);
        }
        return null;
    }

### 资源链接

*   [Hutool Expression API](https://doc.hutool.cn/pages/ExpressionUtil/#%E4%BB%8B%E7%BB%8D)

### 特点概述

Hutool 从 5.5.0 开始提供统一的表达式引擎门面，兼容多种引擎，如：

*   Aviator
    
*   Apache Jexl3
    
*   MVEL
    
*   SpEL
    
*   Rhino

### 实用工具类
```
public class HutoolExpressionUtil {
    private HutoolExpressionUtil() {}

public static <T> T evaluate(Map<String, Object> vars, String expression, Class<T> returnType) {
        try {
            Object result = ExpressionUtil.eval(expression, vars);
            if (result != null && returnType.isAssignableFrom(result.getClass())) {
                return returnType.cast(result);
            }
        } catch (Exception e) {
            throw new RuntimeException("Expression evaluation failed: " + expression, e);
        }
        return null;
    }

public static void main(String[] args) {
        Map<String, Object> vars = new HashMap<>();
        vars.put("name", "example");
        System.out.println(evaluate(vars, "root.name", String.class));
    }
}
```
总结
--

不同的表达式引擎在功能和性能上各具特色。本文列举的工具及其实现方式可作为开发的参考，结合实际需求选用合适的解决方案。如果对多个引擎有需求，Hutool 提供的统一 API 是一个不错的选择。