偶尔博客闲逛发现有人讨论这个问题（我自己没有遇到过），翻了几个帖子没有几个讲清楚的，自己测试下吧
测试类：
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均可！
