Spring EL 表达式简单介绍和使用

发表于 分类于 ， Valine：

SpringEL 介绍

Spring3 中引入了 Spring 表达式语言 ——Spring EL。

Spring EL 是一种强大，简洁的装配 Bean 的方式，他可以通过运行期间执行的表达式将值装配到我们的属性或构造函数当中，更可以调用 JDK 中提供的静态常量，获取外部 Properties 文件中的的配置。

SpringEL 优点

Spring EL 功能非常强大，在 Annotation 的方式开发时可能感觉并不强烈，因为可以直接编写到源代码来实现 Spring EL 的功能，但如果是在 XML 文件中进行配置，Spring EL 可以弥补 XML 静态注入的不足，从而实现更强大的注入。

SpringEL 缺点

Spring EL 在使用时仅仅是一个字符串，不易于排错与测试，也没有 IDE 检查我们的语法（目前 DIEA 可以检测 EL 语言），当出现错误时较难检测。

SpringEL 简单使用

String expressionStr = "'hello world'.toUpperCase().substring(1,5)";
//指定SpelExpressionParser解析器实现类
ExpressionParser parser = new SpelExpressionParser();
//解析表达式
Expression expression = parser.parseExpression(expressionStr);
System.out.println(expression.getValue());	// ELLO

SpringEL 参数传递

String expressionStr = "#info.toUpperCase().substring(#start, #end)";
ExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression(expressionStr);
//设置对象模型基础
EvaluationContext context = new StandardEvaluationContext();
context.setVariable("info", "XiaoJueee");
context.setVariable("start", 1);
context.setVariable("end", 5);
System.out.println(expression.getValue(context));

SpringEL 带缓存工具方法

Spring EL 表达式解析：

import org.apache.commons.lang3.StringUtils;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Spring EL 表达式解析
 */
public class ExpressionUtils {

    private static final ExpressionParser EXPRESSION_PARSER = new SpelExpressionParser();

    private static final Map<String, Expression> EXPRESSION_CACHE = new ConcurrentHashMap<>();

    /**
     * 获取解析后的表达式
     *
     * @param expression EL表达式字符串
     * @return 解析后的表达式，如果之前已经解析过，则返回缓存的表达式
     */
    public static Expression getExpression(String expression) {
        if (StringUtils.isBlank(expression)) {
            return null;
        }
        expression = expression.trim();
        return EXPRESSION_CACHE.computeIfAbsent(expression, EXPRESSION_PARSER::parseExpression);
    }
}

测试调用 Java 方法：

String root = "Hello World";
String expression1 = "length()";
Expression expr1 = ExpressionUtils.getExpression(expression1);
Object sourceType1 = Objects.requireNonNull(expr1).getValue(root, Object.class);
System.out.println(sourceType1); // 11

测试调用 Java 方法并解析处理：

String root = "Hello World";
String expression2 = "split(' ')";
Expression expr2 = ExpressionUtils.getExpression(expression2);
Object sourceType2 = Objects.requireNonNull(expr2).getValue(root, Object.class);
List<Object> preList = new LinkedList<>();
if (sourceType2 instanceof Object[]) {
    Object[] objects = (Object[]) sourceType2;
    for (int i = 0; i < objects.length; i++) {
        preList.add(objects[i].toString());
    }
}
System.out.println(preList);	// [Hello, World]
相关文章