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

1、线上环境对roll back only 的处理

2、线上环境对嵌套事务的解决方案

3、11个demo分析事务失效的场景

4、分布式事务

5、事务也能异步

org.springframework.dao.CannotAcquireLockException: 
### Error updating database.  Cause: com.mysql.cj.jdbc.exceptions.MySQLTransactionRollbackException: Lock wait timeout exceeded; try restarting transaction
### The error may involve xxxMapper.insert-Inline
### The error occurred while setting parameters
### SQL: INSERT INTO xxx
### Cause: com.mysql.cj.jdbc.exceptions.MySQLTransactionRollbackException: Lock wait timeout exceeded; try restarting transaction
; Lock wait timeout exceeded; try restarting transaction; nested exception is com.mysql.cj.jdbc.exceptions.MySQLTransactionRollbackException: Lock wait timeout exceeded; try restarting transaction

@timestamp September 1st 2021, 10:20:24.637
# @version  1
t LOG_DATEFORMAT_PATTERN    yyyy-MM-dd HH:mm:ss.SSS
t LOG_LEVEL_PATTERN %5p
t _id   VMaG
t _index    applog-2021.09.01
# _score    1
t _type doc
t appindex  applog
t appname   app
t host  10.0.74.157
t level ERROR
# level_value   40,000
t logger_name   ExceptionLogCollector
t message   未知异常[500] => Transaction rolled back because it has been marked as rollback-only
# port  10,792
t stack_trace   org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only
at org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback(AbstractPlatformTransactionManager.java:873) ~[spring-tx-5.1.4.RELEASE.jar!/:5.1.4.RELEASE]
at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:710) ~[spring-tx-5.1.4.RELEASE.jar!/:5.1.4.RELEASE]
at org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:533) ~[spring-tx-5.1.4.RELEASE.jar!/:5.1.4.RELEASE]
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:304) ~[spring-tx-5.1.4.RELEASE.jar!/:5.1.4.RELEASE]
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:98) ~[spring-tx-5.1.4.RELEASE.jar!/:5.1.4.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.1.4.RELEASE.jar!/:5.1.4.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:688) ~[spring-aop-5.1.4.RELEASE.jar!/:5.1.4.RELEASE]
spring-tx-5.1.4.RELEASE.jar-
org.springframework.transaction.interceptor.TransactionInterceptor#事务拦截器
avatar

@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
            final InvocationCallback invocation) throws Throwable
方法为protected的，根据源代码注释解析

@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;
        }

        if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
            if (defStatus.isDebug()) {
                logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
            }
            日志追踪的710行-----记住此处传true
            processRollback(defStatus, true);
            return;
        }

        processCommit(defStatus);
    }


private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
        try {
            入参为true
            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);
            日志追踪的873行  抛出异常
            // 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);
        }
    }

try

    {
        methodA()
    }catch

    {
    }

    @Transactional(rollbackFor = Exception.class)
    public methodA() {
        methodB()
    }

    @Transactional(rollbackFor = Exception.class)
    public methodB() {
        try {
            methodC()
        } catch {
        }
    }

    methodC() {
        当C方法抛出异常时
    }

@Slf4j
@Service
public class DemoService {

	@Autowired
	private Test1Mapper test1Mapper;
	
	@Autowired
	private TestMapper testMapper;
	
	@Autowired
	private InvalidTransactionService invalidTransactionService;
	
	@Autowired
	private ExecutorService executorService;
	
	@Autowired
	private DemoService _self;
	
	@Autowired
	private ValidTransactionService validTransactionService;
	
	@Autowired
	private RequireNewTransactionService requireNewTransactionService;
	
	/********************************************************
	 * 事务不生效场景1
	 * 相当于调用this调用，没有产生代理对象调用，解决方法，自己把自己注入以后调用
	 ********************************************************/
	public void demo1() {

		invalidTransaction();
		
		//TODO other logic code here
	}
	
	@Transactional
	public void invalidTransaction() {
		TestDO test = new TestDO();
		test.setName("11111");
		testMapper.insert(test);
		
		Test1DO test1 = new Test1DO();
		test1.setCust("2222");
		test1Mapper.insert(test1);
		throw new WMSException(ErrorCodeEnum.BD10001001.code(),"事务不生效场景1");
	}
	
	/********************************************************
	 * 事务不生效场景二
	 * 这个例子的目的是为了catch住内层事务的异常，让外层事务成功，但是实际上没有内外层事务都回滚了
	 *
	 * 这里A和B都受事务控制，并且是处于同一个事务的。
	 * A调用B，A中抓了B的异常，当B发生异常的时候，B的操作应该回滚，但是A吃了异常，A方法中没有产生异常，所以A的操作又应该提交，二者是相互矛盾的。
	 * spring的事务关联拦截器在抓到B的异常后就会标记rollback-only为true，当A执行完准备提交后，发现rollback-only为true，也会回滚，并抛出异常告诉调用者。
	 *
	 * 报错提示：Transaction rolled back because it has been marked as rollback-only
	 *
	 * 如果想使外层事务生效可以把内层事务传播特性修改为：@Transactional(propagation = Propagation.REQUIRES_NEW)
	 * 
	 ********************************************************/
	@Transactional
	public void demo2() {
		TestDO test = new TestDO();
		test.setName("3333");
		testMapper.insert(test);
		try {
			invalidTransactionService.transaction();
		}catch (Exception e) {
			log.error("服务异常，异常被捕获", e);
		}
	}
	
	/********************************************************
	 * 事务不生效场景三
	 *
	 * 因为开了线程异步执行，等于事务完全在两个线程内，不在一个线程，所以即使抛错，也是一个生效一个不生效，
	 * 事务没有回滚
	 * 
	 ********************************************************/
	@Transactional
	public void demo3() {
		TestDO test = new TestDO();
		test.setName("5555");
		testMapper.insert(test);
		
		executorService.execute(() -> {
			Test1DO test1 = new Test1DO();
			test1.setCust("6666");
			test1Mapper.insert(test1);
		});
		
		throw new WMSException(ErrorCodeEnum.BD10001001.code(),"事务不生效场景3");
	}
	
	/********************************************************
	 * 事务不生效场景八
	 * Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这个例外是unchecked，如果遇到checked意外就不回滚。
	 * Exception包含RuntimeException体系和其他非RuntimeException的体系
	 * Error和RuntimeException及其子类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。
	 * spring声明式事务管理默认对非检查型异常和运行时异常进行事务回滚，而对检查型异常则不进行回滚操作
	 *
	 *
	 *那么什么是检查型异常什么又是非检查型异常呢？
	 * 1.继承自runtimeexception或error的是非检查型异常，而继承自exception的则是检查型异常（当然，runtimeexception本身也是exception的子类）。
	 * 2.对非检查型类异常可以不用捕获，而检查型异常则必须用try语句块进行处理或者把异常交给上级方法处理总之就是必须写代码处理它。所以必须在service捕获异常，然后再次抛出，这样事务方才起效。
	 *
	 * @throws IOException 
	 * 
	 ********************************************************/
	@Transactional
	public void demo8() throws IOException {
		TestDO test = new TestDO();
		test.setName("11111");
		testMapper.insert(test);
		
		Test1DO test1 = new Test1DO();
		test1.setCust("2222");
		test1Mapper.insert(test1);
		throw new IOException("事务不生效场景8");
	}
	
	/********************************************************
	 * 事务不生效场景九
	 * @throws IOException 
	 * 
	 ********************************************************/
	
	public void demo9(){
		invalidTransaction2();
	}
	
	@Transactional
	private void invalidTransaction2() {
		TestDO test = new TestDO();
		test.setName("11111");
		testMapper.insert(test);
		
		Test1DO test1 = new Test1DO();
		test1.setCust("2222");
		test1Mapper.insert(test1);
		throw new WMSException("事务不生效场景9");
	}
	
	/********************************************************
	 * 事务生效场景1
	 * 
	 ********************************************************/
	public void demo4() {
		
		_self.invalidTransaction();
		
		//TODO other logic code here
	}
	
	/********************************************************
	 * 事务生效场景二
	 *
	 * 因为内层没有事务控制，所以内层报错，不会混回滚，同样外层catch住，所以外层业务成功
	 ********************************************************/
	@Transactional
	public void demo5() {
		TestDO test = new TestDO();
		test.setName("7777");
		testMapper.insert(test);
		
		try {
			validTransactionService.transaction();
		}catch (Exception e) {
			log.error("服务异常，异常被捕获", e);
		}
	}
	
	/********************************************************
	 * 事务生效场景三
	 *
	 *内层事务配置的是REQUIRES_NEW，表示自己用自己的，不和外层有牵连，内层如果报错，事务会回滚
	 * 外层如果catch住了，就可以正常执行，外层生效，内层回滚
	 ********************************************************/
	@Transactional
	public void demo6() {
		TestDO test = new TestDO();
		test.setName("9999");
		testMapper.insert(test);
		
		try {
			requireNewTransactionService.transactionWithException();
		}catch (Exception e) {
			log.error("服务异常，异常被捕获", e);
		}
	}
	
	/********************************************************
	 * 独立事务
	 * 内外层事务独立，内层操作未报错，事务正常执行，外层有错，事务回滚。
	 ********************************************************/
	@Transactional
	public void demo7() {
		TestDO test = new TestDO();
		test.setName("9999");
		testMapper.insert(test);
		
		requireNewTransactionService.transaction();
		throw new WMSException(ErrorCodeEnum.BD10001001.code(),"独立事务");
	}
	
}