spring事务源码分析

已于 2024-07-14 14:10:48 修改
阅读量309 收藏 5
点赞数 6
分类专栏： # spring 文章标签： java
于 2024-05-06 10:59:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lxn2zh/article/details/138487304
版权

事务源码分析

<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

与AOP的标签解析相同，tx:annotation-driven标签也是自定义标签，http://www.springframework.org/schema/tx找到对应的handler是TxNamespaceHandler

http\://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler

TxNamespaceHandler

执行init方法

public void init() {
   registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
		registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
		registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
}

在解析tx:annotation-driven标签时使用AnnotationDrivenBeanDefinitionParser来进行解析

public BeanDefinition parse(Element element, ParserContext parserContext) {
   registerTransactionalEventListenerFactory(parserContext);
   String mode = element.getAttribute("mode");
   if ("aspectj".equals(mode)) {
      // mode="aspectj"
      registerTransactionAspect(element, parserContext);
   }
   else {
      // mode="proxy"
      // 创建aop代理  AopAutoProxyConfigurer是内部静态类
     AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
   }
   return null;
}
configureAutoProxyCreator方法
public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
  // 注册了InfrastructureAdvisorAutoProxyCreator的bean
   AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
	// org.springframework.transaction.config.internalTransactionAdvisor
   String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
   if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
      Object eleSource = parserContext.extractSource(element);

      // Create the TransactionAttributeSource definition.
     // 创建TransactionAttributeSource的bean
      RootBeanDefinition sourceDef = new RootBeanDefinition(
            "org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
      sourceDef.setSource(eleSource);
      sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
     // 注册TransactionAttributeSource的bean
      String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);

      // Create the TransactionInterceptor definition.
     // 创建TransactionInterceptor的bean
      RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
      interceptorDef.setSource(eleSource);
      interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
      registerTransactionManager(element, interceptorDef);
      interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
     // 注册TransactionInterceptor的bean
      String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);

      // Create the TransactionAttributeSourceAdvisor definition.
     // 创建TransactionAttributeSourceAdvisor的bean
      RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
      advisorDef.setSource(eleSource);
      advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
     // 将TransactionAttributeSource的bean注入到transactionAttributeSource属性中
      advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
     // // 将TransactionInterceptor的bean注入到adviceBeanName属性中
      advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
      if (element.hasAttribute("order")) {
         advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
      }
     // 注册的bean的名称是org.springframework.transaction.config.internalTransactionAdvisor
      parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);

      CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
      compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
      compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
      compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));
      parserContext.registerComponent(compositeDef);
   }
}
InfrastructureAdvisorAutoProxyCreator

来先看一下InfrastructureAdvisorAutoProxyCreator的结构，发现和之前解析AOP时的AnnotationAwareAspectJAutoProxyCreator很像

事务解析

而且继承的类也是一样的，都是AbstractAdvisorAutoProxyCreator，之后的逻辑就与AOP的很是相似了，找Advisor类的bean，是有一个的，注册BeanFactoryTransactionAttributeSourceAdvisor

public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {

	private TransactionAttributeSource transactionAttributeSource;

	private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
		@Override
		protected TransactionAttributeSource getTransactionAttributeSource() {
			return transactionAttributeSource;
		}
	};


	/**
	 * Set the transaction attribute source which is used to find transaction
	 * attributes. This should usually be identical to the source reference
	 * set on the transaction interceptor itself.
	 * @see TransactionInterceptor#setTransactionAttributeSource
	 */
	public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource) {
		this.transactionAttributeSource = transactionAttributeSource;
	}

	/**
	 * Set the {@link ClassFilter} to use for this pointcut.
	 * Default is {@link ClassFilter#TRUE}.
	 */
	public void setClassFilter(ClassFilter classFilter) {
		this.pointcut.setClassFilter(classFilter);
	}

	@Override
	public Pointcut getPointcut() {
		return this.pointcut;
	}

}

判断pointcut是TransactionAttributeSourcePointcut

public boolean matches(Method method, Class<?> targetClass) {
   if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {
      return false;
   }
  // TransactionAttributeSource是上面进行创建的AnnotationTransactionAttributeSource
   TransactionAttributeSource tas = getTransactionAttributeSource();
   return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}

// 获取事务属性
public TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass) {
		if (method.getDeclaringClass() == Object.class) {
			return null;
		}

		// First, see if we have a cached value.
		Object cacheKey = getCacheKey(method, targetClass);
		TransactionAttribute cached = this.attributeCache.get(cacheKey);
		if (cached != null) {
			// Value will either be canonical value indicating there is no transaction attribute,
			// or an actual transaction attribute.
			if (cached == NULL_TRANSACTION_ATTRIBUTE) {
				return null;
			}
			else {
				return cached;
			}
		}
		else {
			// We need to work it out.
			TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
			// Put it in the cache.
			if (txAttr == null) {
				this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
			}
			else {
				String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
				if (txAttr instanceof DefaultTransactionAttribute) {
					((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
				}
				
				this.attributeCache.put(cacheKey, txAttr);
			}
			return txAttr;
		}
	}

// 解析@Transactional注解 TransactionAttribute
protected TransactionAttribute computeTransactionAttribute(Method method, Class<?> targetClass) {
		// Don't allow no-public methods as required.
		if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
			return null;
		}

		// Ignore CGLIB subclasses - introspect the actual user class.
		Class<?> userClass = ClassUtils.getUserClass(targetClass);
		// The method may be on an interface, but we need attributes from the target class.
		// If the target class is null, the method will be unchanged.
		Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
		// If we are dealing with method with generic parameters, find the original method.
		specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

		// First try is the method in the target class.
  // 先尝试解析方法上有没有@Transactional注解
		TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
		if (txAttr != null) {
			return txAttr;
		}

		// Second try is the transaction attribute on the target class.
  // 如果方法上没有，则解析类上的
		txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
		if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
			return txAttr;
		}

		if (specificMethod != method) {
			// Fallback is to look at the original method.
			txAttr = findTransactionAttribute(method);
			if (txAttr != null) {
				return txAttr;
			}
			// Last fallback is the class of the original method.
			txAttr = findTransactionAttribute(method.getDeclaringClass());
			if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
				return txAttr;
			}
		}

		return null;
	}
方法增强

如果匹配到@Transactional注解就会使用上述注册的TransactionInterceptor来进行方法增强

TransactionInterceptor#invoke方法

对于事务方法的调用，最终会调用TransactionInterceptor#invoke方法，会根据不同的事务处理器以及事务配置情况来进行事务操作

public Object invoke(final MethodInvocation invocation) throws Throwable {
  // 获取代理的目标对象
   Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

   // Adapt to TransactionAspectSupport's invokeWithinTransaction...
   return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
      @Override
      public Object proceedWithInvocation() throws Throwable {
         return invocation.proceed();
      }
   });
}



protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)
			throws Throwable {

		// If the transaction attribute is null, the method is non-transactional.
  // 获取事务属性
		final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
  // 事务管理器
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
  // 方法的唯一标识
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
// 区分不同的事务管理器
  // 对于CallbackPreferringPlatformTransactionManager类型的事务管理器，需要回调函数来实现事务的创建和提交，即声明式事务
  // 对于非CallbackPreferringPlatformTransactionManager类型的，不需要通过回调函数来实现事务的创建和提交，即编程式事务
		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
      // 创建事务，同时把创建事务过程中得到的信息放到TransactionInfo中，保存当前事务状态
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

			Object retVal;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
        // 沿着处理器链进行调用，执行被增强方法
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// target invocation exception
        // 事务处理方法调用中出现异常，事务处理需要根据具体情况进行回滚或者提交
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
        // 重置掉ThreadLocal中的信息transactionInfoHolder.set(this.oldTransactionInfo)
				cleanupTransactionInfo(txInfo);
			}
      // 事务提交
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}

		else { // 需要通过回调方法操作事务
			Object result;
			final ThrowableHolder throwableHolder = new ThrowableHolder();

			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
			try {
				result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
						new TransactionCallback<Object>() {
							@Override
							public Object doInTransaction(TransactionStatus status) {
								TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
								try {
									return invocation.proceedWithInvocation();
								}
								catch (Throwable ex) {
									if (txAttr.rollbackOn(ex)) {
										// A RuntimeException: will lead to a rollback.
										if (ex instanceof RuntimeException) {
											throw (RuntimeException) ex;
										}
										else {
											throw new ThrowableHolderException(ex);
										}
									}
									else {
										// A normal return value: will lead to a commit.
										throwableHolder.throwable = ex;
										return null;
									}
								}
								finally {
									cleanupTransactionInfo(txInfo);
								}
							}
						});
			}
			catch (ThrowableHolderException ex) {
				throw ex.getCause();
			}
			catch (TransactionSystemException ex2) {
				if (throwableHolder.throwable != null) {
					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
					ex2.initApplicationException(throwableHolder.throwable);
				}
				throw ex2;
			}
			catch (Throwable ex2) {
				if (throwableHolder.throwable != null) {
					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
				}
				throw ex2;
			}

			// Check result state: It might indicate a Throwable to rethrow.
			if (throwableHolder.throwable != null) {
				throw throwableHolder.throwable;
			}
			return result;
		}
	}
事务创建方法createTransactionIfNecessary
protected TransactionInfo createTransactionIfNecessary(
      PlatformTransactionManager tm, 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) {
        // 获取TransactionStatus
         status = tm.getTransaction(txAttr);
      }
      else {
         
      }
   }
  // 根据指定的属性和status准备一个TransactionInfo
   return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}




protected TransactionInfo prepareTransactionInfo(PlatformTransactionManager tm,
			TransactionAttribute txAttr, String joinpointIdentification, TransactionStatus status) {

		TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
		if (txAttr != null) {
			// We need a transaction for this method...
			
			// The transaction manager will flag an error if an incompatible tx already exists.
			txInfo.newTransactionStatus(status);
		}
		else {
			// The TransactionInfo.hasTransaction() method will return false. We created it only
			// to preserve the integrity of the ThreadLocal stack maintained in this class.
			
		}

		// We always bind the TransactionInfo to the thread, even if we didn't create
		// a new transaction here. This guarantees that the TransactionInfo stack
		// will be managed correctly even if no transaction was created by this aspect.
  // 将当前的TransactionInfo和线程进行绑定，同时TransactionInfo中由一个变量来保存以前的TransactionInfo，在请求事务时会创建TransactionInfo
		txInfo.bindToThread();
		return txInfo;
	}

getTransaction获取事务

// 1、获取事务
public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
  // 从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)) {
			// Existing transaction found -> check propagation behavior to find out how to behave.
      // 如果已经存在事务
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}

		// Check definition settings for new transaction.
  // 事务超时
		if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
			throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
		}

		// No existing transaction found -> check propagation behavior to find out how to proceed.
  // 当前线程不存在事务，但是TransactionDefinition被声明为PROPAGATION_MANDATORY，则抛出异常
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}
  // 当前线程不存在事务，但是TransactionDefinition被声明为PROPAGATION_REQUIRED或者PROPAGATION_REQUIRES_NEW或者PROPAGATION_NESTED，则新建事务
		else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
      // 空挂起
			SuspendedResourcesHolder suspendedResources = suspend(null);
			
			try {
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        // 开始创建事务，包括设置ConnectionHolder、隔离级别、timeout，如果是新连接，则绑定到当前线程
				doBegin(transaction, definition);
        // 同步事务的设置
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException ex) {
				resume(null, suspendedResources);
				throw ex;
			}
			catch (Error err) {
				resume(null, suspendedResources);
				throw err;
			}
		}
		else {
			// Create "empty" transaction: no actual transaction, but potentially synchronization.
			
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
		}
	}

以DataSourceTransactionManager为例

事务管理器

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
      implements ResourceTransactionManager, InitializingBean {
// 注入的数据源
   private DataSource dataSource;

   private boolean enforceReadOnly = false;


   
   public DataSourceTransactionManager() {
      setNestedTransactionAllowed(true);
   }

   
   public DataSourceTransactionManager(DataSource dataSource) {
      this();
      setDataSource(dataSource);
      afterPropertiesSet();
   }


  
   public void setDataSource(DataSource dataSource) {
      if (dataSource instanceof TransactionAwareDataSourceProxy) {
         
         this.dataSource = ((TransactionAwareDataSourceProxy) dataSource).getTargetDataSource();
      }
      else {
         this.dataSource = dataSource;
      }
   }

   /**
    * Return the JDBC DataSource that this instance manages transactions for.
    */
   public DataSource getDataSource() {
      return this.dataSource;
   }

   
   public void setEnforceReadOnly(boolean enforceReadOnly) {
      this.enforceReadOnly = enforceReadOnly;
   }

   
   public boolean isEnforceReadOnly() {
      return this.enforceReadOnly;
   }

   @Override
   public void afterPropertiesSet() {
      if (getDataSource() == null) {
         throw new IllegalArgumentException("Property 'dataSource' is required");
      }
   }


   @Override
   public Object getResourceFactory() {
      return getDataSource();
   }

   @Override
   protected Object doGetTransaction() {
      DataSourceTransactionObject txObject = new DataSourceTransactionObject();
      txObject.setSavepointAllowed(isNestedTransactionAllowed());
     // 事务工作是由Connection来完成的，把数据库的Connection放入到ConnectionHolder中，然后封装到DataSourceTransactionObject对象中
      ConnectionHolder conHolder =
            (ConnectionHolder) TransactionSynchronizationManager.getResource(this.dataSource);
      txObject.setConnectionHolder(conHolder, false);
      return txObject;
   }
// 判断是否存在事务，由ConnectionHolder的isTransactionActive来决定
   @Override
   protected boolean isExistingTransaction(Object transaction) {
      DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
      return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
   }
// 事务开始
   @Override
   protected void doBegin(Object transaction, TransactionDefinition definition) {
      DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
      Connection con = null;

      try {
         if (!txObject.hasConnectionHolder() ||
               txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
            Connection newCon = this.dataSource.getConnection();
            
           // 设置ConnectionHolder
            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).
        // 需要把自动提交事务关闭，由spring控制提交
         if (con.getAutoCommit()) {
            txObject.setMustRestoreAutoCommit(true);
            
            con.setAutoCommit(false);
         }

         prepareTransactionalConnection(con, definition);
        // 判断当前线程是否存在事务的依据
         txObject.getConnectionHolder().setTransactionActive(true);

         int timeout = determineTimeout(definition);
         if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
            txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
         }

         // Bind the connection holder to the thread.
        // 如果是新开的连接，需要把Connection和线程绑定
         if (txObject.isNewConnectionHolder()) {
            TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());
         }
      }

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

   @Override
   protected Object doSuspend(Object transaction) {
      DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
      txObject.setConnectionHolder(null);
      return TransactionSynchronizationManager.unbindResource(this.dataSource);
   }

   @Override
   protected void doResume(Object transaction, Object suspendedResources) {
      TransactionSynchronizationManager.bindResource(this.dataSource, suspendedResources);
   }
// 事务提交
   @Override
   protected void doCommit(DefaultTransactionStatus status) {
      DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
      Connection con = txObject.getConnectionHolder().getConnection();
      
      try {
         con.commit();
      }
      catch (SQLException ex) {
         throw new TransactionSystemException("Could not commit JDBC transaction", ex);
      }
   }
// 事务回滚
   @Override
   protected void doRollback(DefaultTransactionStatus status) {
      DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
      Connection con = txObject.getConnectionHolder().getConnection();
      
      try {
         con.rollback();
      }
      catch (SQLException ex) {
         throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
      }
   }

   @Override
   protected void doSetRollbackOnly(DefaultTransactionStatus status) {
      DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
      
      txObject.setRollbackOnly();
   }

   @Override
   protected void doCleanupAfterCompletion(Object transaction) {
      DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;

      // Remove the connection holder from the thread, if exposed.
      if (txObject.isNewConnectionHolder()) {
         TransactionSynchronizationManager.unbindResource(this.dataSource);
      }

      // Reset connection.
      Connection con = txObject.getConnectionHolder().getConnection();
      try {
         if (txObject.isMustRestoreAutoCommit()) {
            con.setAutoCommit(true);
         }
         DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());
      }
      catch (Throwable ex) {
         
      }

      if (txObject.isNewConnectionHolder()) {
         
         DataSourceUtils.releaseConnection(con, this.dataSource);
      }

      txObject.getConnectionHolder().clear();
   }


   /**
    * Prepare the transactional {@code Connection} right after transaction begin.
    * <p>The default implementation executes a "SET TRANSACTION READ ONLY" statement
    * if the {@link #setEnforceReadOnly "enforceReadOnly"} flag is set to {@code true}
    * and the transaction definition indicates a read-only transaction.
    * <p>The "SET TRANSACTION READ ONLY" is understood by Oracle, MySQL and Postgres
    * and may work with other databases as well. If you'd like to adapt this treatment,
    * override this method accordingly.
    * @param con the transactional JDBC Connection
    * @param definition the current transaction definition
    * @throws SQLException if thrown by JDBC API
    * @since 4.3.7
    * @see #setEnforceReadOnly
    */
   protected void prepareTransactionalConnection(Connection con, TransactionDefinition definition)
         throws SQLException {

      if (isEnforceReadOnly() && definition.isReadOnly()) {
         Statement stmt = con.createStatement();
         try {
            stmt.executeUpdate("SET TRANSACTION READ ONLY");
         }
         finally {
            stmt.close();
         }
      }
   }


   /**
    * DataSource transaction object, representing a ConnectionHolder.
    * Used as transaction object by DataSourceTransactionManager.
    */
   private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport {

      private boolean newConnectionHolder;

      private boolean mustRestoreAutoCommit;

      public void setConnectionHolder(ConnectionHolder connectionHolder, boolean newConnectionHolder) {
         super.setConnectionHolder(connectionHolder);
         this.newConnectionHolder = newConnectionHolder;
      }

      public boolean isNewConnectionHolder() {
         return this.newConnectionHolder;
      }

      public void setMustRestoreAutoCommit(boolean mustRestoreAutoCommit) {
         this.mustRestoreAutoCommit = mustRestoreAutoCommit;
      }

      public boolean isMustRestoreAutoCommit() {
         return this.mustRestoreAutoCommit;
      }

      public void setRollbackOnly() {
         getConnectionHolder().setRollbackOnly();
      }

      @Override
      public boolean isRollbackOnly() {
         return getConnectionHolder().isRollbackOnly();
      }

      @Override
      public void flush() {
         if (TransactionSynchronizationManager.isSynchronizationActive()) {
            TransactionSynchronizationUtils.triggerFlush();
         }
      }
   }

}

https://zhhll.icu/2022/框架/spring/进阶/8.事务源码分析/

本文由mdnice多平台发布

拾光师
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring源码分析 事务
许诗宇的博客
06-18 270
注意：本文摘自 spring源码深度解析 Spring声明式事务让我们从复杂的事务处理中得到解脱，使我们再也不需要去处理获得连接、 关闭连接、事务提交和回滚等操作，再也不需要在与事务相关的方法中处理大量的 try ... catch ... finally代码。Spring中事务的使用虽然已经相对简单得多，但是，还是有很多的使用及配置规则，有兴趣的读者可以自己查阅相关资料进行深入研究，这里只列举出最常用的使用方法。 同样，我们还是以最简单的示例来进行直观地介绍。 JDBC方式下的事务使用示例
Spring事务源码分析&责任链事务链&事务不生效
qq_30348103的博客
12-16 952
的
Spring事务源码分析
一瓶绿茶三元钱
05-16 516
一、Spring事务使用 1.通过maven方式引入jar包 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.8</version> </dependency> <dependency> <
Spring 事务源码分析
技术分享、唠嗑水文、如有不周、还望海涵
11-14 714
内容来自【自学星球】欢迎大家来了解我的星球，和星主（也就是我）一起学习 Java ，深入 Java 体系中的所有技术。我给自己定的时间是一年，无论结果如何，必定能给星球中的各位带来点东西。
spring源码分析之事务源码分析
Lxn2zh的博客
10-07 495
而且继承的类也是一样的，都是AbstractAdvisorAutoProxyCreator，之后的逻辑就与AOP的很是相似了，找Advisor类的bean，是有一个的，注册BeanFactoryTransactionAttributeSourceAdvisor。与AOP的标签解析相同，tx:annotation-driven标签也是自定义标签，http://www.springframework.org/schema/tx找到对应的handler是TxNamespaceHandler。
spring 事务源码分析
weixin_43785662的博客
12-27 418
我们之前的数十篇文章分析了 Spring 和 Mybatis 的原理，基本上从源码层面都了解了他们的基本原理，那么。在我们日常使用这些框架的时候，还有哪些疑问呢？就楼主而言，楼主已经明白了 IOC ，AOP 的原理，也明白了 Mybatis 的原理，也明白了 Spring 和 Mybatis 是如何整合的。但是，我们漏掉了 JavaEE 中一个非常重要的特性：事务。事务是 Java 程序员开发程序时不可避免的问题。我们就不讨论 ACID 的事务特性，楼主这里假定大家都已经了了解了事务的原理。如果还不了解，可
spring事务的源码分析
06-11
spring的核心就是IC依赖注入，那么就要先解析依赖配置，然后再注入。所以spring的功能都会出现两块，一块是解析mxl，一块是构建BeanDefinition。...事务增强器也是这样，先要解析事务的标签，然后才是执行事务。
Spring5 源码分析(第 2 版)-某Tom老师
07-04
《Spring5 源码分析(第 2 版)》是某Tom老师精心编写的深度解析文档，旨在帮助读者全面理解Spring5的核心机制和设计理念。Spring作为Java领域最为广泛应用的框架之一，其源码的深入理解对于开发者来说至关重要。这篇...
Spring5 源码分析(第 2 版) .zip
07-23
《Spring5 源码分析(第 2 版)》是针对Spring框架第五个主要版本的深度解析著作，由知名讲师倾心打造，旨在帮助读者深入理解Spring框架的内部工作机制，提升对Java企业级应用开发的专业技能。本书涵盖了Spring框架的...
spring学习事务源码
06-02
在源码分析中，我们可以看到当一个方法被@Transactional标记后，Spring会创建一个代理，这个代理在目标方法执行前后插入事务管理逻辑。在方法开始前，如果满足事务启动条件，就会调用`PlatformTransactionManager`的...
spring 事务源码剖析
stay_the_course的博客
11-09 368
spring事务源码看不懂？？不可能的，看完必会！
Spring源码深度解析 事务总结
勤劳的搬运工
03-17 1011
JDBC 方式下的事务使用示例 创建数据表结构 创建对应数据表的 PO 创建表与实体间的映射 创建数据操作接口 创建数据操作接口实现类 创建 Spring 配置文件 测试 默认情况下 Spring 中的 事务处理只对 RuntimeException 方法进行回滚，所以，如果 此处将 RuntimeException 替换成普通的 Exception 不会产生回滚效果 事务自定义标签 在配置文件中有这样一个配置 tx:annotation-driven/ 可以说此处配置是事务的开关 使用
springboot中找事务对象的源码在哪儿
weixin_42613018的博客
12-20 75
在 Spring Boot 中，您可以通过自动配置来获取事务对象。具体来说，可以在启动应用程序时通过 @EnableTransactionManagement 注解来启用事务管理。这会自动配置一个事务管理器，并为您的应用程序提供一个事务对象。 如果您想要深入了解这个过程，可以查看 Spring Boot 的自动配置源代码。在 Spring Boot 2.4.0 版本中，事务自动配置的源代码位于以下...
Spring源码学习(二十)---＜tx:annotation-driven/＞支持事务注解的(@Transactional)标签解析过程
https://juejin.cn/user/4248168663101239/posts
04-28 620
这里主要是使用org.springframework:spring-beans:5.0.2.RELEASE进行分析 文章目录一. XML配置文件开启tx注解二. TxNamespaceHandler类 1. 查看源码相关的快捷键 快捷键 作用 Ctrl + Shift+i 出现类似于预览的小窗口 Ctrl + Enter （接上步）完全打开源码 Ctrl + 鼠标左键 一步到位打开源码 = Ctrl + Shift+i –>Ctrl + Enter Alt+7 查看类的有.
Spring事务源码：创建代理类
最新发布
CRUD工程师
04-01 804
本文我们介绍下Spring中的事务管理的源码，Spring的事务管理主要有申明式事务与编程式事务这两种，如果对这两种方式不了解的朋友可以先看下这篇文章（《Spring事务管理（详解+实例）》）然后再来深入源码分析。我们通过如下方式开启事务，由于申明式事务的注入方式式基于代理方式实现的，因此这里也建议先了解下AOP的源码，这部分我前文已经做了完整的介绍，因此下文将不会对AOP的功能做深入的解析，有需要的朋友可以看下我之前AOP的文章。目录前言。
Spring中tx命名空间和配置注解工作原理浅析
RoxLiu的专栏
03-20 9628
context:component-scan的工作原理？ 从扫描进程的启动，配置文件，标注的产生等等。。。
Spring源码——bean的加载
等一杯咖啡的博客
09-26 4498
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第五章的部分，依照书中内容以及个人理解对Spring进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 在前几篇文章中，我们已经完成了将XML配置文件的信息转换为 B...
NamespaceHandler 接口
Leon_Jinhai_Sun的博客
11-27 411
NamespaceHandler 接口，DefaultBeanDefinitionDocumentReader 使用该接口来处理在spring xml 配置文件中自定义的命名空间。 在jdbc 模块，我们使用JdbcNamespaceHandler 来处理jdbc 配置的命名空间，其代码如下： public class JdbcNamespaceHandler extends NamespaceHandlerSupport { public JdbcNamespaceHandler() .
Spring源码解析之-- 事务注解 处理流程 分析
一直打铁
03-03 738
目录一、背景二、流程介绍2.1 TxNamespaceHandler 入口2.2 AnnotationDrivenBeanDefinitionParser#parse 分析 一、背景 通常我们在XML里面配置 <tx:annotation-driven/> 这个就是配置事务的开关， 如果没有此处配置， 那么Spring 中 将不存在事务的功能,那么我们解析啦就从这个配置开始分析. 这里用的是 spring 5.2.10.RELEASE 版本 二、流程介绍 2.1 TxNamespaceHand
Spring事务源码解析：XML配置与AOP增强机制
Spring事务的源码分析揭示了其对依赖注入和AOP的强大整合，通过解析XML配置和运行时的动态代理机制，提供了灵活且强大的事务管理能力。理解这些核心源码有助于开发者更深入地掌握Spring框架，并在实际项目中更好地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拾光师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值