SpEL 语法

String expression1 = "2>1 and (!true or !false)";  
boolean result1 = parser.parseExpression(expression1).getValue(boolean.class);  
Assert.assertEquals(true, result1);
String expression2 = "2>1 and (NOT true or NOT false)";

boolean result2 = parser.parseExpression(expression2).getValue(boolean.class);

Assert.assertEquals(true, result2);  

//3.给root对象属性赋值  
context.setRootObject(date);  
int result4 = parser.parseExpression("Year = 4").getValue(context, int.class);  
Assert.assertEquals(4, result4);  
parser.parseExpression("Year").setValue(context, 5);  
int result5 = parser.parseExpression("Year").getValue(context, int.class);  
Assert.assertEquals(5, result5); 

Date date = new Date();  
StandardEvaluationContext context = new StandardEvaluationContext(date);  
int result2 = parser.parseExpression("getYear()").getValue(context, int.class);  
Assert.assertEquals(date.getYear(), result2);  

@Test  
public void testBeanExpression() {  
    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext();  
    ctx.refresh();  
    ExpressionParser parser = new SpelExpressionParser();  
    StandardEvaluationContext context = new StandardEvaluationContext();  
    context.setBeanResolver(new BeanFactoryResolver(ctx));  
    Properties result1 = parser.parseExpression("@systemProperties").getValue(context, Properties.class);  
    Assert.assertEquals(System.getProperties(), result1);  
}  

//将返回不可修改的空List  
List<Integer> result2 = parser.parseExpression("{}").getValue(List.class); 

//对于字面量列表也将返回不可修改的List  
List<Integer> result1 = parser.parseExpression("{1,2,3}").getValue(List.class);  
Assert.assertEquals(new Integer(1), result1.get(0));  
try {  
    result1.set(0, 2);  
    //不可能执行到这，对于字面量列表不可修改  
    Assert.fail();  
} catch (Exception e) {  
}  

//对于列表中只要有一个不是字面量表达式，将只返回原始List，  
//不会进行不可修改处理  
String expression3 = "{{1+2,2+4},{3,4+4}}";  
List<List<Integer>> result3 = parser.parseExpression(expression3).getValue(List.class);  
result3.get(0).set(0, 1);  
Assert.assertEquals(2, result3.size());  

//声明一个大小为2的一维数组并初始化  
int[] result2 = parser.parseExpression("new int[2]{1,2}").getValue(int[].class);  

//定义一维数组但不初始化  
int[] result1 = parser.parseExpression("new int[1]").getValue(int[].class);  

//定义多维数组但不初始化  
int[][][] result3 = parser.parseExpression("new int[1][2][3]").getValue(int[][][].class);  

//错误的定义多维数组，多维数组不能初始化  
String expression4 = "new int[1][2][3]{{1}{2}{3}}";  
try {  
    int[][][] result4 = parser.parseExpression(expression4).getValue(int[][][].class);  
    Assert.fail();  
} catch (Exception e) {  
} 

//SpEL目前支持所有集合类型的访问  
Collection<Integer> collection = new HashSet<Integer>();  
collection.add(1);  
collection.add(2);  
EvaluationContext context2 = new StandardEvaluationContext();  
context2.setVariable("collection", collection);  
int result2 = parser.parseExpression("#collection[1]").getValue(context2, int.class);  
//对于任何集合类型通过Iterator来定位元素  
Assert.assertEquals(2, result2);  

//SpEL对Map字典元素访问的支持  
Map<String, Integer> map = new HashMap<String, Integer>();  
map.put("a", 1);  
EvaluationContext context3 = new StandardEvaluationContext();  
context3.setVariable("map", map);  
int result3 = parser.parseExpression("#map['a']").getValue(context3, int.class);  
Assert.assertEquals(1, result3);  

//1.修改数组元素值  
int[] array = new int[] {1, 2};  
EvaluationContext context1 = new StandardEvaluationContext();  
context1.setVariable("array", array);  
int result1 = parser.parseExpression("#array[1] = 3").getValue(context1, int.class);  
Assert.assertEquals(3, result1);  

//2.修改集合值  
Collection<Integer> collection = new ArrayList<Integer>();  
collection.add(1);  
collection.add(2);  
EvaluationContext context2 = new StandardEvaluationContext();  
context2.setVariable("collection", collection);  
int result2 = parser.parseExpression("#collection[1] = 3").getValue(context2, int.class);  
Assert.assertEquals(3, result2);  
parser.parseExpression("#collection[1]").setValue(context2, 4);  
result2 = parser.parseExpression("#collection[1]").getValue(context2, int.class);  
Assert.assertEquals(4, result2);  

//3.修改map元素值  
Map<String, Integer> map = new HashMap<String, Integer>();  
map.put("a", 1);  
EvaluationContext context3 = new StandardEvaluationContext();  
context3.setVariable("map", map);  
int result3 = parser.parseExpression("#map['a'] = 2").getValue(context3, int.class);  
Assert.assertEquals(2, result3);  

//1.首先准备测试数据  
Collection<Integer> collection = new ArrayList<Integer>();  
collection.add(4);   collection.add(5);  
Map<String, Integer> map = new HashMap<String, Integer>();  
map.put("a", 1);    map.put("b", 2);  

//3.测试字典  
EvaluationContext context2 = new StandardEvaluationContext();  
context2.setVariable("map", map);  
List<Integer> result2 =  
parser.parseExpression("#map.![ value+1]").getValue(context2, List.class);  
Assert.assertEquals(2, result2.size()); 

//1.首先准备测试数据  
Collection<Integer> collection = new ArrayList<Integer>();  
collection.add(4);   collection.add(5);  
Map<String, Integer> map = new HashMap<String, Integer>();  
map.put("a", 1);    map.put("b", 2);  

//2.集合或数组测试  
EvaluationContext context1 = new StandardEvaluationContext();  
context1.setVariable("collection", collection);  
Collection<Integer> result1 =  
parser.parseExpression("#collection.?[#this>4]").getValue(context1, Collection.class);  
Assert.assertEquals(1, result1.size());  
Assert.assertEquals(new Integer(5), result1.iterator().next());  

//3.字典测试  
EvaluationContext context2 = new StandardEvaluationContext();  
context2.setVariable("map", map);  
Map<String, Integer> result2 =  
parser.parseExpression("#map.?[#this.key != 'a']").getValue(context2, Map.class);  
Assert.assertEquals(1, result2.size());
List<Integer> result3 =

parser.parseExpression("#map.?[key != 'a'].![value+1]").getValue(context2, List.class);

Assert.assertEquals(new Integer(3), result3.iterator().next());