关于spring事务传播行为引发的Transaction rolled back because it has been marked as rollback-only

偶尔博客闲逛发现有人讨论这个问题（我自己没有遇到过），翻了几个帖子没有几个讲清楚的，自己测试下吧

测试类：

package com.web.service;

import com.StudyApplication;
import com.web.service.i.TransactionalOuter;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = StudyApplication.class)
public class TransactionalTest {
    @Autowired
    private TransactionalOuter transactionalOuter;

    @Test
    public void testTransaction() {
        transactionalOuter.outerBusiness();
    }
}

外层业务类：

package com.web.service;

import com.web.service.i.TransactionalInner;
import com.web.service.i.TransactionalOuter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * @author zhaochao53
 * @date 2020/12/14 10:31
 * @desc
 */
@Service
public class TransactionalOuterImpl implements TransactionalOuter {

    @Autowired
    private TransactionalInner transactionalInner;

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void outerBusiness() {
        try {
            transactionalInner.innerBusiness();
        } catch (Exception e) {
            System.out.println("outer invoke inner  error " + e.getMessage());
        }
        int i = 1 / 1;
    }
}

内层业务类：

package com.web.service;

import com.web.service.i.TransactionalInner;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * @author zhaochao53
 * @date 2020/12/14 10:31
 * @desc
 */
@Service
public class TransactionalInnerImpl implements TransactionalInner {
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void innerBusiness() {
        int i = 1 / 0;
    }
}

在这种情况“同样Propagation.REQUIRED事务传播行为下，外部业务方法调用内部业务方法且对内部业务方法进行了try...catch”的时候会爆出这个错误 Transaction rolled back because it has been marked as rollback-only，为什么呢？

 

跟进源码：

在执行transactionalInner.innerBusiness()报错的时候，会进入经过

> org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction

> org.springframework.transaction.interceptor.TransactionAspectSupport#completeTransactionAfterThrowing

> org.springframework.transaction.PlatformTransactionManager#rollback

> org.springframework.transaction.support.AbstractPlatformTransactionManager#processRollback方法执行doSetRollbackOnly(status)方法

    private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
		try {
			boolean unexpectedRollback = unexpected;

			try {
				triggerBeforeCompletion(status);

				if (status.hasSavepoint()) {
					if (status.isDebug()) {
						logger.debug("Rolling back transaction to savepoint");
					}
					status.rollbackToHeldSavepoint();
				}
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction rollback");
					}
					doRollback(status);
				}
				else {
					// Participating in larger transaction
					if (status.hasTransaction()) {
						if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
							if (status.isDebug()) {
								logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
							}
                            // 执行设置回滚状态的方法
							doSetRollbackOnly(status);
						}
						else {
							if (status.isDebug()) {
								logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
							}
						}
					}
					else {
						logger.debug("Should roll back transaction but cannot - no transaction available");
					}
					// Unexpected rollback only matters here if we're asked to fail early
					if (!isFailEarlyOnGlobalRollbackOnly()) {
						unexpectedRollback = false;
					}
				}
			}
			catch (RuntimeException | Error ex) {
				triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
				throw ex;
			}

			triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

			// Raise UnexpectedRollbackException if we had a global rollback-only marker
			if (unexpectedRollback) {
				throw new UnexpectedRollbackException(
						"Transaction rolled back because it has been marked as rollback-only");
			}
		}
		finally {
			cleanupAfterCompletion(status);
		}
	}

最终调用到org.springframework.transaction.support.ResourceHolderSupport#setRollbackOnly方法将rollbackOnly置为true

    /**
	 * Mark the resource transaction as rollback-only.
	 */
	public void setRollbackOnly() {
		this.rollbackOnly = true;
	}

然后执行到外部方法，异常被catch住，外部outer任务没有异常，继续执行业务方法后，进行事物提交，调用到org.springframework.transaction.support.AbstractPlatformTransactionManager#commit方法

	/**
	 * This implementation of commit handles participating in existing
	 * transactions and programmatic rollback requests.
	 * Delegates to {@code isRollbackOnly}, {@code doCommit}
	 * and {@code rollback}.
	 * @see org.springframework.transaction.TransactionStatus#isRollbackOnly()
	 * @see #doCommit
	 * @see #rollback
	 */
	@Override
	public final void commit(TransactionStatus status) throws TransactionException {
		if (status.isCompleted()) {
			throw new IllegalTransactionStateException(
					"Transaction is already completed - do not call commit or rollback more than once per transaction");
		}

		DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
		if (defStatus.isLocalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Transactional code has requested rollback");
			}
			processRollback(defStatus, false);
			return;
		}

        // 这里由于上面已经设置了rollbackOnly为true，会调用进入下面代码块
		if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
			}
			processRollback(defStatus, true);
			return;
		}

		processCommit(defStatus);
	}

会调用processRollback(defStatus, true)方法，入参的unexpectedRollback值为true，但是当前的事物已经被设置为应该进行回滚，所以会报UnexpectedRollbackException异常。

 

原因：

        Propagation.REQUIRED事务传播行为下，inner与outer使用同一个事物，inner报错的时候已经将标记rollbackOnly置为true，outer在进行commit的时候才会报错。

解决方法：

        inner视业务场景修改为Propagation.REQUIRES_NEW 或 inner不加事物 或 outer在catch到exception之后打印日志在throw出去 或 outer不进行try...catch均可！