Spring中的SpEL

Spring表达式语言（简称SpEL）是一种与JSP 2 EL功能类似的表达式语言，他可以在运行时查询和操作对象图。还支持方法调用和基本字符串模板函数。

SpEL可以独立于SPring容器使用--只是当成简单的表达式语言来使用；也可以在Annotation或XML配置中使用SpEL，这样可以充分利用SpEL简化Spring的Bean配置。

Spring的SpEL

转  spring3.0学习笔记二---SpEL表达式1

相对来讲， java是一门静态语言。而我们今天要讲的是一门动态“语言”---SpEL。

 

动态语言和静态语言的最显著差别在于，举个例子，" 'Hello'.toUperCase()"这只是一个普通的字符串，差别在于能否把它编译和运行起来得到结果。就是说动态语言能把一个字符串解释成程序语句。如果还不是很明白的话没关系，看下面的SpEL例子。（接下去的我就用例子来做介绍了）

 

public void testSpEL1() {

 

//ExpressionParser是Spring3里的一个包，用来动态解释一个字符串。

  ExpressionParser parser = new SpelExpressionParser();

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

  System.out.println((String)exp.getValue());

 }

 

这里'Hello,World' 是一个字符串，解释起来还是一个字符串，所以打印结果是：Hello,World

 

 

 

第二个例子：调用方法

 

public void testSpEL2() {

 

ExpressionParser parser = new SpelExpressionParser();

Expression exp=parser.parseExpression(" 'Hello'.concat(' World!')");  //这里调用了字符串String的concat方法

 

//Expression exp=parser.parseExpression("newString('helloworld').toUpperCase()");

 

Stringmessage=(String)exp.getValue();

 

}

第三个例子：调用属性

ExpressionParser parser= new SpelExpressionParser();

 

Expression exp=parser.parseExpression("'HelloWorld'.bytes");  //得到字符串的byte

 

//Expression exp=parser.parseExpression("'HelloWorld'.bytes.length"); //得到属性的属性

byte [] bytes=(byte[])exp.getValue();

 

 

 

第四个例子：调用类中的属性（下面开始复杂起来了）

 

@Resource

 

public User user;  //注入之后，user.getName() 为 xiaoling

 

public void testSpEL() {

 

    //设“值域”，限定在u这个对象里

    EvaluationContext context = new StandardEvaluationContext(user);  

    ExpressionParser parser = new SpelExpressionParser();

    Expression exp = parser.parseExpression("username"); //==user.getUsername()

    System.out.println((String)exp.getValue(context));  //结果：xiaoling

 }

或者用更简洁的一个方式 ：

  System.out.println((String)exp.getValue(user));

这样就不用设值域了！呵呵！

第五个例子：给对象中的属性设值

StandardEvaluationContext  context = new StandardEvaluationContext(user);

 

parser.parseExpression("username").setValue(context, "ling");

 

第六个例子：做判断

 

Expression exp=parser.parseExpression("name=='xiaoling' ");

boolean result=exp.getValue(context,Boolean.class);  //evaluate stotrue

 

打印出来，结果为true

 

看到这，可能你还是一头雾水：这算什么新特性啊，哪有什么用处！

 

用处就在于，SpEL把java变成“动”的了！（纯属我个人观点！！）

接下来，我们把SpEL用到bean.xml中去

 

先看个例子(例一)

 

<bean id="numberGuess" class="cn.ling.spel.NumberGuess">

   <property name="randomNumber" value="#{T(java.lang.Math).random()*100.0}"/>

 

</bean>

 

怎么样，可以在xml文件里面赋值了！呵呵！

 

value里面都用#{}来赋值。至于T(java.lang.Math)，它是指某个类，即Math这个类。

 

 

 

看这个例子(例二)：systemProperties

 

<property name="defaultLocale" value="#{systemProperties['user.region']}"/>

 

systemProperties是预定义好的，里面有很属性可以用，它就相当于java文件中的System.getProperty("user.region"),它能取出当前计算机所在的国家。

 

 

 

例三：引用xml里面的其它bean

 

<bean id="numberGuess" class="org.spring.samples.NumberGuess">

<property name="randomNumber" value="#{T(java.lang.Math).random()*100.0}"/>

<!--otherproperties-->

</bean>

<bean id="shapeGuess" class="org.spring.samples.ShapeGuess">

<property name="initialShapeSeed" value="#{numberGuess.randomNumber}"/>

<!--otherproperties-->

</bean>

SpEL还可以用在annotation中：

 

例一：用在属性上

 

public static class FieldValueTestBean{

   @Value("#{systemProperties['user.region']}")

   private String defaultLocale;

 

   //set和get方法

   public void setDefaultLocale(StringdefaultLocale) {

      this.defaultLocale=defaultLocale;

   }

 

   public StringgetDefaultLocale(){

      returnthis.defaultLocale;

   }

}

 

例二：用在方法上

 

public static class PropertyValueTestBean{

   private String defaultLocale;

   @Value("#{systemProperties['user.region']}")

   public void setDefaultLocale(String defaultLocale){

      this.defaultLocale=defaultLocale;

   }

   public String getDefaultLocale(){

      return this.defaultLocale;

   }

 

}

}

 

例三：Autowired和构造器中

 

public class SimpleMovieLister{

   private MovieFinder movieFinder;

   private String defaultLocale;

   @Autowired

   public void configure(MovieFinder movieFinder,

      @Value("#{systemProperties['user.region']}"}String defaultLocale){

         this.movieFinder=movieFinder;

         this.defaultLocale=defaultLocale;

      }

//...

}

 

转 Spring3表达式语言(SpEL)学习笔记

最新地址请访问：http://leeyee.github.io/blog/2011/06/19/spring-expression-language

Spring Excpression Language (SpEL)语言支持在运行时操作和查询对象，其语法类似统一的EL语言，但是SpEL提供了额外的功能。

1、文本表达式
2、布尔类和关系操作
3、正则表达式
4、类表达式
5、访问属性、数组、集合和map
6、方法调用
7、关系操作
8、赋值操作
9、调用构造函数
10、Bean 引用
11、数组构造
12、内联list
13、三元操作
14、变量
15、用户自定义函数
16、集合投影
17、集合选择
18、模板表达式

使用SpEl进行表达式操作，基本操作如下：
第一步，构建解析

[java]  view plain  copy

1. ExpressionParser parser = new SpelExpressionParser();  

第二步，使用表达式进行解析

[java]  view plain  copy

1. Expression exp = parser.parseExpression( SpEl);  

第三步，获取结果

[java]  view plain  copy

1. exp.getValue()  

 

2.1 文本表达式
文本表达式支持字符表达式、日期、数字（正数、实数及十六进制数）、布尔类型及null.其中字符表达式需要用单引号声明。
对数字支持负数、指数及小数。默认情况下实数使用Double.parseDouble() 进行表达式类型转换

2.2 属性、数组、列表、字典(map)及索引
在表达式中访问类属性时直接使用属性名，属性名首字母大小写均可。
访问数组时可以使用[index]进行元素对象范围。
访问列表时，可直接使用类表的方法，通过点操作符

2.3 内置列表
列表可以直接表示在表达式中使用{}符号表达。{}本身代表一个空的list

2.4 数组构造(spring3.0.3中会抛出异常)
可以通过熟悉的java语法在表达是语言中定义。但目前不支持定义一个初始化的多维数组
2.5 方法
表达式中的方法调用遵循java语法。

2.6 操作符
2.6.1 关系操作符
支持 eq("=="),ne("!="),le("<="),lt("<"),gt(">"),ge(">="),div("/"),mod("%"),not("!")，正则表达式及instanceof操作              
2.6.2 逻辑操作符
逻辑操作符支持and,or,not

2.6.3 数学运算操作符
加法运算符可以用于数字，字符串和日期。减法可以用在数字和日期。乘法和除法只能用于对数字。其他受支持的数学运算是模数（％）和指数幂（^）。运行顺序按标准运算符优先级执行
2.7 赋值
通过赋值操作进行属性设置。通常是调用setValue方法，但也可以在调用getValue时设置。

2.8 类型
通过特殊的'T'操作符可以用来指定一个java.lang.Class的实例。在实例话对象的静态方法将会被调用。

2.9 构造器
构造器通过new操作被调用。在new操作时需要指明类的完全类名（包括包路径）

2.10 变量
变量可以通过 #变量名 在表达式中被引用。变量通过StandardEvaluationContext类的setVariable方法进行设置
2.10.1 #this变量
变量 #this 被定义为当前操作对象的引用。

2.11 函数
你可以扩展SpEL通过注册自定义函数。注册后的函数可以在表达式中通过其名称进行调用。函数的注册是通过StandardEvaluationContext类的registerFunction方法进行声明
2.12 三元操作

2.13 Elvis操作

Elvis操作是一个短的三元操作符语法，通常在Groovy语言中使用。

Note: Elvis操作在表达式中可以用来生成默认值，当被访问属性为空时。比如@Value

@Value("#systemPro['mail.port'] ? : 25}")  //当mail.port为空时将默认为25

2.14 安全导航操作
该操作是为避免空指针异常。他是来自Groovy语言的。典型的当你有一个指向对象的引用，在你访问其方法或属性时，可能需要验证该对象的方法或属性是否为空，为了避免验证，使用安全导航操作将简单的返回null而不是空指针异常。
2.15 集合选择
选择是一个强大的表达式语言属性，可以使用选择表达式过滤源集合，从而生成一个新的符合选择条件的集合
选择的语法为 ?[selectionExpression] 。他将过滤集合并且返回一个新的集合（原集合的子集）。
选择语句也可用在Map中，过滤keySet及valueSet分别使用key和value关键字
另外：选择语法中，选择符合条件的结果集的第一个元素的语法为 ^[selectionExpression]，选择最后一个元素的语法为$[selectionExpression]
2.16 集合投影
语法 ![projectionExpression] 判断集合中每个元素是否符合语法要求

2.17 表达式模板
表达式模板允许混合文字表达式，一个或多个值计算块。每一个值计算块被声明通过可被自定义的前缀和后缀，一般选择使用 #{}作为一个定界符。

------------    以上就是SpEL的简单介绍。下面直接给出测试用例，这样比较直观，也易于理解。    ------------

pom.xml

[xhtml]  view plain  copy

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
3.     <modelVersion>4.0.0</modelVersion>  
4.     <groupId>study.spring3</groupId>  
5.     <artifactId>study-spring3</artifactId>  
6.     <version>0.0.1-SNAPSHOT</version>  
7.     <dependencies>  
8.         <dependency>  
9.             <groupId>org.springframework</groupId>  
10.             <artifactId>spring-context</artifactId>  
11.             <version>3.0.5.RELEASE</version>  
12.             <scope>runtime</scope>  
13.             <exclusions>  
14.                 <exclusion>  
15.                     <groupId>commons-logging</groupId>  
16.                     <artifactId>commons-logging</artifactId>  
17.                 </exclusion>  
18.             </exclusions>  
19.         </dependency>  
20.         <dependency>  
21.             <groupId>org.slf4j</groupId>  
22.             <artifactId>slf4j-api</artifactId>  
23.             <version>1.5.8</version>  
24.             <scope>runtime</scope>  
25.         </dependency>  
26.         <dependency>  
27.             <groupId>org.slf4j</groupId>  
28.             <artifactId>slf4j-log4j12</artifactId>  
29.             <version>1.5.8</version>  
30.             <scope>runtime</scope>  
31.         </dependency>  
32.         <dependency>  
33.             <groupId>log4j</groupId>  
34.             <artifactId>log4j</artifactId>  
35.             <version>1.2.14</version>  
36.             <scope>runtime</scope>  
37.         </dependency>  
38.         <dependency>  
39.             <groupId>junit</groupId>  
40.             <artifactId>junit</artifactId>  
41.             <version>4.8.1</version>  
42.             <scope>test</scope>  
43.         </dependency>  
44.         <dependency>  
45.             <groupId>commons-logging</groupId>  
46.             <artifactId>commons-logging</artifactId>  
47.             <version>1.1.1</version>  
48.             <scope>test</scope>  
49.         </dependency>  
50.         <dependency>  
51.             <groupId>javax.inject</groupId>  
52.             <artifactId>javax.inject</artifactId>  
53.             <version>1</version>  
54.             <scope>runtime</scope>  
55.         </dependency>  
56.         <dependency>  
57.             <groupId>cglib</groupId>  
58.             <artifactId>cglib</artifactId>  
59.             <version>2.1_3</version>  
60.             <scope>runtime</scope>  
61.         </dependency>  
62.     </dependencies>  
63. </project>  

 

spring-beans.xml

[xhtml]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
4.     xmlns:p="http://www.springframework.org/schema/p"  
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
6.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
7.     <!-- 容器注解扫描 -->  
8.     <context:component-scan base-package="study.spring.beans" />  
9.     <bean id="sputil" name="sputil" class="study.spring.beans.SpElUtil">  
10.         <property name="time" value="#{ new java.util.Date()}" />  
11.         <property name="name" value="#{'override'}" />  
12.         <property name="maps">  
13.             <map>  
14.                 <entry key="1" value="string1" />  
15.                 <entry key="2" value="string2" />  
16.                 <entry key="3" value="string3" />  
17.                 <entry key="4" value="String4" />  
18.             </map>  
19.         </property>  
20.     </bean>  
21. </beans>   

ApplicationContextFactory.java

[java]  view plain  copy

1. package study.spring.context.factory;  
2. import org.springframework.context.ApplicationContext;  
3. import org.springframework.context.support.ClassPathXmlApplicationContext;  
4. public class ApplicationContextFactory {  
5.     private static ApplicationContext ctx;  
6.     private ApplicationContextFactory() {  
7.     }  
8.     public static ApplicationContext createInstance() {  
9.         if (ctx == null) {  
10.             ctx = new ClassPathXmlApplicationContext(  
11.                     new String[] { "spring-beans.xml" });  
12.         }  
13.         return ctx;  
14.     }  
15. }   

SpElUtil.java

[java]  view plain  copy

1. package study.spring.beans;  
2. import java.util.Date;  
3. import java.util.List;  
4. import java.util.Map;  
5. import org.springframework.expression.Expression;  
6. import org.springframework.expression.ExpressionParser;  
7. import org.springframework.expression.spel.standard.SpelExpressionParser;  
8. public class SpElUtil {  
9.     private Date time;  
10.     private String name;  
11.     private SpelTestInnerClass innerClass = new SpelTestInnerClass(  
12.             "innerClass", 29);  
13.     private List<Integer> numbers;  
14.     private Map<Integer, String> maps;  
15.     public static Object sayHelloForSpEl(String express) {  
16.         ExpressionParser exp = new SpelExpressionParser();  
17.         Expression ex = exp.parseExpression(express);  
18.         return ex.getValue();  
19.     }  
20.     /** 
21.      * 自定义方法 
22.      *  
23.      * @param string 
24.      * @return 
25.      */  
26.     public static int len(String string) {  
27.         return string.length();  
28.     }  
29.     public Map<Integer, String> getMaps() {  
30.         return maps;  
31.     }  
32.     public void setMaps(Map<Integer, String> maps) {  
33.         this.maps = maps;  
34.     }  
35.     public List<Integer> getNumbers() {  
36.         return numbers;  
37.     }  
38.     public void setNumbers(List<Integer> numbers) {  
39.         this.numbers = numbers;  
40.     }  
41.     public Date getTime() {  
42.         return time;  
43.     }  
44.     public void setTime(Date time) {  
45.         this.time = time;  
46.     }  
47.     public String getName() {  
48.         return name;  
49.     }  
50.     public void setName(String name) {  
51.         this.name = name;  
52.     }  
53.     public SpelTestInnerClass getInnerClass() {  
54.         return innerClass;  
55.     }  
56.     public void setInnerClass(SpelTestInnerClass innerClass) {  
57.         this.innerClass = innerClass;  
58.     }  
59. }  
60. class SpelTestInnerClass {  
61.     private String name;  
62.     private int age;  
63.     public SpelTestInnerClass(String name, int age) {  
64.         this.name = name;  
65.         this.age = age;  
66.     }  
67.     public boolean isGt30ForAge() {  
68.         return this.age > 30 ? true : false;  
69.     }  
70.     public String getName() {  
71.         return name;  
72.     }  
73.     public int getAge() {  
74.         return age;  
75.     }  
76.     public void setAge(int age) {  
77.         this.age = age;  
78.     }  
79. }   

SpElUtilTest.java

[java]  view plain  copy

1. package study.spring.beans;  
2. import static org.junit.Assert.*;  
3. import java.util.ArrayList;  
4. import java.util.Arrays;  
5. import java.util.Date;  
6. import java.util.HashMap;  
7. import java.util.List;  
8. import java.util.Map;  
9. import org.junit.After;  
10. import org.junit.Before;  
11. import org.junit.Test;  
12. import org.springframework.context.ApplicationContext;  
13. import org.springframework.expression.Expression;  
14. import org.springframework.expression.ExpressionParser;  
15. import org.springframework.expression.common.TemplateParserContext;  
16. import org.springframework.expression.spel.standard.SpelExpressionParser;  
17. import org.springframework.expression.spel.support.StandardEvaluationContext;  
18. import study.spring.context.factory.ApplicationContextFactory;  
19. public class SpElUtilTest {  
20.     // spring配置文件上下文  
21.     ApplicationContext context = null;  
22.     // spring el测试辅助类  
23.     SpElUtil spel = null;  
24.     // 表达式解析对象  
25.     ExpressionParser exp = null;  
26.     // 标准赋值上下文  
27.     StandardEvaluationContext secontext;  
28.     @Before  
29.     public void setUp() throws Exception {  
30.         context = ApplicationContextFactory.createInstance();  
31.         spel = context.getBean(SpElUtil.class);  
32.         secontext = new StandardEvaluationContext(spel);  
33.         exp = new SpelExpressionParser();  
34.     }  
35.     @After  
36.     public void tearDown() throws Exception {  
37.         context = null;  
38.         spel = null;  
39.         secontext = null;  
40.         exp = null;  
41.     }  
42.     /** 
43.      * 文字表达式测试用例 
44.      *  
45.      * @throws Exception 
46.      */  
47.     @Test  
48.     public void testSpELLiteralExpression() throws Exception {  
49.         // 定义各种文字表达式  
50.         String[] lELs = { "'hello SpEL'", "1.028E+7", "0x12EF", "true", "null" };  
51.         assertEquals("hello SpEL",  
52.                 exp.parseExpression(lELs[0]).getValue(String.class));  
53.         assertEquals(new Double(10280000), exp.parseExpression(lELs[1])  
54.                 .getValue(Double.class));  
55.         assertEquals(new Integer(4847),  
56.                 exp.parseExpression(lELs[2]).getValue(Integer.class));  
57.         assertTrue(exp.parseExpression(lELs[3]).getValue(Boolean.class));  
58.         assertNull(exp.parseExpression(lELs[4]).getValue());  
59.     }  
60.     /** 
61.      * 访问属性、数组、集合和 map 测试 
62.      *  
63.      * @throws Exception 
64.      */  
65.     @Test  
66.     public void testSpELProOrArrayOrIndexEtcExpression() throws Exception {  
67.         // 属性测试。time为SpElUtil类Date型数据，这里调用Date的属性Year  
68.         assertEquals(new Integer(2011), exp.parseExpression("time.Year + 1900")  
69.                 .getValue(secontext, Integer.class));  
70.         // 属性测试。innerClass为SpElUtil类中引入的其他类。  
71.         assertEquals(29,  
72.                 exp.parseExpression("innerClass.age").getValue(secontext));  
73.         // 设置SpElUtil类的numbers属性  
74.         spel.setNumbers(Arrays.asList(2, 3, 4, 5, 6, 7, 9));  
75.         // 访问对象属性数组通过索引  
76.         assertEquals(2, exp.parseExpression("numbers[0]").getValue(secontext));  
77.         // 访问map  
78.         assertEquals("string1",  
79.                 exp.parseExpression("maps[1]")  
80.                         .getValue(secontext, String.class));  
81.     }  
82.     /** 
83.      * 内联list测试 
84.      *  
85.      * @throws Exception 
86.      */  
87.     @SuppressWarnings({ "unchecked", "rawtypes" })  
88.     @Test  
89.     public void testSpELInnerListExpression() throws Exception {  
90.         // 构造list  
91.         List<String> nums = (List<String>) exp.parseExpression(  
92.                 "{'a','b','c','d'}").getValue();  
93.         assertEquals(Arrays.asList("a", "b", "c", "d"), nums);  
94.         // 构造List<List<>>  
95.         List listOfLists = (List) exp.parseExpression("{{1,2},{3,4}}")  
96.                 .getValue(secontext);  
97.         assertEquals(Arrays.asList(1, 2), listOfLists.get(0));  
98.     }  
99.     /** 
100.      * Array 构造测试 
101.      *  
102.      * @throws Exception 
103.      */  
104.     @Test  
105.     public void testSpELArrayConstructionExcpression() throws Exception {  
106.         // 创建没有初始值的数组  
107.         int[] a = (int[]) exp.parseExpression("new int[4]").getValue();  
108.         assertEquals(4, a.length);  
109.         // 创建带有初始值的数组  
110.         int[] b = (int[]) exp.parseExpression("new int[4]{1,2,3,4}").getValue();  
111.         assertEquals(3, b[2]);  
112.         // 创建二维数组  
113.         int[][] c = (int[][]) exp.parseExpression("new int[4][5]").getValue();  
114.         assertEquals(4, c.length);  
115.         assertEquals(5, c[0].length);  
116.     }  
117.     /** 
118.      * 方法表达式测试 
119.      *  
120.      * @throws Exception 
121.      */  
122.     @Test  
123.     public void testSpELMethodExcpression() throws Exception {  
124.         // String.replace方法测试  
125.         assertEquals(  
126.                 "abC2def",  
127.                 exp.parseExpression("'abcdef'.replace('c','C2')").getValue(  
128.                         String.class));  
129.         // 自定义类方法测试  
130.         assertFalse(exp.parseExpression("innerClass.isGt30ForAge()").getValue(  
131.                 secontext, Boolean.class));  
132.         spel.getInnerClass().setAge(34);  
133.         assertTrue(exp.parseExpression("innerClass.isGt30ForAge()").getValue(  
134.                 secontext, Boolean.class));  
135.     }  
136.     /** 
137.      * 操作符、正则表达式测试 
138.      *  
139.      * @throws Exception 
140.      */  
141.     @Test  
142.     public void testSpElOperatorAndRegExpression() throws Exception {  
143.         // 关系操作  
144.         assertTrue(exp.parseExpression("1 == 1").getValue(Boolean.class));  
145.         assertTrue(exp.parseExpression("1 eq 1").getValue(Boolean.class));  
146.         assertTrue(exp.parseExpression("1 > -1").getValue(Boolean.class));  
147.         assertTrue(exp.parseExpression("1 gt -1").getValue(Boolean.class));  
148.         assertTrue(exp.parseExpression("'a' < 'b'").getValue(Boolean.class));  
149.         assertTrue(exp.parseExpression("'a' lt 'b'").getValue(Boolean.class));  
150.         assertTrue(exp.parseExpression(  
151.                 " new Integer(123) instanceof T(Integer) ").getValue(  
152.                 Boolean.class));  
153.         assertTrue(exp.parseExpression("'5.00' matches '^-?//d+(//.//d{2})?$'")  
154.                 .getValue(Boolean.class));  
155.         // 逻辑操作  
156.         assertTrue(exp.parseExpression("true and true").getValue(Boolean.class));  
157.         assertTrue(exp.parseExpression("true or false").getValue(Boolean.class));  
158.         assertFalse(exp.parseExpression("innerClass.isGt30ForAge() and false ")  
159.                 .getValue(secontext, Boolean.class));  
160.         assertFalse(exp.parseExpression("!innerClass.isGt30ForAge() and true ")  
161.                 .getValue(secontext, Boolean.class));  
162.         assertTrue(exp.parseExpression("!false").getValue(Boolean.class));  
163.         // 运算操作  
164.         assertEquals(2, exp.parseExpression("1 + 1").getValue());  
165.         assertEquals("ABab",  
166.                 exp.parseExpression("'AB' + 'ab'").getValue(String.class));  
167.         assertEquals(25.0,  
168.                 exp.parseExpression("1 + 2 * 8 div 4 mod 2 + 2 ^ 3 * 3e0")  
169.                         .getValue());  
170.         assertEquals(exp.parseExpression("1 + 2 * 8 / 4 % 2 + 2 ^ 3 ")  
171.                 .getValue(),  
172.                 exp.parseExpression("1 + 2 * 8 div 4 mod 2 + 2 ^ 3 ")  
173.                         .getValue());  
174.     }  
175.     /** 
176.      * 赋值表达式测试 
177.      *  
178.      * @throws Exception 
179.      */  
180.     @SuppressWarnings("deprecation")  
181.     @Test  
182.     public void testSpelAssignmentExpression() throws Exception {  
183.         Date oldDate = spel.getTime();// 获取当前time属性值  
184.         exp.parseExpression("time").setValue(secontext, new Date(113, 2, 25)); // 为time属性重新赋值  
185.         Date newDate = spel.getTime();// 获取赋值后的time属性值  
186.         assertEquals(2013,  
187.                 exp.parseExpression("time.Year + 1900").getValue(secontext));  
188.         assertNotSame(oldDate, newDate);  
189.         // 或者使用下属方法赋值  
190.         assertEquals("abc",  
191.                 exp.parseExpression("Name = 'abc'").getValue(secontext));  
192.         // 还原time默认，避免后续测试错误  
193.         spel.setTime(oldDate);  
194.         spel.setName("override");  
195.     }  
196.     /** 
197.      * 类型操作表达式测试 
198.      *  
199.      * @throws Exception 
200.      */  
201.     @SuppressWarnings("rawtypes")  
202.     @Test  
203.     public void testSpelTypesExpression() throws Exception {  
204.         Class dateClass = exp.parseExpression("T(java.util.Date)").getValue(  
205.                 Class.class);  
206.         assertEquals("java.util.Date", dateClass.getName());  
207.         assertTrue(exp  
208.                 .parseExpression(  
209.                         "T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR")  
210.                 .getValue(Boolean.class));  
211.     }  
212.     /** 
213.      * 构造函数调用测试 
214.      *  
215.      * @throws Exception 
216.      */  
217.     @Test  
218.     public void testSpelConstructorsExpression() throws Exception {  
219.         SpelTestInnerClass spt = exp  
220.                 .parseExpression(  
221.                         "new study.spring.beans.SpelTestInnerClass('constructTest',23)")  
222.                 .getValue(SpelTestInnerClass.class);  
223.         assertEquals(23, spt.getAge());  
224.         assertEquals("constructTest", spt.getName());  
225.     }  
226.     /** 
227.      * 设置变量测试 
228.      *  
229.      * @throws Exception 
230.      */  
231.     @SuppressWarnings("unchecked")  
232.     @Test  
233.     public void testSpelVariablesExpression() throws Exception {  
234.         List<Integer> list = new ArrayList<Integer>();  
235.         list.addAll(Arrays.asList(2, 3, 4, 5, 6, 7, 9));  
236.         secontext.setVariable("list", list);  
237.         List<Integer> vList = (List<Integer>) exp.parseExpression("#list")  
238.                 .getValue(secontext);  
239.         assertEquals(vList, list);  
240.         List<Integer> nums = (List<Integer>) exp.parseExpression(  
241.                 "#list.?[#this >5]").getValue(secontext); // 获取值大于5的元素集合  
242.         assertEquals(nums, Arrays.asList(6, 7, 9));  
243.     }  
244.     /** 
245.      * 自定义函数表达式测试 
246.      *  
247.      * @throws Exception 
248.      */  
249.     @Test  
250.     public void testSpelFunctionExpression() throws Exception {  
251.         StandardEvaluationContext context = new StandardEvaluationContext();  
252.         context.registerFunction("len", SpElUtil.class.getDeclaredMethod("len",  
253.                 new Class[] { String.class }));  
254.         assertEquals(3, exp.parseExpression("#len('abc')").getValue(context));  
255.     }  
256.     @Test  
257.     public void testSpelBeanExpression() throws Exception {  
258.     }  
259.     /** 
260.      * 三元操作测试 
261.      *  
262.      * @throws Exception 
263.      */  
264.     @Test  
265.     public void testSpelTernaryOperatorExpression() throws Exception {  
266.         assertTrue(exp.parseExpression(" true ? true :false").getValue(  
267.                 Boolean.class));  
268.         assertEquals("is true",  
269.                 exp.parseExpression(" 1 == 1 ? 'is true' :'is false'")  
270.                         .getValue(String.class));  
271.     }  
272.     /** 
273.      * Elvis 操作测试 
274.      *  
275.      * @throws Exception 
276.      */  
277.     @Test  
278.     public void testSpeleElvisOperatorExpression() throws Exception {  
279.         Expression ex = exp.parseExpression("name?:'name is null'");  
280.         assertEquals("override", ex.getValue(secontext, String.class));  
281.         spel.setName(null);  
282.         assertEquals("name is null", ex.getValue(secontext, String.class));  
283.         spel.setName("override");  
284.     }  
285.     /** 
286.      * 安全导航操作测试 
287.      *  
288.      * @throws Exception 
289.      */  
290.     @Test  
291.     public void testSpelSafeNavOperatorExpression() throws Exception {  
292.         assertEquals("innerClass", exp.parseExpression("innerClass?.name")  
293.                 .getValue(secontext, String.class));  
294.         spel.setInnerClass(null);  
295.         // 使用这种表达式可以避免抛出空指针异常  
296.         assertNull(exp.parseExpression("innerClass?.name").getValue(secontext,  
297.                 String.class));  
298.     }  
299.     /** 
300.      * 集合选择表达式测试 
301.      *  
302.      * @throws Exception 
303.      */  
304.     @SuppressWarnings("unchecked")  
305.     @Test  
306.     public void testSpelCollectionSelectExpression() throws Exception {  
307.         spel.setNumbers(Arrays.asList(2, 3, 4, 5, 6, 7, 9));  
308.         List<Integer> nums = (List<Integer>) exp.parseExpression(  
309.                 "numbers.?[#this >5]").getValue(secontext);  
310.         assertEquals(nums, Arrays.asList(6, 7, 9));  
311.         // 获取第一个元素  
312.         assertEquals(6,  
313.                 exp.parseExpression("numbers.^[#this > 5]").getValue(secontext));  
314.         // 获取最后一个元素  
315.         assertEquals(9,  
316.                 exp.parseExpression("numbers.$[#this > 5]").getValue(secontext));  
317.         Map<Integer, String> maps = (Map<Integer, String>) exp.parseExpression(  
318.                 "maps.?[value == 'string3' ]").getValue(secontext);  
319.         Map<Integer, String> tmap = new HashMap<Integer, String>();  
320.         tmap.put(3, "string3");  
321.         assertEquals(maps, tmap);  
322.         Map<Integer, String> mapk = (Map<Integer, String>) exp.parseExpression(  
323.                 "maps.?[key > 2 and key < 4 ]").getValue(secontext);  
324.         assertEquals(mapk, tmap);  
325.     }  
326.     /** 
327.      * 投影表达式测试 
328.      *  
329.      * @throws Exception 
330.      */  
331.     @SuppressWarnings("unchecked")  
332.     @Test  
333.     public void testSpelProjectionExpression() throws Exception {  
334.         spel.setNumbers(Arrays.asList(2, 3, 4, 5, 6));  
335.         assertEquals(Arrays.asList(5, 6, 7, 8, 9),  
336.                 exp.parseExpression("numbers.![#this+3]").getValue(secontext));  
337.         List<Integer> keys = (List<Integer>) exp.parseExpression("maps.![key]")  
338.                 .getValue(secontext);  
339.         assertEquals(keys, Arrays.asList(1, 2, 3, 4));  
340.         List<String> mapv = (List<String>) exp.parseExpression("maps.![value]")  
341.                 .getValue(secontext);  
342.         assertEquals(mapv,  
343.                 Arrays.asList("string1", "string2", "string3", "String4"));  
344.         List<Boolean> mapK = (List<Boolean>) exp.parseExpression(  
345.                 "maps.![key > 2 and value !='String4']").getValue(secontext);  
346.         assertEquals(mapK, Arrays.asList(false, false, true, false));  
347.     }  
348.     /** 
349.      * 模板语言测试 
350.      *  
351.      * @throws Exception 
352.      */  
353.     @Test  
354.     public void testSpelTemplate() throws Exception {  
355.         assertEquals(  
356.                 " this is a test 4",  
357.                 exp.parseExpression(" this is a test #{ maps.![key].get(3)}",  
358.                         new TemplateParserContext()).getValue(secontext,  
359.                         String.class));  
360.     }  
361. }  

顶

2

踩