Spring3表達式語言(SpEL)學習筆記

最新地址請訪問：http://leeyee.github.io/blog/2011/06/19/spring-expression-language

Spring Excpression Language (SpEL)語言支持在運行時操作和查詢對象，其語法類似統一的EL語言，但是SpEL提供了額外的功能。

1、文本表達式
2、布爾類和關係操作
3、正則表達式
4、類表達式
5、訪問屬性、數組、集合和map
6、方法調用
7、關係操作
8、賦值操作
9、調用構造函數
10、Bean 引用
11、數組構造
12、內聯list
13、三元操作
14、變量
15、用戶自定義函數
16、集合投影
17、集合選擇
18、模板表達式

使用SpEl進行表達式操作，基本操作如下：
第一步，構建解析ExpressionParser parser = new SpelExpressionParser();
第二步，使用表達式進行解析Expression exp = parser.parseExpression( SpEl);
第三步，獲取結果exp.getValue() 

2.1 文本表達式
文本表達式支持字符表達式、日期、數字（正數、實數及十六進制數）、布爾類型及null.其中字符表達式需要用單引號聲明。
對數字支持負數、指數及小數。默認情況下實數使用Double.parseDouble() 進行表達式類型轉換

2.2 屬性、數組、列表、字典(map)及索引
在表達式中訪問類屬性時直接使用屬性名，屬性名首字母大小寫均可。
訪問數組時可以使用[index]進行元素對象範圍。
訪問列表時，可直接使用類表的方法，通過點操作符

2.3 內置列表
列表可以直接表示在表達式中使用{}符號表達。{}本身代表一個空的list

2.4 數組構造(spring3.0.3中會拋出異常)
可以通過熟悉的java語法在表達是語言中定義。但目前不支持定義一個初始化的多維數組
2.5 方法
表達式中的方法調用遵循java語法。

2.6 操作符
2.6.1 關係操作符
支持 eq("=="),ne("!="),le("<="),lt("<"),gt(">"),ge(">="),div("/"),mod("%"),not("!")，正則表達式及instanceof操作             
2.6.2 邏輯操作符
邏輯操作符支持and,or,not

2.6.3 數學運算操作符
加法運算符可以用於數字，字符串和日期。減法可以用在數字和日期。乘法和除法只能用於對數字。其他受支持的數學運算是模數（％）和指數冪（^）。運行順序按標準運算符優先級執行
2.7 賦值
通過賦值操作進行屬性設置。通常是調用setValue方法，但也可以在調用getValue時設置。

2.8 類型
通過特殊的'T'操作符可以用來指定一個java.lang.Class的實例。在實例話對象的靜態方法將會被調用。

2.9 構造器
構造器通過new操作被調用。在new操作時需要指明類的完全類名（包括包路徑）

2.10 變量
變量可以通過 #變量名 在表達式中被引用。變量通過StandardEvaluationContext類的setVariable方法進行設置
2.10.1 #this變量
變量 #this 被定義爲當前操作對象的引用。

2.11 函數
你可以擴展SpEL通過註冊自定義函數。註冊後的函數可以在表達式中通過其名稱進行調用。函數的註冊是通過StandardEvaluationContext類的registerFunction方法進行聲明
2.12 三元操作

2.13 Elvis操作

Elvis操作是一個短的三元操作符語法，通常在Groovy語言中使用。

Note: Elvis操作在表達式中可以用來生成默認值，當被訪問屬性爲空時。比如@Value

@Value("#systemPro['mail.port'] ? : 25}")  //當mail.port爲空時將默認爲25

2.14 安全導航操作
該操作是爲避免空指針異常。他是來自Groovy語言的。典型的當你有一個指向對象的引用，在你訪問其方法或屬性時，可能需要驗證該對象的方法或屬性是否爲空，爲了避免驗證，使用安全導航操作將簡單的返回null而不是空指針異常。
2.15 集合選擇
選擇是一個強大的表達式語言屬性，可以使用選擇表達式過濾源集合，從而生成一個新的符合選擇條件的集合
選擇的語法爲 ?[selectionExpression] 。他將過濾集合並且返回一個新的集合（原集合的子集）。
選擇語句也可用在Map中，過濾keySet及valueSet分別使用key和value關鍵字
另外：選擇語法中，選擇符合條件的結果集的第一個元素的語法爲 ^[selectionExpression]，選擇最後一個元素的語法爲$[selectionExpression]
2.16 集合投影
語法 ![projectionExpression] 判斷集合中每個元素是否符合語法要求

2.17 表達式模板
表達式模板允許混合文字表達式，一個或多個值計算塊。每一個值計算塊被聲明通過可被自定義的前綴和後綴，一般選擇使用 #{}作爲一個定界符。

------------    以上就是SpEL的簡單介紹。下面直接給出測試用例，這樣比較直觀，也易於理解。    ------------

pom.xml<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>study.spring3</groupId> <artifactId>study-spring3</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>3.0.5.RELEASE</version> <scope>runtime</scope> <exclusions> <exclusion> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.5.8</version> <scope>runtime</scope> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>1.5.8</version> <scope>runtime</scope> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.14</version> <scope>runtime</scope> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.8.1</version> <scope>test</scope> </dependency> <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>1.1.1</version> <scope>test</scope> </dependency> <dependency> <groupId>javax.inject</groupId> <artifactId>javax.inject</artifactId> <version>1</version> <scope>runtime</scope> </dependency> <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>2.1_3</version> <scope>runtime</scope> </dependency> </dependencies> </project> 

spring-beans.xml<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <!-- 容器註解掃描 --> <context:component-scan base-package="study.spring.beans" /> <bean id="sputil" name="sputil" class="study.spring.beans.SpElUtil"> <property name="time" value="#{ new java.util.Date()}" /> <property name="name" value="#{'override'}" /> <property name="maps"> <map> <entry key="1" value="string1" /> <entry key="2" value="string2" /> <entry key="3" value="string3" /> <entry key="4" value="String4" /> </map> </property> </bean> </beans> 

ApplicationContextFactory.javapackage study.spring.context.factory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class ApplicationContextFactory { private static ApplicationContext ctx; private ApplicationContextFactory() { } public static ApplicationContext createInstance() { if (ctx == null) { ctx = new ClassPathXmlApplicationContext( new String[] { "spring-beans.xml" }); } return ctx; } } 

SpElUtil.javapackage study.spring.beans; import java.util.Date; import java.util.List; import java.util.Map; import org.springframework.expression.Expression; import org.springframework.expression.ExpressionParser; import org.springframework.expression.spel.standard.SpelExpressionParser; public class SpElUtil { private Date time; private String name; private SpelTestInnerClass innerClass = new SpelTestInnerClass( "innerClass", 29); private List<Integer> numbers; private Map<Integer, String> maps; public static Object sayHelloForSpEl(String express) { ExpressionParser exp = new SpelExpressionParser(); Expression ex = exp.parseExpression(express); return ex.getValue(); } /** * 自定義方法 * * @param string * @return */ public static int len(String string) { return string.length(); } public Map<Integer, String> getMaps() { return maps; } public void setMaps(Map<Integer, String> maps) { this.maps = maps; } public List<Integer> getNumbers() { return numbers; } public void setNumbers(List<Integer> numbers) { this.numbers = numbers; } public Date getTime() { return time; } public void setTime(Date time) { this.time = time; } public String getName() { return name; } public void setName(String name) { this.name = name; } public SpelTestInnerClass getInnerClass() { return innerClass; } public void setInnerClass(SpelTestInnerClass innerClass) { this.innerClass = innerClass; } } class SpelTestInnerClass { private String name; private int age; public SpelTestInnerClass(String name, int age) { this.name = name; this.age = age; } public boolean isGt30ForAge() { return this.age > 30 ? true : false; } public String getName() { return name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } 

SpElUtilTest.javapackage study.spring.beans; import static org.junit.Assert.*; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.expression.Expression; import org.springframework.expression.ExpressionParser; import org.springframework.expression.common.TemplateParserContext; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.expression.spel.support.StandardEvaluationContext; import study.spring.context.factory.ApplicationContextFactory; public class SpElUtilTest { // spring配置文件上下文 ApplicationContext context = null; // spring el測試輔助類 SpElUtil spel = null; // 表達式解析對象 ExpressionParser exp = null; // 標準賦值上下文 StandardEvaluationContext secontext; @Before public void setUp() throws Exception { context = ApplicationContextFactory.createInstance(); spel = context.getBean(SpElUtil.class); secontext = new StandardEvaluationContext(spel); exp = new SpelExpressionParser(); } @After public void tearDown() throws Exception { context = null; spel = null; secontext = null; exp = null; } /** * 文字表達式測試用例 * * @throws Exception */ @Test public void testSpELLiteralExpression() throws Exception { // 定義各種文字表達式 String[] lELs = { "'hello SpEL'", "1.028E+7", "0x12EF", "true", "null" }; assertEquals("hello SpEL", exp.parseExpression(lELs[0]).getValue(String.class)); assertEquals(new Double(10280000), exp.parseExpression(lELs[1]) .getValue(Double.class)); assertEquals(new Integer(4847), exp.parseExpression(lELs[2]).getValue(Integer.class)); assertTrue(exp.parseExpression(lELs[3]).getValue(Boolean.class)); assertNull(exp.parseExpression(lELs[4]).getValue()); } /** * 訪問屬性、數組、集合和 map 測試 * * @throws Exception */ @Test public void testSpELProOrArrayOrIndexEtcExpression() throws Exception { // 屬性測試。time爲SpElUtil類Date型數據，這裏調用Date的屬性Year assertEquals(new Integer(2011), exp.parseExpression("time.Year + 1900") .getValue(secontext, Integer.class)); // 屬性測試。innerClass爲SpElUtil類中引入的其他類。 assertEquals(29, exp.parseExpression("innerClass.age").getValue(secontext)); // 設置SpElUtil類的numbers屬性 spel.setNumbers(Arrays.asList(2, 3, 4, 5, 6, 7, 9)); // 訪問對象屬性數組通過索引 assertEquals(2, exp.parseExpression("numbers[0]").getValue(secontext)); // 訪問map assertEquals("string1", exp.parseExpression("maps[1]") .getValue(secontext, String.class)); } /** * 內聯list測試 * * @throws Exception */ @SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void testSpELInnerListExpression() throws Exception { // 構造list List<String> nums = (List<String>) exp.parseExpression( "{'a','b','c','d'}").getValue(); assertEquals(Arrays.asList("a", "b", "c", "d"), nums); // 構造List<List<>> List listOfLists = (List) exp.parseExpression("{{1,2},{3,4}}") .getValue(secontext); assertEquals(Arrays.asList(1, 2), listOfLists.get(0)); } /** * Array 構造測試 * * @throws Exception */ @Test public void testSpELArrayConstructionExcpression() throws Exception { // 創建沒有初始值的數組 int[] a = (int[]) exp.parseExpression("new int[4]").getValue(); assertEquals(4, a.length); // 創建帶有初始值的數組 int[] b = (int[]) exp.parseExpression("new int[4]{1,2,3,4}").getValue(); assertEquals(3, b[2]); // 創建二維數組 int[][] c = (int[][]) exp.parseExpression("new int[4][5]").getValue(); assertEquals(4, c.length); assertEquals(5, c[0].length); } /** * 方法表達式測試 * * @throws Exception */ @Test public void testSpELMethodExcpression() throws Exception { // String.replace方法測試 assertEquals( "abC2def", exp.parseExpression("'abcdef'.replace('c','C2')").getValue( String.class)); // 自定義類方法測試 assertFalse(exp.parseExpression("innerClass.isGt30ForAge()").getValue( secontext, Boolean.class)); spel.getInnerClass().setAge(34); assertTrue(exp.parseExpression("innerClass.isGt30ForAge()").getValue( secontext, Boolean.class)); } /** * 操作符、正則表達式測試 * * @throws Exception */ @Test public void testSpElOperatorAndRegExpression() throws Exception { // 關係操作 assertTrue(exp.parseExpression("1 == 1").getValue(Boolean.class)); assertTrue(exp.parseExpression("1 eq 1").getValue(Boolean.class)); assertTrue(exp.parseExpression("1 > -1").getValue(Boolean.class)); assertTrue(exp.parseExpression("1 gt -1").getValue(Boolean.class)); assertTrue(exp.parseExpression("'a' < 'b'").getValue(Boolean.class)); assertTrue(exp.parseExpression("'a' lt 'b'").getValue(Boolean.class)); assertTrue(exp.parseExpression( " new Integer(123) instanceof T(Integer) ").getValue( Boolean.class)); assertTrue(exp.parseExpression("'5.00' matches '^-?//d+(//.//d{2})?$'") .getValue(Boolean.class)); // 邏輯操作 assertTrue(exp.parseExpression("true and true").getValue(Boolean.class)); assertTrue(exp.parseExpression("true or false").getValue(Boolean.class)); assertFalse(exp.parseExpression("innerClass.isGt30ForAge() and false ") .getValue(secontext, Boolean.class)); assertFalse(exp.parseExpression("!innerClass.isGt30ForAge() and true ") .getValue(secontext, Boolean.class)); assertTrue(exp.parseExpression("!false").getValue(Boolean.class)); // 運算操作 assertEquals(2, exp.parseExpression("1 + 1").getValue()); assertEquals("ABab", exp.parseExpression("'AB' + 'ab'").getValue(String.class)); assertEquals(25.0, exp.parseExpression("1 + 2 * 8 div 4 mod 2 + 2 ^ 3 * 3e0") .getValue()); assertEquals(exp.parseExpression("1 + 2 * 8 / 4 % 2 + 2 ^ 3 ") .getValue(), exp.parseExpression("1 + 2 * 8 div 4 mod 2 + 2 ^ 3 ") .getValue()); } /** * 賦值表達式測試 * * @throws Exception */ @SuppressWarnings("deprecation") @Test public void testSpelAssignmentExpression() throws Exception { Date oldDate = spel.getTime();// 獲取當前time屬性值 exp.parseExpression("time").setValue(secontext, new Date(113, 2, 25)); // 爲time屬性重新賦值 Date newDate = spel.getTime();// 獲取賦值後的time屬性值 assertEquals(2013, exp.parseExpression("time.Year + 1900").getValue(secontext)); assertNotSame(oldDate, newDate); // 或者使用下屬方法賦值 assertEquals("abc", exp.parseExpression("Name = 'abc'").getValue(secontext)); // 還原time默認，避免後續測試錯誤 spel.setTime(oldDate); spel.setName("override"); } /** * 類型操作表達式測試 * * @throws Exception */ @SuppressWarnings("rawtypes") @Test public void testSpelTypesExpression() throws Exception { Class dateClass = exp.parseExpression("T(java.util.Date)").getValue( Class.class); assertEquals("java.util.Date", dateClass.getName()); assertTrue(exp .parseExpression( "T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR") .getValue(Boolean.class)); } /** * 構造函數調用測試 * * @throws Exception */ @Test public void testSpelConstructorsExpression() throws Exception { SpelTestInnerClass spt = exp .parseExpression( "new study.spring.beans.SpelTestInnerClass('constructTest',23)") .getValue(SpelTestInnerClass.class); assertEquals(23, spt.getAge()); assertEquals("constructTest", spt.getName()); } /** * 設置變量測試 * * @throws Exception */ @SuppressWarnings("unchecked") @Test public void testSpelVariablesExpression() throws Exception { List<Integer> list = new ArrayList<Integer>(); list.addAll(Arrays.asList(2, 3, 4, 5, 6, 7, 9)); secontext.setVariable("list", list); List<Integer> vList = (List<Integer>) exp.parseExpression("#list") .getValue(secontext); assertEquals(vList, list); List<Integer> nums = (List<Integer>) exp.parseExpression( "#list.?[#this >5]").getValue(secontext); // 獲取值大於5的元素集合 assertEquals(nums, Arrays.asList(6, 7, 9)); } /** * 自定義函數表達式測試 * * @throws Exception */ @Test public void testSpelFunctionExpression() throws Exception { StandardEvaluationContext context = new StandardEvaluationContext(); context.registerFunction("len", SpElUtil.class.getDeclaredMethod("len", new Class[] { String.class })); assertEquals(3, exp.parseExpression("#len('abc')").getValue(context)); } @Test public void testSpelBeanExpression() throws Exception { } /** * 三元操作測試 * * @throws Exception */ @Test public void testSpelTernaryOperatorExpression() throws Exception { assertTrue(exp.parseExpression(" true ? true :false").getValue( Boolean.class)); assertEquals("is true", exp.parseExpression(" 1 == 1 ? 'is true' :'is false'") .getValue(String.class)); } /** * Elvis 操作測試 * * @throws Exception */ @Test public void testSpeleElvisOperatorExpression() throws Exception { Expression ex = exp.parseExpression("name?:'name is null'"); assertEquals("override", ex.getValue(secontext, String.class)); spel.setName(null); assertEquals("name is null", ex.getValue(secontext, String.class)); spel.setName("override"); } /** * 安全導航操作測試 * * @throws Exception */ @Test public void testSpelSafeNavOperatorExpression() throws Exception { assertEquals("innerClass", exp.parseExpression("innerClass?.name") .getValue(secontext, String.class)); spel.setInnerClass(null); // 使用這種表達式可以避免拋出空指針異常 assertNull(exp.parseExpression("innerClass?.name").getValue(secontext, String.class)); } /** * 集合選擇表達式測試 * * @throws Exception */ @SuppressWarnings("unchecked") @Test public void testSpelCollectionSelectExpression() throws Exception { spel.setNumbers(Arrays.asList(2, 3, 4, 5, 6, 7, 9)); List<Integer> nums = (List<Integer>) exp.parseExpression( "numbers.?[#this >5]").getValue(secontext); assertEquals(nums, Arrays.asList(6, 7, 9)); // 獲取第一個元素 assertEquals(6, exp.parseExpression("numbers.^[#this > 5]").getValue(secontext)); // 獲取最後一個元素 assertEquals(9, exp.parseExpression("numbers.$[#this > 5]").getValue(secontext)); Map<Integer, String> maps = (Map<Integer, String>) exp.parseExpression( "maps.?[value == 'string3' ]").getValue(secontext); Map<Integer, String> tmap = new HashMap<Integer, String>(); tmap.put(3, "string3"); assertEquals(maps, tmap); Map<Integer, String> mapk = (Map<Integer, String>) exp.parseExpression( "maps.?[key > 2 and key < 4 ]").getValue(secontext); assertEquals(mapk, tmap); } /** * 投影表達式測試 * * @throws Exception */ @SuppressWarnings("unchecked") @Test public void testSpelProjectionExpression() throws Exception { spel.setNumbers(Arrays.asList(2, 3, 4, 5, 6)); assertEquals(Arrays.asList(5, 6, 7, 8, 9), exp.parseExpression("numbers.![#this+3]").getValue(secontext)); List<Integer> keys = (List<Integer>) exp.parseExpression("maps.![key]") .getValue(secontext); assertEquals(keys, Arrays.asList(1, 2, 3, 4)); List<String> mapv = (List<String>) exp.parseExpression("maps.![value]") .getValue(secontext); assertEquals(mapv, Arrays.asList("string1", "string2", "string3", "String4")); List<Boolean> mapK = (List<Boolean>) exp.parseExpression( "maps.![key > 2 and value !='String4']").getValue(secontext); assertEquals(mapK, Arrays.asList(false, false, true, false)); } /** * 模板語言測試 * * @throws Exception */ @Test public void testSpelTemplate() throws Exception { assertEquals( " this is a test 4", exp.parseExpression(" this is a test #{ maps.![key].get(3)}", new TemplateParserContext()).getValue(secontext, String.class)); } }