对于最新的稳定版本，请使用 Spring Framework 6.2.0！spring-doc.cn

动态语言支持

Spring 为使用已通过在 Spring 中使用动态语言（例如 Groovy）来定义。此支持允许您可以使用支持的动态语言编写任意数量的类，并拥有 Spring 容器透明地实例化、配置和依赖注入生成的对象。spring-doc.cn

Spring 的脚本支持主要针对 Groovy 和 BeanShell。超越这些特别支持的语言，支持 JSR-223 脚本机制用于与任何支持 JSR-223 的语言提供程序集成（从 Spring 4.2 开始），例如 JRuby。spring-doc.cn

您可以找到有关此动态语言支持的完整工作示例立即在 Scenarios 中有用。spring-doc.cn

第一个例子

本章的大部分内容是描述细节。在深入研究动态语言支持的所有细节之前，我们看一个用动态语言定义的 bean 的快速示例。动态第一个 bean 的语言是 Groovy。（此示例的基础取自 Spring 测试套件。如果您想在任何其他支持的语言，请查看源代码）。spring-doc.cn

下一个示例显示了 Groovy bean 将要访问的接口实现。请注意，此接口是用纯 Java 定义的。依赖对象注入了对 do not know underlying implementation 是一个 Groovy 脚本。下面的清单显示了该接口：MessengerMessengerMessengerspring-doc.cn

package org.springframework.scripting;

public interface Messenger {

	String getMessage();
}

以下示例定义一个依赖于接口的类：Messengerspring-doc.cn

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 中实现接口：Messengerspring-doc.cn

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 Schema 前导码。您还需要使用 Spring 实现作为 IoC 容器。支持将动态语言支持的 bean 与普通实现一起使用，但您必须管理 Spring 内部的管道执行此操作。ApplicationContextBeanFactoryspring-doc.cn

有关基于模式的配置的详细信息，请参阅XML 基于模式的配置。spring-doc.cn

最后，以下示例显示了影响 Groovy 定义的实现添加到类的实例中：MessengerDefaultBookingServicespring-doc.cn

<?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>

bean （a ）现在可以正常使用其私有成员变量，因为注入其中的实例是一个实例。这里没有什么特别的事情 — 只是普通的 Java 和普通的 Groovy。bookingServiceDefaultBookingServicemessengerMessengerMessengerspring-doc.cn

希望前面的 XML 代码段是不言自明的，但如果不是，请不要过分担心。请继续阅读，深入了解上述配置的原因和原因。spring-doc.cn

定义由动态语言支持的 Bean

本节准确描述了如何在任何支持的动态语言。spring-doc.cn

请注意，本章并不试图解释支持的动态语言。例如，如果您想使用 Groovy 编写某些类在您的应用程序中，我们假设您已经了解 Groovy。如果您需要更多详细信息关于动态语言本身，请参阅末尾的更多资源本章。spring-doc.cn

常见概念

使用动态语言支持的 bean 所涉及的步骤如下：spring-doc.cn

为动态语言源代码编写测试（自然）。spring-doc.cn
然后编写动态语言源代码本身。spring-doc.cn
通过在 XML 配置中使用适当的元素来定义动态语言支持的 bean（您可以通过以下方式以编程方式定义此类 bean 使用 Spring API，尽管您必须查阅有关如何执行此操作的说明，因为本章不介绍这种类型的高级配置）。请注意，这是一个迭代步骤。每个动态至少需要一个 bean 定义 language 源文件（尽管多个 bean 定义可以引用同一个源文件）。<lang:language/>spring-doc.cn

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

<lang：language/> 元素

上一节列表中的最后一步涉及定义动态语言支持的 bean 定义，每个 bean 定义想要配置（这与普通的 JavaBean 配置没有什么不同）。然而而不是指定要由容器实例化和配置，则可以使用该元素来定义动态语言支持的 Bean。<lang:language/>spring-doc.cn

每种支持的语言都有相应的元素：<lang:language/>spring-doc.cn

<lang:groovy/>（时髦的）spring-doc.cn
<lang:bsh/>（BeanShell）spring-doc.cn
<lang:std/>（JSR-223，例如使用 JRuby）spring-doc.cn

可用于配置的确切属性和子元素取决于确切地说，是用哪种语言定义 Bean（特定于语言的部分本章稍后将详细介绍这一点）。spring-doc.cn

可刷新的 Bean

动态语言最引人注目的附加值之一（也许是唯一的） Spring 中的支持是“可刷新的 bean”功能。spring-doc.cn

可刷新 Bean 是动态语言支持的 Bean。用少量 configuration 中，动态语言支持的 bean 可以监视其底层 bean 中的更改 source file 资源，然后在动态语言源文件为已更改（例如，当您在文件系统上编辑并保存对文件的更改时）。spring-doc.cn

这允许您将任意数量的动态语言源文件部署为应用程序中，配置 Spring 容器以创建由动态语言源文件（使用本章中介绍的机制）和（稍后的随着需求的变化或其他一些外部因素的开始发挥作用）编辑一个动态 language 源文件，并且他们所做的任何更改都会反映在 Bean 中，即由更改的动态语言源文件提供支持。无需关闭正在运行的应用程序（如果是 Web 应用程序，则为 redeploy）。这 dynamic-language-supported bean so modified 从更改了动态语言源文件。spring-doc.cn

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

现在我们可以看一个示例，看看开始使用 refreshable 是多么容易豆。要打开可刷新 bean 功能，您必须指定一个 additional 属性。所以如果我们坚持前面的例子本章，以下示例显示了我们将在 Spring XML 中更改的内容配置以影响可刷新的 bean：<lang:language/>spring-doc.cn

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

这真的就是你所要做的。在 Bean 定义上定义的属性是 Bean 为刷新对基础动态语言源文件所做的任何更改。您可以通过为属性分配负值来关闭刷新行为。请记住，默认情况下，刷新行为为禁用。如果不需要刷新行为，请不要定义该属性。refresh-check-delaymessengerrefresh-check-delayspring-doc.cn

如果我们随后运行以下应用程序，则可以执行可刷新功能。（请原谅那些 “跳过圈子暂停执行 ”的恶作剧在下一段代码中。调用只是为了让程序的执行在您（本方案中的开发人员）离开时暂停并编辑基础动态语言源文件，以便触发刷新在动态语言支持的 bean 上。System.in.read()spring-doc.cn

下面的清单显示了这个示例应用程序：spring-doc.cn

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());
	}
}

然后，为了本例的目的，假设必须更改对 implementation 方法的所有调用，以便消息为用引号括起来。以下清单显示了您（开发人员）应在程序的执行已暂停：getMessage()MessengerMessenger.groovyspring-doc.cn

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
	}
}

当程序运行时，输入暂停之前的输出将为。在对源文件进行更改并保存并且程序恢复执行后，在 Dynamic-Language 支持的实现上调用该方法的结果是（请注意，包含附加引号）。I Can Do The FruggetMessage()Messenger'I Can Do The Frug'spring-doc.cn

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

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

内联动态语言源文件

动态语言支持还可以满足以下动态语言源文件的需求直接嵌入到 Spring bean 定义中。更具体地说，该元素允许您立即定义动态语言源在 Spring 配置文件中。一个例子可以阐明内联脚本功能作品：<lang:inline-script/>spring-doc.cn

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

如果我们把围绕定义 dynamic language 源，该元素在某些情况下可能很有用。例如，我们可能希望快速添加 Spring implementation 到 Spring MVC 中。这只是片刻的使用内联源工作。（有关此类示例。<lang:inline-script/>ValidatorControllerspring-doc.cn

在动态语言支持的 bean 的上下文中理解构造函数注入

关于 Spring 的动态，有一件非常重要的事情需要注意语言支持。也就是说，你不能（目前）提供构造函数参数添加到动态语言支持的 bean 中（因此，构造函数注入不适用于 dynamic-language-backed bean 的 bean）。为了对构造函数和属性 100% 清晰，以下代码和配置的混合不起作用：spring-doc.cn

行不通的方法

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 注入是绝大多数开发人员青睐的注入方式（我们把关于这是否是一件好事的讨论留到另一天）。spring-doc.cn

时髦的 Bean

本节介绍如何在 Spring 中使用 Groovy 中定义的 bean。spring-doc.cn

Groovy 主页包括以下描述：spring-doc.cn

“Groovy 是一种面向 Java 2 平台的敏捷动态语言，它具有许多人们在 Python、Ruby 和 Smalltalk 等语言中非常喜欢的功能，使得它们可供 Java 开发人员使用类似 Java 的语法。spring-doc.cn

如果你直接从顶部阅读了本章，你已经看到了一个 Groovy-dynamic-language-backed 的例子豆。现在考虑另一个示例（再次使用 Spring 测试套件中的示例）：spring-doc.cn

package org.springframework.scripting;

public interface Calculator {

	int add(int x, int y);
}

以下示例在 Groovy 中实现接口：Calculatorspring-doc.cn

package org.springframework.scripting.groovy

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

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

以下 bean 定义使用 Groovy 中定义的计算器：spring-doc.cn

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

最后，以下小型应用程序执行上述配置：spring-doc.cn

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));
	}
}

运行上述程序的结果输出是（不出所料）。（有关更多有趣的示例，请参阅 dynamic language showcase 项目以获取更多 complex 示例，或参阅本章后面的示例场景）。10spring-doc.cn

每个 Groovy 源文件不能定义多个类。虽然这是完美的 legal，这（可以说）是一种糟糕的做法。为了始终如一的方法，您应该（在 Spring 团队看来）尊重标准的 Java 每个源文件一个（public）类的约定。spring-doc.cn

使用回调自定义 Groovy 对象

该接口是一个回调，允许您挂接额外的创建逻辑添加到创建 Groovy 支持的 bean 的过程中。例如此接口的实现可以调用任何所需的初始化方法，设置一些默认属性值，或指定自定义 .以下清单显示了接口定义：GroovyObjectCustomizerMetaClassGroovyObjectCustomizerspring-doc.cn

public interface GroovyObjectCustomizer {

	void customize(GroovyObject goo);
}

Spring Framework 实例化 Groovy 支持的 bean 的实例，然后将 created 传递给指定的（如果已定义）。您可以使用提供的引用执行任何您喜欢的操作。我们预计大多数人都希望使用 this 设置自定义 callback 的 Tim 函数，以下示例显示了如何执行此操作：GroovyObjectGroovyObjectCustomizerGroovyObjectMetaClassspring-doc.cn

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 命名空间支持，那么使用 a 很容易，因为以下示例显示：GroovyObjectCustomizerspring-doc.cn

<!-- 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 命名空间支持，您仍然可以使用该功能，如下例所示：GroovyObjectCustomizerspring-doc.cn

<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 （例如）甚至是与 Spring 的 .此外，您可以设置一个带有自定义的 common 级别的 bean 的配置; 这也会导致共享使用，因此建议在以下情况下使用大量脚本化 bean（避免每个 bean 有一个孤立的实例）。CompilationCustomizerImportCustomizerCompilerConfigurationGroovyObjectCustomizerGroovyClassLoaderConfigurableApplicationContext.setClassLoaderGroovyClassLoaderGroovyClassLoader

BeanShell 豆

本节介绍如何在 Spring 中使用 BeanShell bean。spring-doc.cn

BeanShell 主页包括以下内容描述：spring-doc.cn

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 动态代理，该代理实现了所有 interfaces 的 APIS（这就是为什么您必须在值属性，因此，当您使用 BeanShell 支持的 beans）的 bean 的 T这意味着对 BeanShell 支持的对象的每个方法调用都会通过 JDK 动态代理调用机制。script-interfaces<lang:bsh>spring-doc.cn

现在，我们可以展示一个使用基于 BeanShell 的 bean 的完整工作示例，该 bean 实现本章前面定义的接口。我们再次展示接口定义：MessengerMessengerspring-doc.cn

package org.springframework.scripting;

public interface Messenger {

	String getMessage();
}

下面的示例展示了 BeanShell 的 “实现” （我们在这里松散地使用了这个术语）的界面中：Messengerspring-doc.cn

String message;

String getMessage() {
	return message;
}

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

以下示例显示了定义上述 “实例” 的 Spring XML “class”（同样，我们在这里非常松散地使用这些术语）：spring-doc.cn

<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-doc.cn

场景

在脚本语言中定义 Spring 托管 bean 的可能情况是有益是多种多样的。本节介绍了 Spring 中的动态语言支持。spring-doc.cn

脚本化 Spring MVC 控制器

可以从使用动态语言支持的 bean 中受益的一组类是 Spring MVC 控制器。在纯 Spring MVC 应用程序中，导航流通过 Web 应用程序在很大程度上由封装在你的 Spring MVC 控制器。作为导航流等表示层逻辑的 Web 应用程序需要更新以响应支持问题或更改业务要求，则通过以下方式实现任何此类所需的更改可能更容易编辑一个或多个动态语言源文件，并看到这些更改立即反映在正在运行的应用程序的状态中。spring-doc.cn

请记住，在项目支持的轻量级架构模型中，例如 Spring，您通常的目标是拥有一个非常薄的表示层，其中包含所有包含在域和服务中的应用程序的丰富业务逻辑 Layer 类。将 Spring MVC 控制器开发为动态语言支持的 bean 允许您可以通过编辑和保存文本文件来更改表示图层逻辑。任何对此类动态语言源文件的更改是（取决于配置）自动反映在由动态语言源文件支持的 bean 中。spring-doc.cn

为了实现对 dynamic-language-backed 的任何更改的自动 “拾取” beans 中，您必须启用 “refreshable beans” 功能。有关此功能的完整处理，请参见 Refreshable Bean。

以下示例显示了已实现的通过使用 Groovy 动态语言：org.springframework.web.servlet.mvc.Controllerspring-doc.cn

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。spring-doc.cn

同样，将验证器开发为动态语言支持的 bean 可以让您更改验证逻辑。任何此类更改都是（取决于配置）自动反映在正在运行的应用程序，并且不需要重新启动应用程序。spring-doc.cn

实现对 dynamic-language-backed 的任何更改的自动 “拾取” beans 中，您必须启用 'refreshable beans' 功能。有关此功能的完整和详细处理，请参见 Refreshable Bean。

下面的示例展示了使用 Groovy 动态语言实现的 Spring（有关接口的讨论，请参见使用 Spring 的 Validator 接口进行验证）：org.springframework.validation.ValidatorValidatorspring-doc.cn

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.")
	}
}

其他详细信息

最后一部分包含一些与动态语言支持相关的其他详细信息。spring-doc.cn

AOP — 为脚本化 bean 提供建议

您可以使用 Spring AOP 框架来通知脚本化 bean。Spring AOP 系列框架实际上不知道被通知的 bean 可能是脚本 bean，因此您使用（或打算使用）的所有 AOP 用例和功能使用脚本化 bean。当您建议脚本 bean 时，不能使用基于类的代理。您必须使用基于接口的代理。spring-doc.cn

您不仅限于为脚本 bean 提供建议。你也可以自己编写 aspect 并使用此类 bean 来通知其他 Spring bean。不过，这确实是动态语言支持的高级使用。spring-doc.cn

范围

如果不是很明显，则可以采用与任何其他 bean。各种元素上的属性允许您可以控制底层脚本化 Bean 的范围，就像使用常规的豆。（默认范围为单例，就像 “常规” bean 一样。scope<lang:language/>spring-doc.cn

下面的示例使用该属性来定义一个范围为原型：scopespring-doc.cn

<?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 范围。spring-doc.cn

XML 架构`lang`

Spring XML 配置中的元素处理公开已用动态语言（例如 Groovy 或 BeanShell）编写为 Spring 容器中的 bean。langspring-doc.cn

动态语言支持中全面介绍了这些元素（以及动态语言支持）。请参阅该部分了解有关此支持和 Elements 的完整详细信息。langspring-doc.cn

要使用架构中的元素，您需要在 top 的 Spring XML 配置文件。以下代码段中的文本引用正确的架构，以便命名空间中的标记可供您使用：langlangspring-doc.cn

<?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>