主頁 > 後端開發 > Spring事務原始碼解讀

Spring事務原始碼解讀

2022-05-15 22:18:12 後端開發

一、Spring事務使用

1.通過maven方式引入jar包

     <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.8</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.28</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.20.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.20.RELEASE</version>
    </dependency>

2.創建配置類，使用注解@EnableTransactionManagement開啟事務功能，代碼如下：

package com.ybe.transaction.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@ComponentScan("com.ybe.transaction")
public class TransactionConfig {

    @Bean
    public DataSource dataSource() {
        DruidDataSource data = https://www.cnblogs.com/yuanbeier/p/new DruidDataSource();
        data.setDriverClassName("com.mysql.cj.jdbc.Driver");
        data.setUrl("jdbc:mysql://localhost:3306/xxx?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8");
        data.setUsername("xxx");
        data.setPassword("xxx");
        return data;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

3.使用@Transactional注解，代碼如下：

package com.ybe.transaction.service;

import com.ybe.transaction.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BookService {
    @Autowired
    BookDao bookDao;

    public BookDao getBookDao() {
        return bookDao;
    }

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    /**
     * 結賬：傳入哪個用戶買了哪本書
     * @param id
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void checkout(int id){
        bookDao.updateStock(id);
    }

}


package com.ybe.transaction.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Repository
public class BookDao {
    @Autowired
    JdbcTemplate jdbcTemplate;

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * 減庫存，減去某本書的庫存
     * @param id
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateStock(int id){
        String sql = "update book_stock set stock=stock-1 where id=?";
        jdbcTemplate.update(sql,id);
//        for (int i = 1 ;i>=0 ;i--)
//            System.out.println(10/i);
    }
}

5.Main的代碼

    AnnotationConfigApplicationContext configApplicationContext = new AnnotationConfigApplicationContext(TransactionConfig.class);
    BookService bean = configApplicationContext.getBean(BookService.class);
    bean.checkout(1);
    System.out.println("完成");

三、Spring事務的原始碼分析

Spring事務和SpringAOP一樣，都是利用了SpringIoc容器的插件功能，在SpringIOC容器的生命周期程序中整合了Spring事務的功能，大概程序：通過 @Import注冊 TransactionManagementConfigurationSelector 類，該類中實作了 ImportSelector介面的selectImports方法 ，在創建AnnoteationConfigApplicationContext的建構式中會呼叫refresh()方法，在 invokeBeanFactoryPostProcessors()中會呼叫TransactionManagementConfigurationSelector 類的 selectImports 方法，會生成 AutoProxyRegistrar 的物件和ProxyTransactionManagementConfiguration物件，AutoProxyRegistrar會呼叫該類的registerBeanDefinitions方法注冊型別為InfrastructureAdvisorAutoProxyCreator的RootBeanDefinition，ProxyTransactionManagementConfiguration中注入了BeanFactoryTransactionAttributeSourceAdvisor型別的Bean，即事務通知類，該類繼承了 Advisor， 在finishBeanFactoryInitialization()程序中第一次呼叫 getAdvicesAndAdvisorsForBean 的時候，會先進行Advisors的創建，再獲取候選的Advisors，在創建完 Bean后會呼叫InfrastructureAdvisorAutoProxyCreator的 postProcessAfterInitialization方法，從 Advisors 中查找是否匹配當前正在創建的Bean，如果能匹配，則創建相關的事務動態代理物件，

完整原始碼分析分三部分:Spring事務的初始化、事務的創建、事務的呼叫程序，

一、Spring事務的初始化

主要邏輯是找到所有標注了 @EnableTransactionManagement的類，并且決議標注中的事務通知方法和BeanPostProcessor的實作類BeanFactoryTransactionAttributeSourceAdvisor，

整體代碼流程圖如下：

說明：

  1. 創建 AnnotationConfigApplicationContext() 容器，

  2. 在invokeBeanFactoryPostProcessors()中，會呼叫 ConfigurationClassPostProcessor 的 postProcessBeanDefinitionRegistry() ，在此方法中，會找到 @EnableTransactionManagement的 @Import 屬性傳入的 TransactionManagementConfigurationSelector.class 類，并且執行該類的selectImports() 方法，將型別為 InfrastructureAdvisorAutoProxyCreator、名稱為org.springframework.aop.
    config.internalAutoProxyCreator和型別為 ProxyTransactionManagementConfiguration的 RootBeanDefinition注冊到BeanDefinitionRegistry中，

  3. 在 registerBeanPostProcessors() 中會根據上面一步生成的 RootBeanDefinition物件創建 InfrastructureAdvisorAutoProxyCreator的Bean實體，

  4. 在 finishBeanFactoryInitialization() 中第一次執行到 、AbstractAutowireCapableBeanFactory.initializeBean() 時，會執行一段這樣的代碼，如下

 if (mbd == null || !mbd.isSynthetic()) {
   wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 }

  @Override
 public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
 			throws BeansException {
   Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
	Object current = processor.postProcessAfterInitialization(result, beanName);
	if (current == null) {
	    return result;
	}
	result = current;
    }
    return result;
 }

以上代碼會執行 InfrastructureAdvisorAutoProxyCreator 的 postProcessAfterInitialization() 方法，代碼如下：

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
	   if (bean != null) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		if (this.earlyProxyReferences.remove(cacheKey) != bean) {
		    return wrapIfNecessary(bean, beanName, cacheKey);
		}
	   }
	   return bean;
}

在 wrapIfNecessary 的getAdvicesAndAdvisorsForBean會呼叫findEligibleAdvisors，代碼如下：

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
	List<Advisor> candidateAdvisors = findCandidateAdvisors();
 List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
 extendAdvisors(eligibleAdvisors);
 if (!eligibleAdvisors.isEmpty()) {
 	eligibleAdvisors = sortAdvisors(eligibleAdvisors);
 }
 return eligibleAdvisors;
}

在findCandidateAdvisors方法中會生成所有的 Advisors，其中事務的Advisor 是 BeanFactoryTransactionAttributeSourceAdvisor 類，

protected List<Advisor> findCandidateAdvisors() {
	  Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
	  return this.advisorRetrievalHelper.findAdvisorBeans();
}

advisorRetrievalHelper.findAdvisorBeans()是關鍵，方法里面的邏輯如下：

1.先從cachedAdvisorBeanNames中獲取beanNames
2.如果cachedAdvisorBeanNames為null，
  2.1 則獲取所有型別為 Advisor的 beanNames，并且添加到cachedAdvisorBeanNames中
3. 遍歷 beanNames ，根據beanName獲取具體的Bean物件，添加到advisors中
4.最后回傳 advisors，

advisorRetrievalHelper.findAdvisorBeans()方法會快取所有型別為Advisor的BeanName，方法的最后回傳 advisors，至此整個 Spring事務的初始化完成，

二、事務的創建

? 在創建Bean的生命周期的 initializeBean 方法中，會執行 InfrastructureAdvisorAutoProxyCreator的 postProcessAfterInitialization方法，該方法里會拿快取中BeanFactoryTransactionAttributeSourceAdvisor的pointCut去匹配正在創建的實體Bean的所有方法，如果 BeanFactoryTransactionAttributeSourceAdvisor 和 Bean 的某一個方法能匹配上，則把該BeanFactoryTransactionAttributeSourceAdvisor 添加到 advisor的候選集合中，直到找出匹配Bean的所有Adsivors，最后根據Adsivor的候選集合和Bean型別創建動態代理物件ProxyFactory，

整體代碼流程圖如下：

說明：

1.動態代理的創建

創建動態代理有兩種方法，一種是 JDK ，一種是 CGLib ，

1.如果目標類有實作介面的話，則是使用JDK的方式生成代理物件，

2.配置了使用Cglib進行動態代理或者目標類沒有實作介面,那么使用Cglib的方式創建代理物件，

區別：
創建：CGLIB由于創建多個.class 檔案所以 效率肯定要慢于JDK動態代理
呼叫：CGLIB是要優于JDK的，因為JDK使用的反射，而CGLIB直接呼叫，

三、事務的呼叫程序

? 以上面的Main方法為示例，只分析兩層事務，并且只分析事務提交成功的情況，在呼叫bean.checkout(1)方法的時候會直接呼叫 CglibAopProxy.intercept()方法，里面的大概邏輯如下：

  1. 獲取被代理的實作類；

  2. 找出匹配該checkout 的 BeanFactoryTransactionAttributeSourceAdvisor，并且把 BeanFactoryTransactionAttributeSourceAdvisor 轉成Interceptor型別，回傳攔截器鏈，

  3. 創建 CglibMethodInvocation （該物件中包括了 代理物件、被代理物件、執行的方法、方法引數、被代理物件的型別、事務攔截器）它繼承了 ReflectiveMethodInvocation 物件，執行CglibMethodInvocation 物件的proceed()方法，里面會呼叫 ReflectiveMethodInvocation 的 proceed方法 ，該方法中會進行事務攔截器的遞回呼叫，具體呼叫流程如下圖，ReflectiveMethodInvocation 物件在通知攔截器鏈呼叫中作用很關鍵，有銜接各個攔截器的作用，

代碼流程如下圖：

  1. 在ReflectiveMethodInvocation 的proceed方法中，會先判斷當前攔截器鏈的索引，如果索引等于最后一個那么則執行被代理類的方法，

  2. 如果不是，那么先從攔截器鏈中獲取攔截器（TransactionInterceptor）并且執行該攔截器的 proceed 方法（方法接受 ReflectiveMethodInvocation 物件實體）

  3. TransactionInterceptor會呼叫 invokeWithinTransaction()方法，主要邏輯為

     1. 是否需要創建事務，
 2. 執行具體的方法，
 3. 回滾或者提交事務，

    主要代碼如下：

//創建必要的事務
TransactionInfo txInfo = createTransactionIfNecessary(ptm, 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 {
    cleanupTransactionInfo(txInfo);
}
//事務提交
commitTransactionAfterReturning(txInfo);
  1. createTransactionIfNecessary 中會呼叫 getTransaction 方法，getTransaction 方法執行的關鍵代碼有
    7.1 doGetTransaction(),創建資料源事務物件，并設定 conHolder物件，此時conHolder為null，
// 創建一個資料源事務物件
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
// 是否允許當前事務設定保持點
txObject.setSavepointAllowed(isNestedTransactionAllowed());
/**
* TransactionSynchronizationManager 事務同步管理器物件(該類中都是區域執行緒變數)
* 用來保存當前事務的資訊,我們第一次從這里去執行緒變數中獲取 事務連接持有器物件 通過資料源為key去獲取
* 由于第一次進來開始事務 我們的事務同步管理器中沒有被存放.所以此時獲取出來的conHolder為null
*/
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
// 非新創建連接則寫false
txObject.setConnectionHolder(conHolder, false);
// 回傳事務物件
return txObject;

7.2 isExistingTransaction(transaction),判斷依據為當前執行緒記錄的連接不為空且連接中的transactionActive屬性不為空，此時為不存在連接，所以該方法回傳false，

DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 若第一次進來開始事務，txObject.hasConnectionHolder()回傳的null那么表示不存在事務
return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());

? 7.3 因為checkout()方法 的 事務屬性為Propagation.REQUIRED,所以這里進入如下代碼

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 {
        return startTransaction(def, transaction, debugEnabled, suspendedResources);
    }
    catch (RuntimeException | Error ex) {
        resume(null, suspendedResources);
        throw ex;
    }
}

其中 suspend(null),表示沒有當前事務，因為這個時候當前的執行緒變數中有沒有激活的事物并且transaction 為null 所以這個方法回傳 null，代碼如下：

else {
     // Neither transaction nor synchronization active.
     return null;
}

? 7.4 startTransaction(),開啟事務并回傳事務狀態，

// 是否需要新同步
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 創建新的事務
DefaultTransactionStatus status = newTransactionStatus(
    definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 開啟事務和連接
doBegin(transaction, definition);
// 同步事務的設定，如果執行緒狀態是：NewSynchronization，則設定執行緒同步管理器的相關資訊
prepareSynchronization(status, definition);
return status;

? 其中 doBegin(),創建連接，關閉自動提交，保存連接持有器到當前執行緒管理器中（確保嵌套中的事務屬性物件可以訪問到當前的事務連接器，即事務連接可傳播，內層的事務可以訪問外層的事務），其中 doBegin方法中關鍵代碼如下：

// 通過資料源獲取一個資料庫連接物件
Connection newCon = obtainDataSource().getConnection();

// 把我們的資料庫連接包裝成一個ConnectionHolder物件 然后設定到我們的txObject物件中去
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);

// 關閉自動提交
con.setAutoCommit(false);

//如果是新事務連接持有器則保存連接持有器到執行緒管理器中
if (txObject.isNewConnectionHolder()) {
    TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder());
}

? 其中 prepareSynchronization，同步事務的設定，如果執行緒狀態是：NewSynchronization，則設定執行緒同步管理器的相關資訊，此時執行緒狀態是NewSynchronization，代碼如下：

if (status.isNewSynchronization()) {
    // 系結事務激活
    TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
    // 當前事務的隔離級別
    TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
        definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
        definition.getIsolationLevel() : null);
    // 是否為只讀事務
    TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
    // 事務的名稱
    TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
    TransactionSynchronizationManager.initSynchronization();
}
  1. createTransactionIfNecessary 中的prepareTransactionInfo()，創建一個TransactionInfo，然后設定該事務資訊的新事務狀態，代碼如下：
//創建事務資訊物件
TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
if (txAttr != null) {
   // We need a transaction for this method...
     if (logger.isTraceEnabled()) {
        logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
     }
     // The transaction manager will flag an error if an incompatible tx already exists.
     //設定事務狀態
     txInfo.newTransactionStatus(status);
}
  1. invocation.proceedWithInvocation()執行具體的方法體，這里指checkout()的方法，當執行 bookDao.updateStock(id)的時候，因為bookDao也是代理類，這里會進入第內層代理類的呼叫，即呼叫CglibAopProxy.intercept()方法，

以下代碼是 updateStock(id)方法的事務處理程序：

  1. 前面步驟和 checkout() 都差不多，直到createTransactionIfNecessary 的中getTransaction的代碼：

? 1.1 doGetTransaction(),創建資料源事務物件，并設定conHolder物件，由于是第二次進來創建事務方法， 我們的事務同步管理器中有第一次事務保存的conHolder，所以此時獲取出來的conHolder不為null，

// 創建一個資料源事務物件
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
// 是否允許當前事務設定保持點
txObject.setSavepointAllowed(isNestedTransactionAllowed());
/**
* TransactionSynchronizationManager 事務同步管理器物件(該類中都是區域執行緒變數)
* 用來保存當前事務的資訊,我們第一次從這里去執行緒變數中獲取 事務連接持有器物件 通過資料源為key去獲取
* 由于第二次進來開始事務 我們的事務同步管理器中有第一次事務保存的conHolder.所以此時獲取出來的conHolder不為null
*/
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
// 非新創建連接則寫false
txObject.setConnectionHolder(conHolder, false);

? 1.2 isExistingTransaction(transaction)，判斷依據為當前執行緒記錄的連接不為空且連接中的transactionActive屬性不為空,此時為存在，會執行if代碼塊里面的代碼，執行handleExistingTransaction()方法，在此方法中執行的關鍵代碼如下：

? 1.2.1 由于updateStock的事務屬性為Propagation.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 {
        return startTransaction(definition, transaction, debugEnabled, suspendedResources);
    }
    catch (RuntimeException | Error beginEx) {
        resumeAfterBeginException(transaction, suspendedResources, beginEx);
        throw beginEx;
    }
}

? 1.2.2 suspend方法中主要邏輯為：呼叫doSuspend 掛起連接持有器，然后先從事務管理器中獲取當前事務（外層事務）的名稱、只讀屬性、事務隔離級別、當前事務激活狀態，然后清空事務狀態，再把之前獲取到的屬性封裝為一個掛起的事務屬性SuspendedResourcesHolder回傳出去，該事務屬性用來記錄當前事務的相關屬性，以便內層事務后面用來恢復外層事務，代碼如下：

// 判斷當前的執行緒同步管理器變數中有沒有激活的事物,有需要清空執行緒變數
if (TransactionSynchronizationManager.isSynchronizationActive()) {
	List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
    try {
        Object suspendedResources = null;
        if (transaction != null) {
            //掛起的資源，連接持有器，這里指掛起當前連接，后面備用，會傳入掛起的資源管理器
            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;
			}
}

其中 doSuspend ,主要是掛起外層的事務連接持有器并回傳掛起的物件，代碼邏輯如下

DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 清空連接持有器
txObject.setConnectionHolder(null);
// 解綁執行緒私有的資源，回傳給上一層
return TransactionSynchronizationManager.unbindResource(obtainDataSource());

? 1.2.3 startTransaction 開啟事務并回傳事務狀態，這里會存入上面回傳的掛起的資源連接器，里面保存了外層事務狀態的相關資訊以及連接持有器，

// 是否需要新同步
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 創建新的事務狀態
DefaultTransactionStatus status = newTransactionStatus(
    definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 開啟事務和連接
doBegin(transaction, definition);
// 同步事務的設定，如果執行緒狀態是：新執行緒，則設定執行緒同步管理器的相關資訊
prepareSynchronization(status, definition);
return status;

? 1.2.3.1 doBegin(),創建連接，關閉自動提交，保存連接持有器到當前執行緒管理器中（確保嵌套中的事務屬性物件可以訪問到當前的事務連接器，即事務連接可傳播，內層的事務可以訪問外層的事務），和上面的doBegin作用一樣，

? 1.2.3.2 prepareSynchronization()，同步事務的設定，如果執行緒狀態是：NewSynchronization，則設定執行緒同步管理器的相關資訊，此時執行緒狀態是NewSynchronization，

  1. createTransactionIfNecessary 中 prepareTransactionInfo()，創建一個TransactionInfo，然后設定該事務資訊的新事務狀態，
  2. retVal = invocation.proceedWithInvocation();執行updateStock(id)方法體里面的內容，
  3. commitTransactionAfterReturning 提交具體的事務，由于此時TransactionInfo的TransactionStatus為true，會執行如下代碼：
//當前狀態是新事務
else if (status.isNewTransaction()) {
    if (status.isDebug()) {
   		 logger.debug("Initiating transaction commit");
	}
	unexpectedRollback = status.isGlobalRollbackOnly();
	// 如果是獨立的事務則直接提交
	doCommit(status);
}

? 4.1 其中doCommitf方法中會獲取連接物件，并且完成資料庫事務的提交，代碼如下：

DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
    logger.debug("Committing JDBC transaction on Connection [" + con + "]");
}
try {
    // JDBC連接提交
    con.commit();
}
catch (SQLException ex) {
    throw new TransactionSystemException("Could not commit JDBC transaction", ex);
}
  1. cleanupAfterCompletion，回滾后的處理作業，其中resume方法中會恢復之前掛起的事務，代碼如下：
// 有掛起的事務要恢復
if (status.getSuspendedResources() != null) {
    if (status.isDebug()) {
        logger.debug("Resuming suspended transaction after completion of inner transaction");
    }
    Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
    // 結束之前事務的掛起狀態
    resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
}
  1. resume 中的 doResume 會拿到外層的事務即（checkout方法事務）的連接持有器放入事務同步管理器中，這樣就確保了，在執行到 checkout方法體的時候拿到的連接物件是checkout當時生成的連接物件，以便checkout方法類其他嵌套事務呼叫，
protected void doResume(@Nullable Object transaction, Object suspendedResources) {
	TransactionSynchronizationManager.bindResource(this.obtainDataSource(), suspendedResources);
}

至此，updateStock() 方法執行基本完成，代碼執行回到checkout()方法體中，

  1. checkout執行完畢之后，回到checkout程序中的invocation.proceedWithInvocation()，
  2. 如果成功，則commitTransactionAfterReturning 提交事務，由于此時TransactionInfo的TransactionStatus為true，會執行如下代碼：
//當前狀態是新事務
else if (status.isNewTransaction()) {
    if (status.isDebug()) {
   		 logger.debug("Initiating transaction commit");
	}
	unexpectedRollback = status.isGlobalRollbackOnly();
	// 如果是獨立的事務則直接提交
	doCommit(status);
}

? 2.1 其中doCommitf方法中會獲取連接物件，并且完成資料庫事務的提交，代碼如下：

DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
    logger.debug("Committing JDBC transaction on Connection [" + con + "]");
}
try {
    // JDBC連接提交
    con.commit();
}
catch (SQLException ex) {
    throw new TransactionSystemException("Could not commit JDBC transaction", ex);
}

至此，checkout() 方法執行大概完成，整個代碼呼叫事務也基本完成了，

四、事務的傳播行為總結

事務的傳播行為 外部不存在事務 外部存在事務
REQUIRED（默認） 開啟新事務 融合到外部事務中
SUPPORTS 不開啟新事務 融合到外部事務中
MANDATORY 拋出例外 融合到外部事務中
REQUIRES_NEW 開啟新事務 掛起外部事務，創建新事務
NOT_SUPPORTED 不開啟新事務 掛起外部事務
NEVER 不開啟新事務 拋出例外
NESTED 開啟新的事務 融合到外部事務中，SavePoint機制，外層影響內層，內層不會影響外層

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/474787.html

標籤：Java

上一篇：Java 17 新特性：switch的模式匹配（Preview）

下一篇：CAS 入門實戰(3)--客戶端接入

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂