Spring 事物机制总结

Bertha 。 2022-06-03 00:59 160阅读 0赞

转载地址：[http://blog.csdn.net/pingnanlee/article/details/11488695][http_blog.csdn.net_pingnanlee_article_details_11488695]

Spring两种事物处理机制，一是声明式事物，二是编程式事物

声明式事物

1）Spring的声明式事务管理在底层是建立在AOP的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明（或通过等价的基于标注的方式），便可以将事务规则应用到业务逻辑中。因为事务管理本身就是一个典型的横切逻辑，正是AOP的用武之地。Spring开发团队也意识到了这一点，为声明式事务提供了简单而强大的支持。Spring强大的声明式事务管理功能，这主要得益于Spring依赖注入容器和Spring AOP的支持。依赖注入容器为声明式事务管理提供了基础设施，使得Bean对于Spring框架而言是可管理的；而Spring AOP则是声明式事务管理的直接实现者。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。

2）5种配置方式  
Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。  
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。  
关系图如下：

![http://images.blogjava.net/blogjava\_net/robbie/WindowsLiveWriter/Spring\_9C9C/Spring%E4%BA%8B%E5%8A%A1%E9%85%8D%E7%BD%AE%20(2).jpg][http_images.blogjava.net_blogjava_net_robbie_WindowsLiveWriter_Spring_9C9C_Spring_E4_BA_8B_E5_8A_A1_E9_85_8D_E7_BD_AE_20_2_.jpg]

**\[html\]**  [view plain][]   [copy][view plain]

1.  **<****bean** id="sessionFactory"  
2.      class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"**>**  
3.      **<****property** name="configLocation" value="classpath:hibernate.cfg.xml" **/>**  
4.      **<****property** name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" **/>**  
5.  **</****bean****>**  
6.    
7.    
8.  **<****bean** id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"**>**  
9.      **<****property** name="sessionFactory" ref="sessionFactory" **/>**  
10. **</****bean****>**

注意：sessionFactorty和transactionManager是下面5中配置方式的基本配置，

第一种方式：每个Bean都有一个代理

**\[html\]**  [view plain][]   [copy][view plain]

1.    
2.  **<****bean** id="userDaoTarget" class="com.test.spring.dao.UserDaoImpl"**>**  
3.      **<****property** name="sessionFactory" ref="sessionFactory" **/>**  
4.  **</****bean****>**  
5.    
6.  **<****bean** id="userDao" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"**>**  
7.        
8.      **<****property** name="transactionManager" ref="transactionManager" **/>**  
9.      **<****property** name="target" ref="userDaoTarget" **/>**  
10.     **<****property** name="proxyInterfaces" value="com.test.spring.dao.GeneratorDao" **/>**  
11.       
12.     **<****property** name="transactionAttributes"**>**  
13.         **<****props****>**  
14.             **<****prop** key="\*"**>**PROPAGATION\_REQUIRED**</****prop****>**  
15.         **</****props****>**  
16.     **</****property****>**  
17. **</****bean****>**

第二种方式：所有Bean共享一个代理基类

**\[html\]**  [view plain][]   [copy][view plain]

1.  **<****bean** id="transactionBase" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true" abstract="true"**>**  
2.        
3.      **<****property** name="transactionManager" ref="transactionManager" **/>**  
4.        
5.      **<****property** name="transactionAttributes"**>**  
6.          **<****props****>**  
7.              **<****prop** key="\*"**>**PROPAGATION\_REQUIRED**</****prop****>**  
8.          **</****props****>**  
9.      **</****property****>**  
10. **</****bean****>**  
11.   
12.   
13. **<****bean** id="userDaoTarget" class="com.test.spring.dao.UserDaoImpl"**>**  
14.     **<****property** name="sessionFactory" ref="sessionFactory" **/>**  
15. **</****bean****>**  
16.   
17. **<****bean** id="userDao" parent="transactionBase"**>**  
18.     **<****property** name="target" ref="userDaoTarget" **/>**  
19. **</****bean****>**

第三种方式：使用拦截器

**\[html\]**  [view plain][]   [copy][view plain]

1.  **<****bean** id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"**>**  
2.      **<****property** name="transactionManager" ref="transactionManager" **/>**  
3.        
4.      **<****property** name="transactionAttributes"**>**  
5.          **<****props****>**  
6.              **<****prop** key="\*"**>**PROPAGATION\_REQUIRED**</****prop****>**  
7.          **</****props****>**  
8.      **</****property****>**  
9.  **</****bean****>**  
10.   
11. **<****bean** class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"**>**  
12.     **<****property** name="beanNames"**>**  
13.         **<****list****>**  
14.             **<****value****>**\*Dao**</****value****>**  
15.         **</****list****>**  
16.     **</****property****>**  
17.     **<****property** name="interceptorNames"**>**  
18.         **<****list****>**  
19.             **<****value****>**transactionInterceptor**</****value****>**  
20.         **</****list****>**  
21.     **</****property****>**  
22. **</****bean****>**  
23.   
24.   
25. **<****bean** id="userDao" class="com.test.spring.dao.UserDaoImpl"**>**  
26.     **<****property** name="sessionFactory" ref="sessionFactory" **/>**  
27. **</****bean****>**

第四种方式：使用tx标签配置的拦截器

**\[html\]**  [view plain][]   [copy][view plain]

1.  **<****tx:advice** id="txAdvice" transaction-manager="transactionManager"**>**  
2.      **<****tx:attributes****>**  
3.          **<****tx:method** name="\*" propagation="REQUIRED" **/>**  
4.      **</****tx:attributes****>**  
5.  **</****tx:advice****>**  
6.    
7.  **<****aop:config****>**  
8.      **<****aop:pointcut** id="interceptorPointCuts"  
9.          expression="execution(\* com.test.spring.dao.\*.\*(..))" **/>**  
10.     **<****aop:advisor** advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" **/>**  
11. **</****aop:config****>**

第五种方式：全注解

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** test \{  
2.      @Transactional  
3.      **public** **class** UserDaoImpl **extends** HibernateDaoSupport **implements** UserDao \{  
4.    
5.          **public** List<User> listUsers() \{  
6.              **return** **null**  
7.          \}  
8.      \}  
9.  \}

编程式事务

Spring的编程式事务即在代码中使用编程的方式进行事务处理，可以做到比声明式事务更细粒度。有两种方式一是使用TransactionManager，另外就是TransactionTemplate。

1）TransactionManager使用方式

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** UserDaoImpl **extends** HibernateDaoSupport **implements** UserDao \{  
2.      **private** HibernateTransactionManager transactionManager;  
3.      **private** DefaultTransactionDefinition def;  
4.    
5.      **public** HibernateTransactionManager getTransactionManager() \{  
6.          **return** transactionManager;  
7.      \}  
8.    
9.      **public** **void** setTransactionManager(HibernateTransactionManager transactionManager) \{  
10.         **this**.transactionManager = transactionManager;  
11.     \}  
12.   
13.     **public** **void** createTransactionDefinition() \{  
14.         def = **new** DefaultTransactionDefinition();  
15.         def.setPropagationBehavior(TransactionDefinition.PROPAGATION\_REQUIRED);  
16.         def.setIsolationLevel(TransactionDefinition.ISOLATION\_READ\_COMMITTED);  
17.     \}  
18.   
19.     **public** **void** saveOrUpdate(User user) \{  
20.         TransactionStatus status = transactionManager.getTransaction(def);  
21.         **try** \{  
22.             **this**.getHibernateTemplate().saveOrUpdate(user);  
23.         \} **catch** (DataAccessException ex) \{  
24.             transactionManager.rollback(status);  
25.             **throw** ex;  
26.         \}  
27.         transactionManager.commit(status);  
28.     \}  
29. \}

2）TransactionTemplate方式

**\[java\]**  [view plain][]   [copy][view plain]

1.  ResultDto ret = **null**;  
2.  ret = (ResultDto) **this**.transactionTemplate.execute(**new** TransactionCallback() \{  
3.      @Override  
4.      **public** Object doInTransaction(TransactionStatus status) \{  
5.          ResultDto ret = **null**;  
6.          **try** \{  
7.              drillTaskDao.deleteByKey(taskid);  
8.          \} **catch** (Exception e) \{  
9.              logger.error("delDrillTask:" + e.getMessage(), e);  
10.             ret = ResultBuilder.buildResult(ResultBuilder.FAIL\_CODE, **null**, ErrorCode.COM\_DBDELETEERROR);  
11.             **return** ret;  
12.         \}  
13.         **finally** \{  
14.             status.setRollbackOnly();  
15.         \}  
16.            
17.         ret = cleartaskrelativedata(taskid, appid, **true**);  
18.         **return** ret;  
19.     \}  
20. \});  
21. **return** ret;  
22.

[http_blog.csdn.net_pingnanlee_article_details_11488695]: http://blog.csdn.net/pingnanlee/article/details/11488695
[http_images.blogjava.net_blogjava_net_robbie_WindowsLiveWriter_Spring_9C9C_Spring_E4_BA_8B_E5_8A_A1_E9_85_8D_E7_BD_AE_20_2_.jpg]: /images/20220603/fb314ad614424b21a2dd71789da1a194.png
[view plain]: http://blog.csdn.net/pingnanlee/article/details/11488695#

发表评论取消回复

表情：

评论列表（有 0 条评论，160人围观）

还没有评论，来说两句吧...

相关阅读

相关【MySQL】事物机制

事务机制 1. 事务的概念与特征 2. 关闭MySQL中的自动提交 3. 回滚与提交（rollback and commit） 4. 保存点（sa

柔光的暖阳◎/ 2022年10月22日 08:00/ 0 赞/ 225 阅读

相关 Spring、Springboot中事务传播机制（事物嵌套）

Spring、Springboot中事务传播机制（事物嵌套）事务传播机制： `事务的传播行为是针对嵌套事务而言。即是针对（需要事务的业务方法）调用（需要事务的业务

r囧r小猫/ 2022年08月30日 04:08/ 0 赞/ 298 阅读

相关 spring事物

SPRING的事物关健在类org.springframework.orm.hibernate3.HibernateTransactionManager，而不在org.spr

浅浅的花香味﹌/ 2022年08月25日 14:45/ 0 赞/ 170 阅读

相关 spring 七种事物隔离机制

REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。

╰+攻爆jí腚メ/ 2022年06月12日 03:53/ 0 赞/ 131 阅读

相关 spring事物

spring事物管理分为两种，编程式事物和声明式事物一、编程式事物编程式事物配置相对繁琐，而且不常用，就不在这里详细说明，需要的c友可以参考 [http:

深藏阁楼爱情的钟/ 2022年06月09日 06:16/ 0 赞/ 238 阅读

相关 Spring事物回滚机制测试

1、直接在service写两个插入语句，让第二个异常，也不做任何try catch, 此时能回滚，控制器做异常处理 public int insertSelectiv

我不是女神ヾ/ 2022年06月08日 23:19/ 0 赞/ 265 阅读

相关 Spring 事物机制总结

转载地址：[http://blog.csdn.net/pingnanlee/article/details/11488695][http_blog.csdn.net_pingn

Bertha 。/ 2022年06月03日 00:59/ 0 赞/ 161 阅读

相关 spring事物

@Transactional(rollbackFor=Exception.class) 意思是指定回滚的异常，直接就指定了Exception。只要是Exception或者是E

小鱼儿/ 2022年05月11日 16:22/ 0 赞/ 333 阅读

相关 Spring事物

Spring事物基本原理（AOP）：对执行方法前后进行拦截，然后在目标方法开始之前创建或加入一个事物，在执行完目标方法之后，根据执行情况提交或者回滚事

「爱情、让人受尽委屈。」/ 2022年02月20日 05:37/ 0 赞/ 285 阅读

相关回眸Spring - 事物运行原理机制

Spring的事物是如何运作的? > 首先带着问题看源码: Spring的事物是通过哪些原理实现的? Spring的事物机制是如何提交和回滚的? > ==

た入场券/ 2021年08月12日 00:04/ 0 赞/ 379 阅读