Spring SpEL (Spring Expression Language)：表达式语言的高级用法

Spring SpEL：表达式语言的高级用法 – 当代码遇见诗和远方

各位码农、攻城狮、程序媛们，大家好！今天咱们聊点高雅的，不谈CRUD，不说API，而是来一场代码与艺术的碰撞——Spring SpEL (Spring Expression Language)。

SpEL，全称Spring Expression Language，是Spring框架中一个强大的表达式语言。它允许你在运行时查询和操作对象图。你可以把它想象成代码界的瑞士军刀，功能强大，用途广泛。

1. SpEL，不仅仅是 ${}

很多人初识SpEL，都是通过${}在配置文件中读取属性。没错，这是SpEL最常见的用法之一，但它仅仅是冰山一角。SpEL真正的威力在于它可以动态地计算表达式，操作对象，甚至调用方法。

@Value("#{systemProperties['java.version']}") 这样的注解，我们经常用。它从系统属性中读取Java版本，并将其注入到对应的字段中。

@Component
public class SystemInfo {

    @Value("#{systemProperties['java.version']}")
    private String javaVersion;

    public String getJavaVersion() {
        return javaVersion;
    }
}

但SpEL远不止于此，它可以执行更复杂的操作。

2. SpEL的核心概念：那些你必须知道的

要想玩转SpEL，必须理解以下几个核心概念：

Expression: 表达式，SpEL的核心，它代表着要执行的代码。
EvaluationContext: 上下文，表达式执行的环境，包含了用于计算表达式的对象、变量和函数。
Root Object: 根对象，评估表达式时，默认的对象，可以通过 #root 访问。
PropertyAccessor: 属性访问器，用于访问对象的属性。Spring提供了多种默认的属性访问器，比如Bean属性访问器、字段访问器等。
Parser: 解析器，将字符串表达式解析成可执行的表达式对象。

3. SpEL语法：语法糖的盛宴

SpEL的语法非常灵活，支持各种运算符、函数调用、集合操作等。

字面量表达式:
- 'Hello World' (字符串)
- 123 (整数)
- 3.14 (浮点数)
- true (布尔值)
- null (空值)
属性引用:
- propertyName (引用根对象的属性)
- object.propertyName (引用对象的属性)
- object?.propertyName (安全导航，如果对象为null，则返回null，避免空指针异常)
方法调用:
- object.methodName() (调用对象的方法)
- object.methodName(arg1, arg2) (带参数的方法调用)
运算符:
- +, -, *, /, % (算术运算符)
- ==, !=, <, >, <=, >= (关系运算符)
- and, or, not (逻辑运算符)
- ?: (三元运算符)
- elvis operator (?:) (空值处理，name ?: 'Unknown')
集合操作:
- list[0] (访问列表的第一个元素)
- map['key'] (访问Map中key为’key’的元素)
- list[0 to 2] (列表切片)
- list[#this > 5] (选择集合中大于5的元素，#this 代表当前元素)
- list.?[#this > 5] (同上，使用选择运算符)
- list.![#this * 2] (投影，将集合中的每个元素乘以2)
构造器调用:
- new java.util.Date() (创建Date对象)
变量引用:
- #variableName (引用变量)
函数调用:
- #myFunction(arg1, arg2) (调用自定义函数)

4. SpEL的应用场景：无处不在的灵活性

SpEL的应用场景非常广泛，几乎在任何需要动态计算表达式的地方都可以使用它。

配置文件:
- 动态配置Bean的属性。
- 根据环境选择不同的配置。
数据校验:
- 编写复杂的校验规则。
- 动态校验数据的有效性。
业务规则:
- 定义灵活的业务规则。
- 根据不同的条件执行不同的逻辑。
AOP:
- 动态配置切入点。
- 根据不同的条件执行不同的通知。
Spring Security:
- 定义灵活的权限控制规则。
- 根据用户的角色和权限控制访问权限。

5. SpEL实战：代码示例，一睹芳容

下面通过几个代码示例，来深入了解SpEL的应用。

示例1：简单的属性注入

@Component
public class User {

    @Value("#{'John Doe'}")
    private String name;

    @Value("#{25}")
    private int age;

    @Value("#{true}")
    private boolean active;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public boolean isActive() {
        return active;
    }
}

在这个例子中，我们使用@Value注解将字面量表达式注入到User对象的属性中。

示例2：使用表达式计算属性值

@Component
public class Product {

    @Value("#{10}")
    private int price;

    @Value("#{product.price * 0.8}")
    private double discountPrice;

    public int getPrice() {
        return price;
    }

    public double getDiscountPrice() {
        return discountPrice;
    }
}

在这个例子中，我们使用表达式计算discountPrice属性的值，它是price属性的80%。

示例3：调用方法

@Component
public class StringUtils {

    public String toUpperCase(String str) {
        return str.toUpperCase();
    }
}

@Component
public class Message {

    @Autowired
    private StringUtils stringUtils;

    @Value("#{stringUtils.toUpperCase('hello world')}")
    private String message;

    public String getMessage() {
        return message;
    }
}

在这个例子中，我们调用StringUtils类的toUpperCase方法，将字符串转换为大写。

示例4：使用集合操作

@Component
public class Order {

    @Value("#{ {'apple', 'banana', 'orange'} }")
    private List<String> items;

    @Value("#{ order.items[0] }")
    private String firstItem;

    @Value("#{ order.items.?[#this == 'banana'] }")
    private List<String> filteredItems;

    public List<String> getItems() {
        return items;
    }

    public String getFirstItem() {
        return firstItem;
    }

    public List<String> getFilteredItems() {
        return filteredItems;
    }
}

在这个例子中，我们使用集合操作来创建列表、访问列表元素和过滤列表元素。

示例5：自定义函数

public class MySpelFunctions {

    public static String reverseString(String str) {
        return new StringBuilder(str).reverse().toString();
    }
}

@Configuration
public class SpelConfig {

    @Bean
    public FunctionDefinition reverseStringFunction() throws NoSuchMethodException {
        return new FunctionDefinition("reverseString", MySpelFunctions.class.getDeclaredMethod("reverseString", String.class));
    }

    @Bean
    public StandardEvaluationContext evaluationContext(FunctionDefinition reverseStringFunction) {
        StandardEvaluationContext context = new StandardEvaluationContext();
        context.registerFunction("reverseString", reverseStringFunction.getFunction());
        return context;
    }
}

@Component
public class CustomFunctionExample {

    @Autowired
    private StandardEvaluationContext evaluationContext;

    @Value("#{ #reverseString('hello') }")
    private String reversedString;

    public String getReversedString() {
        return reversedString;
    }
}

在这个例子中，我们定义了一个自定义函数reverseString，并在SpEL表达式中使用它来反转字符串。

6. 高级用法：玩转EvaluationContext

EvaluationContext是SpEL表达式执行的环境，它可以用来设置变量、注册函数等。Spring提供了两种EvaluationContext的实现：

SimpleEvaluationContext: 适用于不需要类型转换、bean引用和方法重载的场景。
StandardEvaluationContext: 功能更强大，支持类型转换、bean引用和方法重载。

6.1 设置变量

可以使用EvaluationContext的setVariable方法来设置变量。

ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();
context.setVariable("name", "John Doe");
Expression expression = parser.parseExpression("#name");
String name = expression.getValue(context, String.class);
System.out.println(name); // 输出: John Doe

6.2 注册函数

可以使用EvaluationContext的registerFunction方法来注册函数。上面的示例5已经展示了如何注册函数。

6.3 使用Root Object

Root Object是评估表达式时默认的对象。可以通过 #root 在表达式中访问root object。

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

ExpressionParser parser = new SpelExpressionParser();
Person person = new Person("Alice", 30);
StandardEvaluationContext context = new StandardEvaluationContext(person); //设置person为root object
Expression expression = parser.parseExpression("#root.name + ' is ' + #root.age + ' years old'");
String description = expression.getValue(context, String.class);
System.out.println(description); // 输出: Alice is 30 years old

7. SpEL的性能考量：精打细算，避免浪费

虽然SpEL功能强大，但也要注意性能问题。

编译表达式: SpEL表达式需要编译才能执行，编译过程比较耗时。因此，对于需要频繁执行的表达式，最好将其编译一次，然后多次使用。
避免复杂的表达式: 过于复杂的表达式会影响性能。尽量将复杂的逻辑拆分成多个简单的表达式。
使用合适的EvaluationContext: SimpleEvaluationContext比StandardEvaluationContext性能更好，如果不需要类型转换、bean引用和方法重载，尽量使用SimpleEvaluationContext。
缓存表达式: 可以使用缓存来存储编译后的表达式，避免重复编译。

8. SpEL的调试技巧：抽丝剥茧，找出真相

调试SpEL表达式可能会比较困难，因为错误信息通常不够明确。以下是一些调试技巧：

使用SpEL解析器: 可以使用SpelExpressionParser来解析表达式，并打印解析后的结果，查看是否有语法错误。
使用try-catch块: 将SpEL表达式的执行代码放在try-catch块中，捕获异常，并打印异常信息。
打印中间结果: 在表达式中插入一些打印语句，查看中间结果，帮助定位问题。
使用调试器: 可以使用调试器来单步执行SpEL表达式，查看变量的值和表达式的执行过程。

9. SpEL的局限性：并非万能，量力而行

SpEL虽然强大，但也有一些局限性：

类型安全: SpEL是动态类型的，在编译时无法检查类型错误。
安全性: SpEL可以执行任意代码，如果使用不当，可能会导致安全问题。
复杂性: SpEL的语法比较复杂，学习曲线较陡峭。

10. 总结：SpEL，让代码更具灵性

Spring SpEL是一个功能强大的表达式语言，它可以让你在运行时查询和操作对象图，实现动态配置、数据校验、业务规则等功能。虽然SpEL有一些局限性，但只要合理使用，它可以极大地提高代码的灵活性和可维护性。

希望这篇文章能够帮助你更好地理解和使用Spring SpEL，让你的代码更加优雅、灵活和强大。记住，代码不仅仅是冰冷的指令，还可以是一门艺术，一种表达方式，一种连接现实与理想的桥梁。

好了，今天就聊到这里，各位码农、攻城狮、程序媛们，咱们下期再见！

Spring SpEL：表达式语言的高级用法 – 当代码遇见诗和远方

发表回复 取消回复

发表回复取消回复