spring xml配置解析context spring中xml配置文件

Spring中XML配置文件的十二个最佳方法

本文介绍Spring中XML配置文件的十二个最佳方法，包括使用简洁形式，使用命名约定，为每个配置文件添加首部注释，Setter注入优于构造函数注入等。

 

1。避免使用自动绑定（autowiring）功能
Spring 可以通过bean类的自省自动绑定依赖性，所以不必显式指明bean的属性和构造函数。Bean属性可以通过属性名称或类型匹配来实现自动绑定。构造函数通过类型匹配来实现自动绑定。甚至可以指定自动检测autowiring模式，它可以引导Spring选择一种适当的运行机制。先来看看下面的一个例子：

1.     <bean id="orderService"  
2.             class="com.lizjason.spring.OrderService"  
3.             autowire="byName"/>

OrderService 类的属性名在容器中用于匹配bean实例。自动绑定可能会节省一些键入工作量并减少混乱。但是在现实项目中不应该使用这种方式，因为它牺牲了配置的可读性和可维护性。许多指南和介绍中大肆吹捧自动绑定是Spring的一项极好的特性，而没有提到这一特性所带来的牺牲。依我来看，这就像Spring中的对象池（object－pooling），更大程度上只是宣传的噱头。对于精简XML配置文件来说，它是一个好办法，但它实际上增加了复杂性，尤其是在运行包含大量类声明的项目时。虽然Spring允许混合使用自动绑定和显式绑定，但这会使XML配置更加晦涩难懂。

2.使用命名约定
该原则对于Java编码也一样适用。在项目中使用清晰的、描述性的、一致的命名约定将非常有利于开发人员理解XML配置。例如，对于bean ID，可以按照Java类字段名约定来命名它。OrderServiceDAO实例的bean ID应该命名为orderServiceDAO。对于大型项目，可以在bean ID前面加上包名作为前缀。

3. 使用简洁形式
简洁形式避免了冗长，因为它将属性值和引用从子元素中移入属性中。例如下面的例子：

1.     <bean id="orderService"  
2.             class="com.lizjason.spring.OrderService">  
3.             <property name="companyName">  
4.                 <value>lizjason</< SPAN>value>  
5.             </<SPAN>property>  
6.             <constructor-arg>  
7.                 <ref bean="orderDAO">  
8.             </<SPAN>constructor-arg>  
9.         </<SPAN>bean>

可以使用简洁形式将上述代码重写为：

1.     <bean id="orderService"  
2.             class="com.lizjason.spring.OrderService">  
3.      
4.             <property name="companyName"  
5.                 value="lizjason"/>  
6.             <constructor-arg ref="orderDAO"/>  
7.         </<SPAN>bean>

简洁形式自1.2版本起就可以使用。注意，对于，没有简洁形式。
简洁形式不但可以节约键入工作量，而且可以使XML配置文件更清晰。当一个配置文件中定义了大量的类时，它可以显著提高可读性。

4. 对于构造函数参数匹配，类型比下标好
当构造函数含有一个以上同种类型的参数，或者属性值的标签已经被占用时，Spring允许使用从0开始的下标来避免混淆。例如：

1.           <bean id="billingService" 
2.                   class="com.lizjason.spring.BillingService"> 
3.                   <constructor-arg index="0" value="lizjason"/> 
4.                   <constructor-arg index="1" value="100"/> 
5.               </< SPAN>bean>

利用type属性来编写会更好一些，如下：

1.           <bean id="billingService" 
2.                   class="com.lizjason.spring.BillingService"> 
3.                   <constructor-arg type="java.lang.String" 
4.                       value="lizjason"/> 
5.            
6.                   <constructor-arg type="int" value="100"/> 
7.               </< SPAN>bean>

使用index可以减少一些代码，但是与type属性相比，它更易于出错且难于阅读。只有在构造函数参数不明确的时候，才应该使用index。

5. 尽可能重用已定义的bean
Spring 提供了一种类似于继承的机制来减少配置信息的复制并简化XML配置。定义一个子类，它就可以从父类那里继承配置信息，而父类实际上成为子类的一个模板。这就是大型项目中所谓的重用。只需在父类bean中设置abstract=true，然后在子bean中指定parent引用。例如：

1.     <bean id="abstractService" abstract="true"  
2.             class="com.lizjason.spring.AbstractService">  
3.             <property name="companyName"  
4.                 value="lizjason"/>  
5.         </<SPAN>bean>  
6.      
7.         <bean id="shippingService"  
8.             parent="abstractService"  
9.             class="com.lizjason.spring.ShippingService">  
10.          <property name="shippedBy" value="lizjason"/>  
11.      </<SPAN>bean>

ShippingService类从abstractService类继承companyName属性的值——lizjason。如果一个bean没有指定类或工厂方法，那么这个bean便是抽象的。

6. 在导入时，首选通过ApplicationContext来汇编bean定义
像Ant脚本中的导入一样，Spring的import元素对于汇编模块化的bean定义来说是很有用的。例如：

1.     <beans>  
2.             <import resource="billingServices.xml"/>  
3.             <import resource="shippingServices.xml"/>  
4.             <bean id="orderService"  
5.                 class="com.lizjason.spring.OrderService"/>  
6.         <beans>

然而，相对于使用import在XML配置中进行预汇编，通过ApplicationContext来配置这些bean则显得更加灵活。使用 ApplicationContext的话，XML配置也更易于管理。可以向ApplictionContext构造函数传递一组bean定义，如下：

1.     String[] serviceResources =   
2.             {"orderServices.xml",  
3.             "billingServices.xml",  
4.             "shippingServices.xml"};  
5.         ApplicationContext orderServiceContext = new  
6.             ClassPathXmlApplicationContext(serviceResources);

7. 使用id作为bean标识符
可以指定一个id或名称来作为bean标识符。虽然使用id不能提高可读性，但是它可以利用XML分析程序来对bean引用进行验证。如果由于XML IDREF的约束而不能使用某个id，那么可以使用名称来作为bean的标识符。XML IDREF的约束是：id必须以字母（或者XML规范中定义的标点符号）开头，后面是字母、数字、连字符、下划线、冒号或句点。实际上，很少会遇到XML IDREF约束问题。

8. 在开发阶段使用依赖性检查（dependency-check）
可以在bean定义中为dependency-check属性设置一个非默认值，比如simple、objects或all，以便容器进行依赖性检查。当需要显式或通过自动绑定设置bean的全部属性（或某类属性）时，依赖性检查便显得很有用。

1.     <bean id="orderService"  
2.             class="com.lizjason.spring.OrderService"  
3.             dependency-check="objects">  
4.             <property name="companyName"  
5.                 value="lizjason"/>  
6.             <constructor-arg ref="orderDAO"/>  
7.         </bean>

在这个例子中，容器确保为orderService bean设置的属性不是primitives或collections。也可以为所有的bean设置默认依赖性检查，但是我们很少这样做，因为有些bean属性根本就不必设置。

9. 为每个配置文件添加首部注释
最好使用描述性的id和名称来取代XML配置文件中的内置注释。此外，添加一个配置文件首部也很有用，它可以概述文件中所定义的bean。可以选择将描述添加到description标签中。例如：

1.     <beans>  
2.             <description>  
3.                 This file defines billing service  
4.                 related beans and it depends on  
5.                 baseServices.xml,which provides  
6.                 service bean templates...  
7.             </description>  
8.             ...  
9.         </beans>

使用description标签的一个好处是可以轻松地利用工具从标签中选获取描述内容。

10. 对于更改，团队成员要积极交流
在重构Java代码时，需要随时更新配置文件并通知团队成员。XML配置文件也是代码，它们是应用程序的至关重要的部分，但是它们难于阅读和维护。大部分情况下，需要同时阅读XML配置文件和运行中的Java代码。

11. Setter注入优于构造函数注入
Spring提供了3种类型的依赖注入：构造函数注入（constructorinjection）、setter注入（setterinjection）和方法注入（method injection）。我们一般只用前两种。

1.     <bean id="orderService"  
2.             class="com.lizjason.spring.OrderService">  
3.             <constructor-arg ref="orderDAO"/>  
4.         </bean>  
5.      
6.         <bean id="billingService"  
7.             class="com.lizjason.spring.BillingService">  
8.             <property name="billingDAO"  
9.                 ref="billingDAO">  
10.      </bean>

在这个例子中，orderService类使用的是构造函数注入，而BillingService类使用的是setter注入。构造函数注入可以确保 bean不会在一个非法状态下被创建，但是setter注入更加灵活且更易于管理，尤其是在类包含许多属性并且其中一些可选的情况下。

12. 不要滥用依赖注入
最 后一点，Spring ApplicationContext可以为您创建Java对象，但并不是所有的Java对象都应通过依赖注入来创建。例如，全局对象不应该通过 ApplicationContext来创建。Spring是一个很棒的框架，但是，就可读性和易管理性而言，如果定义了大量bean，基于XML的配置就可能成为问题。过度使用依赖注入会使XML配置变得复杂且臃肿。要知道，借助于功能强大的IDE（如Eclipse和IntelliJ），Java代码比XML文件更加易读、易维护、易管理。

结束语
XML是通用的Spring配置方式。但如果定义了大量bean，基于XML的配置就会变得冗长而不实用。Spring提供了丰富的配置选项，恰当地利用其中的选项可以使XML配置更清晰，但是，有些选项（如autowiring）往往会降低配置文件的可读性和可维护性。遵循本文中所描述的最佳实践，将有助于您创建出清晰易读的XML配置文件。