SpEL快速入门

　　Spring表达式语言(简称SpEL)是一种鱼JSP2 EL功能类似的变道时语言，它可以在运行时查询和操作对象图。与JSP 2的EL相比，SpEL功能更加强大，它甚至支持方法的调用和基本字符串模板。

　　SpEL可以独立Spring容器使用——只是当初简单的表达式语言来使用;也可以在Annotation或XML配置中使用SpEL,这样可以充分利用SpEL简化Spring Bean的配置。

　　Spring的SpEL可以单独使用，可以使用SpEL对表达式计算，求值。SpEL主要提供如下两个重要的接口。

　　》ExpressionParser:该接口的实例负责解析一个SpEL表达式，返回一个Expression对象。

　　》Expression: 该接口的实例代表一个表达式。

　　Expression实例代表一个表达式，它包含了如下方法可用于计算，得到表达式的值。

　　》Object getValue():计算表达式的值。

　　》<T>T getValue(Class<T> desiredResultType):计算表达式的值，而且尝试将该表达式的值当成desiredResultType类型处理。

　　》Object getValue(EvaluationContext context):使用指定的EvaluationContext来计算表达式的值

　　》<T> T getValue(EvaluationContext context, Class<T> desiredResultType):使用指定EvaluationContext来计算表达式的值。而且尝试将该表达式的值当成desiredResultType类型处理

　　》Object getValue(Object rootObject):以rootObject作为表达式的root对象来计算表达式的值。

　　》<T> getValue(Object rootObject, Class<T> desiredResultType):以rootObject作为表达式的root对象来计算表达式的值。而且尝试将该表达式的值当成desiredResultType类型处理。

　　下面的程序示范了如何利用ExpressionParser和Expression来计算表达式的值

import org.springframework.expression.*;
import org.springframework.expression.spel.standard.*;
import org.springframework.expression.spel.support.*;

import java.util.*;

public class SpELTest
{
    public static void main(String[] args)
    {
        //创建一个ExpressionParser对象，用于解析表达式
        ExpressionParser parser = new SpelExpressionParser();
        //最简单的字符串表达式
        Expression exp = parser.parseExpression("'HelloWorld'");
        System.out.println("'HelloWorld'的结果： " + exp.getValue());
        //调用方法的表达式
        exp = parser.parseExpression("'HelloWorld'.concat('!')");
        System.out.println("'HelloWorld'.concat('!')的结果： "
            + exp.getValue());
        //调用对象的getter方法
        exp = parser.parseExpression("'HelloWorld'.bytes");
        System.out.println("'HelloWorld'.bytes的结果： "
            + exp.getValue());
        //访问对象的属性(d相当于HelloWorld.getBytes().length)
        exp = parser.parseExpression("'HelloWorld'.bytes.length");
        System.out.println("'HelloWorld'.bytes.length的结果："
            + exp.getValue());
        //使用构造器来创建对象
        exp = parser.parseExpression("new String('helloworld')"
            + ".toUpperCase()");
        System.out.println("new String('helloworld')"
            + ".toUpperCase()的结果是： "
            + exp.getValue(String.class));

        Person person = new Person(1 , "孙悟空", new Date());
        exp = parser.parseExpression("name");
        //以指定对象作为root来计算表达式的值
        //相当于调用person.name表达式的值
        System.out.println("以persn为root，name表达式的值是： "
            + exp.getValue(person , String.class));        
        exp = parser.parseExpression("name=='孙悟空'");
        StandardEvaluationContext ctx = new StandardEvaluationContext();
        ctx.setRootObject(person);
        //以指定Context来计算表达式的值
        System.out.println(exp.getValue(ctx , Boolean.class));

        List<Boolean> list = new ArrayList<Boolean>();
        list.add(true);
        EvaluationContext ctx2 = new StandardEvaluationContext();
        //将list设置成EvaluationContext的一个变量
        ctx2.setVariable("list" , list);
        //修饰list变量的第一个元素的值
        parser.parseExpression("#list[0]").setValue(ctx2 , "false");
        //list集合的第一个元素被改变
        System.out.println("list集合的第一个元素为： "
            + list.get(0));
    }
}

　　上面的程序使用了ExpressionParser多次解析了不同类型的表达式，ExpressionParser调用parserExpression()方法将会返回一个Expression实例(表达式对象)。程序调用Expression对象的getValue()方法即可获取该表达式的值。

　　上面的程序还涉及一个EvaluationContext对象，它是SpEL计算表达式值的“上下文”对象，这个Context对象可以包含多个对象，但只能有一个root(跟)对象

　　EvaluationContext有点类似于OGNL的Stack Context,EvaluationContext可以包含多个对象，但只能有一个root对象。

　　为了往EvaluationContext里放入对象(SpEL称之为变量)，可以调用该对象的如下方法。

　　》setVariable(String name, Object value):向EvaluationContext中放入Value对象，该对象名为name

　　为了在SpEL访问EvaluationContext中指定对象，应采用OGNL类似的格式

#name

　　StandardEvaluationContext提供了如下方法来设置root对象。

　　》setRootObject(Object rootObject)

　　在SpEL中访问root对象属性时，可以省略root对象前缀，例如如下代码:

foo.bar    //访问rootObject的foo属性的bar属性

　　当然是用Expression对象计算表达式时，也可以直接指定root对象，例如上面的程序中的代码:

exp.getValue(person, String.class) //以person对象为root对象来计算表达式的值