Spring中的四种声明式事务的配置

如果理解了这两种思想，对于我们学习设计模式和编程有很大的帮助，美国四人帮（GOF）写的设计模式中，有很多都用到了Ioc的思想。简单的说就是依赖注入的思想。常见的一种情况：如果一个类中要复用另外一个类中的功能时，我们可能会首先想到继承，如果你知道Ioc这种思想的话，我想你不会用继承，你会马上想到把要用到功能抽取出来，在我们要用到的类中只需通过set方法简单的注入就可以了，其实这里用到了对象的组合代替继承，这样不仅避免了单一继承，还很好的实现了松耦合。同时也遵循了面向对象的编程的设计原则：多用组合，少用继承。在这里对于Ioc和Aop这两种思想的好处。我就不介绍了。接下来我要说的是Spring中几种常见的事务配置，是Aop和Ioc的充分体现。

在说点题外话，以前EJB在J2EE中开发中可是大名鼎鼎的了。就是因为EJB提供了很多服务，而不需要我们去开发了，其中用到最多的算是它提供的声明式事务了。在Spring没有出现之前，EJB在J2EE开发中扮演着非常重要的角色。同时也是很多项目失败的罪魁祸首。其中的原因就是因为它是重量级，强侵入性收费的框架。需要昂贵的服务器支持，在加上它的测试更是让人头痛。而Spring恰恰与它相反。Spring是一个轻量级的，非侵入性的开源框架。它提供的声明式事务的功能更是强大，不需要容器的支持。这一点吸引力很多人愿意放弃EJB而使用Spring.让我们言归正传吧。

以下两个bean的配置是下面要用到的。

1.  
2.      <bean id="transactionManager" 
3. class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
4.       <property name="sessionFactory"> 
5.        <ref local="sessionFactory" /> 
6.        property> 
7.       bean> 
8.       
9.      <bean id="fundService" 
10. class="com.jack.fund.service.serviceimpl.FundService"> 
11.       <property name="operdao"> 
12.        <ref bean="operatorDAO" /> 
13.        property> 
14.       <property name="producedao"> 
15.        <ref bean="fundProduceDAO" /> 
16.        property> 
17.       <property name="customerdao"> 
18.        <ref bean="customerDAO" /> 
19.        property> 
20.       <property name="accountdao"> 
21.        <ref bean="accountDAO" /> 
22.        property> 
23.       <property name="fundaccountdao"> 
24.        <ref bean="fundAccountDAO" /> 
25.        property> 
26.       <property name="fundtransdao"> 
27.        <ref bean="fundTransDAO" /> 
28.        property> 
29.       bean> 

可能还有其他很多模块。 可能只是其中的模块。

***种：配置声明式事务的方法如下。也是我们最常用的方法了，它适用于你的库表比较少的情况下。

1. <bean id="fundServiceDAOProxy" 
2. class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
3.  
4. <property name="transactionManager"> 
5. <ref bean="transactionManager" /> 
6. property> 
7.  
8. <property name="proxyTargetClass"> 
9. <value>false value> 
10. property> 
11. <property name="proxyInterfaces"> 
12. <value>com.jack.fund.service.IFundService value> 
13. property> 
14.  
15. <property name="target"> 
16. <ref bean="fundService" /> 
17. property> 
18.  
19. <property name="transactionAttributes"> 
20. <props> 
21. <prop key="delete*">PROPAGATION_REQUIRED prop> 
22. <prop key="add*">PROPAGATION_REQUIRED prop> 
23. <prop key="update*">PROPAGATION_REQUIRED prop> 
24. <prop key="save*">PROPAGATION_REQUIRED prop> 
25. <prop   key="find*">PROPAGATION_REQUIRED,readOnly prop> 
26. props> 
27. property> 
28. bean> 

以下可能还有其他的xxxServiceDAOProxy.大家可以看出针对每一个功能模块配置一个业务代理服务。如果模块多大话，就显得代码有点多了，发现他们只是稍微一点不一样。这时我们就应该想到继承的思想。用第二种方法。

第二种：配置声明式事务的方法如下。这种情况适合相对比较多的模块时使用。

1.  
2. <bean id="transactionBase" 
3. class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" 
4. lazy-init="true" abstract="true"> 
5.  
6. <property name="transactionManager"> 
7. <ref bean="transactionManager" /> 
8. property> 
9.  
10. <property name="transactionAttributes"> 
11. <props> 
12. <prop key="delete*">PROPAGATION_REQUIRED prop> 
13. <prop key="add*">PROPAGATION_REQUIRED prop> 
14. <prop key="update*">PROPAGATION_REQUIRED prop> 
15. <prop key="save*">PROPAGATION_REQUIRED prop> 
16. <prop key="find*">PROPAGATION_REQUIRED,readOnly prop> 
17. props> 
18. property> 
19. bean> 
20. 而具体的模块可以简单的这样配置。只要指明它的parent（父类）就可以了。父类一般把abstract="true"，因为在容器加载的时候不需要初始化，等到用的时候再有它的子类调用的时候，再去初始化。  
21. <bean id="fundServiceDAOProxy" parent="transactionBase" > 
22. <property name="target"> 
23. <ref bean="fundService" /> 
24. property> 
25. bean> 

这样配置的话，如果有多个像fundService这样模块时，可以少些很多重复的代码。

第三种：配置声明式事务的方法如下。主要利用BeanNameAutoProxyCreator自动创建事务代理

1. <bean id="transactionInterceptor" 
2. class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
3. <property name="transactionManager"> 
4. <ref bean="transactionManager" /> 
5. property> 
6.  
7. <property name="transactionAttributes"> 
8. <props> 
9. <prop key="delete*">PROPAGATION_REQUIRED prop> 
10. <prop key="add*">PROPAGATION_REQUIRED prop> 
11. <prop key="update*">PROPAGATION_REQUIRED prop> 
12. <prop key="save*">PROPAGATION_REQUIRED prop> 
13. <prop key="find*">PROPAGATION_REQUIRED,readOnly prop> 
14. props> 
15. property> 
16. bean> 
17. <bean 
18. class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
19. <property name="beanNames"> 
20. <list> 
21. <value>fundService value> 
22. list> 
23. property> 
24. <property name="interceptorNames"> 
25. <list> 
26. <value>transactionInterceptor value> 
27. list> 
28. property> 
29. bean> 

这种方法主要利用了拦截器的原理。

前三种方法一般都必需指定具体的模块bean.如果模块过多话，比如一个大型的网站一般有几十个模块。我们就得考虑用第四种的配置方式了。自动创建事务代理的方式了。

第四种：配置声明式事务的方法如下。

1. <bean id="transactionInterceptor" 
2. class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
3. <property name="transactionManager"> 
4. <ref bean="transactionManager" /> 
5. property> 
6.  
7. <bean id="autoproxy" 
8. class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
9.  
10. <property name="beanNames"> 
11. <list> 
12. <value>*Service value> 
13. list> 
14. property> 
15. <property name="interceptorNames"> 
16. <list> 
17. <value>transactionInterceptor value> 
18. list> 
19. property> 
20. bean> 

自动代理还有一种用法就是结合正规表达式和advice使用。

1. <bean id="transactionInterceptor" 
2. class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
3. <property name="transactionManager"> 
4. <ref bean="transactionManager" /> 
5. property> 
6. <bean id="autoProxyCreator" 
7. class="org.springframework.aop.framework.autoproxy.DefaultAdvisor                                                       AutoProxyCreator" /> 
8. <bean id="regexpMethodPointcutAdvisor" 
9. class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> 
10. <property name="advice"> 
11. <ref bean="transactionInterceptor" /> 
12. property> 
13. <property name="pattern"> 
14. <value>.* value> 
15. property> 
16. bean> 

【编辑推荐】

1. Spring控制反转(IoC)容器
2. Spring is coming
3. 在Spring中进行集成测试
4. Spring中的TopLink ServerSession
5. Spring声明式事务