SpringBoot系列:事物创建过程(二)

SpringBoot事物创建过程

文章目录

  • SpringBoot事物创建过程
    • 同系列
    • 一、前言
    • 二、DynamicAdvisedInterceptor & intercept
    • 三、ReflectiveMethodInvocation & proceed
    • 四、TransactionInterceptor & invoke
    • 五、invokeWithinTransaction
    • 六、创建开启事物
      • 6.1、createTransactionIfNecessary
      • 6.2、getTransaction
      • 6.3、doGetTransaction(获取数据库链接以及事物信息)
      • 6.4、suspend 挂起事物
      • 6.5、doSuspendSynchronization
      • 6.6、startTransaction开启事物
      • 6.7、doBegin 真正的开启事物的地方
    • 七、处理嵌套事物
      • 7.1、handleExistingTransaction(嵌套事物的处理)
      • 7.2、createAndHoldSavepoint 创建保存点
    • 八、总结

同系列

SpringBoot系列:事物加载过程(一)
SpringBoot系列:事物创建过程(二)
SpringBoot系列:事物提交回滚过程(三)

一、前言

上一节讲述了事物的加载过程,最后生成代理文件,放到spring容器中。

public class CloudDiskShareInfoDetailServiceImpl$$EnhancerBySpringCGLIB$$ec4fb618
extends CloudDiskShareInfoDetailServiceImpl
implements SpringProxy,Advised,Factory {
    ··· 省略
    @Override
    public final void aaa(Integer n) {
        MethodInterceptor methodInterceptor = this.CGLIB$CALLBACK_0;
        if (methodInterceptor == null) {
            CloudDiskShareInfoDetailServiceImpl$$EnhancerBySpringCGLIB$$ec4fb618.CGLIB$BIND_CALLBACKS(this);
            methodInterceptor = this.CGLIB$CALLBACK_0;
        }
        if (methodInterceptor != null) {
            1、执行代理方法
            Object object = methodInterceptor.intercept(this, CGLIB$aaa$0$Method, new Object[]{n}, CGLIB$aaa$0$Proxy);
            return;
        }
        super.aaa(n);
    }
   ··· 省略
   
}

代理类继承了 被代理类,

实现了两个SpringProxy,Advised,Factory接口,

methodInterceptorDynamicAdvisedInterceptor

为什么实现了这三个接口?为什么是这个拦截器?

原理请跳转 :SpringAop解析的代码块十七之后

二、DynamicAdvisedInterceptor & intercept

@Override
		@Nullable
		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
			Object oldProxy = null;
			boolean setProxyContext = false;
			Object target = null;
            1、获取的被代理类,也就是原始类
			TargetSource targetSource = this.advised.getTargetSource();
			try {
                2、是否对外暴露
				if (this.advised.exposeProxy) {
					oldProxy = AopContext.setCurrentProxy(proxy);
					setProxyContext = true;
				}
				target = targetSource.getTarget();
				Class<?> targetClass = (target != null ? target.getClass() : null);
                3、获取符合条件的增强器 如事物的 TransactionInterceptor
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
				Object retVal;
                4、没有增强器,直接执行 被代理方法
				if (chain.isEmpty() && CglibMethodInvocation.isMethodProxyCompatible(method)) {
					Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
					retVal = invokeMethod(target, method, argsToUse, methodProxy);
				}
				else {
                    5、递归调用process方法,处理所有的拦截器。
					retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
				}
                6、最终返回值
				retVal = processReturnType(proxy, target, method, retVal);
				return retVal;
			}
			finally {
				if (target != null && !targetSource.isStatic()) {
					targetSource.releaseTarget(target);
				}
				if (setProxyContext) {
					// Restore old proxy.
					AopContext.setCurrentProxy(oldProxy);
				}
			}
		}

3、获取符合条件的增强器 这儿在AOP加载过程中,获取符合条件的增强逻辑几乎一致,不再做讲解了。

事物的话就是获取的 TransactionInterceptor,如果是我们常用的如@Before、@After、@Around则会是对应的拦截器,在各自的拦截器内部再次调用process方法,完成整个拦截器链的调用。

5、递归调用process方法,处理所有的拦截器。

具体调用流程解析请跳转:

AOP系列之执行流程

三、ReflectiveMethodInvocation & proceed

public Object proceed() throws Throwable {
    // We start with an index of -1 and increment early.
    1、最后一个拦截器,直接调用目标方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }
	2、根据下标获取对应的拦截器,并执行
    Object interceptorOrInterceptionAdvice =
        this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    3、动态拦截器,判断是否匹配之后再调用
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        InterceptorAndDynamicMethodMatcher dm =
            (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
        }
        else {
            return proceed();
        }
    }
    4、静态拦截器执行
    else {
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

这儿我们只分析事物是怎么执行的。

四、TransactionInterceptor & invoke

public Object invoke(MethodInvocation invocation) throws Throwable {
    1、被代理的原始类
    Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
    return invokeWithinTransaction(invocation.getMethod(), targetClass, new CoroutinesInvocationCallback() {
        @Override
        @Nullable
        public Object proceedWithInvocation() throws Throwable {
            return invocation.proceed();
        }
        @Override
        public Object getTarget() {
            return invocation.getThis();
        }
        @Override
        public Object[] getArguments() {
            return invocation.getArguments();
        }
    });
}

事物相关所有的流程都在 invokeWithinTransaction中进行解析的。

五、invokeWithinTransaction

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
			final InvocationCallback invocation) throws Throwable {
		1AnnotationTransactionAttributeSource事物属性资源获取,也就是一开始注入的
		TransactionAttributeSource tas = getTransactionAttributeSource();
    	1.1、获取事物的属性,@Transaction的属性,如隔离级别,超时等
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
    	2、确定事物管理器,这儿是jdbc的,也可自己设置
		final TransactionManager tm = determineTransactionManager(txAttr);

		if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
			···响应式事物的处理
		}
		3、获取事物管理器
		PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
    	3.1com.zgf.service.impl.CloudDiskShareInfoDetailServiceImpl.aaa,得到方法的全路径
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
		4、进入if,说明不是CallbackPreferringPlatformTransactionManager,也是声明式事物
		if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
            5、创建并开启事务
			TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

			Object retVal;
			try {
                6、再次回调process方法,有可能直接执行被代理方法。
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
                7、事物异常的相关处理
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
                8、清除一些事物的标记,如在ThreadLocal内的一些事物信息
				cleanupTransactionInfo(txInfo);
			}

			if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
				TransactionStatus status = txInfo.getTransactionStatus();
				if (status != null && txAttr != null) {
					retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
				}
			}
			9、事物正常执行的提交操作
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}

		else {
			···编程式事物处理流程
			}
			···省略一堆 catch
			return result;
		}
	}

这儿有三种事物的处理方式:

1、声明式事物:@Transactiion

2、编程式事物

3、响应式事物:ReactiveTransactionManager,笔者也不太了解这种方式,有大佬的话请多多指点指点。

我们这儿只对声明式事务进行解析。

事物全流程

  • 开启事物
  • 执行目标放啊
  • 做出对应的处理:异常处理或提交处理

六、创建开启事物

6.1、createTransactionIfNecessary

protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
			@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {

		//标记名称
		if (txAttr != null && txAttr.getName() == null) {
			txAttr = new DelegatingTransactionAttribute(txAttr) {
				@Override
				public String getName() {
					return joinpointIdentification;
				}
			};
		}

		TransactionStatus status = null;
		if (txAttr != null) {
			if (tm != null) {
                1、创建事物
				status = tm.getTransaction(txAttr);
			}
		}
    	2、创建TransactionInfo,并将事物信息保存到ThreadLocalreturn prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
	}

6.2、getTransaction

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
			throws TransactionException {
		TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
		1、获取一个事物对象
		Object transaction = doGetTransaction();
		boolean debugEnabled = logger.isDebugEnabled();
		2、已经存在事物了,出现嵌套事务,根据事物隔离级别做出不同的处理
		if (isExistingTransaction(transaction)) {
			// Existing transaction found -> check propagation behavior to find out how to behave.
			return handleExistingTransaction(def, transaction, debugEnabled);
		}
		2.1、到这儿说明是第一次进来,还未开启事物
		// Check definition settings for new transaction.
    	校验超时时间是否符合规则,也就是不能为负数,但-1是不设置超时
		if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
			throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
		}

		// No existing transaction found -> check propagation behavior to find out how to proceed.
    	3、检查事物传播行为,到这儿说明之前没有事物,该传播行为需要有事物所以抛出异常
		if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}
    	3.1、这三种传播行为都是需要创建新的事物
		else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
				def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
				def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			SuspendedResourcesHolder suspendedResources = suspend(null);
			if (debugEnabled) {
				logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
			}
			try {
                4、创建新的事物
				return startTransaction(def, transaction, debugEnabled, suspendedResources);
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		else {
            5、否则,配置的事务的传播行为就是剩下的三种:PROPAGATION_SUPPORTS或PROPAGATION_NEVER或PROPAGATION_NOT_SUPPORTED,这三种都是以非事物的方式运行的
			if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
				logger.warn("Custom isolation level specified but no actual transaction initiated; " +
						"isolation level will effectively be ignored: " + def);
			}
            5.1、 为给定参数创建一个新的TransactionStatus,并在适当时初始化事务同步,但是不会真正开启事务。
        		和startTransaction相比,其内部会调用newTransactionStatus和prepareSynchronization,但不会调用doBegin方法
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
		}
	}

6.3、doGetTransaction(获取数据库链接以及事物信息)

@Override
protected Object doGetTransaction() {
    1、初始化一个数据源对象,持有数据源信息以及事物信息
    DataSourceTransactionObject txObject = new DataSourceTransactionObject();
    2、设置是否允许保存点,一般都是允许的,用于嵌套事物
    txObject.setSavepointAllowed(isNestedTransactionAllowed());
    3、第一次开启事物是null,后续会进行填充,若嵌套事物则不为null,所以嵌套事物用的都是同一个数据库链接
    ConnectionHolder conHolder =
        (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
    4false:不是新的事物,后面会重新判断若是第一次会设置为true
    txObject.setConnectionHolder(conHolder, false);
    return txObject;
}

6.4、suspend 挂起事物

protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
    1、判断事物是否同步激活
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        2、执行挂起事物的同步回调方法,有具体的子类实现
        List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
        try {
            Object suspendedResources = null;
            if (transaction != null) {
                3、真正的挂起
                suspendedResources = doSuspend(transaction);
            }
            4、清空一些同步信息:名称、只读状态、隔离级别、激活状态
            String name = TransactionSynchronizationManager.getCurrentTransactionName();
            TransactionSynchronizationManager.setCurrentTransactionName(null);
            boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
            TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
            Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
            TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
            boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
            TransactionSynchronizationManager.setActualTransactionActive(false);
            5、将上述信息进行包装返回
            return new SuspendedResourcesHolder(
                suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
        }
        catch (RuntimeException | Error ex) {
            // doSuspend failed - original transaction is still active...
            doResumeSynchronization(suspendedSynchronizations);
            throw ex;
        }
    }
    else if (transaction != null) {
        // Transaction active but no synchronization active.
        6、事物不是激活状态,但是存在事物,直接挂起
        Object suspendedResources = doSuspend(transaction);
        return new SuspendedResourcesHolder(suspendedResources);
    }
    else {
        // Neither transaction nor synchronization active.
        7、没有事物,返回null
        return null;
    }
}

6.5、doSuspendSynchronization

private List<TransactionSynchronization> doSuspendSynchronization() {
    1、获取线程的所有同步事物
    List<TransactionSynchronization> suspendedSynchronizations =
        TransactionSynchronizationManager.getSynchronizations();
    2、依次挂起事物
    for (TransactionSynchronization synchronization : suspendedSynchronizations) {
        synchronization.suspend();
    }
    3、清空同步事物
    TransactionSynchronizationManager.clearSynchronization();
    return suspendedSynchronizations;
}

6.6、startTransaction开启事物

private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
                                           boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {
	1、传播方式是无需事物,则新建标志设置为false
    boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
    2、status:持有新事物的信息,以及之前挂起的事物信息
    DefaultTransactionStatus status = newTransactionStatus(
        definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
    doBegin(transaction, definition);
    3、绑定TransactionSynchronizationManager内的一系列线程资源如:
       名称、只读状态、隔离级别、激活状态等
    prepareSynchronization(status, definition);
    return status;
}



protected DefaultTransactionStatus newTransactionStatus(
    TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
    boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {
	1、newSynchronization:是否是新事物
    2、第二个判断,因为之前挂起事物清空了同步信息,这儿也是未激活状态
    boolean actualNewSynchronization = newSynchronization: &&
        !TransactionSynchronizationManager.isSynchronizationActive();
    3、返回全新的事物信息
    return new DefaultTransactionStatus(
        transaction, newTransaction, actualNewSynchronization,
        definition.isReadOnly(), debug, suspendedResources);
}

6.7、doBegin 真正的开启事物的地方

protected void doBegin(Object transaction, TransactionDefinition definition) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		Connection con = null;

		try {
            1、是否存在链接,第一次开始事物是不存在的 || 事物同步状态 默认false下面创建完之后会设置ture
			if (!txObject.hasConnectionHolder() ||
					txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
				Connection newCon = obtainDataSource().getConnection();
				if (logger.isDebugEnabled()) {
					logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
				}
                1.1、设置链接,并标记为新的链接
				txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
			}

			txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
			con = txObject.getConnectionHolder().getConnection();
			2、设置隔离级别
			Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
			txObject.setPreviousIsolationLevel(previousIsolationLevel);
            3、设置只读模式
			txObject.setReadOnly(definition.isReadOnly());

			// 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).
            4、是否自动提交,改为手动
			if (con.getAutoCommit()) {
				txObject.setMustRestoreAutoCommit(true);
				if (logger.isDebugEnabled()) {
					logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
				}
				con.setAutoCommit(false);
			}
			5、开启数据库事物的只读模式,会优化查询
			prepareTransactionalConnection(con, definition);
			txObject.getConnectionHolder().setTransactionActive(true);
			6、设置超时时间
			int timeout = determineTimeout(definition);
			if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
				txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
			}

			// Bind the connection holder to the thread.
             7、上面设置的新的链接标志
			if (txObject.isNewConnectionHolder()) {
			 7.1、绑定资源,就是绑定TransactionSynchronizationManager的resources
                 前面用resources做了一系列处理,如事物挂起,就是获取的该资源进行依次挂起
				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);
		}
	}

七、处理嵌套事物

接上述 6.2 中的 2,如果已经存在事物了如何处理。

7.1、handleExistingTransaction(嵌套事物的处理)

	private TransactionStatus handleExistingTransaction(
			TransactionDefinition definition, Object transaction, boolean debugEnabled)
			throws TransactionException {
		1、非事物方式运行,不允许事物出现,直接抛出异常
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
			throw new IllegalTransactionStateException(
					"Existing transaction found for transaction marked with propagation 'never'");
		}
		2、非事物方式运行,若存在事物,则挂起,执行完之后恢复事物继续执行
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
			if (debugEnabled) {
				logger.debug("Suspending current transaction");
			}
            2.1、挂起事物返回挂起信息
			Object suspendedResources = suspend(transaction);
            2.2、是否更新同步信息 TransactionSynchronizationManager内的一系列threadlocal属性
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
            2.3、创建事物状态信息
			return prepareTransactionStatus(
					definition, null, false, newSynchronization, debugEnabled, suspendedResources);
		}
		3、每次都开启一个新的事物,挂起原来的事物
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
			if (debugEnabled) {
				logger.debug("Suspending current transaction, creating new transaction with name [" +
						definition.getName() + "]");
			}
            3.1、挂起原事物
			SuspendedResourcesHolder suspendedResources = suspend(transaction);
			try {
                3.2、开启新事物
				return startTransaction(definition, transaction, debugEnabled, suspendedResources);
			}
			catch (RuntimeException | Error beginEx) {
				resumeAfterBeginException(transaction, suspendedResources, beginEx);
				throw beginEx;
			}
		}
		4、如果当前有事物,则在事物内执行,通过保存点的方式进行回滚,但提交的话是交由外层事物提交。
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			if (!isNestedTransactionAllowed()) {
				throw new NestedTransactionNotSupportedException(
						"Transaction manager does not allow nested transactions by default - " +
						"specify 'nestedTransactionAllowed' property with value 'true'");
			}
			if (debugEnabled) {
				logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
			}
			if (useSavepointForNestedTransaction()) {
				// Create savepoint within existing Spring-managed transaction,
				// through the SavepointManager API implemented by TransactionStatus.
				// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
				DefaultTransactionStatus status =
						prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
                4.2、创建保存点
				status.createAndHoldSavepoint();
				return status;
			}
			else {
				// Nested transaction through nested begin and commit/rollback calls.
				// Usually only for JTA: Spring synchronization might get activated here
				// in case of a pre-existing JTA transaction.
                4.3、通常用于JTA:开启新事物
				return startTransaction(definition, transaction, debugEnabled, null);
			}
		}

		// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
		if (debugEnabled) {
			logger.debug("Participating in existing transaction");
		}
		if (isValidateExistingTransaction()) {
			if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
				Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
				if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
					Constants isoConstants = DefaultTransactionDefinition.constants;
					throw new IllegalTransactionStateException("Participating transaction with definition [" +
							definition + "] specifies isolation level which is incompatible with existing transaction: " +
							(currentIsolationLevel != null ?
									isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
									"(unknown)"));
				}
			}
			if (!definition.isReadOnly()) {
				if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
					throw new IllegalTransactionStateException("Participating transaction with definition [" +
							definition + "] is not marked as read-only but existing transaction is");
				}
			}
		}
        5、剩下的传播行为就是PROPAGATION_SUPPORTS或者PROPAGATION_REQUIRED,不会有PROPAGATION_MANDATORY。
          直接参与当前事务执行。
            
		boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
		return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
	}

挂起之后都返回了挂起的资源,重新设置到事物信息中去。

7.2、createAndHoldSavepoint 创建保存点

	public void createAndHoldSavepoint() throws TransactionException {
		setSavepoint(getSavepointManager().createSavepoint());
	}

设置的保存点:SAVEPOINT_ + 数字形式,如 SAVEPOINT_1

八、总结

到这儿事物的创建已经解析完毕,下一章开始执行完本体方法之后的处理,回滚or提交

1、事物是在AOP内执行的,递归的调用process方法,从而进入对应拦截器的invoke方法,事物进入的就是TransactionInterceptor,事物之旅正式开启。

2、 获取一些事物属性,以及事物管理器,准备着手开始创建事物。

3、首先判断是否已经存在事物,若存在则是嵌套事物按照嵌套事物的处理方式进行处理。

​ 3.1、根据不同的传播行为做出不同的处理方式,如PROPAGATION_REQUIRES_NEW,策略就是挂起原事物,开启新的事物等,具体说明放在最后。

4、不存在事物,则准备开启事物,(不同的传播行为有的会抛出异常,有的创建事物,有的以空事物的方式运行)。

5、设置一系列的事物信息,如隔离级别、只读、手动提交、真正开启事物的方法doBegin方法,从数据库连接池获取一个新的链接,正式开启事物,最终同步spring事物管理器的信息放到threadLocal中,所以为什么说事物不支持多线程

事务传播行为类型 未开启事物 已开启事物 综合说明
PROPAGATION_REQUIRED 默认的传播行为,开启事物。 加入到前一个事物中 若存在事物加入到前一个事物中去,若不存在事物则开启新的事物
PROPAGATION_SUPPORTS 空事物运行 加入到前一个事物 存在事物则加入到前一个事物中去,不存在事物则以空事物运行。
PROPAGATION_NOT_SUPPORTED 创建空事物 将前一个事物挂起,空事物运行。 寸在事物则将事物挂起,创建空事物,不存在则创建空事物。
PROPAGATION_REQUIRES_NEW 创建新事物 挂起前一个,创建新事物 无论是否存在事物,都开启新的事物
PROPAGATION_MANDATORY 抛出异常 使用当前事物 存在事物则加入,不存在抛异常
PROPAGATION_NEVER 空事物运行 抛出异常 存在事物抛出异常,不存在事物创建空事物
PROPAGATION_NESTED 创建新事物 嵌套在内部,通过保存点的方式进行回滚,本质还是一个事物 存在事物,创建保存点加入到事物中,不存在开启新事物

你可能感兴趣的:(SpringBoot,spring,boot,java,spring)