Spring3 表达式语言(SpEL)介绍

最新推荐文章于 2023-09-21 09:16:11 发布
最新推荐文章于 2023-09-21 09:16:11 发布
阅读量738 收藏
点赞数
分类专栏： Spring Java技术 文章标签： spring el

http://leeyee.github.io/blog/2011/06/19/spring-expression-language/


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

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

第一步，构建解析

   
   
  1. ExpressionParser parser = new SpelExpressionParser();

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

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

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

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

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

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

   
   
  1. // 属性测试。time为SpElUtil类Date型数据，这里调用Date的属性Year
  2. assertEquals(new Integer(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, 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);
  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 = new ArrayList<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.         new Class[] { 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 = new HashMap<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.                 new TemplateParserContext()).getValue(secontext,
  5.                 String.class));

一大段测试用例：

   
   
  1. import static 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. public class SpElUtilTest {
  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.     public void setUp() throws Exception {
  26.         context = ApplicationContextFactory.createInstance();
  27.         spel = context.getBean(SpElUtil.class);
  28.         secontext = new StandardEvaluationContext(spel);
  29.         exp = new SpelExpressionParser();
  30.     }
  32.     @After
  33.     public void tearDown() throws Exception {
  34.         context = null;
  35.         spel = null;
  36.         secontext = null;
  37.         exp = null;
  38.     }
  40.     /**
  41.      * 文字表达式测试用例
  42.      * 
  43.      * @throws Exception
  44.      */
  45.     @Test
  46.     public void testSpELLiteralExpression() throws Exception {
  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(new Double(10280000), exp.parseExpression(lELs[1])
  52.                 .getValue(Double.class));
  53.         assertEquals(new Integer(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.     public void testSpELProOrArrayOrIndexEtcExpression() throws Exception {
  66.         // 属性测试。time为SpElUtil类Date型数据，这里调用Date的属性Year
  67.         assertEquals(new Integer(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.     public void testSpELInnerListExpression() throws Exception {
  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.     public void testSpELArrayConstructionExcpression() throws Exception {
  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.     public void testSpELMethodExcpression() throws Exception {
  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.     public void testSpElOperatorAndRegExpression() throws Exception {
  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.     public void testSpelAssignmentExpression() throws Exception {
  193.         Date oldDate = spel.getTime();// 获取当前time属性值
  194.         exp.parseExpression("time").setValue(secontext, new Date(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.     public void testSpelTypesExpression() throws Exception {
  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.     public void testSpelConstructorsExpression() throws Exception {
  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.     public void testSpelVariablesExpression() throws Exception {
  249.         List<Integer> list = new ArrayList<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.     public void testSpelFunctionExpression() throws Exception {
  269.         StandardEvaluationContext context = new StandardEvaluationContext();
  270.         context.registerFunction("len", SpElUtil.class.getDeclaredMethod("len",
  271.                 new Class[] { String.class }));
  272.         assertEquals(3, exp.parseExpression("#len('abc')").getValue(context));
  273.     }
  275.     @Test
  276.     public void testSpelBeanExpression() throws Exception {
  278.     }
  280.     /**
  281.      * 三元操作测试
  282.      * 
  283.      * @throws Exception
  284.      */
  285.     @Test
  286.     public void testSpelTernaryOperatorExpression() throws Exception {
  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.     public void testSpeleElvisOperatorExpression() throws Exception {
  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.     public void testSpelSafeNavOperatorExpression() throws Exception {
  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.     public void testSpelCollectionSelectExpression() throws Exception {
  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 = new HashMap<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.     public void testSpelProjectionExpression() throws Exception {
  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.     public void testSpelTemplate() throws Exception {
  390.         assertEquals(
  391.                 " this is a test 4",
  392.                 exp.parseExpression(" this is a test #{ maps.![key].get(3)}",
  393.                         new TemplateParserContext()).getValue(secontext,
  394.                         String.class));
  395.     }
  396. }
 2011年06月19日  leeyee  spring  spring

ppby2002
关注
专栏目录
spring框架学习 - Spring 表达式语言 (SpEL)
TyuIn的博客
12-19 1642
接上一篇博客：https://blog.csdn.net/qq_43605444/article/details/122019172?spm=1001.2014.3001.5502 六、Spring 表达式语言 (SpEL) Spring 表达式语言（简称“SpEL”）是一种强大的表达式语言，支持在运行时查询和操作对象图。 语言语法类似于统一 EL，但提供了额外的功能，最显着的是方法调用和基本的字符串模板功能。 虽然还有其他几种可用的 Java 表达式语言 — OGNL、MVEL 和 JBoss EL，仅举
Spring表达式语言：SpEL语法
VipMao的博客
06-15 1万+
SpEL表达式语言详解
Spring SpEL表达式
fangchao3652
04-18 1042
Spring Expression Language (SpEL)语言支持在运行时操作和查询对象，其语法类似统一的EL语言，但是SpEL提供了额外的功能。SpEL支持以下功能： 文本表达式布尔类和关系操作正则表达式类表达式访问属性、数组、集合和map方法调用关系操作赋值操作调用构造函数Bean 引用数组构造内联list三元操作变量用户自定义函数集合投影集合选择模板表达式 使用SpEl进行表
Spring3新特性之表达式语言SpEL
zzc1684的博客
09-16 150
概述        Spring表达式语言全称为“Spring Expression Language”，缩写为“SpEL”，类似于Struts2x中使用的OGNL表达式语言，能在运行时构建复杂表达式、存取对象图属性、对象方法调用 等等，并且能与Spring功能完美整合，如能用来配置Bean定义。        表达式语言给静态Java语言增加了动态功能。        SpEL是单独模块，只...
Spring之SpEL表达式
知识手记
11-06 678
最近在学习《Spring实战》一书的过程中发现Spring中的表达式SpEL的应用范围还是很广泛的，特意整理一下SpEL的用法如下： 首先，说一说SpEl表达式支持的特性有：使用Bean的ID来引用Bean； 调用方法和访问对象的属性； 对值进行算术、关系和逻辑运算； 正则表达式匹配； 集合操作；1、引用Bean和访问Bean的属性略过，以下是访问Bean的方法：<property n
Spring表达式语言SpEL简介
达叔
08-04 1578
Spring3引入了Spring表达式语言（Spring Expression Language，SpEL）。 SpEL有很多特性，比较常用的包括： 1、使用bean的id来引用bean， 下面这个例子就是将卧室这个bean通过SpEL注入到house这个bean的bedroom属性中。       2、访问对象的属性和调用方法， 增加一个snoopy
小玩Spring3.X的SpEL表达式
1ouis的专栏
02-23 809
:-)
Spring表达式语言SpEL用法详解
08-25
Spring表达式语言SpEL用法详解 Spring表达式语言SpEL是一种强大的表达式语言，支持运行时查询和操作对象图。SpEL使用#{...}作为定界符，所有在大括号中的字符串均被认为是SpEL。SpEL为bean的属性进行动态赋值提供了...
SpEL--Spring表达式语言
Meiko记录
08-12 533
前言 SpEL(Spring Expression Language)，即Spring表达式语言。它是一种类似JSP的EL表达式、但又比后者更为强大有用的表达式语言。 为什么要用SpEL：因为它可以在spring容器内实时查询和操作数据，尤其是操作List列表型、Array数组型数据。所以使用SpEL可以有效缩减代码量，优化代码结构,笔者认为很有用。 一. 用法 常规SpEL有三种用法： 在注解@Value中使用 在XML配置中使用 在代码中创建Expression对象...
基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志框架+源代码+文档说明
最新发布
11-29
基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志 ### 简介 * 使用annotation来标注方法，标记操作内容 * 使用SpEL来动态生成操作日志内容，使操作日志记录更加详细（记录操作内容ID等关键信息） * ...
Spring3.x--使用SpEL表达式装配
guozehao520的专栏
09-11 548
我们为Bean的
Spring表达式语言-SPEL
会走的桃子的博客
01-16 124
文章目录
Spring SpEL表达式语言
luoyepiaoxue2014的博客
05-24 332
Spring SpEL表达式语言
SpEL表达式
HELLOW，文浩
12-31 2175
概观 Spring Expression Language（缩写为SpEL）是一种强大的表达式语言。在Spring产品组合中，它是表达式计算的基础。它支持在运行时查询和操作对象图，它可以与基于XML和基于注解的Spring配置还有bean定义一起使用。由于它能够在运行时动态分配值，因此可以为我们节省大量Java代码。 项目设置 对于Maven项目，应使用以下依赖项： 前两个依赖项 ...
Spring 表达式语言之 SpEL 语法
热门推荐
夜-feng的专栏
07-14 1万+
5.3 SpEL语法 5.3.1 基本表达式 一、字面量表达式： SpEL支持的字面量包括：字符串、数字类型（int、long、float、double）、布尔类型、null类型。 类型 示例 字符串 String str1 = parser.parseExpression(“‘Hello World!’”).getValue(String.class); Strin
Spring SpEL 表达式语言
REID丶Beginner的博客
09-21 1071
Spring也有自己的EL，叫Spring Expression Language，简称SpEl。其可以在程序中单独使用，也可以在Spring应用中进行bean定义时使用。其核心是org.springframework.expression.Expression接口，Spring使用该接口来表示EL中的表达式。通过Expression接口的系列getValue()方法我们可以获取对应Expression在特定EvaluationContext下的值，也可以通过其系列setValue()方法来设值。
从头认识Spring-1.16 SpEl对集合的操作（1）-建立集合以及访问集合的元素，以<util:list/>为例
raylee2007的专栏
02-05 4031
这一章节我们来讨论一下如何建立集合以及访问集合的元素？1.建立集合？（1）domain蛋糕类：package com.raylee.my_new_spring.my_new_spring.ch01.topic_1_20; public class Cake { private String name = ""; private double size = 0; public Str
从头认识Spring-1.16 SpEl对集合的操作（2）-查询集合以及投影元素集合
raylee2007的专栏
02-05 3387
这一章节我们来讨论一下查询集合以及投影元素集合。我们下面用一个例子说明上面的这两个部分。1.domain蛋糕类：（不变）package com.raylee.my_new_spring.my_new_spring.ch01.topic_1_21; public class Cake { private String name = ""; private double size = 0;
SpEL表达式的使用
qq_32434535的博客
11-21 7215
Spring Expression Language SpEL是Spring提供的一种的表达式语言，支持在运行时查询和操作对象。 SpEL并不直接与Spring相关联，可以独立使用。 SpEL解析器 SpEL提供了对应的解析器SpelExpressionParser用于解析SpEL表达式 EvaluationContext EvaluationContext用于计算表达式以解析属性、方法、字段，并帮助执行类型转换。 Spring提供了两个实现SimpleEvaluationContext和StandardE
Spring表达式语言(SpEL)中文参考指南
"Spring表达式语言(SpEL)是一个强大的表达式语言，用于在运行时查询和操作对象图。这份中文参考手册基于Spring 4.x版本，由刘海刚翻译，涵盖了SpEL的基本使用、方法调用、属性访问、构造函数以及类型转换等功能。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值