此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Framework 6.1.10！

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Framework 6.1.10！

本节介绍 SpEL 接口及其表达式语言的编程用法。 完整的语言参考可以在语言参考中找到。

以下代码演示如何使用 SpEL API 计算文本字符串 表达。Hello World

  • Java

  • Kotlin

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'Hello World'"); (1)
String message = (String) exp.getValue();
1 message 变量的值为 。"Hello World" 
val parser = SpelExpressionParser()
val exp = parser.parseExpression("'Hello World'") (1)
val message = exp.value as String
1 message 变量的值为 。"Hello World"

您最有可能使用的 SpEL 类和接口位于包及其子包中，例如 .org.springframework.expressionspel.support

该接口负责分析表达式字符串。在 前面的示例中，表达式 string 是一个字符串文本，由周围的 单引号。该接口负责评估 定义的表达式字符串。调用时可以引发的两种类型的异常分别是 和 。ExpressionParserExpressionparser.parseExpression(…​)exp.getValue(…​)ParseExceptionEvaluationException

SpEL 支持广泛的功能，例如调用方法、访问属性、 并调用构造函数。

在下面的方法调用示例中，我们对字符串调用该方法 字面。concatHello World

  • Java

  • Kotlin

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'Hello World'.concat('!')"); (1)
String message = (String) exp.getValue();
1 的值现在为 。message"Hello World!" 
val parser = SpelExpressionParser()
val exp = parser.parseExpression("'Hello World'.concat('!')") (1)
val message = exp.value as String
1 的值现在为 。message"Hello World!"

下面的示例演示如何访问 字符串文本 .BytesHello World

  • Java

  • Kotlin

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes()'
Expression exp = parser.parseExpression("'Hello World'.bytes"); (1)
byte[] bytes = (byte[]) exp.getValue();
1 此行将文本转换为字节数组。 
val parser = SpelExpressionParser()

// invokes 'getBytes()'
val exp = parser.parseExpression("'Hello World'.bytes") (1)
val bytes = exp.value as ByteArray
1 此行将文本转换为字节数组。

SpEL 还通过使用标准点表示法（如 ）以及属性值的相应设置来支持嵌套属性。 也可以访问公共字段。prop1.prop2.prop3

下面的示例演示如何使用点表示法来获取字符串文本的长度。

  • Java

  • Kotlin

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes().length'
Expression exp = parser.parseExpression("'Hello World'.bytes.length"); (1)
int length = (Integer) exp.getValue();
1 'Hello World'.bytes.length给出文字的长度。 
val parser = SpelExpressionParser()

// invokes 'getBytes().length'
val exp = parser.parseExpression("'Hello World'.bytes.length") (1)
val length = exp.value as Int
1 'Hello World'.bytes.length给出文字的长度。

可以调用 String 的构造函数，而不是使用字符串文本，如下所示 示例显示。

  • Java

  • Kotlin

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("new String('hello world').toUpperCase()"); (1)
String message = exp.getValue(String.class);
1 从文本中构造一个新，并将其转换为大写。String 
val parser = SpelExpressionParser()
val exp = parser.parseExpression("new String('hello world').toUpperCase()")  (1)
val message = exp.getValue(String::class.java)
1 从文本中构造一个新，并将其转换为大写。String

请注意泛型方法的用法：. 使用此方法无需将表达式的值转换为所需的值 结果类型。如果无法将值转换为 键入或使用已注册的类型转换器进行转换。public <T> T getValue(Class<T> desiredResultType)EvaluationExceptionT

SpEL 更常见的用法是提供经过计算的表达式字符串 针对特定对象实例（称为根对象）。以下示例显示 如何从类的实例中检索属性以及如何 在布尔表达式中引用属性。nameInventorname

  • Java

  • Kotlin

// Create and set a calendar
GregorianCalendar c = new GregorianCalendar();
c.set(1856, 7, 9);

// The constructor arguments are name, birthday, and nationality.
Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian");

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("name"); // Parse name as an expression
String name = (String) exp.getValue(tesla);
// name == "Nikola Tesla"

exp = parser.parseExpression("name == 'Nikola Tesla'");
boolean result = exp.getValue(tesla, Boolean.class);
// result == true
// Create and set a calendar
val c = GregorianCalendar()
c.set(1856, 7, 9)

// The constructor arguments are name, birthday, and nationality.
val tesla = Inventor("Nikola Tesla", c.time, "Serbian")

val parser = SpelExpressionParser()

var exp = parser.parseExpression("name") // Parse name as an expression
val name = exp.getValue(tesla) as String
// name == "Nikola Tesla"

exp = parser.parseExpression("name == 'Nikola Tesla'")
val result = exp.getValue(tesla, Boolean::class.java)
// result == true
1 message 变量的值为 。"Hello World"
1 message 变量的值为 。"Hello World"
1 的值现在为 。message"Hello World!"
1 的值现在为 。message"Hello World!"
1 此行将文本转换为字节数组。
1 此行将文本转换为字节数组。
1 'Hello World'.bytes.length给出文字的长度。
1 'Hello World'.bytes.length给出文字的长度。
1 从文本中构造一个新，并将其转换为大写。String
1 从文本中构造一个新，并将其转换为大写。String

理解EvaluationContext

在计算要解析的表达式时，使用该接口 属性、方法或字段，并帮助执行类型转换。Spring 提供两个 实现。EvaluationContext

  • SimpleEvaluationContext：公开基本 SpEL 语言功能的子集，以及 配置选项，用于不需要完整范围的表达式类别 ，应有意义地限制 SpEL 语言语法。示例包括 but 不限于数据绑定表达式和基于属性的筛选器。

  • StandardEvaluationContext：公开全套 SpEL 语言功能和 配置选项。您可以使用它来指定默认根对象并配置 所有可用的与评估相关的策略。

SimpleEvaluationContext旨在仅支持 SpEL 语言语法的子集。 它不包括 Java 类型引用、构造函数和 Bean 引用。它还需要 显式选择表达式中属性和方法的支持级别。 默认情况下，静态工厂方法仅允许对属性进行读取访问。 您还可以获取构建器来配置所需的确切支持级别，定位 以下一项或某种组合。create()

  • 仅自定义（无反射）PropertyAccessor

  • 只读访问的数据绑定属性

  • 读取和写入的数据绑定属性

类型转换

默认情况下，SpEL 使用 Spring 核心中提供的转换服务 ().此转换服务来了 具有许多用于常见转换的内置转换器，但也是完全可扩展的，因此 您可以在类型之间添加自定义转换。此外，它还具有泛型感知能力。 这意味着，当您在表达式中使用泛型类型时，SpEL 会尝试 转换以保持它遇到的任何对象的类型正确性。org.springframework.core.convert.ConversionService

这在实践中意味着什么？假设正在使用 ，赋值 以设置属性。属性的类型实际上是 。SpEL系列 识别列表的元素需要转换为之前 被放置在其中。下面的示例演示如何执行此操作。setValue()ListList<Boolean>Boolean

  • Java

  • Kotlin

class Simple {
	public List<Boolean> booleanList = new ArrayList<>();
}

Simple simple = new Simple();
simple.booleanList.add(true);

EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();

// "false" is passed in here as a String. SpEL and the conversion service
// will recognize that it needs to be a Boolean and convert it accordingly.
parser.parseExpression("booleanList[0]").setValue(context, simple, "false");

// b is false
Boolean b = simple.booleanList.get(0);
class Simple {
	var booleanList: MutableList<Boolean> = ArrayList()
}

val simple = Simple()
simple.booleanList.add(true)

val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()

// "false" is passed in here as a String. SpEL and the conversion service
// will recognize that it needs to be a Boolean and convert it accordingly.
parser.parseExpression("booleanList[0]").setValue(context, simple, "false")

// b is false
val b = simple.booleanList[0]

解析器配置

可以使用解析器配置来配置 SpEL 表达式解析器 对象 （）。配置 对象控制某些表达式组件的行为。例如，如果您 索引到数组或集合中，指定索引处的元素为 ， SpEL 可以自动创建元素。这在使用由 属性引用链。如果索引为数组或列表并指定索引 即超出当前大小的数组或列表的末尾，SpEL 可以自动 增加数组或列表以容纳该索引。为了在 指定的索引，SpEL 将尝试使用元素类型的默认值创建元素 构造函数，然后设置指定值。如果元素类型没有 默认构造函数，将添加到数组或列表中。如果没有内置 或知道如何设置值的自定义转换器，将保留在数组中或 列表在指定的索引处。以下示例演示了如何自动增长 列表。org.springframework.expression.spel.SpelParserConfigurationnullnullnull

  • Java

  • Kotlin

class Demo {
	public List<String> list;
}

// Turn on:
// - auto null reference initialization
// - auto collection growing
SpelParserConfiguration config = new SpelParserConfiguration(true, true);

ExpressionParser parser = new SpelExpressionParser(config);

Expression expression = parser.parseExpression("list[3]");

Demo demo = new Demo();

Object o = expression.getValue(demo);

// demo.list will now be a real collection of 4 entries
// Each entry is a new empty String
class Demo {
	var list: List<String>? = null
}

// Turn on:
// - auto null reference initialization
// - auto collection growing
val config = SpelParserConfiguration(true, true)

val parser = SpelExpressionParser(config)

val expression = parser.parseExpression("list[3]")

val demo = Demo()

val o = expression.getValue(demo)

// demo.list will now be a real collection of 4 entries
// Each entry is a new empty String

默认情况下，SpEL 表达式不能包含超过 10,000 个字符;但是，是可配置的。如果以编程方式创建，则可以在创建提供给 .如果您愿意 设置用于解析 SpEL 表达式（例如，在 XML Bean 定义等）中，您可以 将 JVM 系统属性或 Spring 属性设置为应用程序所需的最大表达式长度（请参阅支持的 Spring 属性）。maxExpressionLengthSpelExpressionParsermaxExpressionLengthSpelParserConfigurationSpelExpressionParsermaxExpressionLengthApplicationContext@Valuespring.context.expression.maxLength

SpEL 编译

Spring 为 SpEL 表达式提供了一个基本的编译器。表达式通常为 解释，这在评估期间提供了很大的动态灵活性，但不能 提供最佳性能。对于偶尔的表达式使用，这很好，但是，当 由其他组件如Spring Integration使用，性能可能非常重要， 而且没有真正需要活力。

SpEL 编译器旨在满足这一需求。在评估期间，编译器 生成一个 Java 类，该类在运行时体现表达式行为，并使用该类 类来实现更快的表达式评估。由于缺乏打字 表达式，编译器使用在解释评估期间收集的信息 执行编译时的表达式。例如，它不知道类型 纯粹来自表达式的属性引用，但在第一次解释期间 评估，它找出它是什么。当然，基于这样的推导进行编译 如果各种表达式元素的类型，信息可能会在以后引起麻烦 随时间而变化。因此，编译最适合其表达式 类型信息不会在重复计算时更改。

请考虑以下基本表达式。

someArray[0].someProperty.someOtherProperty < 0.1

因为前面的表达式涉及数组访问、一些属性取消引用和 数值运算，性能提升可能非常明显。在一个示例中 micro 基准运行 50,000 次迭代，使用解释器和 使用表达式的编译版本仅 3 毫秒。

编译器配置

默认情况下，编译器未打开，但您可以在两个中打开它 不同的方式。您可以使用解析器配置过程打开它 （已讨论 更早），或者当 SpEL 用法嵌入到另一个 Spring 属性中时使用 Spring 属性 元件。本节将讨论这两个选项。

编译器可以在三种模式之一下运行，这些模式在枚举中捕获。模式如下。org.springframework.expression.spel.SpelCompilerMode

  • OFF（默认值）：编译器已关闭。

  • IMMEDIATE：在即时模式下，表达式会尽快编译。这 通常在第一次解释性评估之后。如果编译的表达式失败 （通常是由于类型更改，如前所述），表达式的调用方 评估收到异常。

  • MIXED：在混合模式下，表达式在解释和 随时间推移的编译模式。经过一定数量的解释运行后，它们切换到编译 形式，如果编译的表单出现问题（例如类型更改，如 如前所述），表达式会自动切换回解释形式 再。稍后，它可能会生成另一个编译的表单并切换到它。 基本上，用户在模式下获得的异常被处理 内部。IMMEDIATE

IMMEDIATE模式之所以存在，是因为模式可能会导致表达式出现问题 有副作用。如果编译后的表达式在部分成功后爆炸，则 可能已经做了一些影响系统状态的事情。如果这 已经发生，调用方可能不希望它以解释模式静默地重新运行， 因为部分表达式可以运行两次。MIXED

选择模式后，使用 配置解析器。这 以下示例演示如何执行此操作。SpelParserConfiguration

  • Java

  • Kotlin

SpelParserConfiguration config = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
		this.getClass().getClassLoader());

SpelExpressionParser parser = new SpelExpressionParser(config);

Expression expr = parser.parseExpression("payload");

MyMessage message = new MyMessage();

Object payload = expr.getValue(message);
val config = SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
		this.javaClass.classLoader)

val parser = SpelExpressionParser(config)

val expr = parser.parseExpression("payload")

val message = MyMessage()

val payload = expr.getValue(message)

指定编译器模式时，还可以指定（允许传递）。编译的表达式在根据 any 创建的子项中定义 这是提供的。重要的是要确保，如果指定了 a，它可以 查看表达式计算过程中涉及的所有类型。如果未指定 ，则使用默认值（通常为 在表达式计算期间运行的线程）。ClassLoadernullClassLoaderClassLoaderClassLoaderClassLoaderClassLoader

配置编译器的第二种方法是在 SpEL 嵌入到某些 其他组件，可能无法通过配置对其进行配置 对象。在这种情况下，可以通过 JVM 系统属性（或通过 SpringProperties 机制）将属性设置为枚举值（、 或 ）之一。spring.expression.compiler.modeSpelCompilerModeoffimmediatemixed

编译器限制

Spring 不支持编译所有类型的表达式。主要关注点 可能在性能关键上下文中使用的常见表达式。这 无法编译以下类型的表达式。

  • 涉及赋值的表达式

  • 依赖于转换服务的表达式

  • 使用自定义解析程序或访问器的表达式

  • 使用重载运算符的表达式

  • 使用数组构造语法的表达式

  • 使用选择或投影的表达式

将来可能会支持其他种类的表达式的编译。