Spring表达式语言(SpEL)

Spring 表达式语言 Spring Expression Language（简称 SpEL ）是一个支持运行时查询和操做对象图的表达式语言 。 语法相似于 EL 表达式 ，但提供了显式方法调用和基本字符串模板函数等额外特性 。

SpEL 虽然做为 Spring 家族中表达式求值的基础，但却能够被独立使用。

1 加入依赖
首先在 pom.xml 中加入依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>${spring.version}</version>
</dependency>

2 简单示例
在此，咱们定义一个简单求和的算术表达式，交给 SpEL 解析：

ExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression("6+2");
Integer result = (Integer) expression.getValue();
System.out.println("result:" + result);

输出结果：

result:8

3 核心接口
SpEL 的相关类和接口都定义在 org.springframework.expression 包、子包和 spel.support 中 。

ExpressionParser 接口用于解析表达式字符串 。 Expression 接口用来计算表达式串的值 。 当调用 ExpressionParser#parseExpression()时可能抛出 ParseException ； 当调用 Expression#getValue() 时可能抛出EvaluationException 异常 。

SpEL 支持方法调用，访问属性和调用构造器等特性。

好比，咱们能够在字符串表达式中加入 concat 方法来拼接字符串：

ExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression("'SpEL'.concat(' thinking')");
String result = (String) expression.getValue();
System.out.println("result:" + result);

输出结果：

result:SpEL thinking

由于 expression.getValue() 返回的是 Object，因此必须进行显式转换。咱们可使用 public <T> T getValue(Class<T> desiredResultType)，来优雅地获取相应类型的值。

String result = expression.getValue(String.class);

SpEL 更常应用于获取某个类实例的属性值。假设咱们有一个 Account 类：

public class Account {
    private String name;
    public Account(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

咱们经过表达式来获取 Account 实例中的 name 值：

Account account=new Account("Deniro");
ExpressionParser parser = new SpelExpressionParser();
EvaluationContext context=new StandardEvaluationContext(account);
Expression expression = parser.parseExpression("name");
String result = expression.getValue(context,String.class);
System.out.println("result:" + result);

输出结果：

result:Deniro

能够在表达式中引用根对象的属性，在解析表达式时，会在内部使用反射会从根对象中获取属性的值。

在单独使用 SpEL 时，须要建立一个 ExpressionParser 解析器，并提供一个 EvaluationContext 求值上下文 。 但在 Spring 框架中，仅须要配置一个 SpEL 表达式（ Spring bean 定义）便可。SpEL 解析器、求值上下文、根对象和其余预约义变量等基础设施都会被隐含建立

EvaluationContext 接口

EvaluationContext 接口定义了获取属性、方法、域字段解析器及类型转换器。 它的实现类 StandardEvaluationContext 使用的是反射机制来操做对象 。 为了提升性能，他会在其内部缓存 java.lang.reflect 的 Method、Field 和 Constructor 实例。

StandardEvaluationContext 类能够经过构造函数来传递求值根对象，也能够经过方法 setRootObject() 来指定求值根对象。 可使用 setVariable() 来设置变量；使用 registerFunction(String name, Method method)来注册自定义函数。

在 StandardEvaluationContext 中，咱们还能够注册自定义的构造函数转换器 ConstructorResolvers、方法转换器 MethodResolvers 及属性转换器 PropertyAccessors 来定制表达式的解析方式 。

默认状况下， SpEL 使用的是 ConversionService 来执行转换服务 。它会根据源类型与目标类型来选择合适的转换器。Spring 内置了不少转换器：

内置转换器（部分）

若是这些内置转换器不能知足业务需求，咱们能够注册自定义转换器。
当表达式中包含泛型时， SpEL 将尝试将当前值转换为对应的目标类型。

public class GenericConvertExample {
    public List<Integer> nums = new ArrayList();

    public static void main(String[] args) {

        GenericConvertExample example = new GenericConvertExample();
        example.nums.add(1);

        //建立表达式上下文
        StandardEvaluationContext context = new StandardEvaluationContext(example);
        //建立表达式解析器
        ExpressionParser parser = new SpelExpressionParser();

        String expression = "nums[0]";
        //自动将 2 转换为 Integer 类型
        parser.parseExpression(expression).setValue(context, 2);
        System.out.println("nums:" + example.nums);

        //抛出 ConverterNotFoundException
        try {
            parser.parseExpression(expression).setValue(context, true);
        } catch (EvaluationException e) {
            e.printStackTrace();s
        } catch (ParseException e) {
            e.printStackTrace();
        }

                //literal expressions 
        Expression exp = parser.parseExpression("'Hello World'");
        String msg1 = exp.getValue(String.class);
        System.out.println(msg1);

        //method invocation
        Expression exp2 = parser.parseExpression("'Hello World'.length()");  
        int msg2 = (Integer) exp2.getValue();
        System.out.println(msg2);

        //Mathematical operators
        Expression exp3 = parser.parseExpression("100 * 2");  
        int msg3 = (Integer) exp3.getValue();
        System.out.println(msg3);

        //create an item object
        Item item = new Item("yiibai", 100);
        //test EL with item object
        StandardEvaluationContext itemContext = new StandardEvaluationContext(item);

        //display the value of item.name property
        Expression exp4 = parser.parseExpression("name");
        String msg4 = exp4.getValue(itemContext, String.class);
        System.out.println(msg4);

        //test if item.name == 'yiibai'
        Expression exp5 = parser.parseExpression("name == 'yiibai'");
        boolean msg5 = exp5.getValue(itemContext, Boolean.class);
        System.out.println(msg5);

    }
}

这里的定义了 List<Integer> 类成员变量，因此咱们能够直接把整型数值传入 setValue() 方法。若是传入一个非整型类型的对象，那么就会抛出 ConverterNotFoundException 异常。

4 SpelCompiler 编译器

默认状况下， SpEL 表达式只有在求值时才会进行表达式计算，因此表达式能够在运行时进行动态修改。但若是一个表达式被重复调用的次数不少，那么就必须使用
SpelCompiler 编译器来保证性能。

SpelCompiler 编译器会将表达式编译成字节码，只有在运行时表达式发生变化时，才会被从新编译。

SpelCompiler 编译器适用于被调用的频率较高且表达式不常常发生变化的场景。

//Spel 解析配置器
SpelParserConfiguration configuration=new SpelParserConfiguration
        (SpelCompilerMode.IMMEDIATE,CompilerExample.class.getClassLoader());

//解析器
SpelExpressionParser parser=new SpelExpressionParser(configuration);

//上下文
EvaluationContext context=new StandardEvaluationContext(new Account("Deniro"));

//表达式
String expression="getName()";

//解析表达式
SpelExpression spelExpression=parser.parseRaw(expression);

System.out.println(spelExpression.getValue(context));

咱们经过指定编译模式和类加载器来新建 Spel 解析配置器。

Spel 解析配置器有三种编译模式（SpelCompilerMode）：

编译模式	说明
OFF	不启用编译模式（默认）。可在 spring.properties 中经过 spring.expression.compiler.mode 属性进行全局设置。
MIXED	在混合模式下，随着时间的推移，表达式会从解释模式自动切换到编译模式。即前面使用解释模式，当调用次数达到某个阈值后，改成使用编译模式。
IMMEDIATE	启用编译模式。实际内部在调用第一次以后，才会真正使用编译模式。

本文展现了Spring表达式解析器的一些基本用法，访问官方Spring表达文档，使用SpEL的例子。