服务端开发

Appearance

Spring Expression Language (SpEL) - Elvis 操作符详解 🎉 ​

什么是 Elvis 操作符？ ​

Elvis 操作符（?:）是 Spring Expression Language (SpEL) 中的一个简洁语法糖，它的名字来源于其形状像猫王埃尔维斯·普雷斯利的发型。这个操作符本质上是三元操作符的简化版本，专门用于处理空值检查和默认值设置。

TIP

Elvis 操作符不仅检查 null 值，还会检查空字符串（""），这使得它在实际开发中更加实用！

为什么需要 Elvis 操作符？ ​

传统方式的痛点 ​

在没有 Elvis 操作符之前，我们通常需要使用冗长的三元操作符：

kotlin
// 传统的三元操作符方式
val name = "Elvis Presley"
val displayName = if (name != null) name else "Unknown"

// 或者在 SpEL 中
val expression = "name != null ? name : 'Unknown'"

这种方式存在以下问题：

  • 代码冗余：需要重复写变量名 name
  • 可读性差：逻辑不够直观
  • 容易出错：容易忘记检查空字符串的情况

Elvis 操作符的优势 ​

kotlin
// 使用 Elvis 操作符
val expression = "name ?: 'Unknown'"
kotlin
// 冗长且容易出错
val parser = SpelExpressionParser()
val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()

val inventor = Inventor()
val name = parser.parseExpression("name != null ? name : 'Unknown'") 
    .getValue(context, inventor, String::class.java)
kotlin
// 简洁且直观
val parser = SpelExpressionParser()
val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()

val inventor = Inventor()
val name = parser.parseExpression("name ?: 'Unknown'") 
    .getValue(context, inventor, String::class.java)

Elvis 操作符的工作原理 ​

IMPORTANT

Elvis 操作符的判断逻辑：

  1. 首先检查左侧表达式的值是否为 null
  2. 然后检查是否为空字符串 ""
  3. 如果两个条件都不满足，返回左侧的值
  4. 否则返回右侧的默认值

实际应用场景 ​

1. 基础用法示例 ​

kotlin
import org.springframework.expression.ExpressionParser
import org.springframework.expression.spel.standard.SpelExpressionParser
import org.springframework.expression.spel.support.SimpleEvaluationContext

class ElvisOperatorDemo {
    
    data class Inventor(
        var name: String? = null,
        var nationality: String? = null
    )
    
    fun basicUsage() {
        val parser = SpelExpressionParser()
        val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
        
        // 场景1：处理 null 值
        val inventor1 = Inventor() // name 为 null
        val name1 = parser.parseExpression("name ?: 'Unknown'") 
            .getValue(context, inventor1, String::class.java)
        println("结果1: $name1") // 输出: Unknown
        
        // 场景2：处理空字符串
        val inventor2 = Inventor(name = "") // name 为空字符串
        val name2 = parser.parseExpression("name ?: 'Unknown'") 
            .getValue(context, inventor2, String::class.java)
        println("结果2: $name2") // 输出: Unknown
        
        // 场景3：正常值
        val inventor3 = Inventor(name = "Nikola Tesla")
        val name3 = parser.parseExpression("name ?: 'Unknown'") 
            .getValue(context, inventor3, String::class.java)
        println("结果3: $name3") // 输出: Nikola Tesla
    }
}

2. 在 Spring Boot 配置中的应用 ​

kotlin
import org.springframework.beans.factory.annotation.Value
import org.springframework.stereotype.Component

@Component
class DatabaseConfig {
    
    // 使用 Elvis 操作符设置默认端口
    @Value("#{systemProperties['db.port'] ?: 3306}") 
    private val dbPort: Int = 0
    
    // 设置默认主机名
    @Value("#{systemProperties['db.host'] ?: 'localhost'}") 
    private val dbHost: String = ""
    
    // 设置默认数据库名
    @Value("#{environment['spring.datasource.database'] ?: 'myapp'}") 
    private val databaseName: String = ""
    
    fun getConnectionUrl(): String {
        return "jdbc:mysql://$dbHost:$dbPort/$databaseName"
    }
}

3. 复杂业务场景应用 ​

kotlin
import org.springframework.expression.ExpressionParser
import org.springframework.expression.spel.standard.SpelExpressionParser
import org.springframework.expression.spel.support.SimpleEvaluationContext

class UserProfileService {
    
    data class User(
        var firstName: String? = null,
        var lastName: String? = null,
        var nickname: String? = null,
        var email: String? = null
    )
    
    private val parser = SpelExpressionParser()
    private val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
    
    fun getDisplayName(user: User): String {
        // 优先级：nickname > firstName + lastName > email > "访客"
        return parser.parseExpression(
            "nickname ?: (firstName + ' ' + lastName) ?: email ?: '访客'"
        ).getValue(context, user, String::class.java) ?: "访客"
    }
    
    fun getContactInfo(user: User): String {
        // 获取联系方式，优先显示邮箱
        return parser.parseExpression(
            "email ?: '未提供联系方式'"
        ).getValue(context, user, String::class.java) ?: "未提供联系方式"
    }
}

4. 在模板引擎中的应用 ​

完整的模板处理示例
kotlin
import org.springframework.expression.ExpressionParser
import org.springframework.expression.spel.standard.SpelExpressionParser
import org.springframework.expression.spel.support.SimpleEvaluationContext

class TemplateProcessor {
    
    data class TemplateContext(
        val user: Map<String, Any?> = emptyMap(),
        val system: Map<String, Any?> = emptyMap(),
        val config: Map<String, Any?> = emptyMap()
    )
    
    private val parser = SpelExpressionParser()
    private val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
    
    fun processTemplate(template: String, templateContext: TemplateContext): String {
        val expressions = mapOf(
            "#{userName}" to "user['name'] ?: '用户'", 
            "#{userRole}" to "user['role'] ?: '普通用户'", 
            "#{systemName}" to "system['name'] ?: '系统'", 
            "#{version}" to "config['version'] ?: '1.0.0'"
        )
        
        var result = template
        expressions.forEach { (placeholder, expression) ->
            val value = parser.parseExpression(expression)
                .getValue(context, templateContext, String::class.java)
            result = result.replace(placeholder, value ?: "")
        }
        
        return result
    }
}

// 使用示例
fun main() {
    val processor = TemplateProcessor()
    val templateContext = TemplateProcessor.TemplateContext(
        user = mapOf("name" to "", "role" to null), // 空值和 null 值
        system = mapOf("name" to "MyApp"),
        config = mapOf("version" to null)
    )
    
    val template = "欢迎 #{userName}（#{userRole}）使用 #{systemName} v#{version}"
    val result = processor.processTemplate(template, templateContext)
    println(result) // 输出: 欢迎 用户（普通用户）使用 MyApp v1.0.0
}

最佳实践与注意事项 ​

✅ 推荐做法 ​

最佳实践

  1. 优先使用 Elvis 操作符：比三元操作符更简洁
  2. 合理设置默认值：默认值应该有业务意义
  3. 链式使用：可以连续使用多个 Elvis 操作符
kotlin
// 推荐：链式使用 Elvis 操作符
val displayText = parser.parseExpression(
    "title ?: subtitle ?: description ?: '暂无内容'"
).getValue(context, article, String::class.java)

⚠️ 注意事项 ​

常见陷阱

Elvis 操作符会同时检查 null 和空字符串，这可能不是你想要的行为

kotlin
// 如果只想检查 null 而不检查空字符串
val result1 = parser.parseExpression("name ?: 'default'") 
    .getValue(context, obj, String::class.java) // 空字符串也会返回 'default'

// 如果只想检查 null
val result2 = parser.parseExpression("name != null ? name : 'default'") 
    .getValue(context, obj, String::class.java) // 只有 null 才返回 'default'

性能考虑

在高频调用的场景中，考虑缓存解析后的表达式对象

kotlin
class OptimizedSpelService {
    // 缓存解析后的表达式
    private val cachedExpressions = mutableMapOf<String, Expression>() 
    private val parser = SpelExpressionParser()
    
    fun evaluateWithCache(expressionString: String, rootObject: Any): Any? {
        val expression = cachedExpressions.computeIfAbsent(expressionString) { 
            parser.parseExpression(it)
        }
        return expression.getValue(rootObject)
    }
}

总结 ​

Elvis 操作符是 SpEL 中一个非常实用的语法糖，它：

  • 简化了空值检查：用 ?: 替代冗长的三元操作符
  • 提高了代码可读性：逻辑更加直观明了
  • 增强了健壮性：同时处理 null 和空字符串
  • 广泛适用：从简单的默认值设置到复杂的模板处理都能胜任

在 Spring Boot 开发中，合理使用 Elvis 操作符可以让你的代码更加简洁优雅，同时保持良好的健壮性。记住，好的代码不仅要能工作，还要让人容易理解和维护！ 💯