前言

SpEL(Spring Expression Language)，即**Spring表达式语言。**它是一种类似JSP的EL表达式、但又比后者更为强大有用的表达式语言。

为什么要用SpEL：因为它可以在spring容器内实时查询和操作数据，尤其是操作List列表型、Array数组型数据。所以使用SpEL可以有效缩减代码量，优化代码结构。

一. 用法

常规SpEL有三种用法：

在注解**@Value**中使用
在XML配置中使用
在代码中创建Expression对象，利用Expression对象来执行SpEL

1. @Value注解

@Value可以加在class的成员变量和形参上。用法如下

    //@Value能修饰成员变量和方法形参
    //#{}内就是SpEL表达式的语法
    //Spring会根据SpEL表达式语法，为变量arg赋值
    @Value("#{表达式}")
    public String arg;

如果修饰成员变量，Spring容器会根据SpEL表达式语法筛选修改数据，然后赋值给所@Value修饰的变量；

如果修饰方法形参，则是过滤传进来的参数值。

PS：value属性的表现形式

@Value()的value属性可以有三种表现形式：

字符串: 可能为普通字符串或者资源路径，例如：

@Value("hello")
private String word;    //将"hello"字符串赋值给word变量

@Value("http://www.baidu.com")
private Resource url;    //从网址"http://www.baidu.com"获取资源

#{}：在大括号内可以为其他bean或者bean的属性、环境变量等，本文大量实例都是使用#{}方式实现的

${}: 在大括号内可以为properties资源文件内的配置项。例如：

//在application.properties或者其他配置文件中添加如下配置项：
//book.author=Albert
 
@Value("${book.author}")
private String author;    //Spring会将Albert赋值给author变量
 
//使用@Value(${})格式时，spring会通过加载框架自带的PropertySourcesPlaceholderConfigurer的Bean，或者通过@PropertySource制定特定的properties文件

2. XML配置

XML配置用在Spring的applicationContext.xml配置文件内的元素上，用法如下：

<bean id="xxx" class="com.java.XXXXX.xx">
    <!-- 同@Value,#{}内是表达式的值，可放在property或constructor-arg内 -->
    <property name="arg" value="#{表达式}">
</bean>

用法跟注解@Value修饰形参类似

3. Expression

在代码中创建Expression对象，利用Expression对象来执行SpEL

import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
 
public class SpELTest {
 
    public static void main(String[] args) {
 
    	//创建ExpressionParser解析表达式
        ExpressionParser parser = new SpelExpressionParser();
        //SpEL表达式语法设置在parseExpression()入参内
        Expression exp = parser.parseExpression("表达式");
        //执行SpEL表达式，执行的默认Spring容器是Spring本身的容器：ApplicationContext
        Object value = exp.getValue();
        
 
        /**也可以使用非Spring的ApplicationContext容器，则用下面的方法*/
        //创建一个虚拟的容器EvaluationContext
        StandardEvaluationContext ctx = new StandardEvaluationContext();
        //向容器内添加bean
        BeanA beanA = new BeanA();
        ctx.setVariable("bean_id", beanA);
        //setRootObject并非必须；一个EvaluationContext只能有一个RootObject，引用它的属性时，可以不加前缀
        ctx.setRootObject(XXX);        
        //getValue有参数ctx，从新的容器中根据SpEL表达式获取所需的值
        Object value = exp.getValue(ctx);
    }
}

Expression用法可以在代码中使用SpEL进行数据的读取过滤和修改，十分方便

二. SpEL表达式语法

1. 直接量表达式

    //@Value("Hello World")  或者用直接字符串
    @Value("#{'Hello World'}")        
    String word;        //变量word赋值直接量：字符串"Hello World"
 
    //注入list
    @Value("7,2,3,5,1")
    private List<Integer> fList;

2. 直接使用java代码

如在SpEL中直接试用new/instance of，像写Java代码一样。

注意：在SpEL中直接使用某个类名时，此类必须是java.lang 包中的类，才可以在SpEL中省略包名；否则需要写全名

    Expression exp = parser.parseExpression("new Spring('Hello World')");

3. 使用T(Type)

使用“T(Type)”来表示java.lang.Class类的实例，即如同java代码中直接写类名。同样，只有java.lang 下的类才可以省略包名。此方法一般用来引用常量或静态方法

    parser.parseExpression("T(Integer).MAX_VALUE");    
	//等同于java代码中的：Integer.MAX_VALUE

4. 变量

获取容器内的变量，可以使用“#bean_id”来获取。有两个特殊的变量，可以直接使用。

#this 使用当前正在计算的上下文
#root 引用容器的root对象，即applicationContext本身

        //从ctx容器内，获取rootObject，并转换为String类型
        String result1 = parser.parseExpression("#root").getValue(ctx, String.class);  
        
        //在ctx容器内，设置abc的值为"abcdef"
        String s = new String("abcdef");
        ctx.setVariable("abc",s);
        //取id为abc的bean，然后调用其中的substring方法，得到结果赋值给result2
        String result2 = parser.parseExpression("#abc.substring(0,1)").getValue(ctx, String.class);

5. 方法调用

SpEL的方法调用与直接编写Java代码没有什么区别。具体可见上例abc.substring(0,1)与java代码"abcdef".substring(0,1)效果一样

        //创建ctx容器
        StandardEvaluationContext ctx = new StandardEvaluationContext();
        //获取java自带的Integer类的parseInt(String)方法
        Method parseInt = Integer.class.getDeclaredMethod("parseInt", String.class);
        //将parseInt方法注册在ctx容器内
        ctx.registerFunction("parseInt", parseInt);
        //再将parseInt方法设为parseInt2
        ctx.setVariable("parseInt2", parseInt);
 
        //创建ExpressionParser解析表达式
        ExpressionParser parser = new SpelExpressionParser();
        //SpEL语法，比对两个方法执行完成后，结果是否相同
        String expreString = "#parseInt('2') == #parseInt2('3')";
        Expression expression = parser.parseExpression(expreString);
        return expression.getValue(ctx, Boolean.class);    //执行结果为false
 
        /** 如果String expreString = "#parseInt('3') == #parseInt2('3')"，执行结果为true */
        /** 可见SpEL正常执行*/

“registerFunction”和“setVariable”都可以注册自定义函数，但是两个方法的含义不一样，推荐使用“registerFunction”方法注册自定义函数。

6. 运算符表达式

算数表达式（“1+2-3*4/2″）
比较表达式（“1>2”）
逻辑表达式（“2>1 and (!true or !false)”）
赋值表达式（“#variableName=value”）
三目表达式（“表达式1?表达式2:表达式3”）
正则表达式（“123′ matches ‘\d{3}”）

等运算符，都可以直接放在SpEL中，执行结果为运算符表达式的结果

7. Elvis运算符

    //SpEL可简写为：
    name?:"other"
 
    //等同于java代码
    name != null? name : "other"

8. 集合定义

使用**“{表达式，……}”**定义List，如“{1,2,3}”

    //SpEL的@Value注解设置List
    @Value("1,2,3")
    private List<Integer> f1;
 
    @RequestMapping(value = "/a", method = RequestMethod.POST)
    public List<Integer> a() throws NoSuchMethodException {
 
        //SpEL
        List<Integer> result1 = parser.parseExpression("{1,2,3}").getValue(List.class);
 
        //等同于如下java代码
        Integer[] integer = new Integer[]{1,2,3};
        List<Integer> result2 = Arrays.asList(integer);
 
        return result1;
    }

9.集合选择

通过一定的规则对及格进行筛选，构造出另一个集合

语法：“(list|map).?[选择表达式]”

选择表达式结果必须是boolean类型，如果true则选择的元素将添加到新集合中，false将不添加到新集合中。

    parser.parseExpression("#collection.?[#this>2]").getValue(context, Collection.class);

目录CONTENT

SpEL表达式总结

前言