41. 基于XML模式的配置

41.1 简介

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


DTD support?

仍然完全支持使用旧的DTD样式编写Spring配置文件。

如果放弃使用基于XML Schema的新方法来编写Spring XML配置文件,那么什么都不会破坏。您失去的一切就是有机会获得更简洁,更清晰的配置。无论XML配置是基于DTD还是基于模式,最终都归结为容器中的相同对象模型(即一个或多个 BeanDefinition 实例)。


迁移到基于XML Schema的配置文件的主要动机是使Spring XML配置更容易。基于'经典' <bean/> 的方法很好,但其通用性质在配置开销方面具有代价。

从Spring IoC容器的角度来看,一切都是bean。这对于Spring IoC容器来说是个好消息,因为如果一切都是bean,那么一切都可以用完全相同的方式处理。然而,从开发人员的角度来看,情况并非同样如此。 Spring XML配置文件中定义的对象并非都是通用的vanilla bean。通常,每个bean都需要一定程度的特定配置。

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

要记住的关键是新的自定义标签最适合基础架构或集成bean:例如,AOP,集合,事务,与第三方框架(如Mule等)的集成,而现有的bean标签最适合于特定于应用程序的bean,例如DAO,服务层对象,验证器等。

下面的示例有望说服您在Spring 2.0中包含XML Schema支持是一个好主意。社区的接待令人鼓舞;此外,请注意这个新配置机制完全可定制和可扩展的事实。这意味着您可以编写自己的特定于域的配置标记,以更好地代表您的应用程序的域;这样做涉及的程序见题为 Chapter 42, Extensible XML authoring 的附录。

41.2 基于XML模式的配置

41.2.1 引用模式

要从DTD样式切换到新的XML Schema样式,您需要进行以下更改。

<?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风格的等效文件会是…

<?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'片段实际上不是必需的,但可以包含它来引用模式的本地副本(在开发期间可能很有用)。

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

本章的其余部分将专门介绍基于Spring XML Schema的新配置示例,每个新标记至少有一个示例。格式遵循前后样式,前面的XML片段显示旧的(但仍然是100%合法和支持)样式,紧接着是一个后续示例,显示了基于新XML Schema的样式中的等效样式。

41.2.2 util模式

首先是 util 标签的覆盖范围。顾名思义, util 标签处理常见的实用程序配置问题,例如配置集合,引用常量等。

要使用 util 模式中的标记,您需要在Spring XML配置文件的顶部包含以下前导码;下面的代码段中的文本引用了正确的架构,以便 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>

<util:constant />

之前…

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

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

以下基于XML Schema的版本更简洁,并清楚地表达了开发人员的意图('注入此常量值'),它只是读得更好。

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

FieldRetrievingFactoryBeanFactoryBean ,它检索 static 或非静态字段值。它通常用于检索 public static final 常量,然后可以使用这些常量为另一个bean设置属性值或构造函数arg。

通过使用 staticField 属性,在下面找到一个显示 static 字段如何公开的示例:

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

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

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

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

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

也可以访问另一个bean的非静态(实例)字段,如 FieldRetrievingFactoryBean 类的API文档中所述。

在Spring中将枚举值作为属性或构造函数参数注入到bean中非常容易,因为您实际上不需要做任何事情或了解Spring内部(甚至是诸如 FieldRetrievingFactoryBean 之类的类)。让我们看一个例子,看看注入枚举值是多么容易;考虑这个JDK 5枚举:

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>

这适用于经典的类型安全模拟枚举(在JDK 1.4和JDK 1.3上); Spring将自动尝试将字符串属性值与枚举类中的常量匹配。

<util:property-path />

之前…

<!-- 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"/>

上面的配置使用Spring FactoryBean 实现 PropertyPathFactoryBean 来创建一个名为 testBean.age 的bean(类型为 int ),其值等于 testBean bean的 age 属性。

后…

<!-- 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 属性的值遵循 beanName.beanProperty 格式。

使用<util:property-path />设置bean属性或构造函数参数

PropertyPathFactoryBeanFactoryBean ,它评估给定目标对象上的属性路径。可以直接指定目标对象,也可以通过bean名称指定目标对象。然后,该值可以在另一个bean定义中用作属性值或构造函数参数。

这是一个通过名称对另一个bean使用路径的示例:

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

在此示例中,针对内部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名称是属性路径。

<!-- 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的名称没有选择。对它的任何引用也必须使用相同的id,即路径。当然,如果用作内部bean,则根本不需要引用它:

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

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

<util:properties />

之前…

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

上面的配置使用Spring FactoryBean 实现 PropertiesFactoryBean 来实例化一个 java.util.Properties 实例,其值从提供的 Resource 位置加载。

后…

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

<util:list />

之前…

<!-- 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>[email protected]</value>
            <value>[email protected]</value>
            <value>[email protected]</value>
            <value>[email protected]</value>
        </list>
    </property>
</bean>

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

后…

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

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

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

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

<util:map />

之前…

<!-- 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="[email protected]"/>
            <entry key="raskolnikov" value="[email protected]"/>
            <entry key="stavrogin" value="[email protected]"/>
            <entry key="porfiry" value="[email protected]"/>
        </map>
    </property>
</bean>

上面的配置使用Spring FactoryBean 实现 MapFactoryBean 来创建一个 java.util.Map 实例,该实例使用从提供的 'sourceMap' 获取的键值对进行初始化。

后…

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

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

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

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

<util:set />

之前…

<!-- 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>[email protected]</value>
            <value>[email protected]</value>
            <value>[email protected]</value>
            <value>[email protected]</value>
        </set>
    </property>
</bean>

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

后…

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

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

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

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

41.2.3 jee架构

jee 标记处理与Java EE(Java Enterprise Edition)相关的配置问题,例如查找JNDI对象和定义EJB引用。

要使用 jee 模式中的标记,您需要在Spring XML配置文件的顶部包含以下前导码;以下代码段中的文本引用了正确的架构,以便 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>

<jee:jndi-lookup />(简单)

之前…

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

<jee:jndi-lookup />(具有单个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>

<jee:jndi-lookup />(具有多个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>

<jee:jndi-lookup />(复杂)

之前…

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

<jee:local-slsb />(简单)

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

之前…

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

<jee:local-slsb />(复杂)

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

<jee:remote-slsb />

<jee:remote-slsb/> 标记配置对 remote EJB Stateless SessionBean的引用。

之前…

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

lang 标签处理暴露用动态语言(如JRuby或Groovy)编写的对象作为Spring容器中的bean。

这些标签(以及动态语言支持)在题为 Chapter 35, Dynamic language support 的章节中全面介绍。有关此支持和 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 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架构

jms 标签用于配置与JMS相关的bean,例如Spring的 MessageListenerContainers 。这些标签详见 JMS chapter Headers 为 Section 30.7, “JMS namespace support” 的部分。有关此支持和 jms 标签本身的详细信息,请参阅该章节。

为了完整性,要使用 jms 模式中的标记,您需要在Spring XML配置文件的顶部有以下前导码;以下代码段中的文本引用了正确的架构,以便 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(事务)架构

tx 标签涉及在Spring对事务的全面支持中配置所有这些bean。这些标签在题为 Chapter 17, Transaction Management 的章节中有所介绍。

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

为了完整性,要使用 tx 模式中的标记,您需要在Spring XML配置文件的顶部包含以下前导码;以下代码段中的文本引用了正确的架构,以便 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中的声明性事务支持是使用AOP实现的)。上面的XML代码段包含引用aop架构所需的相关行,以便您可以使用aop命名空间中的标记。

41.2.7 aop架构

aop 标签用于配置Spring中的所有AOP:这包括Spring自己的基于代理的AOP框架和Spring与AspectJ AOP框架的集成。这些标签在题为 Chapter 11, Aspect Oriented Programming with Spring 的章节中全面介绍。

为了完整性,要使用 aop 模式中的标记,您需要在Spring XML配置文件的顶部有以下前导码;以下代码段中的文本引用了正确的架构,以便 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 标签处理与管道相关的 ApplicationContext 配置 - 也就是说,通常不是对最终用户很重要的bean,而是在Spring中执行大量繁琐工作的bean,例如 BeanfactoryPostProcessors 。以下代码段引用了正确的架构,以便 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>

上下文模式仅在Spring 2.5中引入。

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

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

此元素不会激活Spring的@Transactional注释的处理。为此目的使用<tx:annotation-driven />元素。

该元素在 Section 7.9, “Annotation-based container configuration” 中有详细说明。

该元素在 Section 11.8.4, “Load-time weaving with AspectJ in the Spring Framework” 中有详细说明。

该元素在 Section 11.8.1, “Using AspectJ to dependency inject domain objects with Spring” 中有详细说明。

该元素在 Section 31.4.3, “Configuring annotation based MBean export” 中有详细说明。

41.2.9 工具架构

当您要将特定于工具的元数据添加到自定义配置元素时,可以使用 tool 标记。然后,可以通过知道此元数据的工具使用此元数据,然后工具可以随意执行任何操作(验证等)。

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

41.2.10 jdbc架构

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

要使用 jdbc 模式中的标记,您需要在Spring XML配置文件的顶部包含以下前导码;以下代码段中的文本引用了正确的架构,以便 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 缓存架构

cache 标签可用于启用对Spring的 @CacheEvict@CachePut@Caching 注释的支持。它还支持基于声明的基于XML的缓存。有关详细信息,请参见 Section 36.3.6, “Enable caching annotations”Section 36.5, “Declarative XML-based caching”

要使用 cache 模式中的标记,您需要在Spring XML配置文件的顶部包含以下前导码;以下代码段中的文本引用了正确的架构,以便 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 模式

最后但并非最不重要的是,我们在 beans 架构中有标签。这些是自框架诞生以来Spring中的标签。示例 beans 架构中的各种标签未在此处显示,因为它们在 Section 7.4.2, “Dependencies and configuration in detail” (实际上在整个 chapter 中)得到了全面的介绍。

Spring 2.0中bean标记本身的一个新特点是任意bean元数据的概念。在Spring 2.0中,现在可以向 <bean/> XML定义添加零个或多个键/值对。如果有的话,使用这些额外的元数据完全取决于您自己的自定义逻辑(因此,如果您正在编写自己的自定义标记,通常只能使用,如附录 Headers 为 Chapter 42, Extensible XML authoring 中所述)。

在下面的 <bean/> 的上下文中查找 <meta/> 标记的示例(请注意,没有任何逻辑来解释它,元数据实际上是无用的)。

<?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定义并使用提供的元数据设置一些缓存基础结构。

Updated at: 5 months ago
40.11. 更多资源Table of content42. 可扩展的XML创作
Comment
You are not logged in.

There are no comments.