Spring Expression Language(SpEL) SpEL表达式

4 Spring Expression Language (SpEL) https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions

Spring Expression Language Guide https://www.baeldung.com/spring-expression-language

Spring 从 3.x 开始支持 EL 表达式, Spring Expression Language(SpEL) 是类似于 OGNL 和 JSP EL 的表达式语言, 能够在运行时构建复杂表达式, 存取对象属性、调用对象方法等, 而且所有的 SpEL 都支持 XML 和 Annotation 两种方式, 使用的格式均为: #{SpEL expression}, 例如 @Value("#{'user'.toUpperCase()}")

SpEL表达式求值

4.1 Evaluation https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions-evaluation

通用SpEL表达式求值流程

1、构造 SpelExpressionParser SpEL 解析器 2、调用解析器的 parseExpression() 方法解析表达式 3、调用表达式的 getValue() 方法获取结果，返回是 Object 类型需要强制类型转换，或者调用 getValue(@Nullable Class<T> desiredResultType) 返回指定类型

import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

@Test
public void testSpEL() {
    // 1、构造解析器
    ExpressionParser parser = new SpelExpressionParser();

    // 2、解析表达式
    Expression expression = parser.parseExpression("'this is a str'");

    // 3、获取结果，返回是 Object 类型
    String strValue = (String) expression.getValue();
}

方法调用示例

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'Hello World'.concat('!')");
String message = (String) exp.getValue();

访问JavaBean属性示例

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes()'
Expression exp = parser.parseExpression("'Hello World'.bytes");
byte[] bytes = (byte[]) exp.getValue();

SpEL 还支持嵌套属性，通过点表达式来访问，例如 prop1.prop2.prop3

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes().length'
Expression exp = parser.parseExpression("'Hello World'.bytes.length");
int length = (Integer) exp.getValue();

通过构造方法构造String

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("new String('hello world').toUpperCase()");
String message = exp.getValue(String.class);

基于上下文根对象求值

// Create and set a calendar
GregorianCalendar c = new GregorianCalendar();
c.set(1856, 7, 9);

// The constructor arguments are name, birthday, and nationality.
Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian");

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("name"); // Parse name as an expression
String name = (String) exp.getValue(tesla);
// name == "Nikola Tesla"

exp = parser.parseExpression("name == 'Nikola Tesla'");
boolean result = exp.getValue(tesla, Boolean.class);
// result == true

其中求值调用了 Object getValue(@Nullable Object rootObject) throws EvaluationException; 方法，表达式都是基于 rootObject 的。

EvaluationContext 求值上下文

变量可以通过 StandardEvaluationContext 的 setVariable() 方法设置到上下文中, 然后再 SpEL 表达式中通过 #变量名 使用变量;

// 定义变量
String name = "Tom";
EvaluationContext context = new StandardEvaluationContext();  // 表达式的上下文,
context.setVariable("myName", name);                        // 为了让表达式可以访问该对象, 先把对象放到上下文中
ExpressionParser parser = new SpelExpressionParser();
// 访问变量
parser.parseExpression("#myName").getValue(context, String.class);   // Tom , 使用变量

其中使用了 Object getValue(EvaluationContext context, @Nullable Object rootObject) throws EvaluationException; 求值方法，从上下文中读。

表达式

文本表达式

文本表达式(Literal Expressions) 支持字符串、数字(int, real, hex)、boolean 和 null. 字符串使用单引号分隔。单引号本身在字符串中使用两个单引号字符表示

ExpressionParser parser = new SpelExpressionParser();

// evals to "Hello World"
String helloWorld = (String) parser.parseExpression("'Hello World'").getValue();

double avogadrosNumber = (Double) parser.parseExpression("6.0221415E+23").getValue();

// evals to 2147483647
int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();

boolean trueValue = (Boolean) parser.parseExpression("true").getValue();

Object nullValue = parser.parseExpression("null").getValue();

逻辑运算(布尔运算)

逻辑与 and && 逻辑或 or || 逻辑非 not !

// 逻辑运算
System.out.println(parser.parseExpression("true and false").getValue(Boolean.class));
String exp = "!({'abc','efg','xyz'}.contains('abc')) && ('red' == 'red' && 83.2 > 80) || ('man' == 'man')";
System.out.println(parser.parseExpression(exp).getValue(Boolean.class)); // false

集合筛选(#this)

变量 #this 表示当前操作的对象，常用于集合的过滤

// create an array of integers
List<Integer> primes = new ArrayList<Integer>();
primes.addAll(Arrays.asList(2,3,5,7,11,13,17));

// create parser and set variable 'primes' as the array of integers
ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();
context.setVariable("primes",primes);

// all prime numbers > 10 from the list (using selection ?{...})
// evaluates to [11, 13, 17]
List<Integer> primesGreaterThanTen = (List<Integer>) parser.parseExpression(
        "#primes.?[#this>10]").getValue(context);

集合包含判断

// 集合是否包含key - 表达式内inline构造集合
System.out.println(
        parser.parseExpression("{'abc','efg','xyz'}.contains('abc')").getValue(Boolean.class)); // true
System.out.println(
        parser.parseExpression("!{'abc','efg','xyz'}.contains('abc')").getValue(Boolean.class)); // false

// 集合是否包含key - 将集合变量放入上下文，再从上下文中获取集合变量
context.setVariable("set", ImmutableSet.of("red", "green", "blue"));
System.out.println(parser.parseExpression("#set.contains('red')").getValue(context, Boolean.class)); // true
System.out.println(parser.parseExpression("!#set.contains('red')").getValue(context, Boolean.class)); // false

集合元素访问

// 集合元素访问
List<String> strList = Lists.newArrayList("aaa", "bbb", "ccc");
Map<String, Object> myMap = ImmutableMap.of(
        "strAttr", "strAttrValue",
        "intAttr", 1222,
        "doubleAttr", 92.3,
        "listAttr", strList,
        "mapAttr", ImmutableMap.of("k1", "v1")
);
context.setVariable("strList", strList);
context.setVariable("myMap", myMap);
System.out.println(parser.parseExpression("#strList[0]").getValue(context)); // aaa
System.out.println(parser.parseExpression("#myMap['intAttr']").getValue(context)); // 1222

SpEL 在 Java 对象上匹配求值

public class SpELUtils {
    private static final ExpressionParser PARSER = new SpelExpressionParser();

    /**
     * SpEL 表达式匹配求值
     * @param object 要匹配的对象
     * @param condition 表达式
     * @return
     */
    public static boolean spelObjectMatch(Object object, String condition) {
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("object", object);
        try {
            return Boolean.TRUE.equals(PARSER.parseExpression(condition).getValue(context, Boolean.class));
        } catch (Exception e) {
            System.out.println("SpEL match error " + e.getMessage());
            return false;
        }
    }
}


@Test
public void testObjectMatch() {
    List<Book> books = Lists.newArrayList(
            new Book("语文书", 9.2),
            new Book("数学书", 10D));
    Student student = Student.builder()
            .name("小明")
            .score(93.4)
            .books(books)
            .attributes(ImmutableMap.of(
                    "strAttr", "strAttrValue",
                    "intAttr", 1222,
                    "doubleAttr", 92.3,
                    "listAttr", books,
                    "mapAttr", ImmutableMap.of("k1", "v1")
                    ))
            .build();

    Assertions.assertTrue(SpELUtils.spelObjectMatch(student, "#object.name == '小明'"));
    Assertions.assertTrue(SpELUtils.spelObjectMatch(student, "#object.score >= 90"));
    // 从 book 数组中筛选出 name=语文书 的书比较其 price 值（注意使用 #this.name=='语文书' 做集合筛选后的结果还是割集合，所以后面取元素要加[0]）
    Assertions.assertTrue(SpELUtils.spelObjectMatch(student, "#object.books.?[#this.name=='语文书'][0].price == 9.2"));
    // 从 attributes 的 mapAttr 中获取 k1 的值并比较
    Assertions.assertTrue(SpELUtils.spelObjectMatch(student, "#object.attributes['mapAttr']['k1'] == 'v1'"));
}

@Data
@Builder
private static class Student {
    private String name;
    private Double score;
    private List<Book> books;
    private Map<String, Object> attributes;
}

@Data
@Builder
@AllArgsConstructor
private static class Book {
    private String name;
    private Double price;
}

问题

Property or field 'xx' cannot be found on null

SpelEvaluationException: EL1007E: Property or field 'xx' cannot be found on null

引用前加上 @ @Document(collection = "#{@cname.collectionName}")

SpelEvaluationException: EL1007E: Property or field 'cname' cannot be found on null #15707 https://github.com/spring-projects/spring-boot/issues/15707