Spring---SpEL

SpEL

Spring表达式语言（SpEL)，可以在运行时查询和操作对象图。它支持方法调用和基本字符串模板函数。
SpEL可以单独使用，也可以在Annotation（注解）或XML配置中使用。

SpEL接口：

ExpressionParser：该接口的实例负责解析一个SpEL表达式，返回一个 Expression对象
Expression：该接口的实例代表一个表达式
EvalutionContext：代表计算表达式值的上下文

Expression实例常用方法：

Object getValue()：计算表达式的值
T getValue(Classarg0)：计算表达式的值，尝试将该表达式的值当成arg0类型处理
Object getValue(EvaluationContext context)：使用指定的EvaluationContext来计算表达式的值
Object getValue(EvaluationContext context,Classarg0)：使用指定的EvaluationContext来计算表达式的值，尝试将该表达式的值当成arg类型

SpEL语法

单独使用SpEL表达式

创建一个ExpressionParser对象，用于解析SpEL表达式
ExpressionParser parser=new SpelExpressionParser();
1、常量表达式

Expression exp=parser.parseExpression("0.23");
System.out.println(exp.getValue());
System.out.println(exp.getValue(Double.class));
exp=parser.parseExpression("'HelloWorld!'");//注意字符串需要加单引号作为参数

2、创建数组
exp=parser.parseExpression("new String[]{'1','2','3'}");
3、创建List集合{ele1,ele2,…}
exp=parser.parseExpression("{'1','2','3'}");
4、在表达式中访问List集合
List:list[index],Map:map[key]

    List<String>list=new ArrayList<>();
    Collections.addAll(list, "sda","b","c");
    EvaluationContext ec=new StandardEvaluationContext();//作为SpEL解析变量的上下文
    ec.setVariable("myList", list);//设置变量
    System.out.println(parser.parseExpression("#myList[0]").getValue(ec));

5、调用方法
System.out.println(parser.parseExpression("#myList.size()").getValue(ec));
6、类型运算符
T()：将该运算符内的字符串当成“类”来处理，避免Sprinf对其进行其他解析
System.out.println(parser.parseExpression("T(java.lang.Math).random()").getValue());
7、变量
允许通过EvaluationContext来使用变量，通过setVariable(String name,Obejct value)来设置变量

‘#name(变量名):访问该变量’
‘#this:引用SpEL当前计算的对象’
‘#root：引用SpEL的EcaluationContext的root对象’

    EvaluationContext c=new StandardEvaluationContext();
    c.setVariable("a", 1);
    System.out.println(parser.parseExpression("#a").getValue(c));

8、安全导航操作
foo.bar
若foo对象已经为null，则访问bar属性会引发异常，为了避免此类情况，SpEL支持如下用法：
foo?.bar
9、集合选择
SpEL允许直接对集合进行选择操作，会根据表达式对集合元素进行筛选，符合条件的被筛选出 collection.?[condition_expr]

    List<String>list=new ArrayList<>();
    Collections.addAll(list, "sda","b","c");
    System.out.println(parser.parseExpression("#myList.?[length()>1]").getValue(ec));

Output:[sda]
10、集合投影
SpEL允许对集合进行投影运算，投影运算将依次迭代每个集合元素：collecion.![condition_expr]
System.out.println(parser.parseExpression("#myList.![length()]").getValue(ec));
Output:[3,1,1]
11、表达式模板
表达式模板的本质是对“直接量表达式”的扩展，它允许在“直接量表达式”中插入一个或多个#{expr}，#{expr}会被动态的计算出

    Person p=new Person(1, "ad", new Date());//Person(int,String,Date)
    Expression e=parser.parseExpression("#{name},#{id},#{birth}",new TemplateParserContext());
    System.out.println(e.getValue(p));

TemplateParserContext指定解析式需要计算#{}之间的值

XML配置中使用SpEL

public class Author {

    private String name;
    private Sprots sports;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void setSprots(Sprots s) {
        this.sports = s;
    }
    public void do(){
        System.out.println("I am "+name+",and I'm "+sports.doing());
    }
}

public class Sports {
    public String doing(){
        return "swimming!";
    }
}

XML配置

<?xml version="1.0" encoding="GBK"?>
<!-- Spring配置文件的根元素，使用spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <bean id="author" class="gzy.Author" 
    p:name="#{T(java.lang.Math).random()}"
    p:axe="#{new gzy.Sports()}"
    ></bean>
</beans>

测验

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
    public static void main(String[]args){
        ApplicationContext ctx=
                new ClassPathXmlApplicationContext("beans.xml");
        Author p=ctx.getBean("author",Author.class);
        p.do();
    }
}