概述
SpEL即Spring表达式语言（Spring Expression Language）。
从我通常的使用场景（API开发）来说，SpEL提供的大部分能力都可以划到奇技淫巧的范畴内。但是在一些场景下如缓存配置、ThymeLeaf取值等，SpEL还是大有可为的。
SpEL表达式的默认格式为：#{expression}。SpEL表达式以“#”开头，表达式主体包围在花括号中。
我们通常使用的属性取值表达式（也可称为属性占位符，格式${expression}）不可以嵌套SpEL表达式。不过SpEL表达式可以嵌套属性取值表达式，如下：
|
1 |
#{${someProperty} + 2} |
在上面的这个表达式里面，如果属性“someProperty”的值是2，这个表达式的值就是4。
运算符
下表列出了SpEL支持的运算符：
| Type | Operators |
|---|---|
| Arithmetic | +, -, *, /, %, ^, div, mod |
| Relational | <, >, ==, !=, <=, >=, lt, gt, eq, ne, le, ge |
| Logical | and, or, not, &&, |
| Conditional | ?: |
| Regex | matches |
接下来我们主要以@Value注解的形式介绍并演示这些运算符在SpEL中的应用。
算数运算符（Arithmetic）
如下是算数运算符的使用示例：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
@Value("#{19 + 1}") // 20 private double add; @Value("#{'String1 ' + 'string2'}") // "String1 string2" private String addString; @Value("#{20 - 1}") // 19 private double subtract; @Value("#{10 * 2}") // 20 private double multiply; @Value("#{36 / 2}") // 18 private double divide; @Value("#{36 div 2}") // 18, the same as for / operator private double divideAlphabetic; @Value("#{37 % 10}") // 7 private double modulo; @Value("#{37 mod 10}") // 7, the same as for % operator private double moduloAlphabetic; @Value("#{2 ^ 9}") // 512 private double powerOf; @Value("#{(2 + 2) * 2 + 9}") // 17 private double brackets; |
除运算和取模运算都有字母形式的别名（除运算“div”，取模运算“mod”）。“+”运算符还可以用来执行字符串连接。
关系运算符（Relational）
如下是关系运算符的使用示例：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
@Value("#{1 == 1}") // true private boolean equal; @Value("#{1 eq 1}") // true private boolean equalAlphabetic; @Value("#{1 != 1}") // false private boolean notEqual; @Value("#{1 ne 1}") // false private boolean notEqualAlphabetic; @Value("#{1 < 1}") // false private boolean lessThan; @Value("#{1 lt 1}") // false private boolean lessThanAlphabetic; @Value("#{1 <= 1}") // true private boolean lessThanOrEqual; @Value("#{1 le 1}") // true private boolean lessThanOrEqualAlphabetic; @Value("#{1 > 1}") // false private boolean greaterThan; @Value("#{1 gt 1}") // false private boolean greaterThanAlphabetic; @Value("#{1 >= 1}") // true private boolean greaterThanOrEqual; @Value("#{1 ge 1}") // true private boolean greaterThanOrEqualAlphabetic; |
所有的关系运算都有字母形式的别名。主要是为了适配使用xml配置文件的场景。在xml中使用带有三角符号的运算符（如小于“<”，大于“>”等）是不被允许的，此时我们可以使用字母形式的别名（lt，gt等）来进行运算。
逻辑运算符（Logical）
如下是逻辑运算符的使用示例：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
@Value("#{250 > 200 && 200 < 4000}") // true private boolean and; @Value("#{250 > 200 and 200 < 4000}") // true private boolean andAlphabetic; @Value("#{400 > 300 || 150 < 100}") // true private boolean or; @Value("#{400 > 300 or 150 < 100}") // true private boolean orAlphabetic; @Value("#{!true}") // false private boolean not; @Value("#{not true}") // false private boolean notAlphabetic; |
同关系运算符一样，每个逻辑运算符也都有字母形式的别名。
条件运算符（Conditional）
条件运算符，顾名思义是用来根据不同的情况来注入不同的值。实际上，就是一个三目运算符：
|
1 2 |
@Value("#{2 > 1 ? 'a' : 'b'}") // "a" private String ternary; |
三目运算符主要被用来处理“if-then-else”这样的判定。
三目运算符通常的使用场景式是判断一个属性是否为null，如果是的话就返回一个默认值，如下：
|
1 2 |
@Value("#{worker.name != null ? worker.name : 'zhyea'}") private String ternaryForNull; |
此外还有一种“Elvis”运算符，简化了上面这种“判定是否为空，为空则返回默认值”的场景：
|
1 2 |
@Value("#{worker.name ?: 'zhyea'}") private String elvis; |
如上，“Elvis”运算符的符号是“?:”，我们可以在Groovy语言中见到它。现在SpEL也引入了这个运算符。
正则运算符（Regex）
正则运算符被用来校验字符串是否匹配某个指定的正则表达式。如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
@Value("#{'100' matches '\\d+' }") // true private boolean validNumericStringResult; @Value("#{'100fghdjf' matches '\\d+' }") // false private boolean invalidNumericStringResult; @Value("#{'valid alphabetic string' matches '[a-zA-Z\\s]+' }") // true private boolean validAlphabeticStringResult; @Value("#{'invalid alphabetic string #$1' matches '[a-zA-Z\\s]+' }") // false private boolean invalidAlphabeticStringResult; @Value("#{worker.id matches '\\d+'}") // true if someValue contains only digits private boolean validNumericValue; |
访问List或Map对象
使用SpEL，我们还可以访问容器中的任何Map或List对象。看个例子：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
@Component("workersHolder") public class WorkersHolder { private List<String> workers = new LinkedList<>(); private Map<String, Integer> salaryByWorkers = new HashMap<>(); public WorkersHolder() { workers.add("John"); workers.add("Susie"); workers.add("Alex"); workers.add("George"); salaryByWorkers.put("John", 35000); salaryByWorkers.put("Susie", 47000); salaryByWorkers.put("Alex", 12000); salaryByWorkers.put("George", 14000); } // getters & setters ... } |
这里我们创建了一个List对象来存放工人名字，一个Map对象来存放每个工人的工资。
接下来我们使用SpEL来访问这两个集合对象里面的元素：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
@Value("#{workersHolder.salaryByWorkers['John']}") // 35000 private Integer johnSalary; @Value("#{workersHolder.salaryByWorkers['George']}") // 14000 private Integer georgeSalary; @Value("#{workersHolder.salaryByWorkers['Susie']}") // 47000 private Integer susieSalary; @Value("#{workersHolder.workers[0]}") // John private String firstWorker; @Value("#{workersHolder.workers[3]}") // George private String lastWorker; @Value("#{workersHolder.workers.size()}") // 4 private Integer numberOfWorkers; |
使用程序解析SpEL表达式
有时候会需要编程处理SpEL表达式。Spring也为我们提供了相关的工具类。这些类都位于“spring-expression”包下。下面是一个封装好的解析SpEL表达式的方法：
|
1 2 3 4 5 |
public static <T> T parse(String expr) { ExpressionParser expressionParser = new SpelExpressionParser(); Expression expression = expressionParser.parseExpression(expr); return (T) expression.getValue(); } |
调用ExpressionParser.parseExpression()后获得的值是Object类型的，这里会通过强制类型转换转为需要的类型。
现在我们将字符串（’zhyea’）作为SpEL表达式传入并执行，毫无疑问，执行结果也应当返回字符串“zhyea”：
|
1 2 3 4 |
String expr = "'zhyea'"; String r = parse(expr); Assert.assertEquals("zhyea", r); |
在SpEL中还可以调用方法，访问属性，使用构造器。代码大致如下：
|
1 2 3 4 5 6 7 8 9 10 11 |
// call method length() String expr = "'zhyea'.length()"; int l = parse(expr); // call constructor String expr = "new String('chobit').length()"; int l = parse(expr); // visit properties String expr = "'zhyea'.bytes"; byte[] r = parse(expr); |
代码都上传到了github上，我就不一一贴执行结果了。
之前我们获取解析后的值是通过了一次强制类型转换的。Spring也提供了一个传入泛型类型来获取目标类型结果的方法，简单做了下封装：
|
1 2 3 4 5 |
public static <T> T parse(String expr, Class<T> clazz) { ExpressionParser expressionParser = new SpelExpressionParser(); Expression expression = expressionParser.parseExpression(expr); return expression.getValue(clazz); } |
程序处理SpEL这块儿还有很多的内容，不过从我个人的角度来说，到目前的程度已经够了。如果想继续多了解一些的话可以查阅下方的参考文档。话说，spring官方文档中对SpEL的说明完全是基于程序处理来进行的。
相关代码已上传到了GITHUB/zhyea，如有需要请直接查看。
参考文档
发表评论