`
jinnianshilongnian
  • 浏览: 21503969 次
  • 性别: Icon_minigender_1
博客专栏
5c8dac6a-21dc-3466-8abb-057664ab39c7
跟我学spring3
浏览量：2418633
D659df3e-4ad7-3b12-8b9a-1e94abd75ac3
Spring杂谈
浏览量：3008767
43989fe4-8b6b-3109-aaec-379d27dd4090
跟开涛学SpringMVC...
浏览量：5639455
1df97887-a9e1-3328-b6da-091f51f886a1
Servlet3.1规范翻...
浏览量：259916
4f347843-a078-36c1-977f-797c7fc123fc
springmvc杂谈
浏览量：1597309
22722232-95c1-34f2-b8e1-d059493d3d98
hibernate杂谈
浏览量：250216
45b32b6f-7468-3077-be40-00a5853c9a48
跟我学Shiro
浏览量：5858946
Group-logo
跟我学Nginx+Lua开...
浏览量：701998
5041f67a-12b2-30ba-814d-b55f466529d5
亿级流量网站架构核心技术
浏览量：785219
社区版块
存档分类
最新评论

【第五章】Spring表达式语言 之 5.3 SpEL语法 ——跟我学spring3

spring 
阅读更多

 

5.3  SpEL语法

5.3.1  基本表达式

一、字面量表达式： SpEL支持的字面量包括：字符串、数字类型（int、long、float、double）、布尔类型、null类型。

类型

示例

字符串

String str1 = parser.parseExpression("'Hello World!'").getValue(String.class);

String str2 = parser.parseExpression("\"Hello World!\"").getValue(String.class);

数字类型

int int1 = parser.parseExpression("1").getValue(Integer.class);

long long1 = parser.parseExpression("-1L").getValue(long.class);

float float1 = parser.parseExpression("1.1").getValue(Float.class);

double double1 = parser.parseExpression("1.1E+2").getValue(double.class);

int hex1 = parser.parseExpression("0xa").getValue(Integer.class);

long hex2 = parser.parseExpression("0xaL").getValue(long.class);

布尔类型

boolean true1 = parser.parseExpression("true").getValue(boolean.class);

boolean false1 = parser.parseExpression("false").getValue(boolean.class);

null类型

Object null1 = parser.parseExpression("null").getValue(Object.class);

 

二、算数运算表达式： SpEL支持加(+)、减(-)、乘(*)、除(/)、求余（%）、幂（^）运算。

类型

示例

加减乘除

int result1 = parser.parseExpression("1+2-3*4/2").getValue(Integer.class);//-3

求余

int result2 = parser.parseExpression("4%3").getValue(Integer.class);//1

幂运算

int result3 = parser.parseExpression("2^3").getValue(Integer.class);//8

SpEL还提供求余（MOD）和除（DIV）而外两个运算符，与“%”和“/”等价，不区分大小写。

 

三、关系表达式：等于（==）、不等于(!=)、大于(>)、大于等于(>=)、小于(<)、小于等于(<=)，区间（between）运算，如“parser.parseExpression("1>2").getValue(boolean.class);”将返回false；而“parser.parseExpression("1 between {1, 2}").getValue(boolean.class);”将返回true。

       between运算符右边操作数必须是列表类型，且只能包含2个元素。第一个元素为开始，第二个元素为结束，区间运算是包含边界值的，即 xxx>=list.get(0) && xxx<=list.get(1)。

       SpEL同样提供了等价的“EQ” 、“NE”、 “GT”、“GE”、 “LT” 、“LE”来表示等于、不等于、大于、大于等于、小于、小于等于，不区分大小写。

 

四、逻辑表达式：且（and）、或(or)、非(!或NOT)。

 

java代码：
查看复制到剪贴板打印
  1. String expression1 = "2>1 and (!true or !false)";  
  2. boolean result1 = parser.parseExpression(expression1).getValue(boolean.class);  
  3. Assert.assertEquals(true, result1);  
  4.    
  5. String expression2 = "2>1 and (NOT true or NOT false)";  
  6. boolean result2 = parser.parseExpression(expression2).getValue(boolean.class);  
  7. Assert.assertEquals(true, result2);  

 

注：逻辑运算符不支持 Java中的 && 和 || 。

 

五、字符串连接及截取表达式：使用“+”进行字符串连接，使用“'String'[0] [index]”来截取一个字符，目前只支持截取一个，如“'Hello ' + 'World!'”得到“Hello World!”；而“'Hello World!'[0]”将返回“H”。

 

六、三目运算及Elivis运算表达式：

三目运算符 “表达式1?表达式2:表达式3”用于构造三目运算表达式，如“2>1?true:false”将返回true；

Elivis运算符“表达式1?:表达式2”从Groovy语言引入用于简化三目运算符的，当表达式1为非null时则返回表达式1，当表达式1为null时则返回表达式2，简化了三目运算符方式“表达式1? 表达式1:表达式2”，如“null?:false”将返回false，而“true?:false”将返回true；

 

七、正则表达式：使用“str matches regex，如“'123' matches '\\d{3}'”将返回true；

 

八、括号优先级表达式：使用“(表达式)”构造，括号里的具有高优先级。

 

5.3.3  类相关表达式

一、类类型表达式：使用“T(Type)”来表示java.lang.Class实例，“Type”必须是类全限定名，“java.lang”包除外，即该包下的类可以不指定包名；使用类类型表达式还可以进行访问类静态方法及类静态字段。

        具体使用方法如下：

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testClassTypeExpression() {  
  3.     ExpressionParser parser = new SpelExpressionParser();  
  4.     //java.lang包类访问  
  5.     Class<String> result1 = parser.parseExpression("T(String)").getValue(Class.class);  
  6.     Assert.assertEquals(String.class, result1);  
  7.     //其他包类访问  
  8.     String expression2 = "T(cn.javass.spring.chapter5.SpELTest)";  
  9.     Class<String> result2 = parser.parseExpression(expression2).getValue(Class.class);    Assert.assertEquals(SpELTest.class, result2);  
  10.     //类静态字段访问  
  11.     int result3=parser.parseExpression("T(Integer).MAX_VALUE").getValue(int.class);  
  12.     Assert.assertEquals(Integer.MAX_VALUE, result3);  
  13.     //类静态方法调用  
  14.     int result4 = parser.parseExpression("T(Integer).parseInt('1')").getValue(int.class);  
  15.     Assert.assertEquals(1, result4);  
  16. }  

 

       对于java.lang包里的可以直接使用“T(String)”访问；其他包必须是类全限定名；可以进行静态字段访问如“T(Integer).MAX_VALUE”；也可以进行静态方法访问如“T(Integer).parseInt('1')”。

 

二、类实例化：类实例化同样使用java关键字“new”，类名必须是全限定名，但java.lang包内的类型除外，如String、Integer。

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testConstructorExpression() {  
  3.     ExpressionParser parser = new SpelExpressionParser();  
  4.     String result1 = parser.parseExpression("new String('haha')").getValue(String.class);  
  5.     Assert.assertEquals("haha", result1);  
  6.     Date result2 = parser.parseExpression("new java.util.Date()").getValue(Date.class);  
  7.     Assert.assertNotNull(result2);  
  8. }  

 

       实例化完全跟Java内方式一样。

 

三、instanceof表达式：SpEL支持instanceof运算符，跟Java内使用同义；如“'haha' instanceof T(String)”将返回true。

 

四、变量定义及引用：变量定义通过EvaluationContext接口的setVariable(variableName, value)方法定义；在表达式中使用“#variableName”引用；除了引用自定义变量，SpE还允许引用根对象及当前上下文对象，使用“#root”引用根对象，使用“#this”引用当前上下文对象；

 

java代码：
查看复制到剪贴板打印
  1.       
  2. @Test  
  3. public void testVariableExpression() {  
  4.     ExpressionParser parser = new SpelExpressionParser();  
  5.     EvaluationContext context = new StandardEvaluationContext();  
  6.     context.setVariable("variable", "haha");  
  7.     context.setVariable("variable", "haha");  
  8.     String result1 = parser.parseExpression("#variable").getValue(context, String.class);  
  9.     Assert.assertEquals("haha", result1);  
  10.    
  11.     context = new StandardEvaluationContext("haha");  
  12.     String result2 = parser.parseExpression("#root").getValue(context, String.class);  
  13.     Assert.assertEquals("haha", result2);  
  14.     String result3 = parser.parseExpression("#this").getValue(context, String.class);  
  15.     Assert.assertEquals("haha", result3);  
  16. }  

 

       使用“#variable”来引用在EvaluationContext定义的变量；除了可以引用自定义变量，还可以使用“#root”引用根对象，“#this”引用当前上下文对象，此处“#this”即根对象。

 

五、自定义函数：目前只支持类静态方法注册为自定义函数；SpEL使用StandardEvaluationContext的registerFunction方法进行注册自定义函数，其实完全可以使用setVariable代替，两者其实本质是一样的；

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testFunctionExpression() throws SecurityException, NoSuchMethodException {  
  3.     ExpressionParser parser = new SpelExpressionParser();  
  4.     StandardEvaluationContext context = new StandardEvaluationContext();  
  5.     Method parseInt = Integer.class.getDeclaredMethod("parseInt", String.class);  
  6.     context.registerFunction("parseInt", parseInt);  
  7.     context.setVariable("parseInt2", parseInt);  
  8.     String expression1 = "#parseInt('3') == #parseInt2('3')";  
  9.     boolean result1 = parser.parseExpression(expression1).getValue(context, boolean.class);  
  10.     Assert.assertEquals(true, result1);         
  11. }  
  12.    

       此处可以看出“registerFunction”和“setVariable”都可以注册自定义函数，但是两个方法的含义不一样，推荐使用“registerFunction”方法注册自定义函数。

 

六、赋值表达式：SpEL即允许给自定义变量赋值，也允许给跟对象赋值，直接使用“#variableName=value”即可赋值：

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testAssignExpression() {  
  3.     ExpressionParser parser = new SpelExpressionParser();  
  4.     //1.给root对象赋值  
  5.     EvaluationContext context = new StandardEvaluationContext("aaaa");  
  6.     String result1 = parser.parseExpression("#root='aaaaa'").getValue(context, String.class);  
  7.     Assert.assertEquals("aaaaa", result1);  
  8.     String result2 = parser.parseExpression("#this='aaaa'").getValue(context, String.class);  
  9.     Assert.assertEquals("aaaa", result2);  
  10.    
  11.     //2.给自定义变量赋值  
  12.     context.setVariable("#variable", "variable");  
  13.     String result3 = parser.parseExpression("#variable=#root").getValue(context, String.class);  
  14.     Assert.assertEquals("aaaa", result3);  
  15. }  

       使用“#root='aaaaa'”给根对象赋值，使用“"#this='aaaa'”给当前上下文对象赋值，使用“#variable=#root”给自定义变量赋值，很简单。

 

七、对象属性存取及安全导航表达式：对象属性获取非常简单，即使用如“a.property.property”这种点缀式获取，SpEL对于属性名首字母是不区分大小写的；SpEL还引入了Groovy语言中的安全导航运算符“(对象|属性)?.属性”，用来避免但“?.”前边的表达式为null时抛出空指针异常，而是返回null；修改对象属性值则可以通过赋值表达式或Expression接口的setValue方法修改。

 

java代码：
查看复制到剪贴板打印
  1. ExpressionParser parser = new SpelExpressionParser();  
  2. //1.访问root对象属性  
  3. Date date = new Date();  
  4. StandardEvaluationContext context = new StandardEvaluationContext(date);  
  5. int result1 = parser.parseExpression("Year").getValue(context, int.class);  
  6. Assert.assertEquals(date.getYear(), result1);  
  7. int result2 = parser.parseExpression("year").getValue(context, int.class);  
  8. Assert.assertEquals(date.getYear(), result2);         

 

       对于当前上下文对象属性及方法访问，可以直接使用属性或方法名访问，比如此处根对象date属性“year”，注意此处属性名首字母不区分大小写。

 

 

java代码：
查看复制到剪贴板打印
  1.       
  2. //2.安全访问  
  3. context.setRootObject(null);  
  4. Object result3 = parser.parseExpression("#root?.year").getValue(context, Object.class);  
  5. Assert.assertEquals(null, result3);     
  6.    

 

       SpEL引入了Groovy的安全导航运算符，比如此处根对象为null，所以如果访问其属性时肯定抛出空指针异常，而采用“?.”安全访问导航运算符将不抛空指针异常，而是简单的返回null。

 

java代码：
查看复制到剪贴板打印
  1. //3.给root对象属性赋值  
  2. context.setRootObject(date);  
  3. int result4 = parser.parseExpression("Year = 4").getValue(context, int.class);  
  4. Assert.assertEquals(4, result4);  
  5. parser.parseExpression("Year").setValue(context, 5);  
  6. int result5 = parser.parseExpression("Year").getValue(context, int.class);  
  7. Assert.assertEquals(5, result5);  
  8.    

       给对象属性赋值可以采用赋值表达式或Expression接口的setValue方法赋值，而且也可以采用点缀方式赋值。

 

八、对象方法调用：对象方法调用更简单，跟Java语法一样；如“'haha'.substring(2,4)”将返回“ha”；而对于根对象可以直接调用方法；

 

java代码：
查看复制到剪贴板打印
  1. Date date = new Date();  
  2. StandardEvaluationContext context = new StandardEvaluationContext(date);  
  3. int result2 = parser.parseExpression("getYear()").getValue(context, int.class);  
  4. Assert.assertEquals(date.getYear(), result2);  

 

       比如根对象date方法“getYear”可以直接调用。

 

九、Bean引用：SpEL支持使用“@”符号来引用Bean，在引用Bean时需要使用BeanResolver接口实现来查找Bean，Spring提供BeanFactoryResolver实现；

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testBeanExpression() {  
  3.     ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext();  
  4.     ctx.refresh();  
  5.     ExpressionParser parser = new SpelExpressionParser();  
  6.     StandardEvaluationContext context = new StandardEvaluationContext();  
  7.     context.setBeanResolver(new BeanFactoryResolver(ctx));  
  8.     Properties result1 = parser.parseExpression("@systemProperties").getValue(context, Properties.class);  
  9.     Assert.assertEquals(System.getProperties(), result1);  
  10. }  

 

       在示例中我们首先初始化了一个IoC容器，ClassPathXmlApplicationContext 实现默认会把“System.getProperties()”注册为“systemProperties”Bean，因此我们使用 “@systemProperties”来引用该Bean。

 

5.3.3  集合相关表达式

一、内联List：从Spring3.0.4开始支持内联List，使用{表达式，……}定义内联List，如“{1,2,3}”将返回一个整型的ArrayList，而“{}”将返回空的List，对于字面量表达式列表，SpEL会使用java.util.Collections.unmodifiableList方法将列表设置为不可修改。

 

java代码：
查看复制到剪贴板打印
  1. //将返回不可修改的空List  
  2. List<Integer> result2 = parser.parseExpression("{}").getValue(List.class);  

 

 

 

java代码：
查看复制到剪贴板打印
  1. //对于字面量列表也将返回不可修改的List  
  2. List<Integer> result1 = parser.parseExpression("{1,2,3}").getValue(List.class);  
  3. Assert.assertEquals(new Integer(1), result1.get(0));  
  4. try {  
  5.     result1.set(0, 2);  
  6.     //不可能执行到这，对于字面量列表不可修改  
  7.     Assert.fail();  
  8. } catch (Exception e) {  
  9. }  

 

 

java代码：
查看复制到剪贴板打印
  1. //对于列表中只要有一个不是字面量表达式，将只返回原始List，  
  2. //不会进行不可修改处理  
  3. String expression3 = "{{1+2,2+4},{3,4+4}}";  
  4. List<List<Integer>> result3 = parser.parseExpression(expression3).getValue(List.class);  
  5. result3.get(0).set(0, 1);  
  6. Assert.assertEquals(2, result3.size());  

 

 

java代码：
查看复制到剪贴板打印
  1. //声明一个大小为2的一维数组并初始化  
  2. int[] result2 = parser.parseExpression("new int[2]{1,2}").getValue(int[].class);  

 

 

java代码：
查看复制到剪贴板打印
  1. //定义一维数组但不初始化  
  2. int[] result1 = parser.parseExpression("new int[1]").getValue(int[].class);  

 

 

二、内联数组：和Java 数组定义类似，只是在定义时进行多维数组初始化。

 

 

java代码：
查看复制到剪贴板打印
  1.       
  2. //定义多维数组但不初始化  
  3. int[][][] result3 = parser.parseExpression("new int[1][2][3]").getValue(int[][][].class);  

 

 

java代码：
查看复制到剪贴板打印
  1. //错误的定义多维数组，多维数组不能初始化  
  2. String expression4 = "new int[1][2][3]{{1}{2}{3}}";  
  3. try {  
  4.     int[][][] result4 = parser.parseExpression(expression4).getValue(int[][][].class);  
  5.     Assert.fail();  
  6. } catch (Exception e) {  
  7. }  

 

 

三、集合，字典元素访问：SpEL目前支持所有集合类型和字典类型的元素访问，使用“集合[索引]”访问集合元素，使用“map[key]”访问字典元素；

 

java代码：
查看复制到剪贴板打印
  1. //SpEL内联List访问  
  2. int result1 = parser.parseExpression("{1,2,3}[0]").getValue(int.class);  
  3. //即list.get(0)  
  4. Assert.assertEquals(1, result1);  
  5.    

 

 

java代码：
查看复制到剪贴板打印
  1. //SpEL目前支持所有集合类型的访问  
  2. Collection<Integer> collection = new HashSet<Integer>();  
  3. collection.add(1);  
  4. collection.add(2);  
  5. EvaluationContext context2 = new StandardEvaluationContext();  
  6. context2.setVariable("collection", collection);  
  7. int result2 = parser.parseExpression("#collection[1]").getValue(context2, int.class);  
  8. //对于任何集合类型通过Iterator来定位元素  
  9. Assert.assertEquals(2, result2);  

 

 

java代码：
查看复制到剪贴板打印
  1. //SpEL对Map字典元素访问的支持  
  2. Map<String, Integer> map = new HashMap<String, Integer>();  
  3. map.put("a", 1);  
  4. EvaluationContext context3 = new StandardEvaluationContext();  
  5. context3.setVariable("map", map);  
  6. int result3 = parser.parseExpression("#map['a']").getValue(context3, int.class);  
  7. Assert.assertEquals(1, result3);  

 

       注：集合元素访问是通过Iterator遍历来定位元素位置的。

 

 

四、列表，字典，数组元素修改：可以使用赋值表达式或Expression接口的setValue方法修改；

 

java代码：
查看复制到剪贴板打印
  1. //1.修改数组元素值  
  2. int[] array = new int[] {1, 2};  
  3. EvaluationContext context1 = new StandardEvaluationContext();  
  4. context1.setVariable("array", array);  
  5. int result1 = parser.parseExpression("#array[1] = 3").getValue(context1, int.class);  
  6. Assert.assertEquals(3, result1);  

 

 

java代码：
查看复制到剪贴板打印
  1. //2.修改集合值  
  2. Collection<Integer> collection = new ArrayList<Integer>();  
  3. collection.add(1);  
  4. collection.add(2);  
  5. EvaluationContext context2 = new StandardEvaluationContext();  
  6. context2.setVariable("collection", collection);  
  7. int result2 = parser.parseExpression("#collection[1] = 3").getValue(context2, int.class);  
  8. Assert.assertEquals(3, result2);  
  9. parser.parseExpression("#collection[1]").setValue(context2, 4);  
  10. result2 = parser.parseExpression("#collection[1]").getValue(context2, int.class);  
  11. Assert.assertEquals(4, result2);  

 

 

java代码：
查看复制到剪贴板打印
  1. //3.修改map元素值  
  2. Map<String, Integer> map = new HashMap<String, Integer>();  
  3. map.put("a", 1);  
  4. EvaluationContext context3 = new StandardEvaluationContext();  
  5. context3.setVariable("map", map);  
  6. int result3 = parser.parseExpression("#map['a'] = 2").getValue(context3, int.class);  
  7. Assert.assertEquals(2, result3);  

 

       对数组修改直接对“#array[index]”赋值即可修改元素值，同理适用于集合和字典类型。

 

五、集合投影：在SQL中投影指从表中选择出列，而在SpEL指根据集合中的元素中通过选择来构造另一个集合，该集合和原集合具有相同数量的元素；SpEL使用“（list|map）.![投影表达式]”来进行投影运算：

 

java代码：
查看复制到剪贴板打印
  1. //1.首先准备测试数据  
  2. Collection<Integer> collection = new ArrayList<Integer>();  
  3. collection.add(4);   collection.add(5);  
  4. Map<String, Integer> map = new HashMap<String, Integer>();  
  5. map.put("a", 1);    map.put("b", 2);  

 

 

java代码：
查看复制到剪贴板打印
  1. //2.测试集合或数组  
  2. EvaluationContext context1 = new StandardEvaluationContext();  
  3. context1.setVariable("collection", collection);  
  4. Collection<Integer> result1 =  
  5. parser.parseExpression("#collection.![#this+1]").getValue(context1, Collection.class);  
  6. Assert.assertEquals(2, result1.size());  
  7. Assert.assertEquals(new Integer(5), result1.iterator().next());  
  8.          

 

       对于集合或数组使用如上表达式进行投影运算，其中投影表达式中“#this”代表每个集合或数组元素，可以使用比如“#this.property”来获取集合元素的属性，其中“#this”可以省略。

 

 

java代码：
查看复制到剪贴板打印
  1. //3.测试字典  
  2. EvaluationContext context2 = new StandardEvaluationContext();  
  3. context2.setVariable("map", map);  
  4. List<Integer> result2 =  
  5. parser.parseExpression("#map.![ value+1]").getValue(context2, List.class);  
  6. Assert.assertEquals(2, result2.size());  

 

       SpEL投影运算还支持Map投影，但Map投影最终只能得到List结果，如上所示，对于投影表达式中的“#this”将是Map.Entry，所以可以使用“value”来获取值，使用“key”来获取键。

 

 

六、集合选择：在SQL中指使用select进行选择行数据，而在SpEL指根据原集合通过条件表达式选择出满足条件的元素并构造为新的集合，SpEL使用“(list|map).?[选择表达式]”，其中选择表达式结果必须是boolean类型，如果true则选择的元素将添加到新集合中，false将不添加到新集合中。

 

java代码：
查看复制到剪贴板打印
  1. //1.首先准备测试数据  
  2. Collection<Integer> collection = new ArrayList<Integer>();  
  3. collection.add(4);   collection.add(5);  
  4. Map<String, Integer> map = new HashMap<String, Integer>();  
  5. map.put("a", 1);    map.put("b", 2);  

 

 

java代码：
查看复制到剪贴板打印
  1. //2.集合或数组测试  
  2. EvaluationContext context1 = new StandardEvaluationContext();  
  3. context1.setVariable("collection", collection);  
  4. Collection<Integer> result1 =  
  5. parser.parseExpression("#collection.?[#this>4]").getValue(context1, Collection.class);  
  6. Assert.assertEquals(1, result1.size());  
  7. Assert.assertEquals(new Integer(5), result1.iterator().next());  

 

       对于集合或数组选择，如“#collection.?[#this>4]”将选择出集合元素值大于4的所有元素。选择表达式必须返回布尔类型，使用“#this”表示当前元素。

 

 

java代码：
查看复制到剪贴板打印
  1. //3.字典测试  
  2. EvaluationContext context2 = new StandardEvaluationContext();  
  3. context2.setVariable("map", map);  
  4. Map<String, Integer> result2 =  
  5. parser.parseExpression("#map.?[#this.key != 'a']").getValue(context2, Map.class);  
  6. Assert.assertEquals(1, result2.size());  
  7.    
  8. List<Integer> result3 =  
  9.  parser.parseExpression("#map.?[key != 'a'].![value+1]").getValue(context2, List.class);  
  10. Assert.assertEquals(new Integer(3), result3.iterator().next());  

 

       对于字典选择，如“#map.?[#this.key != 'a']”将选择键值不等于”a”的，其中选择表达式中“#this”是Map.Entry类型，而最终结果还是Map，这点和投影不同；集合选择和投影可以一起使用，如“#map.?[key != 'a'].![value+1]”将首先选择键值不等于”a”的，然后在选出的Map中再进行“value+1”的投影。

 

5.3.4  表达式模板

       模板表达式就是由字面量与一个或多个表达式块组成。每个表达式块由“前缀+表达式+后缀”形式组成，如“${1+2}”即表达式块。在前边我们已经介绍了使用ParserContext接口实现来定义表达式是否是模板及前缀和后缀定义。在此就不多介绍了，如“Error ${#v0} ${#v1}”表达式表示由字面量“Error ”、模板表达式“#v0”、模板表达式“#v1”组成，其中v0和v1表示自定义变量，需要在上下文定义。

 

 

原创内容 转自请注明私塾在线【http://sishuok.com/forum/blogPost/list/0/2463.html】

 

15
顶
1
踩
分享到：
| 【第五章】Spring表达式语言 之 5.1 概述 ...
评论
15 楼 jinnianshilongnian 2013-07-18  
liangzhu 写道
int[] result2 = parser.parseExpression("new int[2]{1,2}").getValue(int[].class); 
这个明显是一维数组初始化。

int[][][] result3 = parser.parseExpression(expression3).getValue(int[][][].class);
这个expression3如果是"{{1+2,2+4},{3,4+4}}"的话那也是二维吧，而且按你下面的说法不能初始化这个式子也有问题。

再有，String expression4 = "new int[1][2][3]{{1}{2}{3}}";  这个声明是三维数组，但初始化部分也是二维数组。


再有，String expression4 = "new int[1][2][3]{{1}{2}{3}}";  这个声明是三维数组，但初始化部分也是二维数组。 

这个本来就是错误的初始化


第二个问题 是复制源代码 漏了一部分
14 楼 jinnianshilongnian 2013-07-18  
liangzhu 写道
int[] result2 = parser.parseExpression("new int[2]{1,2}").getValue(int[].class); 
这个明显是一维数组初始化。

int[][][] result3 = parser.parseExpression(expression3).getValue(int[][][].class);
这个expression3如果是"{{1+2,2+4},{3,4+4}}"的话那也是二维吧，而且按你下面的说法不能初始化这个式子也有问题。

再有，String expression4 = "new int[1][2][3]{{1}{2}{3}}";  这个声明是三维数组，但初始化部分也是二维数组。



确实写错了，我修正下
13 楼 liangzhu 2013-07-18  
int[] result2 = parser.parseExpression("new int[2]{1,2}").getValue(int[].class); 
这个明显是一维数组初始化。

int[][][] result3 = parser.parseExpression(expression3).getValue(int[][][].class);
这个expression3如果是"{{1+2,2+4},{3,4+4}}"的话那也是二维吧，而且按你下面的说法不能初始化这个式子也有问题。

再有，String expression4 = "new int[1][2][3]{{1}{2}{3}}";  这个声明是三维数组，但初始化部分也是二维数组。
12 楼 jinnianshilongnian 2013-07-18  
liangzhu 写道
//声明二维数组并初始化 
int[] result2 = parser.parseExpression("new int[2]{1,2}").getValue(int[].class); 

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

这两处不对吧


为什么不对？
11 楼 liangzhu 2013-07-18  
//声明二维数组并初始化 
int[] result2 = parser.parseExpression("new int[2]{1,2}").getValue(int[].class); 

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

这两处不对吧
10 楼 jinnianshilongnian 2013-01-22  
superscorpio 写道
jinnianshilongnian 写道
superscorpio 写道
正准备用表达式，不过想试试mvel。博主有没有什么建议？

用在spring中吗？ 主要干什么？

如果涉及到模型的类型转换、格式化、验证 建议还是用spel，这个是spring内部支持的。


我们这里有一个挺复杂的查询，好几十个条件，支持的运算符有几种，而且以后很可能扩展。我觉得自己写实现量太大且容易出错，所以打算用解析表达式的方法来处理。

感觉spel的一个好处是可以在上下文中使用容器管理的bean，主要功能跟其他表达式语言差不多。spel借鉴groovy，和投影的部分挺不错。

你需要的明显是一种dsl；而且最主要功能是if-else；所以spel不太适合你，在这方面它有点弱（毕竟目的是表达式语言）；
当然你也可以考虑其他的脚步语言；如javascript；BeanShell；
9 楼 superscorpio 2013-01-21  
jinnianshilongnian 写道
superscorpio 写道
正准备用表达式，不过想试试mvel。博主有没有什么建议？

用在spring中吗？ 主要干什么？

如果涉及到模型的类型转换、格式化、验证 建议还是用spel，这个是spring内部支持的。


我们这里有一个挺复杂的查询，好几十个条件，支持的运算符有几种，而且以后很可能扩展。我觉得自己写实现量太大且容易出错，所以打算用解析表达式的方法来处理。

感觉spel的一个好处是可以在上下文中使用容器管理的bean，主要功能跟其他表达式语言差不多。spel借鉴groovy，和投影的部分挺不错。
8 楼 jinnianshilongnian 2013-01-21  
superscorpio 写道
正准备用表达式，不过想试试mvel。博主有没有什么建议？

用在spring中吗？ 主要干什么？

如果涉及到模型的类型转换、格式化、验证 建议还是用spel，这个是spring内部支持的。
7 楼 superscorpio 2013-01-21  
正准备用表达式，不过想试试mvel。博主有没有什么建议？
6 楼 jinnianshilongnian 2012-11-06  
freezingsky 写道
这一块的内容应该在平常比较少用到。但是对于一些比如需要由用户进行配置的地方就肯定用得上。不过，那时采用的是bsh.

还有一种选择是 javascript 
5 楼 freezingsky 2012-11-06  
这一块的内容应该在平常比较少用到。但是对于一些比如需要由用户进行配置的地方就肯定用得上。不过，那时采用的是bsh.
4 楼 jinnianshilongnian 2012-04-16  
kidalive 写道
jinnianshilongnian 写道
kimifdw 写道
Spring的表达式在项目中用的多么？

目前我还没有遇到过

那你还讲..哈哈.不过做为课程来说是需要讲的..嗯嗯.


我不用 不代表别人不用  。我使用的场景比较小！ 而且SpEL现在是spring比较核心的模块
3 楼 kidalive 2012-04-16  
jinnianshilongnian 写道
kimifdw 写道
Spring的表达式在项目中用的多么？

目前我还没有遇到过

那你还讲..哈哈.不过做为课程来说是需要讲的..嗯嗯.
2 楼 jinnianshilongnian 2012-04-05  
kimifdw 写道
Spring的表达式在项目中用的多么？

目前我还没有遇到过
1 楼 kimifdw 2012-04-05  
Spring的表达式在项目中用的多么？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    跟开涛学Spring

    1.16 【第五章】Spring表达式语言 之 5.3 SpEL语法 ——跟我学spring3 . . . . . . . . . . . . . . . . . . . . . .183 1.17 【第五章】Spring表达式语言 之 5.4在Bean定义中使用EL—跟我学spring3 . . . . . . . ...

    Spring表达式语言中文参考手册.docx

    ### Spring 表达式语言 (SpEL) 中文参考手册概览 #### 一、Spring SpEL 概念与用途 Spring SpEL（Spring Expression Language）是一种强大的表达式语言，用于处理运行时查询和操作对象图。SpEL 的设计目标是提供一...

    spring spEL 表达式详解

    Spring Expression Language，简称SpEL，是Spring框架中的一个强大表达式语言，用于在运行时查询和操作对象图。它提供了丰富的表达式语法，支持属性访问、方法调用、算术运算、逻辑判断以及控制流等操作，极大地简化...

    Spring开发手册_表达式语言_API中文版

    **Spring 表达式语言（SpEL）API 中文版** Spring 表达式语言（Spring Expression Language，简称 SpEL）是 Spring 框架中一个强大的表达式系统，用于在运行时查询和操作对象图。它允许动态访问和修改对象属性、...

    基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志框架+源代码+文档说明

    基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志 ### 简介 * 使用annotation来标注方法，标记操作内容 * 使用SpEL来动态生成操作日志内容，使操作日志记录更加详细（记录操作内容ID等关键信息） * ...

    spring3.0.2api 文档spring表达式语言

    在本文中，我们将深入探讨Spring 3.0.2 API文档中的核心组件，特别是Spring表达式语言（SpEL），它是Spring框架中的一个强大工具，用于在运行时查询和操作对象图。 Spring表达式语言（Spring Expression Language，...

    Spring表达式语言.pdf

    ### Spring表达式语言(SpEL)详解 #### 引言 Spring框架自3.0版本引入了一种全新的配置对象依赖注入的方式—Spring表达式语言(SpEL)，这为开发人员提供了一个灵活且强大的工具，使得在配置文件或注解中进行复杂的...

    Spring_SpEl表达式使用用例

    Spring Expression Language (SpEL)是Spring框架中的一种强大而灵活的表达式语言，主要用于在运行时查询和操作对象图。它提供了在配置元数据中进行表达式评估的能力，使得我们可以更加动态地控制Spring应用程序的...

    opt-log:基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志框架

    opt-log基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志简介使用annotation来标注方法，标记操作内容使用SpEL来动态生成操作日志内容，使操作日志记录更加详细（记录操作内容ID等关键信息）同一个...

    跟我学spring

    【第五章】Spring表达式语言（SpEL）是一个强大的表达式语言，支持在运行时查询和操作对象图。5.1节概述SpEL，5.2节和5.3节详细说明SpEL的基础和语法，5.4节则展示了如何在Bean定义中使用SpEL。 【第六章】面向切面...

    Spring表达式语言SpEL用法详解

    Spring表达式语言SpEL用法详解 Spring表达式语言SpEL是一种强大的表达式语言，支持运行时查询和操作对象图。SpEL使用#{...}作为定界符，所有在大括号中的字符串均被认为是SpEL。SpEL为bean的属性进行动态赋值提供了...

    Spring组件开发模式支持SPEL表达式

    SPEL表达式是Spring框架提供的一种表达式语言，允许开发者使用灵活的语法来表达复杂的业务逻辑。SPEL表达式可以用于实现各种业务逻辑，例如数据验证、数据转换、条件判断等。在Spring框架中，SPEL表达式可以与Bean...

    跟我学spring3 .pdf

    《跟我学Spring3》这本书是针对Spring框架进行深入解析的一本教程，涵盖了Spring的核心特性，包括IoC（Inversion of Control，控制反转）、DI（Dependency Injection，依赖注入）、AOP（Aspect-Oriented Programming...

    跟我学Spring

    《跟我学Spring》这本书主要涵盖了Spring框架的核心概念和使用方法，包括IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入），以及AOP（Aspect Oriented Programming，面向切面编程）、...

    跟我学Spring,Spring3学习资料

    Spring表达式语言（SpEL） - **SpEL概述：** 简介了SpEL的用途以及基本语法。 - **SpEL基础与语法：** 详细解释了SpEL表达式的结构，包括字面量、运算符等。 - **在Bean定义中使用EL：** 展示了如何在Spring配置中...

    跟我学spring3(1-7)

    《跟我学Spring3》这本书是针对Spring框架的入门与进阶教程，主要涵盖了Spring的核心特性，包括IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入），以及Spring的AOP（Aspect-Oriented ...

    跟我学spring3

    《跟我学Spring3》这本书是针对初学者和中级开发者的一份宝贵资源，旨在深入浅出地介绍Spring框架的精髓和核心概念。Spring是Java企业级应用开发中的一个关键框架，它简化了应用程序的构建，提供了依赖注入、面向切...

    跟我学spring3（总共13章）13

    《跟我学Spring3》是针对初学者和有一定基础的开发者设计的一套全面、深入的教程，共计13个章节，涵盖了Spring3的核心概念和技术。Spring3作为Java开发中备受推崇的框架，它提供了丰富的功能，包括依赖注入、AOP...

Magicbox
Global site tag (gtag.js) - Google Analytics