评估 (Evaluation) _ Spring Framework 6.0.23-SNAPSHOT 中文文档(官方文档中文翻译) —

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

本节介绍SpEL接口的简单使用及其表达式语言。完整的语言参考可以在语言参考中找到。Spring中文文档

以下代码介绍了 SpEL API 来计算文本字符串表达式。Hello WorldSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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.supportSpring中文文档

该接口负责分析表达式字符串。在在前面的示例中，表达式字符串是由周围的单个表示的字符串文本引号。该接口负责评估先前定义的表达式字符串。可以抛出两个异常，以及和时调用和，分别。ExpressionParserExpressionParseExceptionEvaluationExceptionparser.parseExpressionexp.getValueSpring中文文档

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

在下面的方法调用示例中，我们在字符串文本上调用该方法：concatSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'Hello World'.concat('!')"); (1)
String message = (String) exp.getValue();

1	现在的值是“Hello World！”。`message`

val parser = SpelExpressionParser()
val exp = parser.parseExpression("'Hello World'.concat('!')") (1)
val message = exp.value as String

1	现在的值是“Hello World！”。`message`

以下调用 JavaBean 属性的示例调用该属性：StringBytesSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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.prop3Spring中文文档

下面的示例演示如何使用点表示法获取文本的长度：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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 的构造函数，而不是使用字符串文本，如下所示示例显示：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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)EvaluationExceptionTSpring中文文档

SpEL 更常见的用法是提供经过计算的表达式字符串针对特定对象实例（称为根对象）。以下示例显示如何从类的实例中检索属性，或者创建布尔条件：nameInventorSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

// 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	现在的值是“Hello World！”。`message`

1	现在的值是“Hello World！”。`message`

1	此行将文本转换为字节数组。

1	此行将文本转换为字节数组。

1	`'Hello World'.bytes.length`给出文字的长度。

1	`'Hello World'.bytes.length`给出文字的长度。

1	从字面上构造一个新的，并使其大写。`String`

1	从字面上构造一个新的，并使其大写。`String`

理解`EvaluationContext`

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

SimpleEvaluationContext：公开基本 SpEL 语言功能的子集，以及配置选项，用于不需要完整范围的表达式类别，应有意义地限制 SpEL 语言语法。示例包括 but 不限于数据绑定表达式和基于属性的筛选器。Spring中文文档
StandardEvaluationContext：公开全套 SpEL 语言功能和配置选项。您可以使用它来指定默认根对象并配置所有可用的与评估相关的策略。Spring中文文档

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

仅自定义（无反射）PropertyAccessorSpring中文文档
只读访问的数据绑定属性Spring中文文档
读取和写入的数据绑定属性Spring中文文档

类型转换

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

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

JavaSpring中文文档
KotlinSpring中文文档

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.SpelParserConfigurationnullnullnullSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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 编译

Spring Framework 4.1 包括一个基本的表达式编译器。表达式通常为解释，这在评估过程中提供了很大的动态灵活性，但不能提供最佳性能。对于偶尔的表达式使用，这很好，但是，当被其他组件（如Spring Integration）使用时，性能可能非常重要，并且不需要动态性。Spring中文文档

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

请考虑以下基本表达式：Spring中文文档

someArray[0].someProperty.someOtherProperty < 0.1

由于前面的表达式涉及数组访问，某些属性取消引用，和数值运算，性能提升可能非常明显。在一个例子中微基准测试运行 50000 次迭代，使用解释器，并且仅使用 3 毫秒的表达式编译版本。Spring中文文档

编译器配置

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

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

OFF（默认值）：编译器已关闭。Spring中文文档
IMMEDIATE：在即时模式下，表达式会尽快编译。这通常在第一次解释性评估之后。如果编译的表达式失败（通常是由于类型更改，如前所述），表达式的调用方评估收到异常。Spring中文文档
MIXED：在混合模式下，表达式在解释和编译之间静默切换模式随时间推移。经过一定数量的解释运行后，它们切换到编译形式，如果编译的表单出现问题（例如类型更改，如如前所述），表达式会自动切换回解释形式再。稍后，它可能会生成另一个编译的表单并切换到它。基本上用户在模式下获得的异常改为在内部处理。IMMEDIATESpring中文文档

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

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

JavaSpring中文文档
KotlinSpring中文文档

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)

指定编译器模式时，还可以指定类装入器（允许传递 null）。编译的表达式在根据提供的任何内容创建的子类加载器中定义。重要的是要确保，如果指定了类装入器，它可以看到表达式评估过程。如果未指定类装入器，则使用缺省类装入器（通常是在表达式计算期间运行的线程的上下文类加载器）。Spring中文文档

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

编译器限制

从 Spring Framework 4.1 开始，基本的编译框架已经到位。但是，框架尚不支持编译所有类型的表达式。最初的重点是可能在性能关键上下文中使用的常见表达式。以下目前无法编译表达式种类：Spring中文文档

涉及赋值的表达式Spring中文文档
依赖于转换服务的表达式Spring中文文档
使用自定义解析程序或访问器的表达式Spring中文文档
使用选择或投影的表达式Spring中文文档

将来将编译更多类型的表达式。Spring中文文档