41. XML Schema-based configuration

41.1 简介

本附录详细介绍了 Spring 2.0 中引入的 XML Schema-based configuration,并在 Spring 2.5 和 3.0 中进行了增强和扩展。


DTD 支持?

仍然完全支持使用旧的 DTD 样式创作 Spring configuration files。

如果您放弃使用新的 XML Schema-based 方法来创作 Spring XML configuration files,那么什么都不会 break。你失去的一切就是有机会更简洁,更清晰的配置。无论 XML configuration 是 DTD-还是 Schema-based,最后它都归结为容器中的同一 object model(即一个或多个BeanDefinition实例)。


迁移到基于 XML Schema 的 configuration files 的主要动机是使 Spring XML configuration 更容易。 '经典'<bean/> -based 方法很好,但它的 generic-nature 在配置开销方面有代价。

从 Spring IoC 容器 point-of-view,一切都是 bean。这对于 Spring IoC 容器来说是个好消息,因为如果一切都是 bean 那么一切都可以用完全相同的方式处理。然而,同样的事情并非来自开发者的 point-of-view。 Spring XML configuration 文件中定义的 objects 并非都是通用的,vanilla beans。通常,每个 bean 都需要一定程度的特定 configuration。

Spring 2.0 的新 XML Schema-based configuration 解决了这个问题。 <bean/>元素仍然存在,如果您愿意,您可以继续使用<bean/>元素编写完全相同的 Spring XML configuration 样式。但是,新的 XML Schema-based configuration 确实使 Spring XML configuration files 更加清晰易读。此外,它允许您表达 bean 定义的意图。

要记住的 key 要注意的是,新的自定义标记最适合基础结构或 integration beans:for example,AOP,collections,transactions,_lgration with 3rd-party frameworks(如 Mule 等),而现有的 bean 标签最适合 application-specific beans ,例如 DAO,服务层对象,验证器等。

下面的示例将有望说服您在 Spring 2.0 中包含 XML Schema 支持是一个很好的 idea。社区的接待令人鼓舞;另外,请注意这个新的 configuration 机制是完全可定制和可扩展的。这意味着您可以编写自己的 domain-specific configuration 标记,以更好地代表您的 application 域;参与这一过程的 process 在题为第 42 章,可扩展的 XML 创作的附录中有所涉及。

41.2 XML Schema-based configuration

41.2.1 引用模式

要从 DTD-style 切换到新 XML Schema-style,您需要进行以下更改。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
        "http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans>

<!-- bean definitions here -->

</beans>

XML Schema-style 中的等效文件将是......

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

    <!-- bean definitions here -->

</beans>

'xsi:schemaLocation'片段实际上并不是必需的,但可以包含在 reference schema 的本地副本中(在开发过程中可能很有用)。

上面的 Spring XML configuration 片段是样板文件,您可以复制和粘贴(!)然后将<bean/>定义插入到您一直以来的过程中。但是,整个切换点是利用新的 Spring 2.0 XML 标签,因为它们使 configuration 更容易。标题为第 41.2.2 节,“util schema”的部分演示了如何使用一些更常见的实用程序标记立即启动。

本章的内容专门用于展示新的基于 Spring XML Schema 的 configuration 的示例,每个新标记至少有一个 example。格式遵循前后样式,前面的 XML 片段显示旧的(但仍然是 100%合法和支持的)样式,紧接着是后 example 显示新 XML Schema-based 样式中的等效样式。

41.2.2 util schema

首先是util标签的覆盖范围。正如 name 所暗示的那样,util标签处理 common,实用程序配置问题,例如配置集合,引用常量等。

要使用util schema 中的标记,您需要在 Spring XML configuration 文件的顶部添加以下前导码;下面的代码段中的文本引用了正确的 schema,以便util命名空间中的标记可供您使用。

<?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:util="http://www.springframework.org/schema/util" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"> <!-- bean definitions here -->

</beans>

< hh:// +21+ 3 >

之前…

<bean id="..." class="...">
    <property name="isolation">
        <bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
                class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" />
    </property>
</bean>

上面的 configuration 使用 Spring FactoryBean implementation,FieldRetrievingFactoryBean,将 bean 上的isolation property 的 value 设置为java.sql.Connection.TRANSACTION_SERIALIZABLE常量的 value。这一切都很好,但它有点冗长,并且(不必要地)将 Spring 的内部管道暴露给最终用户。

以下 XML Schema-based version 更简洁,清楚地表达了开发人员的意图('inject this constant value'),它只是读得更好。

<bean id="..." class="...">
    <property name="isolation">
        <util:constant static-field="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
    </property>
</bean>
从字段 value 设置 bean property 或构造函数 arg

FieldRetrievingFactoryBean是FactoryBean,它检索static或 non-static 字段 value。它通常用于检索public static final常量,然后可以使用它们为另一个 bean 设置 property value 或构造函数 arg。

通过使用staticField property,在下面找到一个显示static字段如何暴露的 example:

<bean id="myField"
        class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
    <property name="staticField" value="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
</bean>

还有一个便利用法表单,其中static字段被指定为 bean name:

<bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
        class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"/>

这确实意味着 bean id 不再有任何选择(因此引用它的任何其他 bean 也必须使用这个更长的 name),但这个表单定义非常简洁,并且非常方便用作内部 bean,因为不必为 bean reference 指定 id:

<bean id="..." class="...">
    <property name="isolation">
        <bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
                class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" />
    </property>
</bean>

也可以访问另一个 bean 的 non-static(实例)字段,如FieldRetrievingFactoryBean class 的 API 文档中所述。

在 Spring 中将 enum 值作为 property 或构造函数 arguments 注入 enum 是非常容易的,因为你实际上不需要做任何事情或者对 Spring 内部有任何了解(或者甚至关于_c 类等的 class)。让我们看一个 example 来看看注入 enum value 是多么容易;考虑这个 JDK 5 enum:

package javax.persistence;

public enum PersistenceContextType {

    TRANSACTION,
    EXTENDED

}

现在考虑一个PersistenceContextType类型的 setter:

package example;

public class Client {

    private PersistenceContextType persistenceContextType;

    public void setPersistenceContextType(PersistenceContextType type) {
        this.persistenceContextType = type;
    }

}
  • 和相应的 bean 定义:
<bean class="example.Client">
    <property name="persistenceContextType" value="TRANSACTION" />
</bean>

这适用于经典的 type-safe 模拟枚举(在 JDK 1.4 和 JDK 1.3 上); Spring 将自动尝试将 string property value 匹配到 enum class 上的常量。

< hh:// +57+ 3 >

之前…

<!-- target bean to be referenced by name -->
<bean id="testBean" class="org.springframework.beans.TestBean" scope="prototype">
    <property name="age" value="10"/>
    <property name="spouse">
        <bean class="org.springframework.beans.TestBean">
            <property name="age" value="11"/>
        </bean>
    </property>
</bean>

<!-- will result in 10, which is the value of property 'age' of bean 'testBean' -->
<bean id="testBean.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>

上面的 configuration 使用 Spring FactoryBean implementation,PropertyPathFactoryBean来创建一个名为testBean.age的__(类型为int),其 value 等于testBean bean 的age property。

后…

<!-- target bean to be referenced by name -->
<bean id="testBean" class="org.springframework.beans.TestBean" scope="prototype">
    <property name="age" value="10"/>
    <property name="spouse">
        <bean class="org.springframework.beans.TestBean">
            <property name="age" value="11"/>
        </bean>
    </property>
</bean>

<!-- will result in 10, which is the value of property 'age' of bean 'testBean' -->
<util:property-path id="name" path="testBean.age"/>

<property-path/>标记的path属性的 value 遵循beanName.beanProperty形式。

使用< hh:// +71+ .h >设置 bean property 或 constructor-argument

PropertyPathFactoryBeanFactoryBean,它评估给定目标 object 上的 property 路径。目标 object 可以直接指定,也可以通过 bean name 指定。然后,此 value 可以在另一个 bean 定义中用作 property value 或构造函数参数。

这是一个 example,其中一个路径用于另一个 bean,由 name:

// target bean to be referenced by name
<bean id="person" class="org.springframework.beans.TestBean" scope="prototype">
    <property name="age" value="10"/>
    <property name="spouse">
        <bean class="org.springframework.beans.TestBean">
            <property name="age" value="11"/>
        </bean>
    </property>
</bean>

// will result in 11, which is the value of property 'spouse.age' of bean 'person'
<bean id="theAge"
        class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
    <property name="targetBeanName" value="person"/>
    <property name="propertyPath" value="spouse.age"/>
</bean>

在此 example 中,针对内部 bean 评估路径:

<!-- will result in 12, which is the value of property 'age' of the inner bean -->
<bean id="theAge"
        class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
    <property name="targetObject">
        <bean class="org.springframework.beans.TestBean">
            <property name="age" value="12"/>
        </bean>
    </property>
    <property name="propertyPath" value="age"/>
</bean>

还有一个快捷方式表单,其中 bean name 是 property 路径。

<!-- will result in 10, which is the value of property 'age' of bean 'person' -->
<bean id="person.age"
        class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>

这个表单确实意味着 bean 的 name 中没有选择。任何 reference 它也必须使用相同的 id,即路径。当然,如果用作内部 bean,则根本不需要引用它:

<bean id="..." class="...">
    <property name="age">
        <bean id="person.age"
                class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>
    </property>
</bean>

结果类型可以在实际定义中具体设置。对于大多数用例来说,这不是必需的,但对某些用例可能有用。有关此 feature 的更多信息,请参阅 Javadocs。

< hh:// +82+ 3 >

之前…

<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
<bean id="jdbcConfiguration" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
    <property name="location" value="classpath:com/foo/jdbc-production.properties"/>
</bean>

上面的 configuration 使用 Spring FactoryBean implementation(PropertiesFactoryBean)来实例化一个java.util.Properties实例,其值从提供的资源位置加载。

后…

<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
<util:properties id="jdbcConfiguration" location="classpath:com/foo/jdbc-production.properties"/>

< hh:// +92+ 3 >

之前…

<!-- creates a java.util.List instance with values loaded from the supplied 'sourceList' -->
<bean id="emails" class="org.springframework.beans.factory.config.ListFactoryBean">
    <property name="sourceList">
        <list>
            <value>[emailprotected]</value>
            <value>[emailprotected]</value>
            <value>[emailprotected]</value>
            <value>[emailprotected]</value>
        </list>
    </property>
</bean>

上面的 configuration 使用 Spring FactoryBean implementation,ListFactoryBean来创建一个java.util.List实例,该实例使用从提供的sourceList获取的值进行初始化。

后…

<!-- creates a java.util.List instance with the supplied values -->
<util:list id="emails">
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
</util:list>

您还可以通过使用<util:list/>元素上的list-class属性显式控制将实例化和填充的List的确切类型。例如,如果我们确实需要实例化java.util.LinkedList,我们可以使用以下 configuration:

<util:list id="emails" list-class="java.util.LinkedList">
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
    <value>d'[emailprotected]</value>
</util:list>

如果未提供list-class属性,则容器将选择List implementation。

< hh:// +109+ 3 >

之前…

<!-- creates a java.util.Map instance with values loaded from the supplied 'sourceMap' -->
<bean id="emails" class="org.springframework.beans.factory.config.MapFactoryBean">
    <property name="sourceMap">
        <map>
            <entry key="pechorin" value="[emailprotected]"/>
            <entry key="raskolnikov" value="[emailprotected]"/>
            <entry key="stavrogin" value="[emailprotected]"/>
            <entry key="porfiry" value="[emailprotected]"/>
        </map>
    </property>
</bean>

上面的 configuration 使用 Spring FactoryBean implementation,MapFactoryBean来创建一个java.util.Map实例,该实例使用从提供的'sourceMap'中获取的 key-value 对进行初始化。

后…

<!-- creates a java.util.Map instance with the supplied key-value pairs -->
<util:map id="emails">
    <entry key="pechorin" value="[emailprotected]"/>
    <entry key="raskolnikov" value="[emailprotected]"/>
    <entry key="stavrogin" value="[emailprotected]"/>
    <entry key="porfiry" value="[emailprotected]"/>
</util:map>

您还可以通过使用<util:map/>元素上的'map-class'属性显式控制将实例化和填充的Map的确切类型。例如,如果我们确实需要实例化java.util.TreeMap,我们可以使用以下 configuration:

<util:map id="emails" map-class="java.util.TreeMap">
    <entry key="pechorin" value="[emailprotected]"/>
    <entry key="raskolnikov" value="[emailprotected]"/>
    <entry key="stavrogin" value="[emailprotected]"/>
    <entry key="porfiry" value="[emailprotected]"/>
</util:map>

如果未提供'map-class'属性,则容器将选择Map implementation。

< hh:// +126+ 3 >

之前…

<!-- creates a java.util.Set instance with values loaded from the supplied 'sourceSet' -->
<bean id="emails" class="org.springframework.beans.factory.config.SetFactoryBean">
    <property name="sourceSet">
        <set>
            <value>[emailprotected]</value>
            <value>[emailprotected]</value>
            <value>[emailprotected]</value>
            <value>[emailprotected]</value>
        </set>
    </property>
</bean>

上面的 configuration 使用 Spring FactoryBean implementation,SetFactoryBean来创建一个java.util.Set实例,该实例使用从提供的'sourceSet'获取的值进行初始化。

后…

<!-- creates a java.util.Set instance with the supplied values -->
<util:set id="emails">
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
</util:set>

您还可以通过使用<util:set/>元素上的'set-class'属性显式控制将实例化和填充的Set的确切类型。例如,如果我们确实需要实例化java.util.TreeSet,我们可以使用以下 configuration:

<util:set id="emails" set-class="java.util.TreeSet">
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
    <value>[emailprotected]</value>
</util:set>

如果未提供'set-class'属性,则容器将选择Set implementation。

41.2.3 jee schema

jee标签处理 Java EE(Java Enterprise Edition)-related configuration 问题,例如查找 JNDI object 和定义 EJB references。

要使用jee schema 中的标记,您需要在 Spring XML configuration 文件的顶部添加以下前导码;以下代码段中的文本引用了正确的 schema,以便jee命名空间中的标记可供您使用。

<?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:jee="http://www.springframework.org/schema/jee" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd"> <!-- bean definitions here -->

</beans>

< hh:// +148+ 3 >(简单)

之前…

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="jdbc/MyDataSource"/>
</bean>
<bean id="userDao" class="com.foo.JdbcUserDao">
    <!-- Spring will do the cast automatically (as usual) -->
    <property name="dataSource" ref="dataSource"/>
</bean>

后…

<jee:jndi-lookup id="dataSource" jndi-name="jdbc/MyDataSource"/>

<bean id="userDao" class="com.foo.JdbcUserDao">
    <!-- Spring will do the cast automatically (as usual) -->
    <property name="dataSource" ref="dataSource"/>
</bean>

< hh:// +153+ 3 >(具有单个 JNDI 环境设置)

之前…

<bean id="simple" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="jdbc/MyDataSource"/>
    <property name="jndiEnvironment">
        <props>
            <prop key="foo">bar</prop>
        </props>
    </property>
</bean>

后…

<jee:jndi-lookup id="simple" jndi-name="jdbc/MyDataSource">
    <jee:environment>foo=bar</jee:environment>
</jee:jndi-lookup>

< hh:// +158+ 3 >(具有多个 JNDI 环境设置)

之前…

<bean id="simple" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="jdbc/MyDataSource"/>
    <property name="jndiEnvironment">
        <props>
            <prop key="foo">bar</prop>
            <prop key="ping">pong</prop>
        </props>
    </property>
</bean>

后…

<jee:jndi-lookup id="simple" jndi-name="jdbc/MyDataSource">
    <!-- newline-separated, key-value pairs for the environment (standard Properties format) -->
    <jee:environment>
        foo=bar
        ping=pong
    </jee:environment>
</jee:jndi-lookup>

< hh:// +163+ 3 >(复杂)

之前…

<bean id="simple" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="jdbc/MyDataSource"/>
    <property name="cache" value="true"/>
    <property name="resourceRef" value="true"/>
    <property name="lookupOnStartup" value="false"/>
    <property name="expectedType" value="com.myapp.DefaultFoo"/>
    <property name="proxyInterface" value="com.myapp.Foo"/>
</bean>

后…

<jee:jndi-lookup id="simple"
        jndi-name="jdbc/MyDataSource"
        cache="true"
        resource-ref="true"
        lookup-on-startup="false"
        expected-type="com.myapp.DefaultFoo"
        proxy-interface="com.myapp.Foo"/>

< hh:// +168+ 3 >(简单)

<jee:local-slsb/>标记配置 EJB Stateless SessionBean 的 reference。

之前…

<bean id="simple"
        class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">
    <property name="jndiName" value="ejb/RentalServiceBean"/>
    <property name="businessInterface" value="com.foo.service.RentalService"/>
</bean>

后…

<jee:local-slsb id="simpleSlsb" jndi-name="ejb/RentalServiceBean"
        business-interface="com.foo.service.RentalService"/>

< hh:// +174+ 3 >(复杂)

<bean id="complexLocalEjb"
        class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">
    <property name="jndiName" value="ejb/RentalServiceBean"/>
    <property name="businessInterface" value="com.foo.service.RentalService"/>
    <property name="cacheHome" value="true"/>
    <property name="lookupHomeOnStartup" value="true"/>
    <property name="resourceRef" value="true"/>
</bean>

后…

<jee:local-slsb id="complexLocalEjb"
        jndi-name="ejb/RentalServiceBean"
        business-interface="com.foo.service.RentalService"
        cache-home="true"
        lookup-home-on-startup="true"
        resource-ref="true">

< hh:// +179+ 3 >

<jee:remote-slsb/>标记配置__ EJB Stateless SessionBean 的 reference。

之前…

<bean id="complexRemoteEjb"
        class="org.springframework.ejb.access.SimpleRemoteStatelessSessionProxyFactoryBean">
    <property name="jndiName" value="ejb/MyRemoteBean"/>
    <property name="businessInterface" value="com.foo.service.RentalService"/>
    <property name="cacheHome" value="true"/>
    <property name="lookupHomeOnStartup" value="true"/>
    <property name="resourceRef" value="true"/>
    <property name="homeInterface" value="com.foo.service.RentalService"/>
    <property name="refreshHomeOnConnectFailure" value="true"/>
</bean>

后…

<jee:remote-slsb id="complexRemoteEjb"
        jndi-name="ejb/MyRemoteBean"
        business-interface="com.foo.service.RentalService"
        cache-home="true"
        lookup-home-on-startup="true"
        resource-ref="true"
        home-interface="com.foo.service.RentalService"
        refresh-home-on-connect-failure="true">

41.2.4 lang schema

lang标签处理将以动态语言(如 JRuby 或 Groovy)编写的 objects 暴露为 Spring 容器中的 beans。

这些标签(和动态语言支持)在题为第 35 章,动态语言支持的章节中全面介绍。有关此支持和lang标签本身的详细信息,请参阅该章节。

为了完整性,要使用lang schema 中的标记,您需要在 Spring XML configuration 文件的顶部有以下前导码;以下代码段中的文本引用了正确的 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 http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd"> <!-- bean definitions here -->

</beans>

41.2.5 jms schema

jms标签用于配置 JMS-related beans,例如 Spring 的MessageListenerContainers。这些标签在JMS 章节标题为Section 30.7,“JMS 命名空间支持”的部分详细说明。有关此支持和jms标签本身的详细信息,请参阅该章节。

为了完整性,要使用jms schema 中的标记,您需要在 Spring XML configuration 文件的顶部有以下前导码;以下代码段中的文本引用了正确的 schema,以便jms命名空间中的标记可供您使用。

<?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:jms="http://www.springframework.org/schema/jms" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms.xsd"> <!-- bean definitions here -->

</beans>

41.2.6 tx(transaction)schema

tx标签处理 Spring 对 transactions 的全面支持中所有 beans 的配置。这些标签在标题为第 17 章,交易管理的章节中介绍。

强烈建议您查看 Spring 发行版附带的'spring-tx.xsd'文件。这个文件(当然)是 Spring 的 transaction configuration 的 XML Schema,它涵盖了tx命名空间中的所有各种标签,包括属性默认值等。该文件以内联方式记录,因此为了遵守 DRY(不要重复自己)原则,此处不再重复这些信息。

为了完整性,要使用tx schema 中的标记,您需要在 Spring XML configuration 文件的顶部有以下前导码;以下代码段中的文本引用了正确的 schema,以便tx命名空间中的标记可供您使用。

<?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:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->

</beans>

通常在tx命名空间中使用标记时,您也将使用aop命名空间中的标记(因为 Spring 中的声明性 transaction 支持是使用 AOP 实现的)。上面的 XML 片段包含_rechema 所需的相关 lines,以便aop命名空间中的标记可供您使用。

41.2.7 aop schema

aop标签用于配置 Spring 中的所有 AOP:这包括 Spring 自己的 proxy-based AOP framework 和 Spring 的 integration 与 AspectJ AOP framework。这些标签在题为第 11 章,使用 Spring 进行面向对象编程的章节中全面介绍。

为了完整性,要使用aop schema 中的标记,您需要在 Spring XML configuration 文件的顶部有以下前导码;以下代码段中的文本引用了正确的 schema,以便aop命名空间中的标记可供您使用。

<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->

</beans>

41.2.8 context schema

context标签处理与管道相关的ApplicationContext configuration - 也就是说,通常不是 beans 对 end-user 很重要,而是 beans 在 Spring 中做很多笨拙的工作,比如BeanfactoryPostProcessors。以下代码段 references 正确的 schema,以便context命名空间中的标记可供您使用。

<?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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here -->

</beans>

context schema 仅在 Spring 2.5 中引入。

<property-placeholder/>

此元素激活${…}占位符的替换,并根据指定的 properties 文件(作为Spring 资源位置)进行解析。这个元素是一个方便的机制,为你设置一个PropertyPlaceholderConfigurer;如果您需要更多地控制PropertyPlaceholderConfigurer,只需明确定义一个。

<annotation-config/>

激活 Spring 基础结构,以便在 bean classes 中检测各种注释:Spring 的@Required和@Autowired,以及 JSR 250 的@PostConstruct@PreDestroy@Resource(如果可用),以及 JPA 的@PersistenceContext@PersistenceUnit(如果可用)。或者,您可以选择为这些注释明确激活单个BeanPostProcessors

此元素不会激活 Spring 的@Transactional annotation 的处理。为此目的使用< 1 >元素。

<component-scan/>

这个元素在第 7.9 节,“Annotation-based 容器配置”中有详细说明。

<load-time-weaver/>

这个元素在第 11.8.4 节,“在 Spring Framework 中使用 AspectJ 编织 Load-time”中有详细说明。

<spring-configured/>

这个元素在第 11.8.1 节,“使用 AspectJ 依赖 inject 域 objects 与 Spring”中有详细说明。

<mbean-export/>

这个元素在Section 31.4.3,“配置基于 MBean export 的 annotation”中有详细说明。

41.2.9 工具 schema

当您要将 tooling-specific 元数据添加到自定义 configuration 元素时,可以使用tool标记。然后,知道此元数据的工具可以使用此元数据,然后工具可以随意执行任何操作(验证,etc.)。

_x标签未在此版本的 Spring 中记录,因为它们目前正在审核中。如果您是第三方工具供应商,并且您想参与此审核 process,请邮寄 Spring 邮件列表。当前支持的tool标记可以在 Spring 源代码分发的'src/org/springframework/beans/factory/xml'目录中的'spring-tool.xsd'文件中找到。

41.2.10 jdbc schema

jdbc标签允许您快速配置嵌入式数据库或初始化现有数据源。这些标记分别记录在第 19.8 节,“嵌入式数据库支持”和???中。

要使用jdbc schema 中的标记,您需要在 Spring XML configuration 文件的顶部添加以下前导码;以下代码段中的文本引用了正确的 schema,以便jdbc命名空间中的标记可供您使用。

<?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:jdbc="http://www.springframework.org/schema/jdbc" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd"> <!-- bean definitions here -->

</beans>

41.2.11 缓存 schema

cache标签可用于启用对 Spring 的@CacheEvict@CachePut@Caching 注释的支持。它还支持声明性 XML-based 缓存。有关详细信息,请参阅第 36.3.6 节,“启用缓存注释”和第 36.5 节,“声明式 XML-based 缓存”。

要使用cache schema 中的标记,您需要在 Spring XML configuration 文件的顶部添加以下前导码;以下代码段中的文本引用了正确的 schema,以便cache命名空间中的标记可供您使用。

<?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:cache="http://www.springframework.org/schema/cache" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd"> <!-- bean definitions here -->

</beans>

41.2.12 beans schema

最后但并非最不重要的是,我们在beans schema 中有标签。这些是自 framework 黎明以来 Spring 中的标签。这里没有显示beans schema 中各种标签的示例,因为它们在第 7.4.2 节,“依赖关系和配置详细”(实际上是整个章节)中得到了非常全面的介绍。

Spring 2.0 中 beans 标签本身的新内容是任意 bean 元数据的 idea。在 Spring 2.0 中,现在可以向<bean/> XML 定义添加零个或多个 key/value 对。如果有的话,使用这些额外的元数据完成的工作完全取决于您自己的自定义逻辑(因此,如果您正在编写自己的自定义标记,通常只能使用,如附录中标题为第 42 章,可扩展的 XML 创作所述)。

在下面的<bean/>的 context 中找到<meta/>标签的 example(请注意,没有任何逻辑来解释它,元数据实际上是无用的 as-is)。

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

    <bean id="foo" class="x.y.Foo">
        <meta key="cacheName" value="foo"/>
        <property name="name" value="Rick"/>
    </bean>

</beans>

在上述示例的情况下,您将假设有一些逻辑将使用 bean 定义并使用提供的元数据设置一些缓存基础结构。