为了测试Spring管理下的Bean，可以自行构造BeanFactory，也可以继承于AbstractDependencyInjectionSpringContextTests，实现public String[] getConfigLocations()函数， 返回applicationContext文件路径的数组。

 protectedString[] getConfigLocations() {
        returnnewString[]{"classpath*:spring/*.xml",  "classpath*:spring/test/*.xml"};
 } 

  并显式写一些需要注入的变量的setter函数。

    tips1：此基类有一个applicationContext的成员变量，所以除了依靠setter注入外，还可以随时用applicationContext.getBean() 取出所需的bean。 

    tips2：注意此基类 默认是autowire by type的，所以如果context文件里有两个相同类型的Bean就会报错，可能需要在getConfigLocations()函数里，setAutowireMode(AUTOWIRE_BY_NAME);把它设回by name，或者取消setter函数，自行用applicationContext.getBean()来显式查找Bean。

2. Dao测试

AbstractTransactionalDataSourceSpringContextTests 继承于AbstractDependencyInjectionSpringContextTests，除了拥有上类的能力外，还管理了每个测试的事务，会在每个测试后默认回滚所有的操作。

深层解释：此类的实现其实依赖于Application Context中定义的 PlatformTransactionManager。由于使用了Autowrie by type，可以任意取名。

         另依赖于Application Context中定义的DataSource，同样可以任意取名。 

tips1：如果需要在测试后提交，需要setRollBack(false); 或者调用setComplete()

tips2：此基类还通过注入的DataSource创建了一个JDBCTemplate 变量，可以跑SQL帮忙核对Hibernate的结果，Spring将确保该查询在同一个事务内执行。为正常工作你需要告诉你的ORM工具'刷新'它的已改变内容，例如使用Hibernate Session 接口的 flush() 方法。

tips3：除了tips2以外，还有countRowsInTable(String tableName)，deleteFromTables(String[] names) ，executeSqlScript(String sqlResourcePath, boolean continueOnError)三个简便函数。

3. Controller测试

Controller测试一般要用MockObject 分离Service层，要copy WEB-INF/下的相关文件copy 到classpath，而且Controller不含太多的逻辑，所有测试controller有点吃力不讨好，建议直接用Selenium进行集成测试，见(Selenium测试概述)。

4.SpringSide里的测试

因为Spring默认的基类名字较长，SpringSide 在core 的org.springside.core.test 中重新继承了它们，并提供了默认读取所有按springside 文件存放规则存放的context 文件的getConfigLocations()函数。

默认读取所有context文件的getConfigLocations()函数对速度和测试的隔离化都有影响，可以在子类重新实现。不过自己重新一个个写相关context文件也好烦，而且其实在全lazy-load的情况下，速度也还可以接受。如何取舍要自己平衡了。

对于CRUD的测试，在helloworld示例里的变量名都作了泛化，可以快速copy到另一个测试里。

另外，留意resources/spring/test 下的文件，利用了Spring的PropertyOverrideConfigurer，新设定测试时的ApplicatonContext 里各个Bean的属性如指定测试用的DataSource，详细用法见Spring配置要点。

在划分事务时，我们需要进行事务定义，也就是配置事务的属性。事务的属性有传播行业，隔离级别，超时值及只读标志。TransactionAttribute接口指定哪些异常将导致一个回滚，哪些应该一次性提交。

(1) 使用ProxyFactoryBean 和TransactionInterceptor

<!--定义本地数据源-->

<bean id="dataSource" name="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

<!-- !定义单个jdbc数据源的事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

<!-定义拦截器-->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
</props>
</property>
</bean>

<!-定义业务对象-->
<bean id="com.prs.application.ehld.sample.biz.service.sampleService.target"
class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO"
ref="com.prs.application.ehld.sample.integration.dao.userInfoDAO">
</property>
</bean>

<!-定义业务对象的事务代理对象-->
<bean id="com.prs.application.ehld.sample.biz.service.sampleService" class="org.springframeword.aop.framework.ProxyFacgtoryBean">
<property name="target"
ref="com.prs.application.ehld.sample.biz.service.sampleService.target">
</property>
<property name="interceptorNames">
<value>transactionInterceptor</value>
</property>
</bean>

通过ProxyFacgtoryBean和TransactionInterceptor组合使用，可以对事务进行更多的控制。所有需要事务控制的对象可以共享一个transactionInterceptor的事务属性。

(2) 使用TransactionProxyFactoryBean

<!-定义业务对象-->
<bean id="com.prs.application.ehld.sample.biz.service.sampleService.target"
class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO"
ref="com.prs.application.ehld.sample.integration.dao.userInfoDAO">
</property>
</bean>

<!-定义业务对象的事务代理对象-->
<bean id="com.prs.application.ehld.sample.biz.service.sampleService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
abstract="true">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="target"
ref="com.prs.application.ehld.sample.biz.service.sampleService.target" />
<property name="transactionAttributes">
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
</props>
</property>
</bean>

使用TransactionProxyFactoryBean需要为每一个代理对象都去定义自己的事务属性。

(3) 使用TransactionProxyFactoryBean及abstract属性来简化配置
这种方工也是目前使用得最多的一种声明式事务配置方法

<!--事务控制代理抽象定义 -->
<bean id="baseTransactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
abstract="true">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
</props>
</property>
</bean>

<!-定义业务对象-->
<bean id="com.prs.application.ehld.sample.biz.service.sampleService.target"
class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO"
ref="com.prs.application.ehld.sample.integration.dao.userInfoDAO">
</property>
</bean>

<!-定义业务对象的事务代理对象-->
<bean id="com.prs.application.ehld.sample.biz.service.sampleService" parent="baseTransactionProxy">
<property name="target"
ref="com.prs.application.ehld.sample.biz.service.sampleService.target">
</property>
</bean>

使用abstract属性，可以让代理对象可以共享一个定义好的事务属性，使配置简化。

(4)使用BeanNameAutoProxyCreator
<!-定义拦截器-->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
</props>
</property>
</bean>

<!-定义bean别名自动代理创建器-->
<bean id="autoProxyCreator"
class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="interceptorNames">
<value>transactionInterceptor</value>
</property>
<property name="beanNames">
<list>
<idref local="com.prs.application.ehld.sample.biz.service.sampleService"/>
</list>
</property>
</bean>

<!-定义业务对象-->
<bean id="com.prs.application.ehld.sample.biz.service.sampleService"
class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO"
ref="com.prs.application.ehld.sample.integration.dao.userInfoDAO">
</property>
</bean>

使用BeanNameAutoProxyCreator可以由框架来提供适当的代理，由一个transactionInterceptor统一定义事务属性，只需要把需要事务控制的bean加到beannames的列表。
对于需要大量声明式事务的bean，BeanNameAutoProxyCreator是十分方便的。减少了代理bean的定义，还可以灵活的决定一个bean是否进行事务控制。

上面四种方法是在Spring中常见的声明式事务配置方法，其中使用TransactionProxyFactoryBean及abstract属性进行配置是最常见的简化方法。
我们暂且把需要进行事务控制的bean叫事务bean.把依赖和调用它的bean叫做业务bean。对事务bean进行代理叫做事务代理bean.

1． 使用ProxyFactoryBean 和TransactionInterceptor，可以由一个TransactionInterceptor统一定义事务属性，对于每一个事务bean都需要再定义一个事务代理bean。如果有n个事务bean，那么就需要定义和维护2n个bean。并且注入到业务bean的不是事务bean本身，而是要求用事务代理bean注入。这增加了理解的难度。
2．使用TransactionProxyFactoryBean需要为每一个事务代理bean都定义自己的事务属性，除了需要维护2n个bean外，还需要为每一个事务代理bean定义事务属性。可以说是最麻烦的。同样需要把事务代理bean注入到业务bean，增加了理解的难度和项目的复杂度。
3．使用TransactionProxyFactoryBean及abstract属性是对使用TransactionProxyFactoryBean的一种简单化配置，可以让所有的事务bean共享一致的事务属性定义。需要维护2n个bean，需要把事务代理bean注入到业务bean。
4． 使用BeanNameAutoProxyCreator最适合在框架中使用，只需要维护n个bean。也无需要事务代理bean。直接把事务bean注入业务bean中。但是它必须把需要事务控制的bean加到beanNames列表中。

2．类型自动代理创建器BeanClassTypeAutoProxyCreator
得于BeanNameAutoProxyCreator的启示，BeanNameAutoProxyCreator可以实现框架来实现自动代理。它只是把需要代理的bean加入beanNames属性列表。大大的简化了代理的配置，减少了代理bean的定义，使用事务bean注入业务对象，而不是代理 bean注入，更合乎事务逻辑。BeanNameAutoProxyCreator仍然需要开发人员除了定义业务bean外，还需要关心事务的定义，当然已经简单了很多。如果能实现一个BeanClassTypeAutoProxyCreator，为它指定一个可以代理的ClassType列表，那么在 context中所有属于ClassType和其子类的bean都自动获得代理。
实现思路：
1．BeanNameAutoProxyCreator继承了AbstractAutoProxyCreator，去实现方法：
protected abstract Object[] getAdvicesAndAdvisorsForBean(
Class beanClass, String beanName, TargetSource customTargetSource)
在BeanNameAutoProxyCreator中的实现是判断beanName 是存在于beanNames列表，如果能找到则Object[]不对空。否则返回null。
所以BeanClassTypeAutoProxyCreator也应该继承AbstractAutoProxyCreator。
getAdvicesAndAdvisorsForBean方法的实现可以参照BeanNameAutoProxyCreator方法的实现
2．BeanClassTypeAutoProxyCreator需要有一个进行代理的ClassType列表，在bean进行初始化后就在context中查找类型为ClassType列表中类型的所有beanName.从而获得一个beanNames列表。
获得beanNames列表后就可以像BeanNameAutoProxyCreator一样实现自动代理了。
3．要想获得当前context，我们可以实现ApplicationContextAware接口。让BeanClassTypeAutoProxyCreator的bean可以获得当前context.
4． 要在bean进行初始化动作，可以实现InitializingBean接口，实现afterPropertiesSet,在这个方法中在context中根据classType查找获得相关的beanName的列表。
5． 写一个空接口，里面没有任何方法。需要事务代理的类实现这个空接口。

这样，只需要把这个空接口的全类名作为BeanClassTypeAutoProxyCreator的classTypes参数值，然后所有需要代理的类都去实现这个接口就可以自动获得代理了。无再需要任何配置。这样就可以让程序员专心于业务逻辑的开发，而无需要去关心事务控制方法，就像是没有使用事务一样。

完整的实现类如下：
BeanClassTypeAutoProxyCreator.java
/**
* 根据类型自动代理Creator
*
* @author yuanguangdong date: Jul 13, 2004
*/
public class BeanClassTypeAutoProxyCreator extends AbstractAutoProxyCreator
implements ApplicationContextAware, InitializingBean {

/** Logger that is available to subclasses */
protected final Log logger = LogFactory.getLog(getClass());

/** ApplicationContext this object runs in */
private ApplicationContext applicationContext;

/** MessageSourceAccessor for easy message access */
private MessageSourceAccessor messageSourceAccessor;

/**被代理的bean别名列表**/
private List beanNames;

/**被代理的classType列表**/
private List classTypes;

//---------------------------------------------------------
//实现AbstractAutoProxyCreator的抽像方法
//---------------------------------------------------------
/**
* @see org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getAdvicesAndAdvisorsForBean(java.lang.Class,
* java.lang.String, org.springframework.aop.TargetSource)
*/
protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass,
String beanName, TargetSource targetSource) throws BeansException {
if (this.beanNames != null) {
if (this.beanNames.contains(beanName)) {
return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
}
}
return DO_NOT_PROXY;
}

//-------------------------------------------------------
//实现ApplicationContextAware接口方法
//-------------------------------------------------------
/**
* @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext)
*/
public void setApplicationContext(ApplicationContext context)
throws BeansException {
if (context == null && !isContextRequired()) {
// Reset internal context state.
this.applicationContext = null;
this.messageSourceAccessor = null;
} else if (this.applicationContext == null) {
// Initialize with passed-in context.
if (!requiredContextClass().isInstance(context)) {
throw new ApplicationContextException(
"Invalid application context: needs to be of type ["
+ requiredContextClass().getName() + "]");
}
this.applicationContext = context;
this.messageSourceAccessor = new MessageSourceAccessor(context);
initApplicationContext();
} else {
// Ignore reinitialization if same context passed in.
if (this.applicationContext != context) {
throw new ApplicationContextException(
"Cannot reinitialize with different application context: current one is ["
+ this.applicationContext
+ "], passed-in one is [" + context + "]");
}
}
}

/**
* Determine whether this application object needs to run in an
* ApplicationContext.
* <p>
* Default is "false". Can be overridden to enforce running in a context
* (i.e. to throw IllegalStateException on accessors if outside a context).
*
* @see #getApplicationContext
* @see #getMessageSourceAccessor
*/
protected boolean isContextRequired() {
return true;
}

/**
* Determine the context class that any context passed to
* <code>setApplicationContext</code> must be an instance of. Can be
* overridden in subclasses.
*
* @see #setApplicationContext
*/
protected Class requiredContextClass() {
return ApplicationContext.class;
}

/**
* Return the ApplicationContext instance used by this object.
*/
public final ApplicationContext getApplicationContext()
throws IllegalStateException {
if (this.applicationContext == null && isContextRequired()) {
throw new IllegalStateException(
"ApplicationObjectSupport instance [" + this
+ "] does not run in an ApplicationContext");
}
return applicationContext;
}

/**
* Return a MessageSourceAccessor for the application context used by this
* object, for easy message access.
*
* @throws IllegalStateException
* if not running in an ApplicationContext
*/
protected final MessageSourceAccessor getMessageSourceAccessor()
throws IllegalStateException {
if (this.messageSourceAccessor == null && isContextRequired()) {
throw new IllegalStateException(
"ApplicationObjectSupport instance [" + this
+ "] does not run in an ApplicationContext");
}
return this.messageSourceAccessor;
}

public void setClassTypes(String[] classTypes) {
this.classTypes = Arrays.asList(classTypes);

}

/**
* Subclasses can override this for custom initialization behavior. Gets
* called by <code>setApplicationContext</code> after setting the context
* instance.
* <p>
* Note: Does </i>not</i> get called on reinitialization of the context but
* rather just on first initialization of this object's context reference.
*
* @throws ApplicationContextException
* in case of initialization errors
* @throws BeansException
* if thrown by ApplicationContext methods
* @see #setApplicationContext
*/
protected void initApplicationContext() throws BeansException {

}

//-----------------------------------
//实现InitializingBean接口方法
//-----------------------------------

/**
* 查找指定classType的beanName列表
*/
private List getBeanNames(String classType) {
List beanNameList = null;
try {
String[] beanName = this.getApplicationContext()
.getBeanNamesForType(Class.forName(classType), true, false);
if (beanName != null) {
beanNameList = Arrays.asList(beanName);
}
} catch (ClassNotFoundException ex) {
throw new IllegalArgumentException("Class not found: "
+ ex.getMessage());
}

return beanNameList;
}

/**
*
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
public void afterPropertiesSet() throws Exception {

if (classTypes != null && !classTypes.isEmpty()) {
beanNames = new ArrayList();
for (int i = 0; i < classTypes.size(); i++) {
String classType = (String) classTypes.get(i);
List aList = getBeanNames(classType);
beanNames.addAll(aList);
}
}
if (logger.isDebugEnabled()) {
for (int i = 0; i < beanNames.size(); i++) {

logger.debug("printBean:" + (String) beanNames.get(i));

}
}

}
}

3.使用BeanClassTypeAutoProxyCreator
3.1为了使用BeanClassTypeAutoProxyCreator，将为所有需要进行代理的类定一个接口。
package com.prs.application.ehld.biz.service;
public interface BaseService {

}

3.2 让需要代理的类实现或继承这个公共接口
package com.prs.application.ehld.sample.biz.service;
public interface SampleService extends BaseService {
public void setUserInfoDAO(UserInfoDAO userInfoDAO);
public void insertUserInfo(UserInfoDTO userInfo) throws BusinessServiceException;
}

3.3 配置事务代理
<!-定义拦截器-->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop>
<prop key="*">PROPAGATION_SUPPORTS,readOnly</prop>
</props>
</property>
</bean>

<!-定义类型自动代理创建器-->
<bean id="autoClassTypeProxyCreator"
class="com.prs.application.ehld.common.aotoproxy.BeanClassTypeAutoProxyCreator">
<property name="interceptorNames">
<value>transactionInterceptor</value>
</property>
<property name="classTypes">
<list>
<value>com.prs.application.ehld.biz.service.BaseService</value>
</list>
</property>
</bean>

<!-定义事务bean-->
<bean id="com.prs.application.ehld.sample.biz.service.sampleService"
class="com.prs.application.ehld.sample.biz.service.impl.SampleServiceImpl">
<property name="userInfoDAO"
ref="com.prs.application.ehld.sample.integration.dao.userInfoDAO">
</property>
</bean>

效果：只需要定义BeanClassTypeAutoProxyCreator，把需要代理的类型BaseService作为classTypes 的值。这样任何实现了BaseService接口的类都自动获得代理。使得程序员就像配置普通bean一样去配置一个需要事务代理的bean。使得程序员只需要去关心业务逻辑。而无需要去关注事务这些框架应该支持的事情。特别是当开发团队成员水平不一，或团队人员流动性大时， BeanClassTypeAutoProxyCreator就发挥了它的作用。一个好的架构设计应该对事务控制，异常处理，日志记录这些方面进行统一的规划和处理，才能保证系统的健壮性。
采用Spring框架进行项目开发，我们在获得它的IOC等好处，同时给我们增加了维护太多配置文件的负担。应该尽量减少bean的定义，更多采用嵌套bean定义。否则将加大项目后期的维护成本。作为一个架构设计者更是应该把通用性比较强的方面进行统一规划。

版权声明：任何获得Matrix授权的网站，转载时请务必保留以下作者信息和链接
作者:Jason;Li;evenbetter(作者的blog:http://blog.matrix.org.cn/page/evenbetter)
原文:http://www.onjava.com/pub/a/onjava/2006/01/25/spring-xml-configuration-best-practices.html
译文:http://www.matrix.org.cn/resource/article/44/44236_Spring+XML+Configurations.html
关键字:Spring;XML;Configurations

在这篇文章里，对于Spring XML的配置，我将向你展示12种比较好的实践。其中的一些实践不仅是好的实践，更是必要的实践。除此以外，还有其他因素，例如领域模型的设计，都能影响XML的配置，但是这篇文章重点研究XML配置的易读性和易管理性。

1.不要使用autowiring

       Spring可以通过类的自省来自动绑定其依赖部分，使得你不必明确指明bean的属性和构造器。Bean的属性可以通过属性名称或类型匹配来实现自动绑定。构造器通过类型匹配来实现自动绑定。你甚至可以指定自动检测自动绑定模式，它可以引导Spring选择一种适当的运行机制。先来看看下面的一个例子：

    <bean id="orderService"   class="com.Aisce.spring.OrderService"  autowire="byName"/>

      OrderService类的属性名在容器中用于匹配bean实例。自动绑定可以潜在地节省一些打字和减少一些混乱。但是在现实世界的工程里你不应该使用这种方式，这是因为它牺牲了配置的清晰性和可维护性。许多指南和介绍中大量吹捧自动绑定是Spring的一种极好的特征而没有提到这一特性所带来的牺牲。依我的观点，这就像Spring中的object－pooling，它更像是一种为了占据更多市场的商业特征。它对于XML配置文件的小巧化是一个好办法，但实际上也增加了复杂程度，尤其当你运行有大量类声明的工程时。虽然Spring允许你混合自动绑定和手动绑定，但是这个矛盾会使XML配置更加晦涩难懂。

2.使用通俗的命名

      这个方式对于Java编码也一样适用。在工程中使用清晰的、描述性的、协调的通俗名称对于开发者理解XML配置是十分有益的。例如对于bean ID，你可以根据通俗的Java类名来命名它。对于例子中OrderServiceDAO的bean ID命名为orderServiceDAO。对于大的工程，你可以在bean ID前面加上包名作为前缀。

3. 使用简洁的形式

简洁形式避免了冗长，是因为它从子元素中将属性值和参考写到属性中。例如下面的例子：

    <bean id="orderService" class="com.Aisce.spring.OrderService">
            <property name="companyName"> 
                     <value>Aisce</value> 
            </property> 
            <constructor-arg>
                  <ref bean="orderDAO">
            </constructor-arg>
   <bean>

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

    <bean id="orderService" class="com.Aisce.spring.OrderService">
         <property name="companyName"  value="Aisce"/>
         <constructor-arg ref="orderDAO"/>
   </bean>

简洁形式功能在1.2版本中可以使用。对于<ref local="...">没有简洁形式。
简洁形式不但可以节约你的打字，而且可以使XML配置文件清晰。它最引人注目的是当在一个配置文件中有大量定义的类时可以提高易读性。

4. 对于构造器参数匹配，类型名比序号好。

当一个构造器含有一个以上的同种类型的参数，或者属性值的标签已经被占用时，Spring允许你使用从0计数的序号来解决这些会带来混淆的问题。例如：

    <bean id="billingService"  class="com.Aisce.spring.BillingService"> 
         <constructor-arg index="0" value="Aisce"/> 
         <constructor-arg index="1" value="100"/> 
    </bean>

像下面这样，利用类型属性来编写会更好一些：

    <bean id="billingService"  class="com.Aisce.spring.BillingService"> 
         <constructor-arg type="java.lang.String"  value="Aisce"/>
         <constructor-arg type="int" value="100"/> 
   </bean>

使用索引可以稍稍减少一些冗长，但是和使用类型属性相比，它还是有容易发生错误的倾向和难于阅读的缺点。你应该只在构造器参数不明确的时候，才使用索引这一方法。

5. 尽可能重用已定义过的bean

Spring提供一种类似继承一样的机制来减少配置信息的复制并简化XML配置。定义一个子类可以从它父类那里继承配置信息，而父类实质上作为子类的一个模板。这就是大工程中所谓的重用。你所需要做的就是在父类bean中设置abstract=true，然后在子bean注明它自己的父类bean。例如：

    <bean id="abstractService" abstract="true"  class="com.Aisce.spring.AbstractService">
         <property name="companyName"  value="Aisce"/>
   </bean> 
   <bean id="shippingService"  parent="abstractService" class="com.Aisce.spring.ShippingService">
         <property name="shippedBy" value="Aisce"/> 
   </bean>

ShippingService类从abstractService类那里继承companyName属性的值--Aisce。如果你没有为一个bean指明类或factory方法，那么这个bean便是抽象的。

6. 尽量使用ApplicationContext来装配定义的bean

像在Ant脚本中的引用一样，Spring的引用对于装配模块化的bean来说是很有用的。例如：

    <beans>
         <import  resource="billingServices.xml"/>
         <import  resource="shippingServices.xml"/>
         <bean id="orderService" class="com.Aisce.spring.OrderService"/>
   <beans>

相对于使用import在XML配置中来预装配，通过ApplicationContext来配置这些beans，显得更加灵活。利用ApplicationContext也使得XML配置易于管理。你可以像下面的例子那样在ApplictionContext构造器里布置bean：

    String[] serviceResources = {"orderServices.xml", "billingServices.xml", "shippingServices.xml"}; 
    ApplicationContext  orderServiceContext = new ClassPathXmlApplicationContext(serviceResources);

7. 利用id作为bean的标识符

你可以指定一个id或名称来作为bean的标识符。虽然使用id不会提高易读性，但是它可以让XML parser对bean的引用有效方面进行更好的验证。如果由于XML IDREF的限制而不能使用某个id，你可以利用names来作为bean的标识符。XML IDREF的限制是id必须以字母开头（或者在XML规范中定义的标点符号），后面接着字母，数字，连字号，下划线，冒号等。实际上，遇到XML IDREF限制的问题是很少见的。

8. 在开发阶段使用依赖检验

你可以在bean中给依赖检验的属性设置值，而不采用原先默认的空值，属性设置例如simple，object或all，以便容器进行依赖检验。当bean的全部的属性（或某类属性）需要被明确设置或自动绑定时，依赖检验便显得很有用。

    <bean id="orderService"  class="com.Aisce.spring.OrderService" dependency-check="objects"> 
         <property name="companyName"  value="Aisce"/> 
         <constructor-arg ref="orderDAO"/>
   </bean>

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

9. 为每个配置文件加上一个header comment

最好使用descriptive id和名称来代替在XML配置文件中的注释。此外，加上一个配置文件header也很有用处，它可以概述文件中所定义的bean。你可以选择将描述内容加入description标签中。例如：

    <beans>        
         <description> This is a Bean description.  </description> 
    </beans>

使用description标签的一个好处是可以容易地利用工具从标签中选取出description（的内容）。

10. 对于任何变化，要与队友积极交流
当你重构Java代码时，你需要随时更新配置文件并且通知队友。XML配置文件也是代码，它们是应用程序的至关重要的部分，但是它们难于阅读和维护。大部分时间你既要阅读XML配置文件又要阅读运行中的Java代码。

11. Setter injection优于constructor injection

Spring提供3种类型的依赖注入： constructor injection,setter injection, 和method injection。我们一般只用前两种类型。

    <bean id="orderService"  class="com.Aisce.spring.OrderService">   
                <constructor-arg ref="orderDAO"/> 
   </bean> 
   <bean id="billingService"   class="com.Aisce.spring.BillingService">        
                <property name="billingDAO"  ref="billingDAO">
   </bean>

这个例子中，orderService类使用的是constructor injection，而BillingService类使用的是setter injection。constructor injection可以确保bean不会在一个非法状态下被创建，但是setter injection更加灵活并且更易管理，尤其当类存在很多属性并且其中一些是可选的情况下。

12. 不要滥用依赖注入

作为最后一点，Spring ApplicationContext可以替你创建Java对象，但是并不是所有的Java对象都通过依赖注入来创建的。例如，全局的对象不应该通过ApplicationContext来创建。Spring是一个很棒的框架，但是，就易读性和易管理性而言，当定义大量bean的时候，基于XML的配置问题就会突出。过度的依赖注入会使XML配置变得复杂而且臃肿。记住！使用强大的IDE时，例如Eclipse和IntelliJ，与XML文件相比，Java代码更加易读，易维护，易管理。

总结
对于Spring的配置，XML是很优秀的方式。但当定义大量bean时，基于XML配置会变得冗长，笨拙。Spring提供了丰富的配置选项。适当地利用其中的选项可以使XML配置清晰，但是，有些选项，例如autowiring（自动绑定），往往会降低易读性和易维护性。文章中所列举的实例，可以帮助你创建出清晰易读的XML配置文件。

关于作者：
Jason Zhicheng Li是Object Computing, Inc. in St. Louis, MO（公司）一名资深的软件工程师。