Spring事务执行过程-TransactionInterceptor-源码解析

背景

因为Spring声明式事务是通过AOP增强实现的，所以现在具体来分析一下Spring事务的执行过程，因为AOP是通过拦截器执行链实现的，所以我们可以把关注点聚焦在拦截器上-TransactionInterceptor

事例

    @Transactional
    public void insertUser(String name,int age){
        userMapper.insertUser(name,age);
    }

    @Test
    public void insertUser(){
        userService.insertUser("test",123);
    }

执行测试用例并DEBUG

• 从图中可以看到UserService中的insertUser加了事务注解，所以被AOP代理了
• 并且可以看到只包含一个增强器，增强器使用的增强通知是-TransactionInterceptor
• 断点往下执行，就是执行AOP拦截器执行链的过程，这里就不再展开的，需要了解AOP执行过程的可以看我之前的文章Spring AOP初始化及执行过程
• 那么我们下面直接围绕TransactionInterceptor展开说明
  

Spring事务处理逻辑的核心-TransactionInterceptor

类图

• 本身属于AOP中的Advice通知
• 为了集成到Spring AOP的拦截器执行链，继承了MethodInterceptor
  

TransactionInterceptor invoke()

• 拦截器接口的方法，拦截器被执行器调用的方法

    /**
	 * @param invocation 拦截器链的执行器，用于执行下一个拦截器
	 * @return 返回连接点的执行结果
	 * @throws Throwable
	 */
	@Override
	@Nullable
	public Object invoke(MethodInvocation invocation) throws Throwable {
		//获取被代理对象的类类型
		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

		//调用父类TransactionAspectSupport方法
		//传入连接点方法对象，代理对象类类型，拦截器执行器MethodInvocation的proceed()方法引用
		return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
	}

TransactionInterceptor invokeWithinTransaction()

• 执行事务的逻辑

   /** 执行事务逻辑
	 * @param method 连接点的方法对象
	 * @param targetClass 被代理的对象，用于执行method
	 * @param invocation 用于执行下一个拦截器
	 * @return the return value of the method, if any
	 * @throws Throwable propagated from the target invocation
	 */
	@Nullable
	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
			final InvocationCallback invocation) throws Throwable {


		//事务注解属性源，包含了保存 事务注解属性的缓存 如果为空不执行事务
		TransactionAttributeSource tas = getTransactionAttributeSource();
		//事务注解属性对象
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
		//事务管理器
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		//获取连接点唯一标识字符串  com.example.UserService.insertUser()
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
		//如果是本地事务执行逻辑
		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {

			//创建事务并返回事务对象信息
			//TransactionInfo 事务信息对象  主要包含 TransactionStatus TransactionAttribute PlatformTransactionManager
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				//执行下一个拦截器，如果只有一个拦截器，那么下一个会执行连接点的方法()
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				//事务回滚
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				//清除事务信息
				cleanupTransactionInfo(txInfo);
			}
			//提交事务
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}
	......	
	｝	

创建事务

createTransactionIfNecessary

• 如果需要则创建事务，需要根据事务传播级别来判断是否创建事务

/**
	 * 如果需要则创建事务，需要根据事务传播级别来判断是否创建事务
	 * @param txAttr the TransactionAttribute (may be {@code null})
	 * @param joinpointIdentification 连接点执行方法的唯一标识
	 * @return a TransactionInfo object, whether or not a transaction was created.
	 * The {@code hasTransaction()} method on TransactionInfo can be used to
	 * tell if there was a transaction created.
	 * @see #getTransactionAttributeSource()
	 */
	@SuppressWarnings("serial")
	protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
			@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {

        //如果没有执行名称，则使用joinpointIdentification，并返回代理对象
		if (txAttr != null && txAttr.getName() == null) {
			txAttr = new DelegatingTransactionAttribute(txAttr) {
				@Override
				public String getName() {
					return joinpointIdentification;
				}
			};
		}

		TransactionStatus status = null;
		//事务属性不为null
		if (txAttr != null) {
			//事务管理器不为null
			if (tm != null) {
				//获取事务
				status = tm.getTransaction(txAttr);
			}
			else {
				if (logger.isDebugEnabled()) {
					logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
							"] because no transaction manager has been configured");
				}
			}
		}
		//创建并初始化TransactionInfo
		return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
	}
	

getTransaction 获取事务

/**
	 * This implementation handles propagation behavior. Delegates to
	 * {@code doGetTransaction}, {@code isExistingTransaction}
	 * and {@code doBegin}.
	 * @see #doGetTransaction
	 * @see #isExistingTransaction
	 * @see #doBegin
	 */
	@Override
	public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
		//返回DataSourceTransactionObject 持有ConnectionHolder 数据库连接
		//如果当前线程已经存在事务，则会从ThreadLocal的Map 以DataSource为key获取ConnectionHolder
		Object transaction = doGetTransaction();

		// Cache debug flag to avoid repeated checks.
		boolean debugEnabled = logger.isDebugEnabled();

		if (definition == null) {
			// Use defaults if no transaction definition given.
			definition = new DefaultTransactionDefinition();
		}

		//当前线程是否存在事务
		if (isExistingTransaction(transaction)) {
			//根据事务隔离传播处理事务
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}

		//注意：以下处理逻辑为不存在事务
		if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
			throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
		}

		//事务传播级别为PROPAGATION_MANDATORY，不存在事务抛出异常
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}
		//以下事务传播级别，在当前不存在事务的情况下，统一创建新的事务
		else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			SuspendedResourcesHolder suspendedResources = suspend(null);
			if (debugEnabled) {
				logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
			}
			try {
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				//创建status
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				//开启事务 获取连接 设置数据库事务隔离级别 设置超时时间 绑定连接资源到本地线程
				doBegin(transaction, definition);
				//初始化事务同步器TransactionSynchronizationManager
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		//如果不是以上四种支持事务的传播级别，
		//即为PROPAGATION_SUPPORTS、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER
		//这三种传播级别以非事务的方式执行
		else {
			// Create "empty" transaction: no actual transaction, but potentially synchronization.
			if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
				logger.warn("Custom isolation level specified but no actual transaction initiated; " +
						"isolation level will effectively be ignored: " + definition);
			}
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
		}
	}

deBegin 创建新的事务

/**
	 * This implementation sets the isolation level but ignores the timeout.
	 */
	@Override
	protected void doBegin(Object transaction, TransactionDefinition definition) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		Connection con = null;

		try {
			if (!txObject.hasConnectionHolder() ||
					txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
				//从数据源获取新的连接
				Connection newCon = obtainDataSource().getConnection();
				if (logger.isDebugEnabled()) {
					logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
				}
				txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
			}

			txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
			con = txObject.getConnectionHolder().getConnection();

			//设置 数据库事务隔离界别
			Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
			txObject.setPreviousIsolationLevel(previousIsolationLevel);

			// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
			// so we don't want to do it unnecessarily (for example if we've explicitly
			// configured the connection pool to set it already).
			if (con.getAutoCommit()) {
				txObject.setMustRestoreAutoCommit(true);
				if (logger.isDebugEnabled()) {
					logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
				}
				//设置为 不自动提交事务 即开启事务
				con.setAutoCommit(false);
			}

			//设置 只读事务
			prepareTransactionalConnection(con, definition);

			//设置事务为生效的
			txObject.getConnectionHolder().setTransactionActive(true);

			//设置连接的超时时间
			int timeout = determineTimeout(definition);
			if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
				txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
			}

			// 绑定新的连接到本地线程 key为对应的数据源
			if (txObject.isNewConnectionHolder()) {
				TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
			}
		}

		catch (Throwable ex) {
			if (txObject.isNewConnectionHolder()) {
				DataSourceUtils.releaseConnection(con, obtainDataSource());
				txObject.setConnectionHolder(null, false);
			}
			throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
		}
	}

回滚

回滚的情况

• 事务执行过程中，抛出异常，默认回滚RuntimeException和Error
• 通过手动回滚，在业务方法中执行以下操作，会在提交方法中判断是否回滚
  • TransactionInterceptor.currentTransactionStatus().setRollbackOnly()

当连接点方法执行发生异常，会被catch捕获到，执行回滚逻辑

......
try {
				//执行下一个拦截器，如果只有一个拦截器，那么下一个会执行连接点的方法()
				retVal = invocation.proceedWithInvocation();
			}
			//捕获连接点抛出的异常
			catch (Throwable ex) {
				//事务回滚
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
 ........

completeTransactionAfterThrowing

• 匹配异常，进行回滚
  • 当在@Transactional中没有定义rollbackFor,默认只回滚RuntimeException和Error
  • 调用数据库连接对象Connection的rollback()进行回滚
• 如果没有匹配的异常，会执行commit()
  • 在commit()方法中，会进行手动回滚的判断

protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
		if (txInfo != null && txInfo.getTransactionStatus() != null) {
			if (logger.isTraceEnabled()) {
				logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
						"] after exception: " + ex);
			}
			//使用RuleBasedTransactionAttribute判断当前异常是否需要回滚-如果注解上定义了@Transactional(rollbackFor = Exception.class)
			//这里会使用ex向上递归查找父类是否和Exception是否相同，如果相同则进行回滚
			if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
				try {
					txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
				}
				catch (TransactionSystemException ex2) {
					logger.error("Application exception overridden by rollback exception", ex);
					ex2.initApplicationException(ex);
					throw ex2;
				}
				catch (RuntimeException | Error ex2) {
					logger.error("Application exception overridden by rollback exception", ex);
					throw ex2;
				}
			}
			//否则执行提交
			else {
				//commit() 会判断通过手动设置回滚的操作，然后也会进行回滚
				try {
					txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
				}
				catch (TransactionSystemException ex2) {
					logger.error("Application exception overridden by commit exception", ex);
					ex2.initApplicationException(ex);
					throw ex2;
				}
				catch (RuntimeException | Error ex2) {
					logger.error("Application exception overridden by commit exception", ex);
					throw ex2;
				}
			}
		}
	}

txInfo.getTransactionManager().commit()中进行手动回滚判断

• 可以在连接点方法中执行TransactionInterceptor.currentTransactionStatus().setRollbackOnly()，这里会进行判断并且执行回滚操作

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;
		//如果执行了TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
		//这里会判断为true并且进行回滚操作
		if (defStatus.isLocalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Transactional code has requested rollback");
			}
			processRollback(defStatus, false);
			return;
		}

		//通过ConnectHolder setRollbackOnly() 设置的回滚
		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);
	}

手动回滚事例

    @Transactional
    public void insertUser(String name,int age) throws Exception {
        userMapper.insertUser(name,age);
        //手动回滚
        TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
    }

   @Test
    public void insertUser() throws Exception {
        userService.insertUser("test",123);
        //查询结果
        userService.selectUser();
    }

执行结果

• test并没有插入成功,并且从控制台中也打印了进行回滚的日志

[{ID=1, NAME=小明, AGE=23}, {ID=2, NAME=小白, AGE=24}]

22:58:09.131 [main] DEBUG org.springframework.jdbc.datasource.DataSourceTransactionManager - Transactional code has requested rollback

以上回滚日志对应到

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

提交

• 连接点方法执行完成，并且没有捕获异常，最后执行提交事务方法commitTransactionAfterReturning
• 最后也是调用jdbc中Connection的commit()进行提交操作

   .........
         try {
		   //执行下一个拦截器，如果只有一个拦截器，那么下一个会执行连接点的方法()
				retVal = invocation.proceedWithInvocation();
			 }
			//捕获连接点抛出的异常
			catch (Throwable ex) {
				//事务回滚
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				//清除事务信息
				cleanupTransactionInfo(txInfo);
			}
			//提交事务
			commitTransactionAfterReturning(txInfo);
			return retVal;

protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
		if (txInfo != null && txInfo.getTransactionStatus() != null) {
			if (logger.isTraceEnabled()) {
				logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
			}
			txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
		}
	

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;
		//如果执行了TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
		//这里会判断为true并且进行回滚操作
		if (defStatus.isLocalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Transactional code has requested rollback");
			}
			processRollback(defStatus, false);
			return;
		}

		//通过ConnectHolder setRollbackOnly() 设置的回滚
		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);
	}

总结

• 创建事务时会根据事务传播级别进行处理
  • 当前线程不同数据库操作引用同一个事务会使用同一个JDBC Connection，否则会建立新的事务或新的连接
• 事务回滚
  • 抛出异常
  • 手动回滚
• 如果连接点执行完毕，则进行提交