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

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

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

第一步，构建解析

1. ExpressionParser parser = new SpelExpressionParser();

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

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

第三步，获取结果

1. exp.getValue()

文本表达式支持字符表达式、日期、数字（正数、实数及十六进制数）、布尔类型及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(new Double(10280000), exp.parseExpression(lELs[1])
5. .getValue(Double.class));
6. assertEquals(new Integer(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());

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

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

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

1. // 属性测试。time为SpElUtil类Date型数据，这里调用Date的属性Year
2. assertEquals(new Integer(2011), exp.parseExpression("time.Year + 1900")
3. .getValue(secontext, Integer.class));
4. // 属性测试。innerClass为SpElUtil类中引入的其他类。
5. assertEquals(29,
6. exp.parseExpression("innerClass.age").getValue(secontext));
7. // 设置SpElUtil类的numbers属性
8. spel.setNumbers(Arrays.asList(2, 3, 4, 5, 6, 7, 9));
9. // 访问对象属性数组通过索引
10. assertEquals(2, exp.parseExpression("numbers[0]").getValue(secontext));
11. // 访问map
12. assertEquals("string1",
13. exp.parseExpression("maps[1]")
14. .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);
5. // 构造List<List<>>
6. List listOfLists = (List) exp.parseExpression("{ {1,2},{3,4} }")
7. .getValue(secontext);
8. assertEquals(Arrays.asList(1, 2), listOfLists.get(0));

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

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

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

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

2.6 操作符

支持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());

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

1. Date oldDate = spel.getTime();// 获取当前time属性值
2. exp.parseExpression("time").setValue(secontext, new Date(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);
7. // 或者使用下属方法赋值
8. assertEquals("abc",
9. 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));

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

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

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

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

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

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

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

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

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));

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

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

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

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

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

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

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

一大段测试用例：

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