spring事务报错Transaction rolled back because it has been marked as rollback-only

超、凢脫俗 2024-03-22 15:18 32阅读 0赞

之前经常报"Transaction rolled back because it has been marked as [rollback][]\-only"这个异常

字面意思是"[事务回滚][Link 1]了，因为它被标记了必须回滚"，最开始完全不懂事务的嵌套，每次出现这个错误都想知道为什么，但是总是不能重现，后面反复折腾终于弄明白了怎么回事。

之前不能重现的一个重要原因是：同一个类，内部方法调用不走代理，spring基于注解的事务是基于代理的，不走代理，被调用的方法就不受事务管理代码的控制，自然无法重现问题.

测试代码:

TestController

1.  `@Autowired`
2.  `TestRollbackService testRollbackService;`
3.  
4.  `@RequestMapping("/test1")`
5.  `public void test1(){`
6.  `try{`
7.  `testRollbackService.test1();`
8.  `}catch(Exception e){`
9.  `e.printStackTrace();`
10. `}`
11. `}`

TestRollbackServiceImpl

1.  `@Autowired`
2.  `StudentMapper studentMapper;`
3.  
4.  `@Autowired`
5.  `TestTransactionService testTransactionService;`
6.  
7.  `@Transactional(rollbackFor = Exception.class)`
8.  `public void test1(){`
9.  `Student studentSelect = new Student();`
10. `studentSelect.setId(new Long(1));`
11. `Student student = studentMapper.selectByPrimaryKey(studentSelect);`
12. `try{`
13. `testTransactionService.test2();`
14. `}catch(Exception e){`
15. `e.printStackTrace();`
16. `}`
17. `}`

![df0b6a49ea1a9ba1e81d2d06bb9c04f1.png][]

TestTransactionServiceImpl

1.  `@Autowired`
2.  `StudentMapper studentMapper;`
3.  
4.  `@Transactional(rollbackFor = Exception.class)`
5.  `public void test2(){`
6.  `Student studentForInsert = new Student();`
7.  `studentForInsert.setId(new Long(19));`
8.  `studentForInsert.setName("测试11");`
9.  `studentForInsert.setScore(new BigDecimal(69));`
10. `studentMapper.updateByPrimaryKey(studentForInsert);`
11. `System.out.println(1/0);`
12. `}`

TestRollbackService.test1(方法A)中调用了TestTransactionService.test2(方法B)，上述代码可以触发回滚异常的报错

两个方法都加了事务注解，并且两个方法都会受到到事务管理的拦截器增强，并且事务传播的方式都是默认的，也就是REQUIRED，当已经存在事务的时候就加入事务，没有就创建事务。这里A和B都受事务控制，并且是处于同一个事务的。

A调用B，A中抓了B的异常，当B发生异常的时候，B的操作应该回滚，但是A吃了异常，A方法中没有产生异常，所以A的操作又应该提交，二者是相互矛盾的。

spring的事务关联拦截器在抓到B的异常后就会标记rollback-only为true，当A执行完准备提交后，发现rollback-only为true，也会回滚，并抛出异常告诉调用者。

程序时序图如下:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDc4OTAz_size_16_color_FFFFFF_t_70][]

#### 1.程序入口 ####

程序入口肯定是代理类，这里走是cglib的代理

入口方法:

org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor\#intercept

该方法中

retVal = (new CglibAopProxy.CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy)).proceed();

继续调用

org.springframework.aop.framework.ReflectiveMethodInvocation\#proceed

然后到了事务管理的拦截器

org.springframework.transaction.interceptor.TransactionInterceptor\#invoke

1.  `@Nullable`
2.  `public Object invoke(MethodInvocation invocation) throws Throwable {`
3.  `Class<?> targetClass = invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null;`
4.  `Method var10001 = invocation.getMethod();`
5.  `invocation.getClass();`
6.  `return this.invokeWithinTransaction(var10001, targetClass, invocation::proceed);`
7.  `}`

#### 2.invokeWithinTransaction(事务管理的主方法) ####

1.  `@Nullable`
2.  `protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, TransactionAspectSupport.InvocationCallback invocation) throws Throwable {`
3.  `TransactionAttributeSource tas = this.getTransactionAttributeSource();`
4.  `TransactionAttribute txAttr = tas != null ? tas.getTransactionAttribute(method, targetClass) : null;`
5.  `PlatformTransactionManager tm = this.determineTransactionManager(txAttr);`
6.  `String joinpointIdentification = this.methodIdentification(method, targetClass, txAttr);`
7.  `Object result;`
8.  `if (txAttr != null && tm instanceof CallbackPreferringPlatformTransactionManager) {`
9.  `TransactionAspectSupport.ThrowableHolder throwableHolder = new TransactionAspectSupport.ThrowableHolder();`
10. 
11. `try {`
12. `result = ((CallbackPreferringPlatformTransactionManager)tm).execute(txAttr, (status) -> {`
13. `TransactionAspectSupport.TransactionInfo txInfo = this.prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);`
14. 
15. `Object var9;`
16. `try {`
17. `Object var8 = invocation.proceedWithInvocation();`
18. `return var8;`
19. `} catch (Throwable var13) {`
20. `if (txAttr.rollbackOn(var13)) {`
21. `if (var13 instanceof RuntimeException) {`
22. `throw (RuntimeException)var13;`
23. `}`
24. 
25. `throw new TransactionAspectSupport.ThrowableHolderException(var13);`
26. `}`
27. 
28. `throwableHolder.throwable = var13;`
29. `var9 = null;`
30. `} finally {`
31. `this.cleanupTransactionInfo(txInfo);`
32. `}`
33. 
34. `return var9;`
35. `});`
36. `if (throwableHolder.throwable != null) {`
37. `throw throwableHolder.throwable;`
38. `} else {`
39. `return result;`
40. `}`
41. `} catch (TransactionAspectSupport.ThrowableHolderException var19) {`
42. `throw var19.getCause();`
43. `} catch (TransactionSystemException var20) {`
44. `if (throwableHolder.throwable != null) {`
45. `this.logger.error("Application exception overridden by commit exception", throwableHolder.throwable);`
46. `var20.initApplicationException(throwableHolder.throwable);`
47. `}`
48. 
49. `throw var20;`
50. `} catch (Throwable var21) {`
51. `if (throwableHolder.throwable != null) {`
52. `this.logger.error("Application exception overridden by commit exception", throwableHolder.throwable);`
53. `}`
54. 
55. `throw var21;`
56. `}`
57. `} else {`
58. `TransactionAspectSupport.TransactionInfo txInfo = this.createTransactionIfNecessary(tm, txAttr, joinpointIdentification);`
59. `result = null;`
60. 
61. `try {`
62. `result = invocation.proceedWithInvocation();`
63. `} catch (Throwable var17) {`
64. `this.completeTransactionAfterThrowing(txInfo, var17);`
65. `throw var17;`
66. `} finally {`
67. `this.cleanupTransactionInfo(txInfo);`
68. `}`
69. 
70. `this.commitTransactionAfterReturning(txInfo);`
71. `return result;`
72. `}`
73. `}`

![aeffac152b220d0b81978cde68b61d35.png][]

程序执行的是最后的else分支，步骤很清晰

1.获取 TransactionAttribute

2.基于TransactionAttribute获取TransactionManager

3.基于TransactionAttribute获取 joinpointIdentification(没研究什么作用)

4. 基于1,2,3创建的对象获取 TransactionAspectSupport.TransactionInfo，transactionInfo是TransactionAspectSupport的一个内部类

5.执行业务方法

6.抓到异常就回滚，并清除事务，然后向上抛异常；没有异常就清除事务，然后提交

对象之间的关联关系

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDc4OTAz_size_16_color_FFFFFF_t_70 1][]

#### 3.各个对象的获取 ####

TransactionManager的获取比较简单，程序里获取到的其实就是自己配置的bean

创建TransactionInfo的过程中要先获取TransactionStatus，TransactionStatus又需要拿到ConnectionHolder

**3.1 createTransactionIfNecessary**

*org.springframework.transaction.interceptor.TransactionAspectSupport\#createTransactionIfNecessary*

1.  `protected TransactionAspectSupport.TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm, @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {`
2.  `if (txAttr != null && ((TransactionAttribute)txAttr).getName() == null) {`
3.  `txAttr = new DelegatingTransactionAttribute((TransactionAttribute)txAttr) {`
4.  `public String getName() {`
5.  `return joinpointIdentification;`
6.  `}`
7.  `};`
8.  `}`
9.  
10. `TransactionStatus status = null;`
11. `if (txAttr != null) {`
12. `if (tm != null) {`
13. `status = tm.getTransaction((TransactionDefinition)txAttr);`
14. `} else if (this.logger.isDebugEnabled()) {`
15. `this.logger.debug("Skipping transactional joinpoint [" + joinpointIdentification + "] because no transaction manager has been configured");`
16. `}`
17. `}`
18. 
19. `return this.prepareTransactionInfo(tm, (TransactionAttribute)txAttr, joinpointIdentification, status);`
20. `}`

![913967c20a49fe5ad3bb9016e1057511.png][]

**3.2 获取TransactionStatus**

这里先调用 status = tm.getTransaction((TransactionDefinition)txAttr) 创建TransactionStatus

*org.springframework.transaction.support.AbstractPlatformTransactionManager\#getTransaction*

1.  `public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {`
2.  `Object transaction = this.doGetTransaction();`
3.  `boolean debugEnabled = this.logger.isDebugEnabled();`
4.  `if (definition == null) {`
5.  `definition = new DefaultTransactionDefinition();`
6.  `}`
7.  
8.  `if (this.isExistingTransaction(transaction)) {`
9.  `return this.handleExistingTransaction((TransactionDefinition)definition, transaction, debugEnabled);`
10. `} else if (((TransactionDefinition)definition).getTimeout() < -1) {`
11. `throw new InvalidTimeoutException("Invalid transaction timeout", ((TransactionDefinition)definition).getTimeout());`
12. `} else if (((TransactionDefinition)definition).getPropagationBehavior() == 2) {`
13. `throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");`
14. `} else if (((TransactionDefinition)definition).getPropagationBehavior() != 0 && ((TransactionDefinition)definition).getPropagationBehavior() != 3 && ((TransactionDefinition)definition).getPropagationBehavior() != 6) {`
15. `if (((TransactionDefinition)definition).getIsolationLevel() != -1 && this.logger.isWarnEnabled()) {`
16. `this.logger.warn("Custom isolation level specified but no actual transaction initiated; isolation level will effectively be ignored: " + definition);`
17. `}`
18. 
19. `boolean newSynchronization = this.getTransactionSynchronization() == 0;`
20. `return this.prepareTransactionStatus((TransactionDefinition)definition, (Object)null, true, newSynchronization, debugEnabled, (Object)null);`
21. `} else {`
22. `AbstractPlatformTransactionManager.SuspendedResourcesHolder suspendedResources = this.suspend((Object)null);`
23. `if (debugEnabled) {`
24. `this.logger.debug("Creating new transaction with name [" + ((TransactionDefinition)definition).getName() + "]: " + definition);`
25. `}`
26. 
27. `try {`
28. `boolean newSynchronization = this.getTransactionSynchronization() != 2;`
29. `DefaultTransactionStatus status = this.newTransactionStatus((TransactionDefinition)definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);`
30. `this.doBegin(transaction, (TransactionDefinition)definition);`
31. `this.prepareSynchronization(status, (TransactionDefinition)definition);`
32. `return status;`
33. `} catch (Error | RuntimeException var7) {`
34. `this.resume((Object)null, suspendedResources);`
35. `throw var7;`
36. `}`
37. `}`
38. `}`

![323f97fb95ba69330365de8e9b5aec74.png][]

**3.3 获取transactionStatus前先获取DataSourceTransactionObject**

程序最上面: Object transaction = this.doGetTransaction();　创建DataSourceTransactionObject对象，这是DataSourceTransactionManager的内部类

*org.springframework.jdbc.datasource.DataSourceTransactionManager\#doGetTransaction*

1.  `protected Object doGetTransaction() {`
2.  `DataSourceTransactionManager.DataSourceTransactionObject txObject = new DataSourceTransactionManager.DataSourceTransactionObject();`
3.  `txObject.setSavepointAllowed(this.isNestedTransactionAllowed());`
4.  `ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.obtainDataSource());`
5.  `txObject.setConnectionHolder(conHolder, false);`
6.  `return txObject;`
7.  `}`

这里还获取了ConnectionHolder对象，这里newConnectionHolder为false

获取的方法如下:

*org.springframework.transaction.support.TransactionSynchronizationManager\#getResource*

1.  `@Nullable`
2.  `public static Object getResource(Object key) {`
3.  `Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);`
4.  `Object value = doGetResource(actualKey);`
5.  `if (value != null && logger.isTraceEnabled()) {`
6.  `logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");`
7.  `}`
8.  `return value;`
9.  `}`

看代码很有意思，好像是通过一个key获取的，类似于从一个池子里面拿东西一样，其实当A方法执行的时候并没有获取到ConnectionHolder，拿到的是null

*org.springframework.transaction.support.TransactionSynchronizationManager\#doGetResource*

1.  `private static Object doGetResource(Object actualKey) {`
2.  `Map<Object, Object> map = (Map)resources.get();`
3.  `if (map == null) {`
4.  `return null;`
5.  `} else {`
6.  `Object value = map.get(actualKey);`
7.  `if (value instanceof ResourceHolder && ((ResourceHolder)value).isVoid()) {`
8.  `map.remove(actualKey);`
9.  `if (map.isEmpty()) {`
10. `resources.remove();`
11. `}`
12. 
13. `value = null;`
14. `}`
15. 
16. `return value;`
17. `}`
18. `}`

![b5824079c84798ab3a5df8a4f3eb626a.png][]

resources对象其实是一个ThreadLocal，意思是同一个线程中拿到的ConnectionHolder是相同的

**3.3 doBegin方法**

*org.springframework.jdbc.datasource.DataSourceTransactionManager\#doBegin*

1.  `protected void doBegin(Object transaction, TransactionDefinition definition) {`
2.  `DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)transaction;`
3.  `Connection con = null;`
4.  
5.  `try {`
6.  `if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {`
7.  `Connection newCon = this.obtainDataSource().getConnection();`
8.  `if (this.logger.isDebugEnabled()) {`
9.  `this.logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");`
10. `}`
11. 
12. `txObject.setConnectionHolder(new ConnectionHolder(newCon), true);`
13. `}`
14. 
15. `txObject.getConnectionHolder().setSynchronizedWithTransaction(true);`
16. `con = txObject.getConnectionHolder().getConnection();`
17. `Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);`
18. `txObject.setPreviousIsolationLevel(previousIsolationLevel);`
19. `if (con.getAutoCommit()) {`
20. `txObject.setMustRestoreAutoCommit(true);`
21. `if (this.logger.isDebugEnabled()) {`
22. `this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit");`
23. `}`
24. 
25. `con.setAutoCommit(false);`
26. `}`
27. 
28. `this.prepareTransactionalConnection(con, definition);`
29. `txObject.getConnectionHolder().setTransactionActive(true);`
30. `int timeout = this.determineTimeout(definition);`
31. `if (timeout != -1) {`
32. `txObject.getConnectionHolder().setTimeoutInSeconds(timeout);`
33. `}`
34. 
35. `if (txObject.isNewConnectionHolder()) {`
36. `TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder());`
37. `}`
38. 
39. `} catch (Throwable var7) {`
40. `if (txObject.isNewConnectionHolder()) {`
41. `DataSourceUtils.releaseConnection(con, this.obtainDataSource());`
42. `txObject.setConnectionHolder((ConnectionHolder)null, false);`
43. `}`
44. 
45. `throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", var7);`
46. `}`
47. `}`

![87a48eb4d43826a8b7dfff569c7b5e6e.png][]

截取该方法的重要几行:

1.  `Connection newCon = this.obtainDataSource().getConnection();`
2.  `if (this.logger.isDebugEnabled()) {`
3.  `this.logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");`
4.  `}`
5.  
6.  `txObject.setConnectionHolder(new ConnectionHolder(newCon), true);`

先获取连接(java.sql.Connection)，然后创建ConnectionHolder，*newConnectionHolder设置为true，如果之前已经不为空了,newConnectionHolder就为false*

*如果newConnectionHolder 为 true，还需要将 connectionHolder放到threadLocal里面，让后面的方法可以获取到相同的ConnectionHolder*，截取的代码如下:

1.  `if (txObject.isNewConnectionHolder()) {`
2.  `TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder());`
3.  `}`

到这里TransactionStatus就创建好了

**3.3 获取TransactionInfo**

*org.springframework.transaction.interceptor.TransactionAspectSupport\#prepareTransactionInfo*

1.  `protected TransactionAspectSupport.TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm, @Nullable TransactionAttribute txAttr, String joinpointIdentification, @Nullable TransactionStatus status) {`
2.  `TransactionAspectSupport.TransactionInfo txInfo = new TransactionAspectSupport.TransactionInfo(tm, txAttr, joinpointIdentification);`
3.  `if (txAttr != null) {`
4.  `if (this.logger.isTraceEnabled()) {`
5.  `this.logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");`
6.  `}`
7.  
8.  `txInfo.newTransactionStatus(status);`
9.  `} else if (this.logger.isTraceEnabled()) {`
10. `this.logger.trace("Don't need to create transaction for [" + joinpointIdentification + "]: This method isn't transactional.");`
11. `}`
12. 
13. `txInfo.bindToThread();`
14. `return txInfo;`
15. `}`

![608a10a14152c4496c24c600973612e9.png][]

细看 txInfo.bindToThread();

*org.springframework.transaction.interceptor.TransactionAspectSupport.TransactionInfo\#bindToThread*

1.  `private void bindToThread() {`
2.  `this.oldTransactionInfo = (TransactionAspectSupport.TransactionInfo)TransactionAspectSupport.transactionInfoHolder.get();`
3.  `TransactionAspectSupport.transactionInfoHolder.set(this);`
4.  `}`

*java.lang.ThreadLocal\#get*

1.  `public T get() {`
2.  `Thread t = Thread.currentThread();`
3.  `ThreadLocalMap map = getMap(t);`
4.  `if (map != null) {`
5.  `ThreadLocalMap.Entry e = map.getEntry(this);`
6.  `if (e != null) {`
7.  `@SuppressWarnings("unchecked")`
8.  `T result = (T)e.value;`
9.  `return result;`
10. `}`
11. `}`
12. `return setInitialValue();`
13. `}`

bindToThread()的的作用是获取oldTransactionInfo，还有线程有关(具体原理未知)

#### ４.B方法抛异常后的回滚操作 ####

*org.springframework.transaction.interceptor.TransactionAspectSupport\#completeTransactionAfterThrowing*

1.  `protected void completeTransactionAfterThrowing(@Nullable TransactionAspectSupport.TransactionInfo txInfo, Throwable ex) {`
2.  `if (txInfo != null && txInfo.getTransactionStatus() != null) {`
3.  `if (this.logger.isTraceEnabled()) {`
4.  `this.logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "] after exception: " + ex);`
5.  `}`
6.  
7.  `if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {`
8.  `try {`
9.  `txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());`
10. `} catch (TransactionSystemException var6) {`
11. `this.logger.error("Application exception overridden by rollback exception", ex);`
12. `var6.initApplicationException(ex);`
13. `throw var6;`
14. `} catch (Error | RuntimeException var7) {`
15. `this.logger.error("Application exception overridden by rollback exception", ex);`
16. `throw var7;`
17. `}`
18. `} else {`
19. `try {`
20. `txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());`
21. `} catch (TransactionSystemException var4) {`
22. `this.logger.error("Application exception overridden by commit exception", ex);`
23. `var4.initApplicationException(ex);`
24. `throw var4;`
25. `} catch (Error | RuntimeException var5) {`
26. `this.logger.error("Application exception overridden by commit exception", ex);`
27. `throw var5;`
28. `}`
29. `}`
30. `}`
31. 
32. `}`

![913967c20a49fe5ad3bb9016e1057511.png][]

txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());调用transactionManager进行rollback

*org.springframework.transaction.support.AbstractPlatformTransactionManager\#rollback*

1.  `public final void rollback(TransactionStatus status) throws TransactionException {`
2.  `if (status.isCompleted()) {`
3.  `throw new IllegalTransactionStateException("Transaction is already completed - do not call commit or rollback more than once per transaction");`
4.  `} else {`
5.  `DefaultTransactionStatus defStatus = (DefaultTransactionStatus)status;`
6.  `this.processRollback(defStatus, false);`
7.  `}`
8.  `}`

进一步调自身的processRollback

org.springframework.transaction.support.AbstractPlatformTransactionManager\#processRollback

1.  `private void processRollback(DefaultTransactionStatus status, boolean unexpected) {`
2.  `try {`
3.  `boolean unexpectedRollback = unexpected;`
4.  
5.  `try {`
6.  `this.triggerBeforeCompletion(status);`
7.  `if (status.hasSavepoint()) {`
8.  `if (status.isDebug()) {`
9.  `this.logger.debug("Rolling back transaction to savepoint");`
10. `}`
11. 
12. `status.rollbackToHeldSavepoint();`
13. `} else if (status.isNewTransaction()) {`
14. `if (status.isDebug()) {`
15. `this.logger.debug("Initiating transaction rollback");`
16. `}`
17. 
18. `this.doRollback(status);`
19. `} else {`
20. `if (status.hasTransaction()) {`
21. `if (!status.isLocalRollbackOnly() && !this.isGlobalRollbackOnParticipationFailure()) {`
22. `if (status.isDebug()) {`
23. `this.logger.debug("Participating transaction failed - letting transaction originator decide on rollback");`
24. `}`
25. `} else {`
26. `if (status.isDebug()) {`
27. `this.logger.debug("Participating transaction failed - marking existing transaction as rollback-only");`
28. `}`
29. 
30. `this.doSetRollbackOnly(status);`
31. `}`
32. `} else {`
33. `this.logger.debug("Should roll back transaction but cannot - no transaction available");`
34. `}`
35. 
36. `if (!this.isFailEarlyOnGlobalRollbackOnly()) {`
37. `unexpectedRollback = false;`
38. `}`
39. `}`
40. `} catch (Error | RuntimeException var8) {`
41. `this.triggerAfterCompletion(status, 2);`
42. `throw var8;`
43. `}`
44. 
45. `this.triggerAfterCompletion(status, 1);`
46. `if (unexpectedRollback) {`
47. `throw new UnexpectedRollbackException("Transaction rolled back because it has been marked as rollback-only");`
48. `}`
49. `} finally {`
50. `this.cleanupAfterCompletion(status);`
51. `}`
52. 
53. `}`

![64842c825de9f260db901f99ed014da2.png][]

this.triggerBeforeCompletion(status)　这个方法好像释放了连接

B不是新事务，所以最后会执行 this.doSetRollbackOnly(status);

*org.springframework.jdbc.datasource.DataSourceTransactionManager\#doSetRollbackOnly*

1.  `protected void doSetRollbackOnly(DefaultTransactionStatus status) {`
2.  `DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)status.getTransaction();`
3.  `if (status.isDebug()) {`
4.  `this.logger.debug("Setting JDBC transaction [" + txObject.getConnectionHolder().getConnection() + "] rollback-only");`
5.  `}`
6.  
7.  `txObject.setRollbackOnly();`
8.  `}`

*org.springframework.jdbc.datasource.DataSourceTransactionManager.DataSourceTransactionObject\#setRollbackOnly*

1.  `public void setRollbackOnly() {`
2.  `this.getConnectionHolder().setRollbackOnly();`
3.  `}`

*这里可以看到最终设置的是connectionHolder的rollbackonly属性*

#### 5.A方法尝试提交时的操作 ####

*org.springframework.transaction.interceptor.TransactionAspectSupport\#commitTransactionAfterReturning*

1.  `protected void commitTransactionAfterReturning(@Nullable TransactionAspectSupport.TransactionInfo txInfo) {`
2.  `if (txInfo != null && txInfo.getTransactionStatus() != null) {`
3.  `if (this.logger.isTraceEnabled()) {`
4.  `this.logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");`
5.  `}`
6.  
7.  `txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());`
8.  `}`
9.  
10. `}`

同样的，这里调用transactionManager进行提交

*org.springframework.transaction.support.AbstractPlatformTransactionManager\#commit*

1.  `public final void commit(TransactionStatus status) throws TransactionException {`
2.  `if (status.isCompleted()) {`
3.  `throw new IllegalTransactionStateException("Transaction is already completed - do not call commit or rollback more than once per transaction");`
4.  `} else {`
5.  `DefaultTransactionStatus defStatus = (DefaultTransactionStatus)status;`
6.  `if (defStatus.isLocalRollbackOnly()) {`
7.  `if (defStatus.isDebug()) {`
8.  `this.logger.debug("Transactional code has requested rollback");`
9.  `}`
10. 
11. `this.processRollback(defStatus, false);`
12. `} else if (!this.shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {`
13. `if (defStatus.isDebug()) {`
14. `this.logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");`
15. `}`
16. 
17. `this.processRollback(defStatus, true);`
18. `} else {`
19. `this.processCommit(defStatus);`
20. `}`
21. `}`
22. `}`

![87a48eb4d43826a8b7dfff569c7b5e6e.png][]

这个方法判断了一些无法提交的情况，程序这里走第二个分支，部分代码如下:

1.  `else if (!this.shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {`
2.  `if (defStatus.isDebug()) {`
3.  `this.logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");`
4.  `}`
5.  
6.  `this.processRollback(defStatus, true);`
7.  `}`

判断条件为:

1.全局不是rollbackonly的时候也提交(这个可能是一个配置的参数，配合在rollbackonly的时候也提交，也就是出现现在这种情况后，不用回滚，直接提交)

2.并且全局是rollbackonly

org.springframework.transaction.support.DefaultTransactionStatus\#isGlobalRollbackOnly

1.  `public boolean isGlobalRollbackOnly() {`
2.  `return this.transaction instanceof SmartTransactionObject && ((SmartTransactionObject)this.transaction).isRollbackOnly();`
3.  `}`

这里又要满足两个条件

1 .这里的transaction是DataSourceTransactionObject

DataSourceTransaction继承 JdbcTransactionObjectSupport

JdbcTransactionObjectSupport又实现 SmartTransactionObject，所以第一个条件满足

2. DatSourceTransactionObject的 RollbackOnly 的get和set方法如下

1.  `public void setRollbackOnly() {`
2.  `this.getConnectionHolder().setRollbackOnly();`
3.  `}`
4.  
5.  `public boolean isRollbackOnly() {`
6.  `return this.getConnectionHolder().isRollbackOnly();`
7.  `}`

之前B方法抛出异常的时候，就是调用的DataSourceTransactionObject的set方法设置rollbackonly为true，现在再用get方法获取，只要是同一个connectionHolder，A获取到的rollbackOnly就是true，就会触发回滚，执行 this.processRollback(defStatus, true);

*org.springframework.transaction.support.AbstractPlatformTransactionManager\#processRollback*

![2fdca4454be2e2255cee7e92330274f9.png][]

到这里 unexpectedRollback为true，就抛出了 "Transaction rolled back because it has been marked as rollback-only"这个异常了。

解决方案  
原场景，内层事务的异常被外层事务捕获，内层被标记rollback，而外层提交，最后事务提交校验时抛出Transaction rolled back because it has been marked as rollback-only异常

@Transactional(rollbackFor = Exception.class)
    public void methodA(){
        insert();
        System.out.println(1 / 0);
    }
    
    @Transactional(rollbackFor = Exception.class)
    public void methodB(){
        try{
            methodA();
        }catch(Exception e){
            System.out.println("有异常");
        }
    }

可以分两种情况来解决这个异常  
如果我们需要内层异常的情况下，回滚整个事务，可以让内层事务抛出的异常被外层事务的try----catch处理，再抛出新的异常，或者外层不通过try—catch处理这个异常。  
当然如果内层事务没有复用过，只是在这个地方使用，直接把内层的事务去了，让他和外层合并成一个事务也能解决这个问题。

@Transactional(rollbackFor = Exception.class)
    public void methodA(){
        System.out.println(1 / 0);
    }
    
    @Transactional(rollbackFor = Exception.class)
    public void methodB(){
        try{
            insert();
            methodA();
        }catch(Exception e){
            throw new Exception("存在异常")
        }
    }

如果内层事务异常的情况下只回滚内层事务，修改内层事务的事务传播方式

@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    public void methodA(){
        System.out.println(1 / 0);
    }
    
    @Transactional(rollbackFor = Exception.class)
    public void methodB(){
        try{
            insert();
            methodA();
        }catch(Exception e){
            System.out.println("有异常");
        }
    }

[rollback]: https://so.csdn.net/so/search?q=rollback&spm=1001.2101.3001.7020
[Link 1]: https://so.csdn.net/so/search?q=%E4%BA%8B%E5%8A%A1%E5%9B%9E%E6%BB%9A&spm=1001.2101.3001.7020
[df0b6a49ea1a9ba1e81d2d06bb9c04f1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/aa52f13c66394d4b8028c5d4ce939871.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDc4OTAz_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/838284075c80445086fbebcc69b00c19.png
[aeffac152b220d0b81978cde68b61d35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ee1c4ba7d26d489b9e4ba671c3458f3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDc4OTAz_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/db53eac5a75e4ac1bf286b5a1c1f8ad7.png
[913967c20a49fe5ad3bb9016e1057511.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a419bb73cba742229b260854a7d1a254.png
[323f97fb95ba69330365de8e9b5aec74.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/f6016e40a8e74a74b114e26f3f161165.png
[b5824079c84798ab3a5df8a4f3eb626a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/bdfa6728cd26406fbf732a83fb9ea418.png
[87a48eb4d43826a8b7dfff569c7b5e6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c89fbcdbef0b4570ad94feaea5fddb99.png
[608a10a14152c4496c24c600973612e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/50b9392e28cc443fbb021168a0a3a3e8.png
[64842c825de9f260db901f99ed014da2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a9fa8a1cfda049869b320227ce7a89b1.png
[2fdca4454be2e2255cee7e92330274f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/de17809d7c324453b84db6bd732b2167.png