spring bean 定义可能包含大量的配置信息，包括容器相关的信息（比如初始化方法，静态工厂方法

等）、构造函数参数、属性等。如果两个bean之间的配置信息大同小异，可采用bean的继承来减少重

复配置工作。子bean定义可以从父bean定义继承部分配置。它也可覆盖一些配置，或者添加一些配置

。使用继承配置可以节省很多输入工作，实际上就是一种模板形式。

spring中事务配置中就有这样例子，为了使用事务只要父配置了事务代理就可以了，所有需要事务的

bean只要继承父就可以了。说到这个就在多说几句，父bean通常不需要实例化的，而仅仅作为子bean

定的的模板使用；而ApplicationContext默认预初始化所有的singleton bean。为了阻止父bean被预

初始化，可以使用abstract属性设置父bean为抽象bean。容器会忽略所有的抽象bean定义，预初始化

时不初始化抽象bean。

2， spring 事务管理

传统的J2EE开发者对事务管理可能采用两种策略

（1），全局事务：全局事务通常由应用服务器管理，使用JTA。全局事务可跨越多个事务性的资源，保证

在多个事务性资源间跨越时资源一致性。
（2），局部事务：局部事务和特定资源相关，如，一个和JDBC链接关联的事务。该事务尽能保证对该

JDBC连接数据库的一致性，对局部事务，应用服务器不需要参与事务管理，不能保证跨越多个资源的

事务正确性。

3，编程式事务

Spring 提供两种编程式的事务管理

（1）使用TransactionTemplate事务管理

（2）直接使用一个PlatformTransactionManager实现类管理事务。

两种编程式的事务都不需要与特定的事务API耦合，第一种更符合Spring模板式的编程模型，因此通常推荐采用第一种方式，第二种非常类似于JTA的UserTransaction的API编程，区别是减少了异常处理。

4，声明式事务

Spring的声明式事务是通过面向切面（AOP）实现。

（1）使用声明式事务管理

通常，通过TransactionPoxyFactoryBean为目标Bean生成Spring事务代理。当bean实例的方法需要事务管理时，采用TransactionPoxyFactoryBean来自目标bean生成事务代理。每个TransactionPoxyFactoryBean为一个具体的目标bean生成代理对象，代理对象的方法改写了目标bean的方法，就是在目标bean的方法执行之前加入开始事务，在目标bean方法结束之后提交事务，遇到指定异常回滚事务。

    定义事务代理bean模板

Xml代码

1. <bean id="txProxyTemplate" abstract="true"  
2.     class="<SPAN style="COLOR: #ff0000">org.springframework.transaction.interceptor.TransactionProxyFactoryBean</SPAN>">  
3.     <property name="transactionManager">  
4.         <ref bean="transactionManager" />  
5.     </property>  
6.     <property name="transactionAttributes">  
7.         <props>  
8.             <prop key="trans_*">PROPAGATION_REQUIRED</prop>  
9.             <prop key="query*">  
10.                 PROPAGATION_REQUIRED,readOnly,-Exception   
11.             </prop>  
12.             <prop key="find*">  
13.                 PROPAGATION_REQUIRED,readOnly,-Exception   
14.             </prop>  
15.             <prop key="load*">  
16.                 PROPAGATION_REQUIRED,readOnly,-Exception   
17.             </prop>  
18.             <prop key="*">PROPAGATION_REQUIRED,-Exception</prop>  
19.         </props>  
20.     </property>  
21. </bean>  

	<bean id="txProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="transactionAttributes">
<props>
<prop key="trans_*">PROPAGATION_REQUIRED</prop>
<prop key="query*">
PROPAGATION_REQUIRED,readOnly,-Exception
</prop>
<prop key="find*">
PROPAGATION_REQUIRED,readOnly,-Exception
</prop>
<prop key="load*">
PROPAGATION_REQUIRED,readOnly,-Exception
</prop>
<prop key="*">PROPAGATION_REQUIRED,-Exception</prop>
</props>
</property>
</bean>

（2）根据BeanName自动创建事务代理

如果同一个应用中有很多目标bean需要生成事务代理，当然可以为每个目标bean额外配置一个TransactionPoxyFactoryBean bean.这样做的缺点是，配置文件相当臃肿而且难以维护，此时可以考虑使用自动事务代理。自动事务代理的思路是，当ApplicationContext初始化完成后，由上下文中的某个bean"后处理"每个目标bean，为这些目标bean生成事务代理。

能为目标bean执行"后处理"的bean必须实现BeanFactoryPostProcessor接口，ApplicationContext完成初始化后，会自动初始化所有实现BeanFactoryPostProcessor接口的bean，并且让它“后处理”其他bean.Spring提供BeanFactoryPostProcessor的实现类BeanNameAutoPoxyCreator，BeanNameAutoPoxyCreator可以用来处理ApplicationContext中其他bean，方法是通过名称来识别，并且把他们用事务代理包装起来。BeanNameAutoPoxyCreator生成的事务代理，和使用TransactionPoxyFactoryBean生成的事务代理基本一致。

    定义事务拦截bean

Xml代码

1.  <bean id="transactionInterceptor"  
2.   class="<SPAN style="COLOR: #ff0000">org.springframework.transaction.interceptor.TransactionInterceptor</SPAN>">  
3.   <property name="transactionManager" ref="TransactionManager" />  
4.      
5.   <property name="transactionAttributes">  
6.    <props>  
7.     <prop key="create*">  
8.      PROPAGATION_REQUIRED,-Exception   
9.     </prop>  
10.     <prop key="delete*">  
11.      PROPAGATION_REQUIRED,-Exception   
12.     </prop>    
13.     <prop key="update*">  
14.      PROPAGATION_REQUIRED,-Exception   
15.     </prop>           
16.     <prop key="get*">PROPAGATION_REQUIRED</prop>  
17.    </props>  
18.   </property>  
19.  </bean>  

 <bean id="transactionInterceptor"
  class="org.springframework.transaction.interceptor.TransactionInterceptor">
  <property name="transactionManager" ref="TransactionManager" />
  
  <property name="transactionAttributes">
   <props>
    <prop key="create*">
     PROPAGATION_REQUIRED,-Exception
    </prop>
    <prop key="delete*">
     PROPAGATION_REQUIRED,-Exception
    </prop> 
    <prop key="update*">
     PROPAGATION_REQUIRED,-Exception
    </prop>        
    <prop key="get*">PROPAGATION_REQUIRED</prop>
   </props>
  </property>
 </bean>

Xml代码

1.  <bean  
2.   class="<SPAN style="COLOR: #ff0000">org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator</SPAN>">  
3.   <property name="beanNames">  
4.    <value>*Service</value>  
5.   </property>  
6.   <property name="interceptorNames">  
7.    <list>  
8.     <value>transactionInterceptor</value>  
9.    </list>  
10.   </property>  
11.  </bean>   

 <bean
  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  <property name="beanNames">
   <value>*Service</value>
  </property>
  <property name="interceptorNames">
   <list>
    <value>transactionInterceptor</value>
   </list>
  </property>
 </bean> 

次配置关键在两个bean

TransactionInterceptor

BeanNameAutoProxyCreator

（3）基于注释式事务代理配置

当采用XML描述配置元数据时，将通过<bean/>元素的class属性来指定实例化对象的类型。class 属性 (对应BeanDefinition实例的Class属性)通常是必须的(不过也有两种例外的情形，“使用实例工厂方法实例化”和“bean定义的继承”)。class属性主要有两种用途：在大多数情况下，容器将直接通过反射调用指定类的构造器来创建bean(这有点等类似于在Java代码中使用new操作符)；在极少数情况下，容器将调用类的静态工厂方法来创建bean实例，class属性将用来指定实际具有静态工厂方法的类(至于调用静态工厂方法创建的对象类型是当前class还是其他的class则无关紧要)。

2, 延迟初始化bean
ApplicationContext实现的默认行为就是在启动时将所有singleton bean提前进行实例化。提前实例化意味着作为初始化过程的一部分，ApplicationContext实例会创建并配置所有的singleton bean。通常情况下这是件好事，因为这样在配置中的任何错误就会即刻被发现（否则的话可能要花几个小时甚至几天）。

有时候这种默认处理可能并不是你想要的。如果你不想让一个singleton bean在ApplicationContext实现在初始化时被提前实例化，那么可以将bean设置为延迟实例化。一个延迟初始化bean将告诉IoC 容器是在启动时还是在第一次被用到时实例化。

在XML配置文件中，延迟初始化将通过<bean/>元素中的lazy-init属性来进行控制。例如：

<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true">
    <!-- various properties here... -->
</bean>
  <bean name="not.lazy" class="com.foo.AnotherBean">
    <!-- various properties here... -->
</bean>
当ApplicationContext实现加载上述配置时，设置为lazy的bean将不会在ApplicationContext启动时提前被实例化，而not.lazy却会被提前实例化。

需要说明的是，如果一个bean被设置为延迟初始化，而另一个非延迟初始化的singleton bean依赖于它，那么当ApplicationContext提前实例化singleton bean时，它必须也确保所有上述singleton 依赖bean也被预先初始化，当然也包括设置为延迟实例化的bean。因此，如果Ioc容器在启动的时候创建了那些设置为延迟实例化的bean的实例，你也不要觉得奇怪，因为那些延迟初始化的bean可能在配置的某个地方被注入到了一个非延迟初始化singleton bean里面。

在容器层次中通过在<beans/>元素上使用'default-lazy-init'属性来控制延迟初始化也是可能的。如下面的配置：
<beans default-lazy-init="true">
    <!-- no beans will be eagerly pre-instantiated... -->
</beans>

3,自动装配（autowire）协作者
Spring IoC容器可以自动装配（autowire）相互协作bean之间的关联关系。因此，如果可能的话，可以自动让Spring通过检查BeanFactory中的内容，来替我们指定bean的协作者（其他被依赖的bean）。由于autowire可以针对单个bean进行设置，因此可以让有些bean使用autowire，有些bean不采用。autowire的方便之处在减少或者消除属性或构造器参数的设置，这样可以给我们的配置文件减减肥！[2] 在xml配置文件中，autowire一共有五种类型，可以在<bean/>元素中使用autowire属性指定:

Table 3.2. Autowiring modes

模式 说明

    no 不使用自动装配。必须通过ref元素指定依赖，这是默认设置。由于显式指定协作者可以使配置更灵活、更清晰，因此对于较大的部署配置，推荐采用该设置。而且在某种程度上，它也是系统架构的一种文档形式。
 
    byName 根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配。例如，在bean定义中将autowire设置为by name，而该bean包含master属性（同时提供setMaster(..)方法），Spring就会查找名为master的bean定义，并用它来装配给master属性。
 
    byType 如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配。如果存在多个该类型的bean，那么将会抛出异常，并指出不能使用byType方式进行自动装配。若没有找到相匹配的bean，则什么事都不发生，属性也不会被设置。如果你不希望这样，那么可以通过设置dependency-check="objects"让Spring抛出异常。
 
    constructor 与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。
 
    autodetect 通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。
 

如果直接使用property和constructor-arg注入依赖的话，那么将总是覆盖自动装配。而且目前也不支持简单类型的自动装配，这里所说的简单类型包括基本类型、String、Class以及简单类型的数组（这一点已经被设计，将考虑作为一个功能提供）。自动装配还可以与依赖检查结合使用，这样依赖检查将在自动装配完成之后被执行。

理解自动装配的优缺点是很重要的。其中优点包括：

自动装配能显著减少配置的数量。不过，采用bean模板（见这里）也可以达到同样的目的。

自动装配可以使配置与java代码同步更新。例如，如果你需要给一个java类增加一个依赖，那么该依赖将被自动实现而不需要修改配置。因此强烈推荐在开发过程中采用自动装配，而在系统趋于稳定的时候改为显式装配的方式。

自动装配的一些缺点：

尽管自动装配比显式装配更神奇，但是，正如上面所提到的，Spring会尽量避免在装配不明确的时候进行猜测，因为装配不明确可能出现难以预料的结果，而且Spring所管理的对象之间的关联关系也不再能清晰的进行文档化。

对于那些根据Spring配置文件生成文档的工具来说，自动装配将会使这些工具没法生成依赖信息。

如果采用by type方式自动装配，那么容器中类型与自动装配bean的属性或者构造函数参数类型一致的bean只能有一个，如果配置可能存在多个这样的bean，那么就要考虑采用显式装配了。

尽管使用autowire没有对错之分，但是能在一个项目中保持一定程度的一致性是最好的做法。例如，通常情况下如果没有使用自动装配，那么仅自动装配一个或两个bean定义可能会引起开发者的混淆。

应该注意的是，即使单例与原型作用域beans的基本（内在）实现发生了变化，上述变化对最终用户来说是透明的...现有的配置不需要改变或放弃。

<bean id="role" class="spring.chapter2.maryGame.Role" scope="singleton"/>

下面分别对spring 中的作用域分别介绍一下：

1、singleton作用域

当一个bean的作用域设置为singleton，那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时候，spring的IOC容器中只会存在一个该bean。

配置实例：

<bean id="role" class="spring.chapter2.maryGame.Role" scope="singleton"/>

或者

<bean id="role" class="spring.chapter2.maryGame.Role" singleton="true"/>

2、prototype

prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）都会产生一个新的bean实例，相当于一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责。（让Spring容器释放被singleton作用域bean占用资源的一种可行方式是，通过使用bean的后置处理器，该处理器持有要被清除的bean的引用。）

配置实例：

<bean id="role" class="spring.chapter2.maryGame.Role" scope="prototype"/>

或者

<beanid="role" class="spring.chapter2.maryGame.Role" singleton="false"/>

 
3、request

request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效，配置实例：

request、session、global session使用的时候，首先要在初始化web的web.xml中做如下配置：

如果你使用的是Servlet 2.4及以上的web容器，那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可：

<web-app> ... <listener> <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class> </listener> ... </web-app>

如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现：

<web-app> .. <filter> <filter-name>requestContextFilter</filter-name> <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class> </filter> <filter-mapping> <filter-name>requestContextFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> ... </web-app>

接着既可以配置bean的作用域了：

<bean id="role" class="spring.chapter2.maryGame.Role" scope="request"/>

4、session

session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效，配置实例：

配置实例：

和request配置实例的前提一样，配置好web启动文件就可以如下配置：

<bean id="role" class="spring.chapter2.maryGame.Role" scope="session"/>

5、global session

global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean，那么，web会自动当成session类型来使用。

配置实例：

和request配置实例的前提一样，配置好web启动文件就可以如下配置：

<bean id="role" class="spring.chapter2.maryGame.Role" scope="global session"/>

6、自定义bean装配作用域

在spring 2.0中作用域是可以任意扩展的，你可以自定义作用域，甚至你也可以重新定义已有的作用域（但是你不能覆盖singleton和prototype），spring的作用域由接口org.springframework.beans.factory.config.Scope来定义，自定义自己的作用域只要实现该接口即可，下面给个实例：

我们建立一个线程的scope，该scope在表示一个线程中有效，代码如下：

publicclass MyScope implements Scope ...{ privatefinal ThreadLocal threadScope = new ThreadLocal() ...{ protected Object initialValue() ...{ returnnew HashMap(); } }; public Object get(String name, ObjectFactory objectFactory) ...{ Map scope = (Map) threadScope.get(); Object object = scope.get(name); if(object==null) ...{ object = objectFactory.getObject(); scope.put(name, object); } return object; } public Object remove(String name) ...{ Map scope = (Map) threadScope.get(); return scope.remove(name); } publicvoid registerDestructionCallback(String name, Runnable callback) ...{ } public String getConversationId() ...{ // TODO Auto-generated method stub returnnull; } }

注：本文的原文来源于网络。