動態語言支援

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 Schema 前導資訊。您還需要使用 Spring ApplicationContext 實現作為您的 IoC 容器。雖然支援將由動態語言支援的 bean 與純粹的 BeanFactory 實現一起使用，但您必須管理 Spring 內部機制才能實現這一點。

有關基於 Schema 配置的更多資訊，請參閱基於 XML Schema 的配置。

最後，以下示例顯示了將 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 不支援構造器注入）。為了使對構造器和屬性的這一特殊處理完全清晰，以下程式碼和配置的組合將無法工作

一種無法工作的方法

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 Framework 例項化由 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"/>

您也可以在與 Spring 的 GroovyObjectCustomizer 相同的位置指定一個 Groovy CompilationCustomizer（例如 ImportCustomizer）甚至是一個完整的 Groovy CompilerConfiguration 物件。此外，您可以在 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，它實現了本章前面定義的 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 Controller

可以受益於使用動態語言支援的 bean 的一類是 Spring MVC controller。在純粹的 Spring MVC 應用中，Web 應用的導航流很大程度上由封裝在 Spring MVC controller 中的程式碼決定。隨著 Web 應用的導航流和其他表示層邏輯需要更新以響應支援問題或不斷變化的業務需求，透過編輯一個或多個動態語言原始檔並立即看到這些更改反映在正在執行的應用狀態中，可能會更容易地實現任何此類所需的更改。

請記住，在 Spring 等專案倡導的輕量級架構模型中，您通常的目標是擁有一個非常薄的表示層，而應用的所有核心業務邏輯都包含在領域層和服務層類中。將 Spring MVC controller 開發為動態語言支援的 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>

指令碼化 Validator

Spring 應用開發的另一個領域，可能會受益於動態語言支援的 bean 所提供的靈活性，那就是驗證。使用鬆散型別的動態語言（可能還支援內聯正則表示式）來表達複雜的驗證邏輯，可能比使用常規 Java 更容易。

同樣，將 validator 開發為動態語言支援的 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 一樣。（預設作用域是singleton，與“常規”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 Framework 中作用域支援的完整討論，請參見IoC 容器中的Bean 作用域。

`lang` XML schema

Spring XML 配置中的 lang 元素用於將用動態語言（如 Groovy 或 BeanShell）編寫的物件作為 bean 公開到 Spring 容器中。

這些元素（以及動態語言支援）在動態語言支援中得到了全面介紹。有關此支援和 lang 元素的完整詳細資訊，請參見該部分。

要使用 lang schema 中的元素，您需要在 Spring XML 配置檔案頂部新增以下前言。以下片段中的文字引用了正確的 schema，以便您可以使用 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>