XML 模式创作

从 2.0 版本开始，Spring 就提供了一种机制，用于向基本的 Spring XML 格式添加基于模式的扩展，以定义和配置 Bean。本节介绍如何编写您自己的自定义 XML Bean 定义解析器并将此类解析器集成到 Spring IoC 容器中。

为了方便创作使用模式感知 XML 编辑器的配置文件，Spring 的可扩展 XML 配置机制基于 XML Schema。如果您不熟悉 Spring 标准分发版附带的当前 XML 配置扩展，则应首先阅读上一节关于XML 模式的内容。

创建新的 XML 配置扩展

编写一个 XML 模式来描述您的自定义元素。
编写一个自定义NamespaceHandler实现。
编写一个或多个BeanDefinitionParser实现（这是真正的工作所在）。
注册您的新构件到 Spring。

为了提供一个统一的示例，我们创建一个 XML 扩展（自定义 XML 元素），它允许我们配置SimpleDateFormat（来自java.text包）类型的对象。完成后，我们将能够按如下方式定义SimpleDateFormat类型的 Bean 定义

<myns:dateformat id="dateFormat"
	pattern="yyyy-MM-dd HH:mm"
	lenient="true"/>

（我们在本附录的后面包含更详细的示例。第一个简单示例的目的是引导您完成创建自定义扩展的基本步骤。）

编写模式

为 Spring 的 IoC 容器创建 XML 配置扩展始于编写 XML 模式来描述该扩展。对于我们的示例，我们使用以下模式来配置SimpleDateFormat对象

<!-- myns.xsd (inside package org/springframework/samples/xml) -->

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.mycompany.example/schema/myns"
		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
		xmlns:beans="http://www.springframework.org/schema/beans"
		targetNamespace="http://www.mycompany.example/schema/myns"
		elementFormDefault="qualified"
		attributeFormDefault="unqualified">

	<xsd:import namespace="http://www.springframework.org/schema/beans"/>

	<xsd:element name="dateformat">
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="beans:identifiedType"> (1)
					<xsd:attribute name="lenient" type="xsd:boolean"/>
					<xsd:attribute name="pattern" type="xsd:string" use="required"/>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>
</xsd:schema>

1	指示的行包含所有可识别标签的扩展基（意味着它们具有一个`id`属性，我们可以将其用作容器中的 Bean 标识符）。我们可以使用此属性，因为我们导入了 Spring 提供的`beans`命名空间。

前面的模式允许我们通过使用<myns:dateformat/>元素直接在 XML 应用程序上下文文件中配置SimpleDateFormat对象，如下例所示

<myns:dateformat id="dateFormat"
	pattern="yyyy-MM-dd HH:mm"
	lenient="true"/>

请注意，在我们创建基础结构类之后，前面的 XML 片段与以下 XML 片段基本相同

<bean id="dateFormat" class="java.text.SimpleDateFormat">
	<constructor-arg value="yyyy-MM-dd HH:mm"/>
	<property name="lenient" value="true"/>
</bean>

前两个片段中的第二个在容器中创建一个 Bean（由名为dateFormat的SimpleDateFormat类型标识），并设置了几个属性。

基于模式的配置格式创建方法允许与具有模式感知 XML 编辑器的 IDE 紧密集成。通过使用正确编写的模式，您可以使用自动完成功能让用户在枚举中定义的多个配置选项之间进行选择。

编写`NamespaceHandler`

除了模式之外，我们还需要一个NamespaceHandler来解析 Spring 在解析配置文件时遇到的此特定命名空间的所有元素。对于此示例，NamespaceHandler应该负责解析myns:dateformat元素。

NamespaceHandler接口具有三个方法

init()：允许初始化NamespaceHandler，并在使用处理程序之前由 Spring 调用。
BeanDefinition parse(Element, ParserContext)：当 Spring 遇到顶级元素（未嵌套在 Bean 定义或不同命名空间内）时调用。此方法本身可以注册 Bean 定义、返回 Bean 定义或同时执行这两项操作。
BeanDefinitionHolder decorate(Node, BeanDefinitionHolder, ParserContext)：当 Spring 遇到不同命名空间的属性或嵌套元素时调用。一个或多个 Bean 定义的修饰用于（例如）Spring 支持的作用域。我们首先突出显示一个简单的示例，不使用修饰，然后在一个稍微高级的示例中展示修饰。

虽然您可以为整个命名空间编写自己的NamespaceHandler（因此提供解析命名空间中每个元素的代码），但在 Spring XML 配置文件中，每个顶级 XML 元素通常都会导致单个 Bean 定义（在我们的示例中，单个<myns:dateformat/>元素会导致单个SimpleDateFormat Bean 定义）。Spring 具有许多支持此场景的便捷类。在下面的示例中，我们使用NamespaceHandlerSupport类

Java
Kotlin

package org.springframework.samples.xml;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class MyNamespaceHandler extends NamespaceHandlerSupport {

	public void init() {
		registerBeanDefinitionParser("dateformat", new SimpleDateFormatBeanDefinitionParser());
	}
}

package org.springframework.samples.xml

import org.springframework.beans.factory.xml.NamespaceHandlerSupport

class MyNamespaceHandler : NamespaceHandlerSupport {

	override fun init() {
		registerBeanDefinitionParser("dateformat", SimpleDateFormatBeanDefinitionParser())
	}
}

您可能会注意到，此类中实际上并没有很多解析逻辑。实际上，NamespaceHandlerSupport类具有内置的委托概念。它支持注册任意数量的BeanDefinitionParser实例，当它需要解析其命名空间中的元素时，它会委托给这些实例。这种关注点的清晰分离允许NamespaceHandler处理其命名空间中所有自定义元素的解析协调，同时委托给BeanDefinitionParsers来完成 XML 解析的繁重工作。这意味着每个BeanDefinitionParser只包含解析单个自定义元素的逻辑，正如我们在下一步中看到的那样。

使用`BeanDefinitionParser`

如果NamespaceHandler遇到已映射到特定 Bean 定义解析器（在本例中为dateformat）类型的 XML 元素，则使用BeanDefinitionParser。换句话说，BeanDefinitionParser负责解析模式中定义的单个不同的顶级 XML 元素。在解析器中，我们可以访问 XML 元素（以及它的子元素），以便我们可以解析我们的自定义 XML 内容，如下例所示

Java
Kotlin

package org.springframework.samples.xml;

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;

import java.text.SimpleDateFormat;

public class SimpleDateFormatBeanDefinitionParser extends AbstractSingleBeanDefinitionParser { (1)

	protected Class getBeanClass(Element element) {
		return SimpleDateFormat.class; (2)
	}

	protected void doParse(Element element, BeanDefinitionBuilder bean) {
		// this will never be null since the schema explicitly requires that a value be supplied
		String pattern = element.getAttribute("pattern");
		bean.addConstructorArgValue(pattern);

		// this however is an optional property
		String lenient = element.getAttribute("lenient");
		if (StringUtils.hasText(lenient)) {
			bean.addPropertyValue("lenient", Boolean.valueOf(lenient));
		}
	}

}

1	我们使用 Spring 提供的`AbstractSingleBeanDefinitionParser`来处理创建单个`BeanDefinition`的大部分基本繁重工作。
2	我们向`AbstractSingleBeanDefinitionParser`超类提供单个`BeanDefinition`表示的类型。

package org.springframework.samples.xml

import org.springframework.beans.factory.support.BeanDefinitionBuilder
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser
import org.springframework.util.StringUtils
import org.w3c.dom.Element

import java.text.SimpleDateFormat

class SimpleDateFormatBeanDefinitionParser : AbstractSingleBeanDefinitionParser() { (1)

	override fun getBeanClass(element: Element): Class<*>? { (2)
		return SimpleDateFormat::class.java
	}

	override fun doParse(element: Element, bean: BeanDefinitionBuilder) {
		// this will never be null since the schema explicitly requires that a value be supplied
		val pattern = element.getAttribute("pattern")
		bean.addConstructorArgValue(pattern)

		// this however is an optional property
		val lenient = element.getAttribute("lenient")
		if (StringUtils.hasText(lenient)) {
			bean.addPropertyValue("lenient", java.lang.Boolean.valueOf(lenient))
		}
	}
}

1	我们使用 Spring 提供的`AbstractSingleBeanDefinitionParser`来处理创建单个`BeanDefinition`的大部分基本繁重工作。
2	我们向`AbstractSingleBeanDefinitionParser`超类提供单个`BeanDefinition`表示的类型。

在这个简单的例子中，这就是我们需要做的全部。单个BeanDefinition的创建由AbstractSingleBeanDefinitionParser超类处理，Bean 定义唯一标识符的提取和设置也是如此。

注册处理程序和模式

编码已完成。剩下的就是让 Spring XML 解析基础结构了解我们的自定义元素。我们通过在两个专用属性文件中注册我们的自定义namespaceHandler和自定义 XSD 文件来做到这一点。这两个属性文件都放置在应用程序中的META-INF目录中，并且可以例如与您的二进制类一起分发到 JAR 文件中。Spring XML 解析基础结构通过使用这些特殊的属性文件来自动拾取您的新扩展，其格式将在接下来的两节中详细介绍。

编写`META-INF/spring.handlers`

名为spring.handlers的属性文件包含 XML 模式 URI 与命名空间处理程序类的映射。对于我们的示例，我们需要编写以下内容

http\://www.mycompany.example/schema/myns=org.springframework.samples.xml.MyNamespaceHandler

（:字符是 Java 属性格式中的有效分隔符，因此 URI 中的:字符需要用反斜杠转义。）

键值对的第一部分（键）是与您的自定义命名空间扩展关联的 URI，并且需要与您自定义 XSD 模式中指定的targetNamespace属性的值完全匹配。

编写'META-INF/spring.schemas'

名为spring.schemas 的属性文件包含 XML Schema 位置的映射（在使用该 Schema 作为xsi:schemaLocation 属性一部分的 XML 文件中，与 Schema 声明一起引用）。此文件是为了防止 Spring 绝对必须使用需要互联网访问才能检索 Schema 文件的默认EntityResolver。如果在此属性文件中指定映射，Spring 将在类路径中搜索 Schema（在本例中，org.springframework.samples.xml 包中的myns.xsd）。以下代码片段显示了我们需要为自定义 Schema 添加的行

http\://www.mycompany.example/schema/myns/myns.xsd=org/springframework/samples/xml/myns.xsd

（请记住，必须转义: 字符。）

建议您将 XSD 文件（或文件）与NamespaceHandler 和BeanDefinitionParser 类一起部署在类路径上。

在 Spring XML 配置中使用自定义扩展

使用您自己实现的自定义扩展与使用 Spring 提供的“自定义”扩展没有什么不同。以下示例在 Spring XML 配置文件中使用了在上一步中开发的自定义<dateformat/> 元素

<?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:myns="http://www.mycompany.example/schema/myns"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.mycompany.example/schema/myns http://www.mycompany.com/schema/myns/myns.xsd">

	<!-- as a top-level bean -->
	<myns:dateformat id="defaultDateFormat" pattern="yyyy-MM-dd HH:mm" lenient="true"/> (1)

	<bean id="jobDetailTemplate" abstract="true">
		<property name="dateFormat">
			<!-- as an inner bean -->
			<myns:dateformat pattern="HH:mm MM-dd-yyyy"/>
		</property>
	</bean>

</beans>

1	我们的自定义 bean。

更详细的示例

本节介绍一些更详细的自定义 XML 扩展示例。

在自定义元素中嵌套自定义元素

本节提供的示例演示了如何编写满足以下配置目标所需的各种工件

<?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:foo="http://www.foo.example/schema/component"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.foo.example/schema/component http://www.foo.example/schema/component/component.xsd">

	<foo:component id="bionic-family" name="Bionic-1">
		<foo:component name="Mother-1">
			<foo:component name="Karate-1"/>
			<foo:component name="Sport-1"/>
		</foo:component>
		<foo:component name="Rock-1"/>
	</foo:component>

</beans>

前面的配置将自定义扩展彼此嵌套。<foo:component/> 元素实际配置的类是Component 类（在下例中显示）。请注意，Component 类没有公开components 属性的 setter 方法。这使得使用 setter 注入来配置Component 类的 bean 定义变得困难（或者更确切地说是不可能）。以下清单显示了Component 类

Java
Kotlin

package com.foo;

import java.util.ArrayList;
import java.util.List;

public class Component {

	private String name;
	private List<Component> components = new ArrayList<Component> ();

	// there is no setter method for the 'components'
	public void addComponent(Component component) {
		this.components.add(component);
	}

	public List<Component> getComponents() {
		return components;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

package com.foo

import java.util.ArrayList

class Component {

	var name: String? = null
	private val components = ArrayList<Component>()

	// there is no setter method for the 'components'
	fun addComponent(component: Component) {
		this.components.add(component)
	}

	fun getComponents(): List<Component> {
		return components
	}
}

解决此问题的典型方法是创建一个自定义FactoryBean，该工厂公开components 属性的 setter 属性。以下清单显示了这样一个自定义FactoryBean

Java
Kotlin

package com.foo;

import org.springframework.beans.factory.FactoryBean;

import java.util.List;

public class ComponentFactoryBean implements FactoryBean<Component> {

	private Component parent;
	private List<Component> children;

	public void setParent(Component parent) {
		this.parent = parent;
	}

	public void setChildren(List<Component> children) {
		this.children = children;
	}

	public Component getObject() throws Exception {
		if (this.children != null && this.children.size() > 0) {
			for (Component child : children) {
				this.parent.addComponent(child);
			}
		}
		return this.parent;
	}

	public Class<Component> getObjectType() {
		return Component.class;
	}

	public boolean isSingleton() {
		return true;
	}
}

package com.foo

import org.springframework.beans.factory.FactoryBean
import org.springframework.stereotype.Component

class ComponentFactoryBean : FactoryBean<Component> {

	private var parent: Component? = null
	private var children: List<Component>? = null

	fun setParent(parent: Component) {
		this.parent = parent
	}

	fun setChildren(children: List<Component>) {
		this.children = children
	}

	override fun getObject(): Component? {
		if (this.children != null && this.children!!.isNotEmpty()) {
			for (child in children!!) {
				this.parent!!.addComponent(child)
			}
		}
		return this.parent
	}

	override fun getObjectType(): Class<Component>? {
		return Component::class.java
	}

	override fun isSingleton(): Boolean {
		return true
	}
}

这很好用，但它向最终用户公开了大量的 Spring 内部机制。我们将要做的是编写一个自定义扩展，隐藏所有这些 Spring 内部机制。如果我们坚持前面描述的步骤，我们将首先创建 XSD 模式来定义自定义标签的结构，如下例所示

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<xsd:schema xmlns="http://www.foo.example/schema/component"
		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
		targetNamespace="http://www.foo.example/schema/component"
		elementFormDefault="qualified"
		attributeFormDefault="unqualified">

	<xsd:element name="component">
		<xsd:complexType>
			<xsd:choice minOccurs="0" maxOccurs="unbounded">
				<xsd:element ref="component"/>
			</xsd:choice>
			<xsd:attribute name="id" type="xsd:ID"/>
			<xsd:attribute name="name" use="required" type="xsd:string"/>
		</xsd:complexType>
	</xsd:element>

</xsd:schema>

再次遵循前面描述的过程，我们接下来创建自定义NamespaceHandler

Java
Kotlin

package com.foo;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class ComponentNamespaceHandler extends NamespaceHandlerSupport {

	public void init() {
		registerBeanDefinitionParser("component", new ComponentBeanDefinitionParser());
	}
}

package com.foo

import org.springframework.beans.factory.xml.NamespaceHandlerSupport

class ComponentNamespaceHandler : NamespaceHandlerSupport() {

	override fun init() {
		registerBeanDefinitionParser("component", ComponentBeanDefinitionParser())
	}
}

接下来是自定义BeanDefinitionParser。请记住，我们正在创建一个描述ComponentFactoryBean 的BeanDefinition。以下清单显示了我们的自定义BeanDefinitionParser 实现

Java
Kotlin

package com.foo;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.ManagedList;
import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.util.xml.DomUtils;
import org.w3c.dom.Element;

import java.util.List;

public class ComponentBeanDefinitionParser extends AbstractBeanDefinitionParser {

	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
		return parseComponentElement(element);
	}

	private static AbstractBeanDefinition parseComponentElement(Element element) {
		BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(ComponentFactoryBean.class);
		factory.addPropertyValue("parent", parseComponent(element));

		List<Element> childElements = DomUtils.getChildElementsByTagName(element, "component");
		if (childElements != null && childElements.size() > 0) {
			parseChildComponents(childElements, factory);
		}

		return factory.getBeanDefinition();
	}

	private static BeanDefinition parseComponent(Element element) {
		BeanDefinitionBuilder component = BeanDefinitionBuilder.rootBeanDefinition(Component.class);
		component.addPropertyValue("name", element.getAttribute("name"));
		return component.getBeanDefinition();
	}

	private static void parseChildComponents(List<Element> childElements, BeanDefinitionBuilder factory) {
		ManagedList<BeanDefinition> children = new ManagedList<>(childElements.size());
		for (Element element : childElements) {
			children.add(parseComponentElement(element));
		}
		factory.addPropertyValue("children", children);
	}
}

package com.foo

import org.springframework.beans.factory.config.BeanDefinition
import org.springframework.beans.factory.support.AbstractBeanDefinition
import org.springframework.beans.factory.support.BeanDefinitionBuilder
import org.springframework.beans.factory.support.ManagedList
import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser
import org.springframework.beans.factory.xml.ParserContext
import org.springframework.util.xml.DomUtils
import org.w3c.dom.Element

import java.util.List

class ComponentBeanDefinitionParser : AbstractBeanDefinitionParser() {

	override fun parseInternal(element: Element, parserContext: ParserContext): AbstractBeanDefinition? {
		return parseComponentElement(element)
	}

	private fun parseComponentElement(element: Element): AbstractBeanDefinition {
		val factory = BeanDefinitionBuilder.rootBeanDefinition(ComponentFactoryBean::class.java)
		factory.addPropertyValue("parent", parseComponent(element))

		val childElements = DomUtils.getChildElementsByTagName(element, "component")
		if (childElements != null && childElements.size > 0) {
			parseChildComponents(childElements, factory)
		}

		return factory.getBeanDefinition()
	}

	private fun parseComponent(element: Element): BeanDefinition {
		val component = BeanDefinitionBuilder.rootBeanDefinition(Component::class.java)
		component.addPropertyValue("name", element.getAttribute("name"))
		return component.beanDefinition
	}

	private fun parseChildComponents(childElements: List<Element>, factory: BeanDefinitionBuilder) {
		val children = ManagedList<BeanDefinition>(childElements.size)
		for (element in childElements) {
			children.add(parseComponentElement(element))
		}
		factory.addPropertyValue("children", children)
	}
}

最后，需要通过修改META-INF/spring.handlers 和META-INF/spring.schemas 文件，将各种工件注册到 Spring XML 基础结构中，如下所示

# in 'META-INF/spring.handlers'
http\://www.foo.example/schema/component=com.foo.ComponentNamespaceHandler

# in 'META-INF/spring.schemas'
http\://www.foo.example/schema/component/component.xsd=com/foo/component.xsd

“普通”元素上的自定义属性

编写您自己的自定义解析器和相关的工件并不难。但是，有时这不是正确的做法。考虑一下您需要向现有 bean 定义添加元数据的情况。在这种情况下，您肯定不想编写您自己的整个自定义扩展。相反，您只想向现有的 bean 定义元素添加一个附加属性。

举另一个例子，假设您为一个服务对象定义了一个 bean 定义，该服务对象（对其未知）访问一个集群化的JCache，并且您想确保命名 JCache 实例在周围集群中被急切地启动。以下清单显示了这样的定义

<bean id="checkingAccountService" class="com.foo.DefaultCheckingAccountService"
		jcache:cache-name="checking.account">
	<!-- other dependencies here... -->
</bean>

然后，当解析'jcache:cache-name' 属性时，我们可以创建另一个BeanDefinition。这个BeanDefinition 然后为我们初始化命名的 JCache。我们还可以修改'checkingAccountService' 的现有BeanDefinition，使其依赖于这个新的 JCache 初始化BeanDefinition。以下清单显示了我们的JCacheInitializer

Java
Kotlin

package com.foo;

public class JCacheInitializer {

	private final String name;

	public JCacheInitializer(String name) {
		this.name = name;
	}

	public void initialize() {
		// lots of JCache API calls to initialize the named cache...
	}
}

package com.foo

class JCacheInitializer(private val name: String) {

	fun initialize() {
		// lots of JCache API calls to initialize the named cache...
	}
}

现在我们可以继续进行自定义扩展。首先，我们需要编写描述自定义属性的 XSD 模式，如下所示

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<xsd:schema xmlns="http://www.foo.example/schema/jcache"
		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
		targetNamespace="http://www.foo.example/schema/jcache"
		elementFormDefault="qualified">

	<xsd:attribute name="cache-name" type="xsd:string"/>

</xsd:schema>

接下来，我们需要创建相关的NamespaceHandler，如下所示

Java
Kotlin

package com.foo;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class JCacheNamespaceHandler extends NamespaceHandlerSupport {

	public void init() {
		super.registerBeanDefinitionDecoratorForAttribute("cache-name",
			new JCacheInitializingBeanDefinitionDecorator());
	}

}

package com.foo

import org.springframework.beans.factory.xml.NamespaceHandlerSupport

class JCacheNamespaceHandler : NamespaceHandlerSupport() {

	override fun init() {
		super.registerBeanDefinitionDecoratorForAttribute("cache-name",
				JCacheInitializingBeanDefinitionDecorator())
	}

}

接下来，我们需要创建解析器。请注意，在这种情况下，因为我们将解析 XML 属性，所以我们编写BeanDefinitionDecorator 而不是BeanDefinitionParser。以下清单显示了我们的BeanDefinitionDecorator 实现

Java
Kotlin

package com.foo;

import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.BeanDefinitionDecorator;
import org.springframework.beans.factory.xml.ParserContext;
import org.w3c.dom.Attr;
import org.w3c.dom.Node;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JCacheInitializingBeanDefinitionDecorator implements BeanDefinitionDecorator {

	private static final String[] EMPTY_STRING_ARRAY = new String[0];

	public BeanDefinitionHolder decorate(Node source, BeanDefinitionHolder holder,
			ParserContext ctx) {
		String initializerBeanName = registerJCacheInitializer(source, ctx);
		createDependencyOnJCacheInitializer(holder, initializerBeanName);
		return holder;
	}

	private void createDependencyOnJCacheInitializer(BeanDefinitionHolder holder,
			String initializerBeanName) {
		AbstractBeanDefinition definition = ((AbstractBeanDefinition) holder.getBeanDefinition());
		String[] dependsOn = definition.getDependsOn();
		if (dependsOn == null) {
			dependsOn = new String[]{initializerBeanName};
		} else {
			List dependencies = new ArrayList(Arrays.asList(dependsOn));
			dependencies.add(initializerBeanName);
			dependsOn = (String[]) dependencies.toArray(EMPTY_STRING_ARRAY);
		}
		definition.setDependsOn(dependsOn);
	}

	private String registerJCacheInitializer(Node source, ParserContext ctx) {
		String cacheName = ((Attr) source).getValue();
		String beanName = cacheName + "-initializer";
		if (!ctx.getRegistry().containsBeanDefinition(beanName)) {
			BeanDefinitionBuilder initializer = BeanDefinitionBuilder.rootBeanDefinition(JCacheInitializer.class);
			initializer.addConstructorArg(cacheName);
			ctx.getRegistry().registerBeanDefinition(beanName, initializer.getBeanDefinition());
		}
		return beanName;
	}
}

package com.foo

import org.springframework.beans.factory.config.BeanDefinitionHolder
import org.springframework.beans.factory.support.AbstractBeanDefinition
import org.springframework.beans.factory.support.BeanDefinitionBuilder
import org.springframework.beans.factory.xml.BeanDefinitionDecorator
import org.springframework.beans.factory.xml.ParserContext
import org.w3c.dom.Attr
import org.w3c.dom.Node

import java.util.ArrayList

class JCacheInitializingBeanDefinitionDecorator : BeanDefinitionDecorator {

	override fun decorate(source: Node, holder: BeanDefinitionHolder,
						ctx: ParserContext): BeanDefinitionHolder {
		val initializerBeanName = registerJCacheInitializer(source, ctx)
		createDependencyOnJCacheInitializer(holder, initializerBeanName)
		return holder
	}

	private fun createDependencyOnJCacheInitializer(holder: BeanDefinitionHolder,
													initializerBeanName: String) {
		val definition = holder.beanDefinition as AbstractBeanDefinition
		var dependsOn = definition.dependsOn
		dependsOn = if (dependsOn == null) {
			arrayOf(initializerBeanName)
		} else {
			val dependencies = ArrayList(listOf(*dependsOn))
			dependencies.add(initializerBeanName)
			dependencies.toTypedArray()
		}
		definition.setDependsOn(*dependsOn)
	}

	private fun registerJCacheInitializer(source: Node, ctx: ParserContext): String {
		val cacheName = (source as Attr).value
		val beanName = "$cacheName-initializer"
		if (!ctx.registry.containsBeanDefinition(beanName)) {
			val initializer = BeanDefinitionBuilder.rootBeanDefinition(JCacheInitializer::class.java)
			initializer.addConstructorArg(cacheName)
			ctx.registry.registerBeanDefinition(beanName, initializer.getBeanDefinition())
		}
		return beanName
	}
}

最后，我们需要通过修改META-INF/spring.handlers 和META-INF/spring.schemas 文件，将各种工件注册到 Spring XML 基础结构中，如下所示

# in 'META-INF/spring.handlers'
http\://www.foo.example/schema/jcache=com.foo.JCacheNamespaceHandler

# in 'META-INF/spring.schemas'
http\://www.foo.example/schema/jcache/jcache.xsd=com/foo/jcache.xsd