文章目录
SpEL是什么
SpEL即Spring表达式语言(Spring Expression Language)。
SpEL表达式的默认格式为:#{expression}
。SpEL表达式以“#”
开头,表达式主体包围在花括号中。
- 我们通常使用的属性取值表达式(也可称为
属性占位符,格式${expression}
)不可以嵌套SpEL表达式。不过SpEL表达式可以嵌套属性取值表达式,如下:
#{
${
someProperty} + 2}
//如果属性“someProperty”的值是2,这个表达式的值就是4。
运算符
- 算数运算符(Arithmetic):+, -, *, /, %, ^, div, mod
- 关系运算符(Relational):<, >, ==, !=, <=, >=, lt, gt, eq, ne, le, ge
- 逻辑运算符(Logical): and, or, not, &&,
- 条件运算符(Conditional):?:
- 正则运算符(Regex)
接下来我们主要以@Value
注解的形式介绍并演示这些运算符在SpEL中的应用。
算数运算符(Arithmetic)
@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)
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)
@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)
条件运算符,顾名思义是用来根据不同的情况来注入不同的值。实际上,就是一个三目运算符:
@Value("#{2 > 1 ? 'a' : 'b'}") // "a"
private String ternary;
三目运算符主要被用来处理“if-then-else”这样的判定。
- 通常的使用场景式是判断一个属性是否为null,如果是的话就返回一个默认值,如下:
@Value("#{worker.name != null ? worker.name : 'zhyea'}")
private String ternaryForNull;
此外还有一种“Elvis
”运算符,简化了上面这种“判定是否为空,为空则返回默认值”的场景:
@Value("#{worker.name ?: 'zhyea'}")
private String elvis;
如上,“Elvis”运算符的符号是“?:
”,我们可以在Groovy语言
中见到它。现在SpEL也
引入了这个运算符。
正则运算符(Regex)
正则运算符被用来校验字符串是否匹配某个指定的正则表达式
。如下:
@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对象。看个例子:
如:们创建了一个List对象来存放工人名字,一个Map对象来存放每个工人的工资。
@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 ...
}
使用SpEL来访问这两个集合对象里面的元素:
@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表达式的方法:
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”:String expr = "'zhyea'"; String r = parse(expr); Assert.assertEquals("zhyea", r);
在SpEL中还可以调用方法,访问属性,使用构造器
。代码大致如下:
// 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);
之前我们获取解析后的值是通过了一次强制类型转换的。Spring也提供了一个传入泛型类型来获取目标类型结果的方法
,简单做了下封装:
public static <T> T parse(String expr, Class<T> clazz) {
ExpressionParser expressionParser = new SpelExpressionParser();
Expression expression = expressionParser.parseExpression(expr);
return expression.getValue(clazz);
}
变量与赋值
变量:在表达式中使用语法#变量名
引用
ExpressionParser ep= new SpelExpressionParser();
//创建上下文变量
EvaluationContext ctx = new StandardEvaluationContext();
//在上下文中设置变量,变量名为name,内容为Hello
ctx.setVariable("name", "Hello");
System.out.println(ep.parseExpression("#name").getValue(ctx));//输出:Hello
赋值:属性设置是通过使用赋值运算符。这通常是在调用setValue
中执行但也可以在调用getValue内,也可通过”#varName=value
”的形式给变量赋值。
System.out.println(ep.parseExpression("#name='Ryo'").getValue(ctx));//输出:Ryo