服务端开发

Appearance

Spring Expression Language (SpEL) 数组构造详解 🚀 ​

概述 ​

Spring Expression Language (SpEL) 是 Spring 框架提供的强大表达式语言，它不仅支持基本的属性访问和方法调用，还支持复杂的数据结构操作，包括数组构造。本文将深入探讨 SpEL 中的数组构造功能，帮助你理解其原理、用法和实际应用场景。

NOTE

SpEL 的数组构造功能让我们能够在运行时动态创建数组，这在配置驱动的应用程序中特别有用。

为什么需要 SpEL 数组构造？ 🤔 ​

在传统的 Java 开发中，我们通常在编译时就确定了数组的结构和内容。但在某些场景下，我们需要根据运行时的条件动态创建数组：

  • 配置驱动的应用：根据配置文件动态生成数组
  • 动态数据处理：基于用户输入或外部数据源创建数组
  • 模板引擎：在模板中动态生成数组数据
  • 规则引擎：根据业务规则动态构造数据结构
kotlin
// 编译时确定的数组
val staticArray = intArrayOf(1, 2, 3, 4)

// 无法根据运行时条件动态调整
fun createArray(size: Int): IntArray {
    return IntArray(size) // 只能创建空数组
}
kotlin
// 运行时动态创建数组
val parser = SpelExpressionParser()
val context = StandardEvaluationContext()

// 根据表达式动态创建
val dynamicArray = parser.parseExpression("new int[] {1, 2, 3}")
    .getValue(context) as IntArray

SpEL 数组构造语法详解 📚 ​

1. 基础数组构造 ​

SpEL 支持使用熟悉的 Java 语法来构造数组：

kotlin
import org.springframework.expression.spel.standard.SpelExpressionParser
import org.springframework.expression.spel.support.StandardEvaluationContext

class SpELArrayDemo {

    private val parser = SpelExpressionParser()
    private val context = StandardEvaluationContext()

    fun basicArrayConstruction() {
        // 创建指定大小的空数组
        val emptyArray = parser.parseExpression("new int[4]") 
            .getValue(context) as IntArray
        println("空数组长度: ${emptyArray.size}") // 输出: 4
        println("空数组内容: ${emptyArray.contentToString()}") // 输出: [0, 0, 0, 0]
    }
}

2. 带初始化器的数组构造 ​

更实用的是创建带有初始值的数组：

kotlin
fun arrayWithInitializer() {
    // 创建带初始值的数组
    val initializedArray = parser.parseExpression("new int[] {1, 2, 3, 4, 5}") 
        .getValue(context) as IntArray

    println("初始化数组: ${initializedArray.contentToString()}") // 输出: [1, 2, 3, 4, 5]

    // 创建字符串数组
    val stringArray = parser.parseExpression("new String[] {'Hello', 'SpEL', 'World'}") 
        .getValue(context) as Array<String>

    println("字符串数组: ${stringArray.contentToString()}") // 输出: [Hello, SpEL, World]
}

3. 多维数组构造 ​

SpEL 也支持多维数组的创建：

kotlin
fun multiDimensionalArray() {
    // 创建二维数组
    val matrix = parser.parseExpression("new int[3][4]") 
        .getValue(context) as Array<IntArray>

    println("二维数组维度: ${matrix.size} x ${matrix[0].size}") // 输出: 3 x 4

    // 创建三维数组
    val cube = parser.parseExpression("new int[2][3][4]") 
        .getValue(context) as Array<Array<IntArray>>

    println("三维数组维度: ${cube.size} x ${cube[0].size} x ${cube[0][0].size}") // 输出: 2 x 3 x 4
}
kotlin
fun multiDimensionalArray() {
    // 创建二维数组
    val matrix = parser.parseExpression("new int[3][4]") 
        .getValue(context) as Array<IntArray>

    println("二维数组维度: ${matrix.size} x ${matrix[0].size}") // 输出: 3 x 4

    // 创建三维数组
    val cube = parser.parseExpression("new int[2][3][4]") 
        .getValue(context) as Array<Array<IntArray>>

    println("三维数组维度: ${cube.size} x ${cube[0].size} x ${cube[0][0].size}") // 输出: 2 x 3 x 4
}

WARNING

目前 SpEL 不支持为多维数组提供初始化器。例如，new int[][] {{1,2},{3,4}} 这样的语法是不支持的。

实际应用场景 💼 ​

场景 1：配置驱动的数据初始化 ​

kotlin
@Component
class ConfigurableDataProcessor {

    @Value("#{new int[] {1, 2, 3, 4, 5}}")
    private lateinit var defaultPriorities: IntArray

    @Value("#{new String[] {'admin', 'user', 'guest'}}")
    private lateinit var defaultRoles: Array<String> 

    fun processWithDefaults() {
        println("默认优先级: ${defaultPriorities.contentToString()}")
        println("默认角色: ${defaultRoles.contentToString()}")
    }
}

场景 2：动态数组生成服务 ​

kotlin
@Service
class DynamicArrayService {

    private val parser = SpelExpressionParser()

    fun createNumberSequence(start: Int, count: Int): IntArray {
        val context = StandardEvaluationContext().apply {
            setVariable("start", start) 
            setVariable("count", count) 
        }
        // 动态构建表达式
        val expression = buildString {
            append("new int[] {")
            repeat(count) { i ->
                if (i > 0) append(", ")
                append("(#start + $i)") // 修正：添加括号确保正确的计算顺序
            }
            append("}")
        }

        return parser.parseExpression(expression) 
            .getValue(context) as IntArray
    }

    fun createMatrix(rows: Int, cols: Int): Array<IntArray> {
        val context = StandardEvaluationContext().apply {
            setVariable("rows", rows)
            setVariable("cols", cols)
        }
        return parser.parseExpression("new int[#rows][#cols]") 
            .getValue(context) as Array<IntArray>
    }
}

场景 3：条件化数组构造 ​

kotlin
@Service
class ConditionalArrayService {

    private val parser = SpelExpressionParser()

    fun createConditionalArray(condition: String, trueValues: String, falseValues: String): IntArray {
        val context = StandardEvaluationContext().apply {
            setVariable("condition", condition)
            setVariable("trueValues", trueValues)
            setVariable("falseValues", falseValues)
        }

        // 根据条件选择不同的数组构造表达式
        val expression = "#condition == 'positive' ? $trueValues : $falseValues"

        return parser.parseExpression(expression) 
            .getValue(context) as IntArray
    }
}

// 使用示例
fun demonstrateConditionalArray() {
    val service = ConditionalArrayService()

    val positiveArray = service.createConditionalArray(
        "positive",
        "new int[] {1, 2, 3}",
        "new int[] {-1, -2, -3}"
    )

    println("条件数组: ${positiveArray.contentToString()}") // 输出: [1, 2, 3]
}

SpEL 数组构造的执行流程 🔄 ​

让我们通过时序图来理解 SpEL 数组构造的内部执行流程：

性能考虑与最佳实践 ⚡ ​

1. 表达式缓存 ​

kotlin
@Service
class OptimizedArrayService {

    // 缓存已解析的表达式以提高性能
    private val expressionCache = ConcurrentHashMap<String, Expression>() 
    private val parser = SpelExpressionParser()

    fun createArrayWithCache(expressionString: String, context: EvaluationContext): IntArray {
        val expression = expressionCache.computeIfAbsent(expressionString) { 
            parser.parseExpression(it)
        }
        return expression.getValue(context) as IntArray
    }
}

2. 编译限制注意事项 ​

CAUTION

SpEL 的数组构造表达式无法被编译为字节码。这意味着每次执行都需要解释执行，性能相对较低。在高频调用的场景中需要特别注意。

kotlin
// 不推荐：高频调用中的动态数组构造
fun highFrequencyOperation() {
    repeat(10000) {
        val array = parser.parseExpression("new int[] {1, 2, 3}") 
            .getValue(context) as IntArray
        // 处理数组...
    }
}

// 推荐：预先构造或使用缓存
fun optimizedHighFrequencyOperation() {
    val cachedExpression = parser.parseExpression("new int[] {1, 2, 3}") 
    repeat(10000) {
        val array = cachedExpression.getValue(context) as IntArray 
        // 处理数组...
    }
}

完整示例：动态报表数据生成器 📊 ​

Details

点击查看完整示例代码

kotlin
@Service
class DynamicReportGenerator {

    private val parser = SpelExpressionParser()
    private val expressionCache = ConcurrentHashMap<String, Expression>()

    /**
     * 根据配置动态生成报表数据数组
     */
    fun generateReportData(config: ReportConfig): ReportData {
        val context = StandardEvaluationContext().apply {
            setVariable("startValue", config.startValue)
            setVariable("increment", config.increment)
            setVariable("count", config.count)
        }
        // 动态构造数值数组
        val valuesExpression = buildValuesExpression(config.count)
        val values = getOrParseExpression(valuesExpression)
            .getValue(context) as IntArray
        // 动态构造标签数组
        val labelsExpression = buildLabelsExpression(config.labels)
        val labels = getOrParseExpression(labelsExpression)
            .getValue(context) as Array<String>

        return ReportData(values, labels)
    }

    private fun buildValuesExpression(count: Int): String {
        return buildString {
            append("new int[] {")
            repeat(count) { i ->
                if (i > 0) append(", ")
                append("#startValue + (#increment * $i)")
            }
            append("}")
        }
    }
    private fun buildLabelsExpression(labels: List<String>): String {
        val labelsList = labels.joinToString(", ") { "'$it'" }
        return "new String[] {$labelsList}"
    }
    private fun getOrParseExpression(expressionString: String): Expression {
        return expressionCache.computeIfAbsent(expressionString) {
            parser.parseExpression(it)
        }
    }
}

data class ReportConfig(
    val startValue: Int,
    val increment: Int,
    val count: Int,
    val labels: List<String>
)

data class ReportData(
    val values: IntArray,
    val labels: Array<String>
) {
    override fun toString(): String {
        return "ReportData(values=${values.contentToString()}, labels=${labels.contentToString()})"
    }
}

// 使用示例
@RestController
class ReportController(private val reportGenerator: DynamicReportGenerator) {
    @PostMapping("/generate-report")
    fun generateReport(@RequestBody config: ReportConfig): ReportData {
        return reportGenerator.generateReportData(config)
    }
}

总结 📝 ​

SpEL 的数组构造功能为我们提供了在运行时动态创建数组的强大能力。通过本文的学习，你应该掌握了：

✅ 基础语法：如何使用 SpEL 创建各种类型的数组
✅ 实际应用：在 Spring 应用中的具体使用场景
✅ 性能优化：表达式缓存和最佳实践
✅ 限制理解：编译限制和多维数组初始化限制

TIP

在实际项目中，建议将 SpEL 数组构造用于配置驱动的场景，而不是高频的业务逻辑处理。合理使用表达式缓存可以显著提升性能。

SpEL 数组构造虽然功能强大，但也要注意其性能特性。在合适的场景下使用，它能让你的 Spring 应用更加灵活和动态！ 🎉