Spring表达式语言（SpEL）应用 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

SpEL，Spring 的小秘密武器：让你的配置飞起来！🚀

各位观众老爷们，大家好！我是你们的老朋友，代码界的段子手，bug 界的克星，今天要跟大家聊聊 Spring 家族里一个低调却实力爆表的成员：Spring 表达式语言，简称 SpEL。

你是不是经常被 Spring 的各种配置搞得头昏脑胀？XML 文件里密密麻麻的标签，注解里一长串的属性，看着就想放弃治疗？别怕，有了 SpEL，一切都会变得不一样！

SpEL，就像 Spring 给你的一把瑞士军刀，它可以帮你动态地计算属性值，引用 Bean，调用方法，甚至还能玩转集合和数组。用好了 SpEL，你的配置将会变得简洁、灵活、充满魔力！🧙‍♂️

今天，我们就一起揭开 SpEL 的神秘面纱，看看它到底有多么神奇。准备好了吗？让我们开始吧！

一、SpEL 是个啥？为什么需要它？

SpEL (Spring Expression Language) 是一个强大的表达式语言，它支持在运行时查询和操作对象图。说白了，就是让你在 Spring 的配置中，不再只是简单地写死值，而是可以写一些表达式，让 Spring 在运行时帮你计算出结果。

想象一下，你有一个 User 类，里面有 name 和 age 两个属性。你想根据用户的年龄，动态地设置 Bean 的 description 属性。如果没有 SpEL，你可能需要在代码里写一堆 if-else 判断，丑陋不堪。但是有了 SpEL，你只需要一行表达式，就能搞定！

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

    // Getters and setters
}

public class BeanWithDescription {
    private String description;

    public void setDescription(String description) {
        this.description = description;
    }

    // Getter
}

// Spring 配置
<bean id="user" class="com.example.User">
    <property name="name" value="张三"/>
    <property name="age" value="25"/>
</bean>

<bean id="beanWithDescription" class="com.example.BeanWithDescription">
    <property name="description" value="#{user.age > 18 ? '成年人' : '未成年人'}"/>
</bean>

看到没？#{user.age > 18 ? '成年人' : '未成年人'} 这就是 SpEL 表达式。它会先获取 user Bean 的 age 属性，然后判断是否大于 18，最后根据结果设置 description 属性。是不是很方便？😎

为什么需要 SpEL？

动态性： 允许在运行时计算属性值，而不是写死。
灵活性： 可以引用 Bean，调用方法，操作集合，功能强大。
简洁性： 减少代码量，使配置更加简洁易懂。
可维护性： 易于修改和维护，降低了代码的耦合度。

总之，SpEL 就像一个万能的胶水，可以把 Spring 的各个组件粘合在一起，让你的配置更加灵活、强大。

二、SpEL 的语法速览：磨刀不误砍柴工 🪓

SpEL 的语法其实并不复杂，掌握几个常用的操作符和表达式，就能玩转大部分场景。

操作符/表达式	描述	示例
`#{...}`	SpEL 表达式的定界符，所有 SpEL 表达式都必须包含在 `#{...}` 中。	`#{'Hello, world!'}`
`.`	属性访问，用于访问 Bean 的属性。	`#{user.name}` (访问 `user` Bean 的 `name` 属性)
`[]`	数组和集合的索引，用于访问数组或集合中的元素。	`#{users[0]}` (访问 `users` 集合的第一个元素), `#{names[2]}` (访问 `names` 数组的第三个元素)
`?:`	Elvis 操作符，类似于三元运算符，但更加简洁。如果左边的表达式为 null，则返回右边的表达式，否则返回左边的表达式。	`#{user.name ?: 'Unknown'}` (如果 `user.name` 为 null，则返回 ‘Unknown’，否则返回 `user.name`)
`?.`	安全导航操作符，避免空指针异常。如果左边的表达式为 null，则直接返回 null，不会抛出异常。	`#{user?.address?.city}` (如果 `user` 或 `address` 为 null，则返回 null，不会抛出空指针异常)
`T()`	类型引用，用于访问类中的静态方法和常量。	`#{T(java.lang.Math).random()}` (调用 `java.lang.Math` 类的 `random()` 静态方法), `#{T(com.example.Constants).MAX_VALUE}` (访问 `com.example.Constants` 类的 `MAX_VALUE` 静态常量)
`new`	创建对象。	`#{new java.util.Date()}` (创建一个新的 `Date` 对象)
算术运算符	`+`, `-`, `*`, `/`, `%`, `^` (求幂)	`#{1 + 2}`, `#{10 - 5}`, `#{3 * 4}`, `#{10 / 2}`, `#{10 % 3}`, `#{2 ^ 3}`
关系运算符	`==`, `!=`, `<`, `>`, `<=`, `>=`	`#{1 == 1}`, `#{1 != 2}`, `#{1 < 2}`, `#{1 > 0}`, `#{1 <= 1}`, `#{2 >= 1}`
逻辑运算符	`and`, `or`, `not` (`!`)	`#{true and false}`, `#{true or false}`, `#{not true}`
三元运算符	`expression ? valueIfTrue : valueIfFalse`	`#{user.age > 18 ? 'Adult' : 'Minor'}`
正则表达式	`matches`	`#{'123456' matches '[0-9]+'}` (判断字符串是否匹配正则表达式)
集合选择	`.?[]`	`#{users.?[age > 18]}` (选择 `users` 集合中所有 `age` 大于 18 的元素), `#{users.^[age > 18]}` (选择 `users` 集合中第一个 `age` 大于 18 的元素), `#{users.$[age > 18]}` (选择 `users` 集合中最后一个 `age` 大于 18 的元素)
集合投影	`.![]`	`#{users.![name]}` (获取 `users` 集合中所有元素的 `name` 属性，返回一个新的集合)

这些只是 SpEL 的一些基本语法，但已经足够应付大部分场景了。记住，熟能生巧，多练习才能真正掌握。

三、SpEL 的应用场景：哪里需要它，就往哪里搬 🚚

SpEL 的应用场景非常广泛，只要你需要动态地计算属性值，都可以考虑使用 SpEL。下面列举一些常见的应用场景：

配置属性： 这是 SpEL 最常见的应用场景，用于动态地设置 Bean 的属性值。

<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
    <property name="url" value="#{systemProperties['jdbc.url']}"/>
    <property name="username" value="#{systemProperties['jdbc.username']}"/>
    <property name="password" value="#{systemProperties['jdbc.password']}"/>
</bean>

这个例子中，我们使用 SpEL 从系统属性中获取数据库的连接信息，避免了硬编码。

条件判断： 用于根据不同的条件，选择不同的 Bean 或执行不同的操作。
```
@Component
public class MessageService {

    @Value("#{'hello' eq 'world' ? '你好' : '世界'}")
    private String message;

    public String getMessage() {
        return message;
    }
}
```
这个例子中，我们使用 SpEL 判断字符串 ‘hello’ 是否等于 ‘world’，根据结果设置 message 属性。
集合操作： 用于对集合进行过滤、转换等操作。
```
@Component
public class UserService {

    @Value("#{users.?[age > 18].![name]}")
    private List<String> adultUserNames;

    // ...
}
```
这个例子中，我们使用 SpEL 从 users 集合中选择所有 age 大于 18 的用户，然后获取他们的 name 属性，最终得到一个包含所有成年用户姓名的集合。
方法调用： 用于调用 Bean 的方法，并获取返回值。
```
<bean id="calculator" class="com.example.Calculator"/>

<bean id="result" class="java.lang.Integer">
    <constructor-arg value="#{calculator.add(10, 20)}"/>
</bean>
```
这个例子中，我们使用 SpEL 调用 calculator Bean 的 add() 方法，并将返回值作为 result Bean 的构造器参数。

注解驱动的 AOP： 用于在 AOP 切面中，动态地获取方法参数或返回值。

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.*.*(.., @com.example.LoggableParam (*), ..)) && @annotation(loggable)")
    public void logMethod(JoinPoint joinPoint, Loggable loggable) {
        String paramName = loggable.paramName();
        Object arg = Arrays.stream(joinPoint.getArgs())
                .filter(a -> a.getClass().isAnnotationPresent(LoggableParam.class))
                .findFirst()
                .orElse(null);

        System.out.println("Logging method: " + joinPoint.getSignature().getName() + " with param: " + arg);
    }
}

这个例子中，我们使用 SpEL 和自定义注解，实现了动态的参数日志记录。

总之，SpEL 的应用场景非常广泛，只要你需要动态地处理数据，都可以考虑使用 SpEL。

四、SpEL 的进阶技巧：更上一层楼 🪜

掌握了 SpEL 的基本语法和应用场景，你就可以开始探索一些更高级的技巧，让你的 SpEL 表达式更加强大和灵活。

自定义 SpEL 函数： 如果你需要执行一些复杂的逻辑，可以自定义 SpEL 函数，并在表达式中调用。

public class SpelFunctions {

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

// Spring 配置
<bean id="spelFunctions" class="com.example.SpelFunctions"/>

<bean id="reversedName" class="java.lang.String">
    <constructor-arg value="#{@spelFunctions.reverseString(user.name)}"/>
</bean>

这个例子中，我们定义了一个 reverseString() 方法，用于反转字符串，然后在 SpEL 表达式中调用该方法。

注意： 需要将自定义函数注册到 EvaluationContext 中才能在 SpEL 表达式中使用。

使用 EvaluationContext： EvaluationContext 是 SpEL 的核心接口，它提供了访问变量、函数、Bean 等上下文信息的能力。你可以自定义 EvaluationContext，并将其传递给 Expression.getValue() 方法，从而实现更高级的 SpEL 功能。
```
// 创建一个 SimpleEvaluationContext
SimpleEvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();

// 设置变量
context.setVariable("message", "Hello, world!");

// 创建一个 SpEL 表达式
Expression expression = parser.parseExpression("#message");

// 执行表达式
String result = expression.getValue(context, String.class);
```
这个例子中，我们创建了一个 SimpleEvaluationContext，并设置了一个名为 message 的变量，然后在 SpEL 表达式中引用该变量。

使用 PropertyAccessor： PropertyAccessor 用于访问对象的属性，你可以自定义 PropertyAccessor，并将其注册到 EvaluationContext 中，从而实现自定义的属性访问逻辑。

public class MyPropertyAccessor implements PropertyAccessor {

    @Override
    public Class<?>[] getSpecificTargetClasses() {
        return new Class<?>[]{User.class};
    }

    @Override
    public boolean canRead(EvaluationContext context, Object target, String name) throws AccessException {
        return true;
    }

    @Override
    public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException {
        User user = (User) target;
        if ("fullName".equals(name)) {
            return new TypedValue(user.getFirstName() + " " + user.getLastName());
        }
        return null;
    }

    // ... (其他方法)
}

这个例子中，我们定义了一个 MyPropertyAccessor，用于访问 User 对象的 fullName 属性，该属性实际上是由 firstName 和 lastName 拼接而成。

注意： 自定义 PropertyAccessor 需要实现 PropertyAccessor 接口的所有方法。

五、SpEL 的注意事项：避坑指南 ⚠️

虽然 SpEL 非常强大，但在使用过程中，也需要注意一些问题，避免掉入坑里。

安全性： SpEL 表达式可以执行任意代码，因此需要谨慎使用，避免恶意代码注入。特别是当 SpEL 表达式来自用户输入时，更要小心。
性能： SpEL 表达式需要在运行时计算，因此会带来一定的性能开销。对于复杂的表达式，需要进行性能测试，确保不会影响系统的性能。
类型转换： SpEL 表达式中的类型转换可能会出现问题，需要仔细检查，确保类型匹配。
空指针异常： 在使用安全导航操作符 ?. 时，需要注意链式调用可能导致的空指针异常。
调试： SpEL 表达式的调试比较困难，需要使用调试工具，逐步执行表达式，才能找到问题所在。

六、总结：SpEL，让你的 Spring 配置更上一层楼！ 🏆

SpEL 作为 Spring 的一个重要组成部分，为我们提供了强大的表达式语言，可以动态地计算属性值，引用 Bean，调用方法，甚至还能玩转集合和数组。用好了 SpEL，你的配置将会变得简洁、灵活、充满魔力！

希望通过今天的讲解，大家对 SpEL 有了更深入的了解。记住，熟能生巧，多练习才能真正掌握 SpEL 的精髓。

好了，今天的分享就到这里，感谢大家的观看！如果你觉得这篇文章对你有帮助，请点赞、评论、转发，让更多的人了解 SpEL 的魅力！

下次再见！ 👋