Spring源码浅析之事务管理.md

原创 已于 2022-02-10 18:20:51 修改 · 311 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #aop

于 2020-07-16 18:13:20 首次发布
本文详细剖析了Spring如何通过AOP注入TransactionInterceptor实现声明式事务管理，解释了事务的传播机制，包括NEVER、NOT_SUPPORTED、REQUIRES_NEW、NESTED、MANDATORY、REQUIRED和SUPPORTS等属性的应用场景。

文章目录

思考

  • spring是怎样帮助我们进行事务管理的
  • spring是如何实现事务的传播的

概览

spring声明式事务需要aop的支持，在spring容器初始化的时候，会将一个TransactionInterceptor的实例注入到所有方法上加了@Transactional注解的bean的代理对象的advisor数组中，当我们执行事务方法时，就会去执行TransactionInterceptor.invoke方法进行事务处理

TransactionInterceptor

注入TransactionInterceptor的过程参考

1. 首先初始化所有Advisor，这个过程会把容器中实现了advisor接口的beanDefinition对应的类实例化并加入到一个AdvisedSupport对象中，最后会注入到代理对象

        AbstractAutoProxyCreator.postProcessBeforeInstantiation()

            --->AspectJAwareAdvisorAutoProxyCreator.shouldSkip()

               --->AspectJAwareAdvisorAutoProxyCreator.findCandidateAdvisors()

2. 代理bean

       AbstractAutoProxyCreator.postProcessAfterInitialization()

            -->AbstractAutoProxyCreator.wrapIfNecessary()
	               //这里面会去选择使用jdk或者cglib进行代理对象的创建
                -->AbstractAutoProxyCreator.createProxy()

TransactionInterceptor类图

TransactionInterceptor类图.png
这里可以到到TransactionInterceptor最终是实现了Avice接口，所以在前面的1中就会把TransactionInterceptor实例化好作为拦截器注入到代理对象中

事务处理流程

全局

invokeWithinTransaction()

当我们调用加了@Transactional的bean的目标方法时，首先会进入TransactionInterceptor.invoke，这里是因为TransactionInterceptor实现了MethodInterceptor（具体可参考spring aop原理）。然后会调用TransactionAspectSupport.invokeWithinTransaction()

    @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);
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            // Standard transaction demarcation with getTransaction and commit/rollback calls.
            //初始化事务所需要的所有信息到txInfo，包括隔离级别，数据源等
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            Object retVal = null;
            try {
                //继续执行后续的拦截器，最终返回目标方法执行结果
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                //异常回滚
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {
            	//清除线程本地变量保存的事务信息
                cleanupTransactionInfo(txInfo);
            }
            //无异常则commit
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }

开启事务管理

createTransactionIfNecessary()

这里有个createTransactionIfNecessary(tm, txAttr, joinpointIdentification)方法，它保存了事务执行过程中所需要的全部信息，其内部会处理事务的传播，例如当propagation设置为REQUIRES_NEW时，它会去挂起当前事务，挂起主要是把当前事务的jdbc连接从线程的threadlocalMap中清除，并保存到新的事务的TransactionStatus中。然后把当前事务的transactionInfo保存到新建立的transactioninfo的oldTransactionInfo属性中

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

		// If no name specified, apply method identification as transaction name.
		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) {
                //初始化事务的状态，后续提交跟回滚时会通过这个对象拿到这个事务的传播属性
               //处理事务的传播属性
				status = tm.getTransaction(txAttr);
			}
		}
        //初始化当前事务，并把当前事务加入到当前线程的threadLocalMap中
        //将先前的事务加入到当前事务的oldTransactionInfo属性中
		return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
	}

进入tm.getTransaction()

@Override
	public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
        //获取当前线程绑定的transactionResource对象
		Object transaction = doGetTransaction();

		boolean debugEnabled = logger.isDebugEnabled();

		if (definition == null) {
			definition = new DefaultTransactionDefinition();
		}

         //如果当前已经存在一个事务
		if (isExistingTransaction(transaction)) {
            //处理事务的传播性
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}
		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);
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
                //为当前session设置隔离级别，关闭自动提交
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		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);
            //构建transcationStatus对象
			return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
		}
	}

事务挂起

	@Nullable
	protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
		if (TransactionSynchronizationManager.isSynchronizationActive()) {
			List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
			try {
				Object suspendedResources = null;
				if (transaction != null) {
					//把transaction中旧的连接信息包装返回，然后置空
					suspendedResources = doSuspend(transaction);
				}
				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);
				//返回被挂起的连接信息
				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.
			Object suspendedResources = doSuspend(transaction);
			return new SuspendedResourcesHolder(suspendedResources);
		}
		else {
			// Neither transaction nor synchronization active.
			return null;
		}
	}

把旧的连接信息保存起来，并把当前transaction对象中的连接信息置空

commit

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

		//调用TransactionStatus.setRollbackOnly()会进入这个处理
		if (defStatus.isLocalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Transactional code has requested rollback");
			}
			processRollback(defStatus, false);
			return;
		}
		//像内部REQUIRED的方法抛出异常回滚，会设置ResourceHolderSupport.rollbackOnly为true，
		//如果外部事务方法catch这个异常
		//外部方法就会尝试提交事务并最终走到这
		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);
	}
	
	private void processCommit(DefaultTransactionStatus status) throws TransactionException {
		try {
			boolean beforeCompletionInvoked = false;

			boolean unexpectedRollback = false;
			beforeCompletionInvoked = true;

			if (status.hasSavepoint()) {
				if (status.isDebug()) {
					logger.debug("Releasing transaction savepoint");
				}
				unexpectedRollback = status.isGlobalRollbackOnly();
				//删除savepoint
				status.releaseHeldSavepoint();
			}
			//像REQURED传播性，这个值就为false，
			//保证了内部RUQUIRED方法不会触发事务提交
			else if (status.isNewTransaction()) {
				if (status.isDebug()) {
					logger.debug("Initiating transaction commit");
				}
				unexpectedRollback = status.isGlobalRollbackOnly();
				//提交事务
				doCommit(status);
			}
			else if (isFailEarlyOnGlobalRollbackOnly()) {
				unexpectedRollback = status.isGlobalRollbackOnly();
				}
		}
		finally {
			//还原当前session，
			//把之前被挂起的连接信息重新设置到当前线程的threadLocalMap中
			cleanupAfterCompletion(status);
		}
	}

如果业务方法没有抛出异常，最终会调用commit

Rollback

	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");
					}
					//回滚事务至savepoint并清除savepoint
					status.rollbackToHeldSavepoint();
				}
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction rollback");
					}

					doRollback(status);
				}
				//如果传播级别是RUQUIRED
				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");
							}
							//设置状态，commit的时候rollbackOnly为true会触发回滚
							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");
					}
					
					if (!isFailEarlyOnGlobalRollbackOnly()) {
						unexpectedRollback = false;
					}
				}
			}
			catch (RuntimeException | Error ex) {
				triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
				throw ex;
			}
		}
		finally {
			cleanupAfterCompletion(status);
		}
	}

这里我们会发现一个小细节，当外部带事务的方法调用了传播性为REQUIRED的内部方法，如果内部方法抛异常了，这个时候内部方法的事务管理在catch到异常之后，只会设置一个回滚标志位，等到外部方法去提交时，再出发回滚

TransactionStatus.isNewTransaction

这个值很重要，直接决定了事务能否提交与回滚，REQUIRED,SUPPORTS,NESTED就需要依赖这个来实现传播

finally处理–cleanupTransactionInfo

最后执行完目标方法回到invokeWithinTransaction，我们来看看finally里的cleanupTransactionInfo()做了什么事情

    protected void cleanupTransactionInfo(@Nullable TransactionInfo txInfo) {
		if (txInfo != null) {
			txInfo.restoreThreadLocalStatus();
		}
	}

    private void restoreThreadLocalStatus() {
			// Use stack to restore old transaction TransactionInfo.
			// Will be null if none was set.
			transactionInfoHolder.set(this.oldTransactionInfo);
	}
private static final ThreadLocal<TransactionInfo> transactionInfoHolder =
			new NamedThreadLocal<>("Current aspect-driven transaction");

这里我们发现，它把先前内层事务（如果存在）保存下来的事务信息重新设置到了当前线程的threadlocalMap中，这里主要在TransactionAspectSupport.currentTransactionStatus()可以获取到这个transactionInfo的status属性

传播属性

代码段来自AbstractPlatformTransactionManager类的getTransaction &handleExistingTransaction()

核心源码预览

	@Override
	public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
		//如果当前不存在事务，且传播属性是这些，就开启一个新的事务
		//否则啥都不做
		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);
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		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);
		}
	}
	private TransactionStatus handleExistingTransaction(
			TransactionDefinition definition, Object transaction, boolean debugEnabled)
			throws TransactionException {
			//如果当前存在事务，newSynchronization设置为false
			boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
			return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
	}

NEVER

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
			throw new IllegalTransactionStateException(
					"Existing transaction found for transaction marked with propagation 'never'");
		}

进入handleExistingTransaction的条件是当前已经存在一个事务，所以这里可以看出，NERVER不能运行在一个已经存在的事务里，同时在getTransaction()方法内不会去关闭事务的自动提交，这就意味着spring不会帮我们去控制事务的提交与回滚

NOT_SUPPORTED

		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
			if (debugEnabled) {
				logger.debug("Suspending current transaction");
			}
			//挂起已存在的事务
			Object suspendedResources = suspend(transaction);
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			//第三个参数为false，控制了spring后面不会去调用真正的事务提交方法
			//可参考AbstractPlatformTransactionManager#741行
			return prepareTransactionStatus(
					definition, null, false, newSynchronization, debugEnabled, suspendedResources);
		}

所以我们可以知道，NOT_SUPPORTED就是说，如果当前方法已经存在一个事务中，就会挂起当前事务，无论如何，被这个标注的方法，spring都不会去进行事务管理，但是，它与NERVER的区别是，不会抛出异常
挂起主要是保存当前事务的jdbc连接信息到TranscationStatus中
把当前线程的threadlocalMap里的连接信息切换成新的连接信息

REQUIRES_NEW

		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
			if (debugEnabled) {
				logger.debug("Suspending current transaction, creating new transaction with name [" +
						definition.getName() + "]");
			}
			//挂起已存在的事务
			SuspendedResourcesHolder suspendedResources = suspend(transaction);
			try {
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				//参数3为true意味着对应的事务可用自主提交
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				//拿到新的连接，设置隔离级别，关闭自动提交
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error beginEx) {
				resumeAfterBeginException(transaction, suspendedResources, beginEx);
				throw beginEx;
			}
		}

如果当前已存在事务，则挂起当前事务，开启一个新的事务

NESTED

		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			//是否通过安全点实现嵌套事务，默认是
			if (useSavepointForNestedTransaction()) {
				//没有挂起当前事务，说明当前方法跟外层方法在同一个session里
				//第3个参数为false意味着当前方法最后不会触发事务的全局commit跟rollback
				DefaultTransactionStatus status =
						prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
				//创建一个savepoint，如果后面业务出异常，(mysql语法：savepoint + name)
				//spring会自动帮助我们把事务回滚到这个savepoint
				status.createAndHoldSavepoint();
				return status;
			}
			//如果不使用savepoint，就通过内部加嵌套的begin跟commit/rollback
			else {
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, null);
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
		}
		//回滚处理
		private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
		try {
			boolean unexpectedRollback = unexpected;

			try {
				triggerBeforeCompletion(status);
				//如果有savepoint
				if (status.hasSavepoint()) {
					if (status.isDebug()) {
						logger.debug("Rolling back transaction to savepoint");
					}
					//事务回滚至savepoint
					status.rollbackToHeldSavepoint();
				}
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction rollback");
					}
					doRollback(status);
				}
			}
		}
	private void processCommit(DefaultTransactionStatus status) throws TransactionException {
		try {
			boolean beforeCompletionInvoked = false;

			try {
				boolean unexpectedRollback = false;
				prepareForCommit(status);
				triggerBeforeCommit(status);
				triggerBeforeCompletion(status);
				beforeCompletionInvoked = true;
				
				if (status.hasSavepoint()) {
					if (status.isDebug()) {
						logger.debug("Releasing transaction savepoint");
					}
					unexpectedRollback = status.isGlobalRollbackOnly();
					//删除savepoint
					status.releaseHeldSavepoint();
				}
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction commit");
					}
					unexpectedRollback = status.isGlobalRollbackOnly();
					doCommit(status);
				}

这里可以看到，嵌套事务利用了savepoint，内部事务不会commit，如果发生异常，只会把事务rollback至创建的savepoint

MANDATORY

	@Override
	public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
		if (isExistingTransaction(transaction)) {
			// Existing transaction found -> check propagation behavior to find out how to behave.
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}

这里很明显，如果当前方法没有运行在一个已存在的事务内，就会抛异常

REQUIRED

SUPPORTS

		//当前不存在事务，并且传播机制是这几种
		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);
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				//开启事务管理
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		//不参与事务管理
		else {
			if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
		}

这里可以看出，如果当前已存在事务，REQUIRED跟SUPPORTS的处理方式都是延用当前事务，但是如果当前不存在事务，REQUIRED会开启一个事务管理，SUPPORTS则不做任何处理，spring不介入事务处理

总结

Spring声明式事务通过AOP注入TranscationInterceptor生成代理对象来对目标方法进行拦截，通过关闭db事务的自动提交来介入事务管理，并在内部对事务的传播做了一系列的控制

Spring源码解析：Spring 事务
Java技术攻略的博客
04-23 400
我们再⼩节⼀下，⽂章先介绍了事务的使⽤示例，以及事务的执⾏流程。先匹配出 model 对象所有关于事务的切⾯列表，并将匹配成功的事务属性保存到缓存；从缓存取出事务属性，然后创建、启动事务，执⾏业务逻辑，最后提交或者回滚事务。
专题二：Spring源码编译
热门推荐
Jeremy程序员
06-29 11万+
Spring 源码配置：1、下载源码 2、配置Gradle 3、源码配置文件修改
Spring事务管理源码分析
This Is Why We Coding
11-09 783
Spring有两种事务管理方式： 编程式事务和声明式事务，为了和业务功能区分开来，实际项目中一般都使用 声明式事务。今天就来看一下在Spring源码中事务是如何一步步实现的。 整个过程主要是依靠TransactionInterceptor、TransactionAspectSupport来实现的，其中TransactionInterceptor 继承了TransactionAspec
Spring事务源码分析
m0_56794629的博客
04-23 444
一个Bean在执行Bean的创建生命周期时，会经过InfrastructureAdvisorAutoProxyCreator的初始 化后的方法，会判断当前当前Bean对象是否和BeanFactoryTransactionAttributeSourceAdvisor匹 配，匹配逻辑为判断该Bean的类上是否存在@Transactional注解，或者类中的某个方法上是否存在 @Transactional注解，如果存在则表示该Bean需要进行动态代理产生一个代理对象作为Bean对象。
【Spring】Spring事务相关源码分析
daohangtaiqian的博客
06-13 953
上一次分享讲解到 Mybatis的数据源与事务的相关源码分析，但是具体事务中Spring是怎么管理事务，怎么去管理、创建、销毁等操作的呢？这一次来分解一下。事务是逻辑上的一组操作，要么都执行，要么都不执行。用于获取一个新的事务或者加入一个现有的事务。该方法接受一个对象，用于指定事务的属性，如隔离级别、传播行为等。@Override// TransactionDefinition 存在直接返回 否则创建一个 TransactionDefinition 对象实例提供默认的事务定义数据。= null?
遇到的经典问题+不断积累
༺ bestcxx的专栏 ༻
12-12 9721
目录 java.lang.NoSuchMethodError: org.springframework.util.Assert.isTrue(ZLj References to interface static methods are allowed only at source level 1.8 org.springframework.web.HttpMediaType...
Spring源码案例.md
07-03
Spring源码案例.md
6.Spring事务管理源码深度解析.mp4
04-19
6.Spring事务管理源码深度解析.mp4
Spring事务底层源码解析(一)
最新发布
qq_40228720的博客
10-21 1378
我们在看了jdbc 代码以后可以清楚的知道，事务就是由connection 对象控制的，所以 connection 对象是和事务是绑定的，然后用户请求过来时又需要数据库连接来执行sql 语句， 所以用户请求线程又是跟connection 是绑定的。再看下核心的advice，生成后的代理对象，在调用方法的时候最终会先执行到TransactionInterceptor的invoke方法，然后再invokeWithinTransaction方法里面完成了事务的开启，原始方法的调用，事物的提交和回滚等。
spring security异常记录：org.springframework.security.access.AccessDeniedException: Access is denied
qq_56769991的博客
02-11 2万+
最近在做ssm项目的时候用到spring security时遇到了异常，如下所示： 15:06:28,144 DEBUG FilterSecurityInterceptor:348 - Previously Authenticated: org.springframework.security.authentication.AnonymousAuthenticationToken@52dd6d71: Principal: anonymousUser; Credentials: [PROTECTED]; .
Spring学习笔记--声明式事务源码
qq_40977467的博客
05-20 272
Spring学习笔记–声明式事务源码 声明式事务很⽅便，尤其纯注解模式，仅仅几个注解就能控制事务了 思考：这些注解都做了什么？好神奇！ @EnableTransactionManagement @Transactional @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(TransactionManagementConfigurationSelector.class) public @inte
Spring事务捕获异常后依旧回滚
weixin_64314555的博客
01-14 8531
前沿 一段生产事故发人深省，在Spring的声明式事务中手动捕获异常，居然判定回滚了，这是什么操作？话不多说直接上代码 @Service public class A { @Autowired private B b; @Autowired private C c; @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT) public...
Spring事务执行过程
weixin_30472035的博客
04-24 381
　　先说一下启动过程中的几个点： 　　加载配置文件： 　　AbstractAutowireCapableBeanFactory.doCreateBean --> initializeBean --> applyBeanPostProcessorsAfterInitialization --> beanProcessor.postProcessAfterIni...
Spring事务（二）——事务的提交
奔跑的蜗牛_Kieasr
10-29 4443
前世：JDK如何控制事务 判断是否在同一个事务的标准就是多个DML是否为同一个连接对象 Mysql的事务的提交方式默认为自动提交，如果有多个DML操作，每一个执行结束都会自动提交，所以要想多个DML操作在一个事务，必须将自动提交关闭（前提）。 开启事务 执行被代理方法 关闭事务 今生：Spring事务 首先Spring的事务也是运用了AOP的思想，我们知道，要实现AOP功能，必须有代理的入口类，那就是在类上加@EnableTransactionManagement注解，表示...
回首Spring源码之声明式事务源码级详解（中篇）
w7sss的博客
06-16 356
在上一篇介绍了@EnableTransactionManagement和@Transactional这两个注解，spring声明式事务的准备工作完成了，下面正式进入事务的执行流程。声明式事务本质是aop的一个环绕通知，也就是这个拦截器：TransactionInterceptor，来到TransactionInterceptor的invoke方法： 这个方法有点长，稍微总结一下： TransactionAttribute txAttr = (tas != null ? tas.getTransactio
spring事务管理实现原理-源码-传播属性-工作小结
王海涛的博客
11-01 8627
本博客分为两点，一个是spring事务实现原理源码解读（个人能力，初步解读），二是spring事务的传播属性   简单案例，保存订单，修改商品数量 就是这两个方法，第一个方法中引用了第二个方法，都用@Transactional注解。debug调用shopping方法。   spring事务实现的源码 在调用方法时会扫描@Transactional，进入方法前会判断是否有注解（在...
Spring5.x Transaction 自定义事务标签
lemon
02-29 1271
1、自定义事务标签XML配置 <tx: annotation-driven transaction-manager="transactionManager" mode="aspectj "/> 2、自定义事务标签命名空间处理器TxNamespaceHandler public class TxNamespaceHandler extends NamespaceHandl...
spring事务处理
我主人生
03-24 998
1.编程式事务处理： Spring提供编程式和声明式两种事务处理方式，我们首先通过一个编程式事务的小例子了解Spring中编程式事务处理的基本实现： [java] view plaincopy //通过DefaultTransactionDefinition对象来持有事务处理属性  TransactionDefinition td = new DefaultTransac
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值