“Transaction rolled back because it has been marked as rollback-only”

spring的声明事务提供了强大功能,让我们把业务关注和非业务关注的东西又分离开了。好东西的使用,总是需要有代价的。使用声明事务的时候,一 个不小心经常会碰到“Transaction rolled back because it has been marked as rollback-only”这个异常。有时候又常常会纳闷,"我已经try-catch了,为什么还这样呢?"

Xml代码  

  1. <!-- 0 placeHolder -->
  2. <bean  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  3. <property name="locations">
  4. <list>
  5. <value>files/pro.properties</value>
  6. </list>
  7. </property>
  8. </bean>
  9. <!-- 1 dataSource -->
  10. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  11. <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  12. <property name="url" value="${jdbc.mysql.url}"></property>
  13. <property name="username" value="${jdbc.username}"></property>
  14. <property name="password" value="${jdbc.userpassword}"></property>
  15. </bean>
  16. <!-- 2 jdbcTemplate -->
  17. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  18. <property name="dataSource" ref="dataSource"></property>
  19. </bean>
  20. <!-- 3 BaseDao -->
  21. <bean id="baseDao" class="transaction.dao.BaseDao" abstract="true">
  22. <property name="jdbcTemplate" ref="jdbcTemplate" />
  23. </bean>
  24. <bean id="aDao" class="transaction.dao.Adao" parent="baseDao">
  25. </bean>
  26. <bean id="bDao" class="transaction.dao.Bdao" parent="baseDao">
  27. </bean>
  28. <!-- 4 service -->
  29. <bean id="aBo" class="transaction.bo.AboImpl">
  30. <property name="aDao" ref="aDao" />
  31. <property name="bBo" ref="bBo" />
  32. </bean>
  33. <bean id="bBo" class="transaction.bo.BboImpl">
  34. <property name="bDao" ref="bDao" />
  35. </bean>
  36. <!-- 5 transaction -->
  37. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  38. <property name="dataSource" ref="dataSource" />
  39. </bean>
  40. <bean id="transactionInterceptor1" class="org.springframework.transaction.interceptor.TransactionInterceptor" >
  41. <property name="transactionManager" ref="transactionManager"></property>
  42. <property name="transactionAttributes">
  43. <props>
  44. <prop key="*">PROPAGATION_REQUIRED</prop>
  45. </props>
  46. </property>
  47. </bean>
  48. <bean id="autoProxy1"  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  49. <property name="beanNames">
  50. <list>
  51. <value>*Bo</value>
  52. </list>
  53. </property>
  54. <property name="interceptorNames">
  55. <list>
  56. <!--
  57. <value>transactionInterceptor2</value>
  58. -->
  59. <value>transactionInterceptor1</value>
  60. </list>
  61. </property>
  62. </bean>

这里的声明事务是作用于所有以Bo为后缀的bean的所有方法上,使用REQUIRED传播方式。

Java代码  

  1. public int insertA(A a)
  2. {
  3. aDao.insertA(a);
  4. B b = new B();
  5. b.setName("bbb");
  6. try
  7. {
  8. bBo.insertB(b);
  9. }
  10. catch(Exception e)
  11. {
  12. System.out.println("aaa");
  13. }
  14. return 0;
  15. }

这里,insertA 开始一个事务,调用aDao.insertA(a)[一个简单的数据库操作],然后调用 bBo.insertB(b)[bo调dao,dao直接抛异常]。bBo的insertB方法,也要开始一个事务,但是这里的传播机制是 REQUIRED。OK,和insertA 的事务合二为一吧。因为bBo.insertB(b)会抛异常出来,这里try-catch下,希望aDao.insertA(a)的操作能够成功。

但是现实总是残酷的,这里会有一个大大的 “Transaction rolled back because it has been marked as rollback-only” ,结果你会发现aDao.insertA(a)的操作也没有成功。

try-catch不起作用的原因简单的说就是,try-catch的不是地方,你认为你的try-catch是最接近异常抛出点了,是第一个处理 的handler了。实际上,spring在更早一步就try-catch 住了,同时还设置了一些标志位,再把catch住的异常往外抛。这个时候才是我们的try-catch。而"Transaction rolled back because it has been marked as rollback-only"就是因为事务在提交的时候,发现标志位已经被设置了,不应该去提交了,然后吭哧吭哧的回滚调,再提示你已经被设置成 rollback-only了。

原因是既然如此,那么在不改变代码的情况下,依靠配置能否解决这个问题呢?使用PROPAGATION_REQUIRES_NEW吧。对于 bBo.insertB(b)开个新的事务,如果失败了就回滚调,不影响外面的insertA不就OK了。最简单的情况就是在 transactionInterceptor1前面,再加个拦截器transactionInterceptor2,该拦截器只针对insertB的事 务属性进行修改。

Xml代码  

  1. <bean id="autoProxy1"  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  2. <property name="beanNames">
  3. <list>
  4. <value>*Bo</value>
  5. </list>
  6. </property>
  7. <property name="interceptorNames">
  8. <list>
  9. <value>transactionInterceptor2</value>
  10. <value>transactionInterceptor1</value>
  11. </list>
  12. </property>
  13. </bean>
  14. <bean id="transactionInterceptor2" class="org.springframework.transaction.interceptor.TransactionInterceptor" >
  15. <property name="transactionManager" ref="transactionManager"></property>
  16. <property name="transactionAttributes">
  17. <props>
  18. <prop key="insertB">PROPAGATION_REQUIRES_NEW</prop>
  19. </props>
  20. </property>
  21. </bean>

注意interceptorNames里面元素的位置。先要使用transactionInterceptor2,再使用 transactionInterceptor1.因为调用insertB的时候,transactionInterceptor2先开了一个新事务,而 后transactionInterceptor1融合进这个事务。如果这2个拦截器的顺序颠倒的话,那么还是会出现“Transaction rolled back because it has been marked as rollback-only”。因为,transactionInterceptor2生成事务回滚以后,还是会把ex抛给 transactionInterceptor1。这个时候,transactionInterceptor1的事务和insertA的事务是同一个。 transactionInterceptor1,把标志设置好,等到insertA真的结束的时候,因为异常被我们的try-catch捕获 了,spring就会发现需要提交的事务具有一个已经被标记号的rollback。所以就又抛出来了。

但是如果系统有很多遗留的因素导致你不敢盲目的修改配置文件的话(比如事务的poincut),那么我们就再加一个事务proxy就OK了。

Xml代码  

  1. <bean id="autoProxy2" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  2. <property name="beanNames">
  3. <list>
  4. <value>*Bo</value>
  5. </list>
  6. </property>
  7. <property name="interceptorNames">
  8. <list>
  9. <value>transactionInterceptor2</value>
  10. <!--
  11. <value>transactionInterceptor1</value>
  12. -->
  13. </list>
  14. </property>
  15. </bean>
  16. <bean id="autoProxy1"  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  17. <property name="beanNames">
  18. <list>
  19. <value>*Bo</value>
  20. </list>
  21. </property>
  22. <property name="interceptorNames">
  23. <list>
  24. <value>transactionInterceptor1</value>
  25. <!--
  26. <value>transactionInterceptor2</value>
  27. -->
  28. </list>
  29. </property>
  30. </bean>

如上的配置还是会带来悲剧的“Transaction rolled back because it has been marked as rollback-only”。

但是如果我们把 autoProxy2 放到 autoProxy1 或者给自动代理加上顺序的话。。。结果就是喜剧了。。

Xml代码  

  1. <bean id="autoProxy1"  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  2. <property name="beanNames">
  3. <list>
  4. <value>*Bo</value>
  5. </list>
  6. </property>
  7. <property name="interceptorNames">
  8. <list>
  9. <value>transactionInterceptor1</value>
  10. <!--
  11. <value>transactionInterceptor2</value>
  12. -->
  13. </list>
  14. </property>
  15. </bean>
  16. <bean id="autoProxy2" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  17. <property name="beanNames">
  18. <list>
  19. <value>*Bo</value>
  20. </list>
  21. </property>
  22. <property name="interceptorNames">
  23. <list>
  24. <value>transactionInterceptor2</value>
  25. <!--
  26. <value>transactionInterceptor1</value>
  27. -->
  28. </list>
  29. </property>
  30. </bean>

造成这个原因是由使用了2个代理的顺序导致的。

在做自动代理的时候,spring会按照postBeanProcessor bean声明的顺序(如果没有设置顺序的话),来依次处理bean。如果autoProxy2 在 autoProxy1 之前,这样transactionInterceptor2 就会更加贴近insertB的调用,其效果就像

Xml代码  

  1. <bean id="autoProxy1"  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  2. <property name="beanNames">
  3. <list>
  4. <value>*Bo</value>
  5. </list>
  6. </property>
  7. <property name="interceptorNames">
  8. <list>
  9. <value>transactionInterceptor1</value>
  10. <value>transactionInterceptor2</value>
  11. </list>
  12. </property>
  13. </bean>

的配置。

看来~~~ spring 还是要注意bean的顺序啊,哈哈哈。。。

时间: 11-11

“Transaction rolled back because it has been marked as rollback-only”的相关文章

Spring事务嵌套抛异常org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only

在业务接口中,一个方法嵌套了另外一个方法,2个方法上都加了@Transactional事务注解. 业务接口: @Service public class TransactionalTestServiceImpl implements TransactionalTestService { @Autowired private TransactionalTestHandle transactionalTestHandle; @Override @Transactional public void f

SQL Anywhere(ASA) 数据库“File is shorter than expected -- transaction rolled back”错误修复

最近几天接了几个SqlAnywhere(ASA)数据库的修复,其中两个数据库都是报"File is shorter than expected -- transaction rolled back"错误,如图: 通过客户的描述,客户使用的是"珠宝首饰管理信息系统",在使用中突然死机,强制重启后,软件无法连接数据库,且数据库启动报错. 拿到数据库文件后(jewel.db),能过Winhex分析文件底层结构,发现文件结构有损坏,手工修正错误后,数据库正常启动,对数据库做

Spring Transaction属性之Propagation

Spring Transaction中有一个很重要的属性:Propagation.主要用来配置当前需要执行的方法,与当前是否有transaction之间的关系. 我晓得有点儿抽象,这也是为什么我想要写这篇博客的原因.看了后面的例子,大家应该就明白了. 一.Propagation取值: REQUIRED(默认值):在有transaction状态下执行:如当前没有transaction,则创建新的transaction: SUPPORTS:如当前有transaction,则在transaction状

spring事务声明的几种传播特性

最近遇到了一个spring事务导致的问题,所以写了几个小程序了解了一下事务的传播特性,下面分别举例子分别看看事务的传播特性. 事务的几种传播特性 1. PROPAGATION_REQUIRED: 如果存在一个事务,则支持当前事务.如果没有事务则开启 Java代码   /** * TransactionTestService     test1和test2配有事务(PROPAGATION_REQUIRED) */ public interface TransactionTestService {

Spring事务管理源码分析

Spring事务管理方式 依据Spring.xsd文件可以发现,Spring提供了advice,annotation-driven,jta-transaction-manager3种事务管理方式.详情可查看相应版本xsd文件.这里参照的版本是3.2.我们也只分析advice方式的源码,期望以此为突破口了解Spring事务管理的原理. Advice事务管理 XSD文件 我们先来看下xsd文件的配置 <xsd:element name="advice"> <xsd:com

spring管理的事务

之前对spring的事务传播机制没有概念,花点时间去看了事务的源码,以及这些事务传播机制使用的文档,在此做一下简单的笔记 正文 下面说提到的共享事务的意思就是几个service共用同一个事务,如传播机制Propagation.REQUIRED 从源码看AOP如何实现事务 我们想使用事务,那就得配置spring元数据,配置事务管理器以及aop的事务的切面,当然可以在spring的xml配置文件中配置,也可以使用注解,其结果是一样的. 在aop的切面中,配置了切点,IOC在读取元数据信息,进而装配,

Spring事务传递性探讨

本篇主要讨论下面几点获取[下载地址]  : 一: Spring 事务的传递性介绍 二: 第三方调用含有事务的Service抛异常方法探讨 一: Spring 事务的传递性介绍 事务传播行为,所谓事务的传播行为是指,如果在开始当前事务之前,一个事务上下文已经存在,此时有若干选项可以指定一个事务性方法的执行行为.在TransactionDefinition定义中包括了如下几个表示传播行为的常量: TransactionDefinition.PROPAGATION_REQUIRED:如果当前存在事务,

Oracle java.sql.SQLException: 数字溢出

六月 30, 2016 5:47:47 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions信息: Loading XML bean definitions from class path resource [org/springframework/jdbc/support/sql-error-codes.xml]六月 30, 2016 5:47:47 下午 org.springf

Spring 事务源码分析——Hibernate篇

在Spring与Hibernate整合的时候,可以利用Spring的事务管理机制,为我们管理事务的开启.提交.回滚等操作.这样的方式极大的减少了我们的代码量,让我们只专注于业务代码的编写.在使用Hibernate的时候,每一个操作都要经历事务开启与提交这样的操作,他们在业务代码的周围,这样来看是不是就想到了AOP编程,把这部分代码抽取出来.没错,Spring正是这样做的,Spring的事务管理就是基于AOP的. 1 Spring的事务隔离与传播 Srping的事务定义了五个隔离等级(isolat