程序博客网 > 网络交流的特点

Spring SpEL表达式

来源：互联网 发布：网络交流的特点 编辑：程序博客网 时间：2024/05/10 13:47

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

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. }
原文：http://leeyee.github.io/blog/2011/06/19/spring-expression-language/#t1
0 0
网络交流的特点 网络交流的特点
原创粉丝点击
热门IT博客
it helpdesk招聘it helpdesk招聘
三维动画制作软件下载三维动画制作软件下载
中国农业银行mac版
一个网络女歌手翻唱
餐厅叫号软件
php炫酷源码
淘宝修改标题
g20 淘宝
saas概念知乎
三星手机的系统负优化
js添加单击事件
mssql fetch array
android点餐源码
windows sdk 7.1
星际淘宝系统
怎么重启linux服务器
excel删除列重复数据
docker 运行golang
林弯弯淘宝店铺名称
淘宝客服岗位要求
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 哗哩哔哩 哔哩哗哩 投屏 禁止想象 bilibi bilbili bilibiki bilubili bilinili bilibilu bibili pilipili biibii biibili bilibii bilili bilibilo 哔嘀影视 哔嘀哔嘀影视 哔嘀 论扮猪吃虎 哔站难民 哙 哙的读音 哙怎么读 耻与哙伍 羞与哙伍 哚哚影视 哚哚 培哚普利叔丁胺 哚哚影视dingding76 影视哚哚 哚哚影视dingding82 哚哚影视dingding78 培哚普利叔丁胺片 培哚普利 培哚普利片 哚 培哚普利吲达帕胺片 哚哚影音 培哚普利吲达帕胺 雅施达培哚普利片

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里