动态语言支持

Spring 提供了全面支持，用于使用通过动态语言（如 Groovy）定义的类和对象。此支持允许您用支持的动态语言编写任意数量的类，并使 Spring 容器能够透明地实例化、配置和依赖注入生成的对象。

Spring 的脚本支持主要针对 Groovy 和 BeanShell。除了这些特定支持的语言之外，还支持 JSR-223 脚本机制以与任何支持 JSR-223 的语言提供程序集成（从 Spring 4.2 开始），例如 JRuby。

您可以在场景中找到此动态语言支持在何处立即发挥作用的完整工作示例。

第一个示例

本章的大部分内容都致力于详细描述动态语言支持。在深入了解动态语言支持的所有细节之前，我们先来看一个用动态语言定义的 Bean 的快速示例。此第一个 Bean 的动态语言是 Groovy。（此示例的基础取自 Spring 测试套件。如果您想查看任何其他支持语言中的等效示例，请查看源代码）。

下一个示例显示了Messenger 接口，Groovy Bean 将实现该接口。请注意，此接口是在纯 Java 中定义的。注入对Messenger 的引用的依赖对象不知道底层实现是 Groovy 脚本。以下清单显示了Messenger 接口

package org.springframework.scripting;

public interface Messenger {

	String getMessage();
}

以下示例定义了一个类，该类依赖于Messenger 接口

package org.springframework.scripting;

public class DefaultBookingService implements BookingService {

	private Messenger messenger;

	public void setMessenger(Messenger messenger) {
		this.messenger = messenger;
	}

	public void processBooking() {
		// use the injected Messenger object...
	}
}

以下示例在 Groovy 中实现了Messenger 接口

package org.springframework.scripting.groovy

// Import the Messenger interface (written in Java) that is to be implemented
import org.springframework.scripting.Messenger

// Define the implementation in Groovy in file 'Messenger.groovy'
class GroovyMessenger implements Messenger {

	String message
}

要使用自定义动态语言标记来定义动态语言支持的 Bean，您需要在 Spring XML 配置文件的顶部使用 XML 模式序言。您还需要使用 Spring ApplicationContext 实现作为您的 IoC 容器。使用动态语言支持的 Bean 与普通BeanFactory 实现是支持的，但是您必须管理 Spring 内部组件的连接才能这样做。

有关基于模式的配置的更多信息，请参阅基于 XML 模式配置。

最后，以下示例显示了影响将 Groovy 定义的Messenger 实现注入到DefaultBookingService 类实例中的 Bean 定义

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:lang="http://www.springframework.org/schema/lang"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">

	<!-- this is the bean definition for the Groovy-backed Messenger implementation -->
	<lang:groovy id="messenger" script-source="classpath:Messenger.groovy">
		<lang:property name="message" value="I Can Do The Frug" />
	</lang:groovy>

	<!-- an otherwise normal bean that will be injected by the Groovy-backed Messenger -->
	<bean id="bookingService" class="x.y.DefaultBookingService">
		<property name="messenger" ref="messenger" />
	</bean>

</beans>

bookingService Bean（一个DefaultBookingService）现在可以像往常一样使用其私有messenger 成员变量，因为注入到其中的Messenger 实例是一个Messenger 实例。这里没有任何特殊操作——只是纯 Java 和纯 Groovy。

希望前面的 XML 代码片段不言自明，但如果它不是，也不要过于担心。继续阅读以了解前面配置的原因和来龙去脉。

定义由动态语言支持的 Bean

本节描述了如何在任何支持的动态语言中定义 Spring 托管的 Bean。

请注意，本章不尝试解释支持的动态语言的语法和习惯用法。例如，如果您想使用 Groovy 编写应用程序中的某些类，我们假设您已经了解 Groovy。如果您需要有关动态语言本身的更多详细信息，请参阅本章末尾的更多资源。

常见概念

使用动态语言支持的 Bean 所涉及的步骤如下

编写动态语言源代码的测试（当然）。
然后编写动态语言源代码本身。
使用 XML 配置中相应的<lang:language/> 元素定义动态语言支持的 Bean（您可以使用 Spring API 以编程方式定义此类 Bean，尽管您需要查阅源代码以了解如何执行此操作，因为本章不涵盖此类高级配置）。请注意，这是一个迭代步骤。您需要为每个动态语言源文件至少定义一个 Bean 定义（尽管多个 Bean 定义可以引用同一个源文件）。

前两个步骤（测试和编写动态语言源文件）超出了本章的范围。请参阅您选择的动态语言的语言规范和参考手册，并继续开发您的动态语言源文件。但是，您首先需要阅读本章的其余部分，因为 Spring 的动态语言支持确实对动态语言源文件的内容做出了一些（小的）假设。

`<lang:language/>` 元素

上一节中的列表中的最后一步涉及定义动态语言支持的 Bean 定义，每个您要配置的 Bean 一个（这与普通 JavaBean 配置没有什么不同）。但是，您可以使用<lang:language/> 元素来定义动态语言支持的 Bean，而不是指定要由容器实例化和配置的类的完全限定类名。

每个支持的语言都有一个对应的<lang:language/> 元素

<lang:groovy/>（Groovy）
<lang:bsh/>（BeanShell）
<lang:std/>（JSR-223，例如，使用 JRuby）

可用于配置的确切属性和子元素取决于 Bean 使用哪种语言定义（本章后面的特定于语言的部分对此进行了详细说明）。

可刷新 Bean

Spring 中动态语言支持的（也许是唯一）最引人注目的增值功能是“可刷新 Bean”功能。

可刷新 Bean 是一个动态语言支持的 Bean。只需少量配置，动态语言支持的 Bean 就可以监视其底层源文件资源的变化，然后在动态语言源文件更改时重新加载自身（例如，当您编辑并在文件系统上保存对文件的更改时）。

这允许您将任意数量的动态语言源文件作为应用程序的一部分进行部署，配置 Spring 容器以创建由动态语言源文件支持的 Bean（使用本章中描述的机制），以及（稍后，随着需求的变化或某些其他外部因素的出现）编辑动态语言源文件，并使其所做的任何更改都反映在由已更改的动态语言源文件支持的 Bean 中。无需关闭正在运行的应用程序（或者在 Web 应用程序的情况下重新部署）。经修改的动态语言支持的 Bean 从已更改的动态语言源文件获取新状态和逻辑。

此功能默认情况下处于关闭状态。

现在，我们可以看一个示例，了解使用可刷新 Bean 有多么容易。要打开可刷新 Bean 功能，您必须在 Bean 定义的<lang:language/>元素上指定一个额外的属性。因此，如果我们坚持使用本章前面部分的示例，以下示例显示了我们将在 Spring XML 配置中进行的更改以实现可刷新 Bean。

<beans>

	<!-- this bean is now 'refreshable' due to the presence of the 'refresh-check-delay' attribute -->
	<lang:groovy id="messenger"
			refresh-check-delay="5000" <!-- switches refreshing on with 5 seconds between checks -->
			script-source="classpath:Messenger.groovy">
		<lang:property name="message" value="I Can Do The Frug" />
	</lang:groovy>

	<bean id="bookingService" class="x.y.DefaultBookingService">
		<property name="messenger" ref="messenger" />
	</bean>

</beans>

这确实是您需要做的全部工作。在 messenger Bean 定义上定义的 refresh-check-delay 属性是在对底层动态语言源文件进行任何更改后刷新 Bean 的毫秒数。您可以通过为 refresh-check-delay 属性分配负值来关闭刷新行为。请记住，默认情况下，刷新行为是被禁用的。如果您不希望刷新行为，请不要定义该属性。

如果我们随后运行以下应用程序，我们就可以使用可刷新功能。（请原谅此代码片段中“跳过障碍以暂停执行”的把戏。）System.in.read() 调用仅用于在程序执行暂停时（在此场景中为开发人员）离开并编辑底层动态语言源文件，以便在程序恢复执行时触发动态语言支持的 Bean 的刷新。

以下列表显示了此示例应用程序。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scripting.Messenger;

public final class Boot {

	public static void main(final String[] args) throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
		Messenger messenger = (Messenger) ctx.getBean("messenger");
		System.out.println(messenger.getMessage());
		// pause execution while I go off and make changes to the source file...
		System.in.read();
		System.out.println(messenger.getMessage());
	}
}

然后，出于本示例的目的，假设对 Messenger 实现的 getMessage() 方法的所有调用都必须更改，以便消息用引号括起来。以下列表显示了在程序执行暂停时您（开发人员）应对 Messenger.groovy 源文件进行的更改。

package org.springframework.scripting

class GroovyMessenger implements Messenger {

	private String message = "Bingo"

	public String getMessage() {
		// change the implementation to surround the message in quotes
		return "'" + this.message + "'"
	}

	public void setMessage(String message) {
		this.message = message
	}
}

当程序运行时，输入暂停之前的输出将为 I Can Do The Frug。在对源文件进行更改并保存以及程序恢复执行后，在动态语言支持的 Messenger 实现上调用 getMessage() 方法的结果为 'I Can Do The Frug'（注意添加了额外的引号）。

如果更改发生在 refresh-check-delay 值的窗口内，则对脚本的更改不会触发刷新。实际上，直到在动态语言支持的 Bean 上调用方法时才会获取对脚本的更改。只有当在动态语言支持的 Bean 上调用方法时，它才会检查其底层脚本源是否已更改。与刷新脚本相关的任何异常（例如遇到编译错误或发现脚本文件已被删除）都会导致致命异常传播到调用代码。

前面描述的可刷新 Bean 行为不适用于使用 <lang:inline-script/> 元素表示法定义的动态语言源文件（请参阅内联动态语言源文件）。此外，它仅适用于可以实际检测到对底层源文件进行更改的 Bean（例如，通过检查文件系统上存在的动态语言源文件的最后修改日期的代码）。

内联动态语言源文件

动态语言支持还可以满足直接嵌入到 Spring Bean 定义中的动态语言源文件。更具体地说，<lang:inline-script/> 元素允许您在 Spring 配置文件内立即定义动态语言源。一个示例可能会阐明内联脚本功能的工作原理。

<lang:groovy id="messenger">
	<lang:inline-script>

		package org.springframework.scripting.groovy

		import org.springframework.scripting.Messenger

		class GroovyMessenger implements Messenger {
			String message
		}

	</lang:inline-script>
	<lang:property name="message" value="I Can Do The Frug" />
</lang:groovy>

如果我们将围绕在 Spring 配置文件中定义动态语言源是否为最佳实践的问题放在一边，<lang:inline-script/> 元素在某些情况下可能很有用。例如，我们可能希望快速向 Spring MVC Controller 添加 Spring Validator 实现。使用内联源只需片刻即可完成。（有关此类示例，请参阅脚本验证器）。

了解动态语言支持的 Bean 上下文中的构造函数注入

关于 Spring 的动态语言支持，有一件非常重要的事情需要注意。也就是说，您目前无法向动态语言支持的 Bean 提供构造函数参数（因此，构造函数注入不适用于动态语言支持的 Bean）。为了使构造函数和属性的这种特殊处理 100% 清晰，以下代码和配置的混合不起作用。

一种不可行的方案。

package org.springframework.scripting.groovy

import org.springframework.scripting.Messenger

// from the file 'Messenger.groovy'
class GroovyMessenger implements Messenger {

	GroovyMessenger() {}

	// this constructor is not available for Constructor Injection
	GroovyMessenger(String message) {
		this.message = message;
	}

	String message

	String anotherMessage
}

<lang:groovy id="badMessenger"
	script-source="classpath:Messenger.groovy">
	<!-- this next constructor argument will not be injected into the GroovyMessenger -->
	<!-- in fact, this isn't even allowed according to the schema -->
	<constructor-arg value="This will not work" />

	<!-- only property values are injected into the dynamic-language-backed object -->
	<lang:property name="anotherMessage" value="Passed straight through to the dynamic-language-backed object" />

</lang>

在实践中，此限制并不像最初看起来那么重要，因为 setter 注入是绝大多数开发人员青睐的注入方式（我们是否认为这是一件好事，我们留待以后再讨论）。

Groovy Bean

本节介绍如何在 Spring 中使用在 Groovy 中定义的 Bean。

Groovy 主页包含以下描述：

“Groovy 是一种面向 Java 2 平台的敏捷动态语言，它具有人们在 Python、Ruby 和 Smalltalk 等语言中非常喜欢的许多特性，使 Java 开发人员能够使用类似 Java 的语法来使用这些特性。”

如果您从头到尾阅读了本章，那么您已经看到过一个 Groovy 动态语言支持的 Bean 的示例。现在考虑另一个示例（再次使用 Spring 测试套件中的示例）。

package org.springframework.scripting;

public interface Calculator {

	int add(int x, int y);
}

以下示例在 Groovy 中实现了 Calculator 接口。

package org.springframework.scripting.groovy

// from the file 'calculator.groovy'
class GroovyCalculator implements Calculator {

	int add(int x, int y) {
		x + y
	}
}

以下 Bean 定义使用在 Groovy 中定义的计算器。

<!-- from the file 'beans.xml' -->
<beans>
	<lang:groovy id="calculator" script-source="classpath:calculator.groovy"/>
</beans>

最后，以下小型应用程序使用上述配置。

package org.springframework.scripting;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
		Calculator calc = ctx.getBean("calculator", Calculator.class);
		System.out.println(calc.add(2, 8));
	}
}

运行上述程序产生的输出（毫不奇怪）是 10。（有关更有趣的示例，请参阅动态语言展示项目以获取更复杂的示例，或参阅本章后面的示例场景）。

您不得在每个 Groovy 源文件中定义多个类。虽然这在 Groovy 中是完全合法的，但（可以说）这是一个不好的做法。为了采用一致的方法，您应该（在 Spring 团队看来）遵守每个源文件一个（公共）类的标准 Java 约定。

使用回调自定义 Groovy 对象

GroovyObjectCustomizer 接口是一个回调，它允许您将额外的创建逻辑挂钩到创建 Groovy 支持的 Bean 的过程中。例如，此接口的实现可以调用任何必需的初始化方法，设置一些默认属性值，或指定自定义 MetaClass。以下列表显示了 GroovyObjectCustomizer 接口定义。

public interface GroovyObjectCustomizer {

	void customize(GroovyObject goo);
}

Spring 框架实例化您的 Groovy 支持的 Bean 的实例，然后将创建的 GroovyObject 传递给指定的 GroovyObjectCustomizer（如果已定义）。您可以对提供的 GroovyObject 引用执行任何操作。我们预计大多数人希望使用此回调设置自定义 MetaClass，以下示例显示了如何操作。

public final class SimpleMethodTracingCustomizer implements GroovyObjectCustomizer {

	public void customize(GroovyObject goo) {
		DelegatingMetaClass metaClass = new DelegatingMetaClass(goo.getMetaClass()) {

			public Object invokeMethod(Object object, String methodName, Object[] arguments) {
				System.out.println("Invoking '" + methodName + "'.");
				return super.invokeMethod(object, methodName, arguments);
			}
		};
		metaClass.initialize();
		goo.setMetaClass(metaClass);
	}

}

关于 Groovy 中元编程的完整讨论超出了 Spring 参考手册的范围。请参阅 Groovy 参考手册的相关部分或在线搜索。大量文章讨论了这个主题。实际上，如果您使用 Spring 命名空间支持，那么使用 GroovyObjectCustomizer 非常容易，如下例所示。

<!-- define the GroovyObjectCustomizer just like any other bean -->
<bean id="tracingCustomizer" class="example.SimpleMethodTracingCustomizer"/>

	<!-- ... and plug it into the desired Groovy bean via the 'customizer-ref' attribute -->
	<lang:groovy id="calculator"
		script-source="classpath:org/springframework/scripting/groovy/Calculator.groovy"
		customizer-ref="tracingCustomizer"/>

如果您不使用 Spring 命名空间支持，您仍然可以使用 GroovyObjectCustomizer 功能，如下例所示。

<bean id="calculator" class="org.springframework.scripting.groovy.GroovyScriptFactory">
	<constructor-arg value="classpath:org/springframework/scripting/groovy/Calculator.groovy"/>
	<!-- define the GroovyObjectCustomizer (as an inner bean) -->
	<constructor-arg>
		<bean id="tracingCustomizer" class="example.SimpleMethodTracingCustomizer"/>
	</constructor-arg>
</bean>

<bean class="org.springframework.scripting.support.ScriptFactoryPostProcessor"/>

您还可以指定 Groovy CompilationCustomizer（例如 ImportCustomizer）甚至完整的 Groovy CompilerConfiguration 对象，位置与 Spring 的 GroovyObjectCustomizer 相同。此外，您可以在 ConfigurableApplicationContext.setClassLoader 级别为您的 Bean 设置一个通用的 GroovyClassLoader，并进行自定义配置；这也会导致共享 GroovyClassLoader 使用，因此在大量脚本 Bean 的情况下建议使用此方法（避免每个 Bean 使用一个孤立的 GroovyClassLoader 实例）。

BeanShell Bean

本节介绍如何在 Spring 中使用 BeanShell Bean。

BeanShell 主页包含以下描述

BeanShell is a small, free, embeddable Java source interpreter with dynamic language
features, written in Java. BeanShell dynamically runs standard Java syntax and
extends it with common scripting conveniences such as loose types, commands, and method
closures like those in Perl and JavaScript.

与 Groovy 相比，BeanShell 支持的 Bean 定义需要一些（少量）额外的配置。Spring 中 BeanShell 动态语言支持的实现很有趣，因为 Spring 创建了一个 JDK 动态代理，它实现了 <lang:bsh> 元素的 script-interfaces 属性值中指定的所有接口（这就是为什么您必须在属性的值中提供至少一个接口，因此，当您使用 BeanShell 支持的 Bean 时，请针对接口进行编程）。这意味着对 BeanShell 支持的对象的每个方法调用都将通过 JDK 动态代理调用机制。

现在，我们可以展示一个使用基于 BeanShell 的 Bean 的完整工作示例，该 Bean 实施了本章前面定义的 Messenger 接口。我们再次显示 Messenger 接口的定义。

package org.springframework.scripting;

public interface Messenger {

	String getMessage();
}

以下示例显示了 Messenger 接口的 BeanShell“实现”（我们在这里松散地使用此术语）。

String message;

String getMessage() {
	return message;
}

void setMessage(String aMessage) {
	message = aMessage;
}

以下示例显示了定义上述“类”（我们在这里也松散地使用这些术语）的“实例”的 Spring XML。

<lang:bsh id="messageService" script-source="classpath:BshMessenger.bsh"
	script-interfaces="org.springframework.scripting.Messenger">

	<lang:property name="message" value="Hello World!" />
</lang:bsh>

请参阅场景，了解您可能希望使用基于 BeanShell 的 Bean 的一些场景。

场景

在脚本语言中定义 Spring 托管 Bean 可能有益的场景多种多样。本节描述了 Spring 中动态语言支持的两个可能的用例。

脚本化的 Spring MVC 控制器

一类可以从使用动态语言支持的 Bean 中获益的类是 Spring MVC 控制器。在纯 Spring MVC 应用程序中，Web 应用程序的导航流程在很大程度上由封装在 Spring MVC 控制器中的代码决定。随着 Web 应用程序的导航流程和其他表示层逻辑需要更新以响应支持问题或不断变化的业务需求，通过编辑一个或多个动态语言源文件并查看这些更改如何立即反映在正在运行的应用程序状态中，可能会更容易地实现任何此类所需的更改。

请记住，在 Spring 等项目所倡导的轻量级架构模型中，您通常的目标是拥有一个非常薄的表示层，应用程序的所有核心业务逻辑都包含在域和服务层类中。将 Spring MVC 控制器开发为动态语言支持的 Bean，使您可以通过编辑和保存文本文件来更改表示层逻辑。对这些动态语言源文件所做的任何更改（取决于配置）都会自动反映在由动态语言源文件支持的 Bean 中。

为了实现对任何动态语言支持的 Bean 更改的自动“获取”，您必须启用“可刷新 Bean”功能。有关此功能的完整介绍，请参阅可刷新 Bean。

以下示例显示了一个使用 Groovy 动态语言实现的org.springframework.web.servlet.mvc.Controller

package org.springframework.showcase.fortune.web

import org.springframework.showcase.fortune.service.FortuneService
import org.springframework.showcase.fortune.domain.Fortune
import org.springframework.web.servlet.ModelAndView
import org.springframework.web.servlet.mvc.Controller

import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse

// from the file '/WEB-INF/groovy/FortuneController.groovy'
class FortuneController implements Controller {

	@Property FortuneService fortuneService

	ModelAndView handleRequest(HttpServletRequest request,
			HttpServletResponse httpServletResponse) {
		return new ModelAndView("tell", "fortune", this.fortuneService.tellFortune())
	}
}

<lang:groovy id="fortune"
		refresh-check-delay="3000"
		script-source="/WEB-INF/groovy/FortuneController.groovy">
	<lang:property name="fortuneService" ref="fortuneService"/>
</lang:groovy>

脚本化验证器

使用 Spring 进行应用程序开发的另一个可能受益于动态语言支持的 Bean 所提供的灵活性的领域是验证。与常规 Java 相比，使用松散类型的动态语言（也可能支持内联正则表达式）来表达复杂的验证逻辑可能会更容易。

同样，将验证器开发为动态语言支持的 Bean，使您可以通过编辑和保存简单的文本文件来更改验证逻辑。任何此类更改（取决于配置）都会自动反映在正在运行的应用程序的执行中，并且不需要重新启动应用程序。

为了实现对任何动态语言支持的 Bean 更改的自动“获取”，您必须启用“可刷新 Bean”功能。有关此功能的完整详细介绍，请参阅可刷新 Bean。

以下示例显示了一个使用 Groovy 动态语言实现的 Spring org.springframework.validation.Validator（有关Validator接口的讨论，请参阅使用 Spring 的 Validator 接口进行验证）

import org.springframework.validation.Validator
import org.springframework.validation.Errors
import org.springframework.beans.TestBean

class TestBeanValidator implements Validator {

	boolean supports(Class clazz) {
		return TestBean.class.isAssignableFrom(clazz)
	}

	void validate(Object bean, Errors errors) {
		if(bean.name?.trim()?.size() > 0) {
			return
		}
		errors.reject("whitespace", "Cannot be composed wholly of whitespace.")
	}
}

其他细节

本节包含一些与动态语言支持相关的其他细节。

AOP——为脚本化 Bean 提供建议

您可以使用 Spring AOP 框架为脚本化 Bean 提供建议。Spring AOP 框架实际上并不知道正在提供建议的 Bean 可能是脚本化 Bean，因此您使用（或打算使用）的所有 AOP 用例和功能都适用于脚本化 Bean。当您为脚本化 Bean 提供建议时，不能使用基于类的代理。您必须使用基于接口的代理。

您不仅限于为脚本化 Bean 提供建议。您还可以用受支持的动态语言编写方面本身，并使用这些 Bean 为其他 Spring Bean 提供建议。不过，这确实将是动态语言支持的高级用法。

作用域

如果它并不立即显而易见，脚本化 Bean 可以像任何其他 Bean 一样进行作用域设置。各种<lang:language/>元素上的scope属性允许您控制底层脚本化 Bean 的作用域，就像它对常规 Bean 所做的那样。（默认作用域是单例，就像“常规”Bean 一样。）

以下示例使用scope属性将一个 Groovy Bean 的作用域定义为原型

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:lang="http://www.springframework.org/schema/lang"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">

	<lang:groovy id="messenger" script-source="classpath:Messenger.groovy" scope="prototype">
		<lang:property name="message" value="I Can Do The RoboCop" />
	</lang:groovy>

	<bean id="bookingService" class="x.y.DefaultBookingService">
		<property name="messenger" ref="messenger" />
	</bean>

</beans>

有关 Spring 框架中作用域支持的完整讨论，请参阅IoC 容器中的Bean 作用域。

`lang` XML 模式

Spring XML 配置中的lang元素用于将用动态语言（如 Groovy 或 BeanShell）编写的对象作为 Spring 容器中的 Bean 公开。

这些元素（以及动态语言支持）在动态语言支持中得到了全面介绍。有关此支持和lang元素的完整详细信息，请参阅该部分。

要使用lang模式中的元素，您需要在 Spring XML 配置文件的顶部具有以下序言。以下代码段中的文本引用了正确的模式，以便lang命名空间中的标记可供您使用

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:lang="http://www.springframework.org/schema/lang"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">

	<!-- bean definitions here -->

</beans>