Spring3 表达式语言(SpEL)介绍

文本引用：http://leeyee.github.io/blog/2011/06/19/spring-expression-language/

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

• 文本表达式
• 布尔类和关系操作
• 正则表达式
• 类表达式
• 访问属性、数组、集合和map
• 方法调用
• 关系操作
• 赋值操作
• 调用构造函数
• Bean 引用
• 数组构造
• 内联list
• 三元操作
• 变量
• 用户自定义函数
• 集合投影
• 集合选择
• 模板表达式

使用SpEl进行表达式操作，基本操作如下：

第一步，构建解析

1. ExpressionParser parser =newSpelExpressionParser();

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

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

第三步，获取结果

1. exp.getValue()

2.1 文本表达式

文本表达式支持字符表达式、日期、数字（正数、实数及十六进制数）、布尔类型及null.其中字符表达式需要用单引号声明。

对数字支持负数、指数及小数。默认情况下实数使用Double.parseDouble()进行表达式类型转换

1. String[] lELs ={"'hello SpEL'","1.028E+7","0x12EF","true","null"};
2. assertEquals("hello SpEL",
3. exp.parseExpression(lELs[0]).getValue(String.class));
4. assertEquals(newDouble(10280000), exp.parseExpression(lELs[1])
5. .getValue(Double.class));
6. assertEquals(newInteger(4847),
7. exp.parseExpression(lELs[2]).getValue(Integer.class));
8. assertTrue(exp.parseExpression(lELs[3]).getValue(Boolean.class));
9. assertNull(exp.parseExpression(lELs[4]).getValue());

2.2 属性、数组、列表、字典(map)及索引

在表达式中访问类属性时直接使用属性名，属性名首字母大小写均可。

访问数组时可以使用[index]进行元素对象范围。

访问列表时，可直接使用类表的方法，通过点操作符

1. // 属性测试。time为SpElUtil类Date型数据，这里调用Date的属性Year
2. assertEquals(newInteger(2011), exp.parseExpression("time.Year + 1900")
3. .getValue(secontext,Integer.class));
5. // 属性测试。innerClass为SpElUtil类中引入的其他类。
6. assertEquals(29,
7. exp.parseExpression("innerClass.age").getValue(secontext));
9. // 设置SpElUtil类的numbers属性
10. spel.setNumbers(Arrays.asList(2,3,4,5,6,7,9));
12. // 访问对象属性数组通过索引
13. assertEquals(2, exp.parseExpression("numbers[0]").getValue(secontext));
15. // 访问map
16. assertEquals("string1",
17. exp.parseExpression("maps[1]")
18. .getValue(secontext,String.class));

2.3 内置列表

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

1. // 构造list
2. List<String> nums =(List<String>) exp.parseExpression(
3. "{'a','b','c','d'}").getValue();
4. assertEquals(Arrays.asList("a","b","c","d"), nums);
6. // 构造List<List<>>
7. List listOfLists =(List) exp.parseExpression("{ {1,2},{3,4} }")
8. .getValue(secontext);
9. assertEquals(Arrays.asList(1,2), listOfLists.get(0));

2.4 数组构造(spring3.0.3中会抛出异常)

可以通过熟悉的java语法在表达是语言中定义。但目前不支持定义一个初始化的多维数组

1. // 创建没有初始值的数组
2. int[] a =(int[]) exp.parseExpression("new int[4]").getValue();
3. assertEquals(4, a.length);
5. // 创建带有初始值的数组
6. int[] b =(int[]) exp.parseExpression("new int[4]{1,2,3,4}").getValue();
7. assertEquals(3, b[2]);
9. // 创建二维数组
10. int[][] c =(int[][]) exp.parseExpression("new int[4][5]").getValue();
11. assertEquals(4, c.length);
12. assertEquals(5, c[0].length);

2.5 方法调用

表达式中的方法调用遵循java语法。

1. assertEquals(
2. "abC2def",
3. exp.parseExpression("'abcdef'.replace('c','C2')").getValue(
4. String.class));
6. // 自定义类方法测试
7. assertFalse(exp.parseExpression("innerClass.isGt30ForAge()").getValue(
8. secontext,Boolean.class));
9. spel.getInnerClass().setAge(34);
10. assertTrue(exp.parseExpression("innerClass.isGt30ForAge()").getValue(
11. secontext,Boolean.class));

2.6 操作符

2.6.1 关系操作符

支持eq("==")、ne("!=")、le("<=")、lt("<")、gt(">")、ge(">=")、div("/")、mod("%")、not("!")、正则表达式及instanceof操作

1. assertTrue(exp.parseExpression("1 == 1").getValue(Boolean.class));
2. assertTrue(exp.parseExpression("1 eq 1").getValue(Boolean.class));
3. assertTrue(exp.parseExpression("1 > -1").getValue(Boolean.class));
4. assertTrue(exp.parseExpression("1 gt -1").getValue(Boolean.class));
5. assertTrue(exp.parseExpression("'a' < 'b'").getValue(Boolean.class));
6. assertTrue(exp.parseExpression("'a' lt 'b'").getValue(Boolean.class));
7. assertTrue(exp.parseExpression(
8. " new Integer(123) instanceof T(Integer) ").getValue(
9. Boolean.class));
10. assertTrue(exp.parseExpression("'5.00' matches '^-?\\d+(\\.\\d{2})?$'")
11. .getValue(Boolean.class));

2.6.2 逻辑操作符

逻辑操作符支持and,or,not

1. assertTrue(exp.parseExpression("true and true").getValue(Boolean.class));

2.6.3 数学运算操作符

加法运算符可以用于数字，字符串和日期。减法可以用在数字和日期。乘法和除法只能用于对数字。其他受支持的数学运算是模数（％）和指数幂（^）。运行顺序按标准运算符优先级执行

1. assertEquals(25.0,
2. exp.parseExpression("1 + 2 * 8 div 4 mod 2 + 2 ^ 3 * 3e0")
3. .getValue());

2.7 赋值操作

通过赋值操作进行属性设置。通常是调用setValue方法，但也可以在调用getValue时设置。

1. Date oldDate = spel.getTime();// 获取当前time属性值
2. exp.parseExpression("time").setValue(secontext,newDate(113,2,25));// 为time属性重新赋值
3. Date newDate = spel.getTime();// 获取赋值后的time属性值
4. assertEquals(2013,
5. exp.parseExpression("time.Year + 1900").getValue(secontext));
6. assertNotSame(oldDate, newDate);
8. // 或者使用下属方法赋值
9. assertEquals("abc",
10. exp.parseExpression("Name = 'abc'").getValue(secontext));

2.8 类型

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

1. Class dateClass = exp.parseExpression("T(java.util.Date)").getValue(Class.class);
2. assertEquals("java.util.Date", dateClass.getName());
3. assertTrue(exp
4. .parseExpression(
5. "T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR")
6. .getValue(Boolean.class));

2.9 构造器

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

1. SpelTestInnerClass spt = exp
2. .parseExpression(
3. "new leeyee.study.spring3.bean.SpelTestInnerClass('constructTest',23)")
4. .getValue(SpelTestInnerClass.class);

2.10 变量

变量可以通过 #变量名 在表达式中被引用。变量通过StandardEvaluationContext类的setVariable方法进行设置

1. List<Integer> list =newArrayList<Integer>();
2. list.addAll(Arrays.asList(2,3,4,5,6,7,9));
4. secontext.setVariable("list", list);
5. List<Integer> vList =(List<Integer>) exp.parseExpression("#list")
6. .getValue(secontext);
7. assertEquals(vList, list);

2.10.1  #this变量

变量#this被定义为当前操作对象的引用。

1. List<Integer> nums =(List<Integer>) exp.parseExpression(
2. "#list.?[#this >5]").getValue(secontext);// 获取值大于5的元素集合
3. assertEquals(nums,Arrays.asList(6,7,9));

2.11 用户自定义函数

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

1. context.registerFunction("len",SpElUtil.class.getDeclaredMethod("len",
2. newClass[]{String.class}));
3. assertEquals(3, exp.parseExpression("#len('abc')").getValue(context));

2.12 三元操作

1. assertTrue(exp.parseExpression(" true ? true :false").getValue(
2. Boolean.class));

2.13 Elvis操作

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

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

1. @Value("#systemPro['mail.port'] ? : 25}")
2. // 当mail.port为空时将默认为25
3. Expression ex = exp.parseExpression("name?:'name is null'");
4. assertEquals("override", ex.getValue(secontext,String.class));
5. spel.setName(null);
6. assertEquals("name is null", ex.getValue(secontext,String.class));
7. spel.setName("override");

2.14 安全导航操作

该操作是为避免空指针异常。他是来自Groovy语言的。典型的当你有一个指向对象的引用，在你访问其方法或属性时，可能需要验证该对象的方法或属性是否为空，为了避免验证，使用安全导航操作将简单的返回null而不是空指针异常。

1. assertEquals("innerClass", exp.parseExpression("innerClass?.name")
2. .getValue(secontext,String.class));
3. spel.setInnerClass(null);
4. // 使用这种表达式可以避免抛出空指针异常
5. assertNull(exp.parseExpression("innerClass?.name").getValue(secontext,
6. String.class));

2.15 集合选择

选择是一个强大的表达式语言属性，可以使用选择表达式过滤源集合，从而生成一个新的符合选择条件的集合

选择的语法为?[selectionExpression]。他将过滤集合并且返回一个新的集合（原集合的子集）。选择语句也可用在Map中，过滤keySet及valueSet分别使用key和value关键字。另外：选择语法中，选择符合条件的结果集的第一个元素的语法为 ^[selectionExpression]，选择最后一个元素的语法为$[selectionExpression]

1. spel.setNumbers(Arrays.asList(2,3,4,5,6,7,9));
3. List<Integer> nums =(List<Integer>) exp.parseExpression(
4. "numbers.?[#this >5]").getValue(secontext);
5. assertEquals(nums,Arrays.asList(6,7,9));
7. // 获取第一个元素
8. assertEquals(6,
9. exp.parseExpression("numbers.^[#this > 5]").getValue(secontext));
11. // 获取最后一个元素
12. assertEquals(9,
13. exp.parseExpression("numbers.$[#this > 5]").getValue(secontext));
15. Map<Integer,String> maps =(Map<Integer,String>) exp.parseExpression(
16. "maps.?[value == 'string3' ]").getValue(secontext);
17. Map<Integer,String> tmap =newHashMap<Integer,String>();
18. tmap.put(3,"string3");
19. assertEquals(maps, tmap);
21. Map<Integer,String> mapk =(Map<Integer,String>) exp.parseExpression(
22. "maps.?[key > 2 and key < 4 ]").getValue(secontext);
23. assertEquals(mapk, tmap);

2.16 集合投影

语法![projectionExpression]判断集合中每个元素是否符合语法要求

1. assertEquals(Arrays.asList(5,6,7,8,9), exp
2. .parseExpression("numbers.![#this+3]").getValue(secontext));

2.17 模板表达式

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

1. assertEquals(
2. " this is a test 4",
3. exp.parseExpression(" this is a test #{ maps.![key].get(3)}",
4. newTemplateParserContext()).getValue(secontext,
5. String.class));

一大段测试用例：

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