服务端开发

Appearance

Spring Expression Language (SpEL) 变量详解 🚀 ​

概述 ​

Spring Expression Language (SpEL) 中的变量系统是一个强大而灵活的特性，它允许我们在表达式中引用和操作外部数据。想象一下，如果没有变量系统，我们每次都需要硬编码值或者通过复杂的方法调用来获取数据，这将使表达式变得冗长且难以维护。

NOTE

SpEL 变量系统的核心价值在于提供了一种优雅的方式来在表达式中引用外部数据，使得表达式更加灵活和可重用。

变量的基本概念与使用 ​

什么是 SpEL 变量？ ​

SpEL 变量是通过 #variableName 语法引用的命名数据容器。它们通过 EvaluationContext 的 setVariable() 方法进行设置，为表达式提供了访问外部数据的桥梁。

变量命名规则 ​

IMPORTANT

变量名必须遵循以下规则：

  • 必须以字母、下划线 _ 或美元符号 $ 开头
  • 可以包含字母、数字、下划线和美元符号
  • 支持 Unicode 字符（如中文、日文等）
kotlin
// 有效的变量名示例
context.setVariable("userName", "张三")           
context.setVariable("_privateData", "secret")    
context.setVariable("$systemVar", "system")      
context.setVariable("用户名", "李四")              
context.setVariable("user123", "test")
kotlin
// 无效的变量名示例
context.setVariable("123user", "test")    
context.setVariable("user-name", "test")  
context.setVariable("user name", "test")

基础使用示例 ​

让我们通过一个实际的 Spring Boot 应用场景来理解变量的使用：

kotlin
@Service
class UserService {
    
    private val parser = SpelExpressionParser()
    
    fun updateUserName(user: User, newName: String): User {
        // 创建评估上下文
        val context = SimpleEvaluationContext.forReadWriteDataBinding().build()
        
        // 设置变量
        context.setVariable("newName", newName) 
        
        // 使用变量更新用户名
        parser.parseExpression("name = #newName") 
            .getValue(context, user)
        
        return user
    }
}

data class User(
    var name: String,
    var email: String
)

TIP

在实际开发中，变量常用于动态配置、条件判断和数据转换等场景。

特殊变量：#this 和 #root ​

SpEL 提供了两个特殊的内置变量，它们在表达式评估过程中具有特殊的含义和用途。

#this 变量 ​

#this 变量始终指向当前评估对象，在不同的上下文中会动态变化。

#root 变量 ​

#root 变量始终指向根上下文对象，在整个表达式评估过程中保持不变。

实际应用场景 ​

场景一：集合筛选 ​

在电商系统中，我们经常需要根据条件筛选商品：

kotlin
@Service
class ProductService {
    
    private val parser = SpelExpressionParser()
    
    fun filterExpensiveProducts(products: List<Product>, threshold: Double): List<Product> {
        val context = SimpleEvaluationContext.forReadWriteDataBinding().build()
        context.setVariable("products", products)
        context.setVariable("threshold", threshold) 
        
        // 使用 #this 引用集合中的每个产品，筛选价格大于阈值的产品
        val expression = "#products.?[#this.price > #threshold]"
        
        return parser.parseExpression(expression)
            .getValue(context) as List<Product>
    }
}

data class Product(
    val name: String,
    val price: Double,
    val category: String
)

NOTE

在集合筛选表达式 ?[...] 中，#this 指向集合中的每个元素，使得我们可以对每个元素进行条件判断。

场景二：数据投影与转换 ​

在用户管理系统中，我们可能需要生成格式化的用户信息：

kotlin
@Service
class UserReportService {
    
    private val parser = SpelExpressionParser()
    
    fun generateUserReports(company: Company): List<String> {
        val context = SimpleEvaluationContext.forReadWriteDataBinding().build()
        
        // 使用 #root 和 #this 生成用户报告
        val expression = "#root.employees.![#root.name + '公司的员工：' + #this.name + '，邮箱：' + #this.email]"
        
        return parser.parseExpression(expression)
            .getValue(context, company) as List<String>
    }
}

data class Company(
    val name: String,
    val employees: List<Employee>
)

data class Employee(
    val name: String,
    val email: String,
    val department: String
)

场景三：动态配置验证 ​

在配置管理场景中，我们可以使用变量进行动态验证：

kotlin
@Service
class ConfigValidationService {
    
    private val parser = SpelExpressionParser()
    
    fun validateConfig(config: AppConfig): ValidationResult {
        val context = SimpleEvaluationContext.forReadWriteDataBinding().build()
        
        // 设置验证规则变量
        context.setVariable("minPort", 1024) 
        context.setVariable("maxPort", 65535) 
        context.setVariable("validEnvs", listOf("dev", "test", "prod")) 
        
        val validations = mapOf(
            "端口范围检查" to "port >= #minPort and port <= #maxPort", 
            "环境有效性检查" to "#validEnvs.contains(environment)", 
            "超时时间检查" to "timeout > 0 and timeout <= 30000"
        )
        
        val errors = mutableListOf<String>()
        
        validations.forEach { (name, expression) ->
            try {
                val isValid = parser.parseExpression(expression)
                    .getValue(context, config, Boolean::class.java) ?: false
                
                if (!isValid) {
                    errors.add("$name 失败")
                }
            } catch (e: Exception) {
                errors.add("$name 执行异常: ${e.message}")
            }
        }
        
        return ValidationResult(errors.isEmpty(), errors)
    }
}

data class AppConfig(
    val port: Int,
    val environment: String,
    val timeout: Long
)

data class ValidationResult(
    val isValid: Boolean,
    val errors: List<String>
)
kotlin
@RestController
class ConfigController(
    private val validationService: ConfigValidationService
) {
    
    @PostMapping("/config/validate")
    fun validateConfig(@RequestBody config: AppConfig): ResponseEntity<ValidationResult> {
        val result = validationService.validateConfig(config)
        
        return if (result.isValid) {
            ResponseEntity.ok(result)
        } else {
            ResponseEntity.badRequest().body(result)
        }
    }
}

最佳实践与注意事项 ​

1. 类型可见性 ​

WARNING

当设置变量或根上下文对象时，建议使用 public 类型。非公共类型可能导致某些 SpEL 表达式评估或编译失败。

kotlin
// 推荐：使用 public 类
data class PublicUser(val name: String) 

// 避免：使用 private 或 internal 类
private data class PrivateUser(val name: String)

2. 命名空间冲突 ​

CAUTION

变量与函数共享同一个命名空间，必须确保变量名和函数名不重复。

kotlin
val context = SimpleEvaluationContext.forReadWriteDataBinding().build()

// 避免命名冲突
context.setVariable("length", 10)           // 变量名
context.registerFunction("length", ...)     // 函数名 - 会产生冲突!

// 推荐的做法
context.setVariable("maxLength", 10)        
context.registerFunction("calculateLength", ...)

3. 性能优化建议 ​

性能优化技巧

  • 重用 ExpressionParser 实例
  • 缓存已解析的表达式
  • 避免在循环中重复设置相同的变量
kotlin
@Service
class OptimizedSpelService {
    
    // 重用解析器实例
    private val parser = SpelExpressionParser() 
    
    // 缓存已解析的表达式
    private val expressionCache = ConcurrentHashMap<String, Expression>() 
    
    fun evaluateWithCache(expressionString: String, context: EvaluationContext, rootObject: Any): Any? {
        val expression = expressionCache.computeIfAbsent(expressionString) { 
            parser.parseExpression(it) 
        } 
        
        return expression.getValue(context, rootObject)
    }
}

总结 ​

SpEL 变量系统为我们提供了强大的表达式动态化能力：

✅ 灵活性：通过变量可以轻松地在表达式中引用外部数据
✅ 可重用性：同一个表达式可以通过不同的变量值产生不同的结果
✅ 表达力：#this 和 #root 变量使得复杂的集合操作变得简洁明了
✅ 类型安全：结合 Kotlin 的类型系统，提供了良好的开发体验

通过合理使用 SpEL 变量，我们可以构建出更加灵活、可维护的 Spring Boot 应用程序。无论是配置管理、数据验证还是业务规则处理，SpEL 变量都能为我们提供优雅的解决方案。

TIP

在实际项目中，建议将常用的 SpEL 表达式和变量配置抽象成可配置的组件，这样既提高了代码的可维护性，也增强了系统的灵活性。