第六章 Spring事务传播属性分析笔记

忘是亡心i 2023-06-29 05:59 16阅读 0赞

接着上面第五章关于事务传播属性的源码分析：

## **一、创建事务状态对象、开启事务** ##

**第一：创建事务状态对象，**事务状态就是记录事务流转过程中状态数据的，有一个数据非常重要，直接决定了提交，回滚和恢复绑定操作，就是newTransaction属性，这个属性要牢记。如果为true就代表当前事务允许单独提交和回滚，一般是第一次创建事务或者事务传播属性为PROPAGATION\_REQUIRES\_NEW的时候。如果为false则当前事务不能单独提交和回滚。

**第二：****doBegin****该方法则是开启事务的核心方法，点进去看看：**

### **1、从数据源连接池中获取连接** ###

org.springframework.jdbc.datasource.DataSourceTransactionManager\#doBegin

**protected void** doBegin(Object transaction, TransactionDefinition definition) \{   
   DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
   Connection con = **null**;  
   **try** \{   
      *//如果没有数据库连接*  
*      ***if** (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) \{   
         *//从连接池里面获取连接*  
*         *Connection newCon = obtainDataSource().getConnection();  
         **if** (**logger**.isDebugEnabled()) \{   
            **logger**.debug(**"Acquired Connection \["** \+ newCon + **"\] for JDBC transaction"**);  
         \}  
         *//把连接包装成ConnectionHolder，然后设置到事务对象中*  
*         *txObject.setConnectionHolder(**new** ConnectionHolder(newCon), **true**);  
      \}

这块从数据源获取到连接对象，有一个数据源要提一下，就是动态切换数据源的一个抽象类：

AbstractRoutingDataSource，如果有多数据源的需求，可以自己定义数据源对象然后往自定义对象中设置目标数据源和默认数据源，通过切面控制动态切换逻辑：

**1.1、动态数据源代码示例：**

代码详见com.chj.datasource.DynamicDataSource，从ThreadLocal中获取连接字符串：

**public class** DynamicDataSource **extends** AbstractRoutingDataSource \{   
    @Override  
    **protected** Object determineCurrentLookupKey() \{   
        String ds = DynamicDataSourceHolder.*getDs*();  
        System.***out***.println(**"=========选择的数据源："** \+ ds);  
        **return** ds;  
    \}  
\}

注意：ThreadLocal类，用来保存当前线程和数据源字符串的关系

**public class** DynamicDataSourceHolder \{   
    **private static** ThreadLocal<String> *local* = **new** ThreadLocal<String>();  
    **public static** String getDs() \{   
        **return** *local*.get();  
    \}  
    **public static** ThreadLocal getLocal() \{   
        **return** *local*;  
    \}  
\}

**1.2、切面类代码示例：**

通过获取调用方法上面的注解来获取选择的数据源字符串，然后把这个字符串设置到ThreadLocal中跟当前线程绑定：com.chj.aop.aspectj.AspectDs

@Component  
@Aspect  
@Order(-1)  
**public class** AspectDs \{   
    @Before(value = **"@annotation(targetSource)"**,argNames = **"joinPoint,targetSource"**)  
    **public void** xx(JoinPoint joinPoint, TargetSource targetSource) \{   
        System.***out***.println(**"========AspectDs.xx"**);  
        String value = targetSource.value();  
        **if**(value != **null** && !**""**.equals(value)) \{   
            DynamicDataSourceHolder.*getLocal*().set(value);  
        \} **else** \{   
            DynamicDataSourceHolder.*getLocal*().set(**"ds1"**);  
        \}  
    \}  
\}

**1.3、动态数据源初始化：**

com.chj.datasource.DataSourceConfiguration

@Bean  
**public** DataSource dynamicDataSource() \{   
    ComboPooledDataSource comboPooledDataSource = **new** ComboPooledDataSource();  
    **try** \{   
        comboPooledDataSource.setDriverClass(**driverClass**);  
        comboPooledDataSource.setJdbcUrl(**jdbcUrl**);  
        comboPooledDataSource.setUser(**user**);  
        comboPooledDataSource.setPassword(**password**);  
        comboPooledDataSource.setMinPoolSize(10);  
        comboPooledDataSource.setMaxPoolSize(100);  
        comboPooledDataSource.setMaxIdleTime(1800);  
        comboPooledDataSource.setAcquireIncrement(3);  
        comboPooledDataSource.setMaxStatements(1000);  
        comboPooledDataSource.setInitialPoolSize(10);  
        comboPooledDataSource.setIdleConnectionTestPeriod(60);  
        comboPooledDataSource.setAcquireRetryAttempts(30);  
        comboPooledDataSource.setBreakAfterAcquireFailure(**false**);  
        comboPooledDataSource.setTestConnectionOnCheckout(**false**);  
        comboPooledDataSource.setAcquireRetryDelay(100);  
    \} **catch** (PropertyVetoException e) \{   
        e.printStackTrace();  
    \}  
    Map<Object, Object> targetDataSources = **new** HashMap<>();  
    targetDataSources.put(**"ds1"**,comboPooledDataSource);  
    DynamicDataSource dynamicDataSource = **new** DynamicDataSource();  
    dynamicDataSource.setTargetDataSources(targetDataSources);  
    dynamicDataSource.setDefaultTargetDataSource(comboPooledDataSource);  
    **return** dynamicDataSource;  
\}

**这里建立了****字符串****和****数据源对象****的映射关系，**然后把映射关系保存到了动态数据源对象中，动态数据源对象通过钩子方法determineCurrentLookupKey就可以从ThreadLocal中获取到字符串，然后根据字符串从映射关系中找到选择的数据源对象。

### **2、设置只读事务** ###

从这一点设置的时间点开始（时间点a）到这个事务结束的过程中，其他事务所提交的数据，该事务将看不见。设置只读事务就是告诉数据库，我这个事务内没有新增、修改、删除操作只有查询操作，不需要数据库锁等操作，减少数据库压力。

org.springframework.jdbc.datasource.DataSourceTransactionManager\#doBegin

prepareTransactionalConnection(con, definition);  
**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();  
      \}  
   \}  
\}

### **3、把自动提交关闭** ###

org.springframework.jdbc.datasource.DataSourceTransactionManager\#doBegin

**if** (con.getAutoCommit()) \{   
   txObject.setMustRestoreAutoCommit(**true**);  
   **if** (**logger**.isDebugEnabled()) \{   
      **logger**.debug(**"Switching JDBC Connection \["** \+ con + **"\] to manual commit"**);  
   \}  
   *//关闭连接的自动提交，其实这步就是开启了事务*  
*   *con.setAutoCommit(**false**);  
\}

### **4、建立ThreadLocal的绑定关系** ###

这个绑定关系就是前面提到的，从绑定关系中可以拿到map，map中建立的是数据源对象和连接对象的映射。

*// Bind the connection holder to the thread.*  
**if** (txObject.isNewConnectionHolder()) \{   
   *//如果是新创建的事务，则建立当前线程和数据库连接的关系*  
*   *TransactionSynchronizationManager.*bindResource*(obtainDataSource(), txObject.getConnectionHolder());  
\}

org.springframework.transaction.support.TransactionSynchronizationManager\#bindResource

**public static void** bindResource(Object key, Object value) **throws** IllegalStateException \{   
   Object actualKey = TransactionSynchronizationUtils.*unwrapResourceIfNecessary*(key);  
   Assert.*notNull*(value, **"Value must not be null"**);  
**   Map<Object, Object> map =** ***resources*****.get();**  
   *// set ThreadLocal Map if none found*  
*   ***if** (map == **null**) \{   
      map = **new** HashMap<>();  
      ***resources***.set(map);  
   \}  
   Object oldValue = map.put(actualKey, value);  
   *// Transparently suppress a ResourceHolder that was marked as void...*  
*   ***if** (oldValue **instanceof** ResourceHolder && ((ResourceHolder) oldValue).isVoid()) \{   
      oldValue = **null**;  
   \}  
   **if** (oldValue != **null**) \{   
      **throw new** IllegalStateException(**"Already value \["** \+ oldValue + **"\] for key \["** \+  
            actualKey + **"\] bound to thread \["** \+ Thread.*currentThread*().getName() + **"\]"**);  
   \}  
   **if** (***logger***.isTraceEnabled()) \{   
      ***logger***.trace(**"Bound value \["** \+ value + **"\] for key \["** \+ actualKey + **"\] to thread \["** \+  
            Thread.*currentThread*().getName() + **"\]"**);  
   \}  
\}

数据源对象和连接对象的映射关系存放到ThreadLocal对象中：

**private static final** ThreadLocal<Map<Object, Object>> ***resources*** = **new** NamedThreadLocal<>(**"Transactional resources"**);

到这里，doBegin基本结束了，事务已经开启了。

### **5、嵌套事务分析** ###

这里我们重点看一下这个代码：

*//第一次进来connectionHolder为空的，所以不存在事务*  
**if** (isExistingTransaction(transaction)) \{   
   *// Existing transaction found -> check propagation behavior to find out how to behave.*  
*   ***return** **handleExistingTransaction(definition, transaction, debugEnabled);**  
\}

**这个代码只有存在事务传播的时候才会走进来，就是事务下面又有事务。**

com.chj.service.transaction.TransationServiceImpl

@Service(**"transationServiceImpl"**)  
**public class** TransationServiceImpl **implements** TransationService \{   
    @Autowired  
    AreaService **areaService**;  
    @Autowired  
    GoodsService **goodsService**;  
    @Autowired  
    CommonMapper **commonMapper**;  
    *//****TODO 开启了事务***  
***   ****** ***@Transactional(propagation = Propagation.***REQUIRED***)  
    @Override  
    **public void** transation(ConsultConfigArea area, ZgGoods zgGoods) \{   
        **areaService**.addArea(area);  
        **goodsService**.addGoods(zgGoods);  
    \}

就类似于这种代码，transaction 方法上面存在事务，而下面的方法也存在事务的情况下，那么这个代码块就会进来；这个代码里面，判断了第一个事务下面的事务特性，根据传播特性来控制事务。

**重点看一下这两种：****PROPAGATION\_REQUIRES\_NEW****，****PROPAGATION\_NESTED**

**5.1、PROPAGATION\_REQUIRES\_NEW**

org.springframework.transaction.support.AbstractPlatformTransactionManager\#handleExistingTransaction

**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***);  
      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;  
   \}  
\}

这个事务传播属性意思是，如果当前没事务创建事务，如果当前有事务则把当前事务挂起并创建新的事务，反正就是要用自己创建的事务。

**第一，挂起事务**

SuspendedResourcesHolder suspendedResources = suspend(transaction);

挂起事务其实就是把事务对象中的连接对象设置为null，并且解除ThreadLocal的绑定关系

org.springframework.transaction.support.AbstractPlatformTransactionManager\#suspend

@Nullable  
**protected final** SuspendedResourcesHolder suspend(@Nullable Object transaction) **throws** TransactionException \{   
   **if** (TransactionSynchronizationManager.*isSynchronizationActive*()) \{   
      List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();  
      **try** \{   
         Object suspendedResources = **null**;  
         *//第一次进来，肯定为null的*  
*         ***if** (transaction != **null**) \{   
   **         *****//******把******connectionHolder设置为空***  
***            *****suspendedResources = doSuspend(transaction);**  
         \}

org.springframework.jdbc.datasource.DataSourceTransactionManager\#doSuspend

@Override  
**protected** Object doSuspend(Object transaction) \{   
   DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
   txObject.setConnectionHolder(**null**);  
   *//解除绑定关系，*  
*   ***return** TransactionSynchronizationManager.*unbindResource*(obtainDataSource());  
\}

然后再返回了老的上一个事务的连接对象，这个一定要注意，因为会根据这个返回的连接对象，在该事务提交的时候重新的建立绑定关系的。

**第二，****doBegin****开启事务，这里不赘述**

**第三，返回事务状态**

**5.2、PROPAGATION\_NESTED**

嵌套事务，其实就是按照回滚点来回滚事务。

**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**);  
      *//创建回滚点*  
*      *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.*  
*      ***boolean** newSynchronization = (getTransactionSynchronization() != ***SYNCHRONIZATION\_NEVER***);  
      DefaultTransactionStatus status = newTransactionStatus(  
            definition, transaction, **true**, newSynchronization, debugEnabled, **null**);  
      doBegin(transaction, definition);  
      prepareSynchronization(status, definition);  
      **return** status;  
   \}  
\}

在这个代码里面就是用连接对象创建了回滚点，是在方法调用之前创建了回滚点，并且并没有做挂起和开启事务doBegin的操作，从这里就能判断当前事务的连接对象和前事务的连接对象是一致的。

前面事务开启已经做完，接下来就是火炬传递了

### **6、增强链调用与事务回滚、提交** ###

**6.1、增强循环调用（火炬传递）**

org.springframework.transaction.interceptor.TransactionAspectSupport\#invokeWithinTransaction

*//获取事务管理器*  
**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.*  
*   *TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);  
   Object retVal = **null**;  
   **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);  
   **return** retVal;  
\}

如果链式调用过程中不存在advice了，则会调用到被代理方法，执行相应的业务操作，如果业务操作没问题则提交事commitTransactionAfterReturning(txInfo); 提交的时候要注意一下事务状态，newTransaction

**6.2、事务提交**

org.springframework.transaction.interceptor.TransactionAspectSupport\#commitTransactionAfterReturning

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

org.springframework.transaction.support.AbstractPlatformTransactionManager\#commit

processCommit(defStatus);

如果都是PROPAGATION\_REQUIRED，最外层的才会走进来统一提交，如果是PROPAGATION\_REQUIRES\_NEW，每一个事务都会进来

org.springframework.transaction.support.AbstractPlatformTransactionManager\#processCommit

**if** (status.hasSavepoint()) \{   
   **if** (status.isDebug()) \{   
      **logger**.debug(**"Releasing transaction savepoint"**);  
   \}  
   unexpectedRollback = status.isGlobalRollbackOnly();  
   status.releaseHeldSavepoint();  
\}  
***//如果都是PROPAGATION\_REQUIRED，最外层的才会走进来统一提交，如果是PROPAGATION\_REQUIRES\_NEW，每一个事务都会进来***  
**else if (status.isNewTransaction()) \{**   
   **if** (status.isDebug()) \{   
      **logger**.debug(**"Initiating transaction commit"**);  
   \}  
   unexpectedRollback = status.isGlobalRollbackOnly();  
**   doCommit(status);**  
\}

只有事务状态是true时才允许直接提交，为new只会发生在第一次事务进来或者传播属性为new的情况下。如果是有回滚点，在提交的时候把回滚点抹掉了，这种情况只可能是第一次事务后面的嵌套事务提交才能发生的情况。

然后在事务提交完成后，还有一个点要注意，就是资源释放和重新建立绑定关系操作：

**finally** \{   
   cleanupAfterCompletion(status);  
\}

**private void** cleanupAfterCompletion(DefaultTransactionStatus status) \{   
   status.setCompleted();  
   **if** (status.isNewSynchronization()) \{   
      TransactionSynchronizationManager.*clear*();  
   \}  
   **if** (status.isNewTransaction()) \{   
      doCleanupAfterCompletion(status.getTransaction());  
   \}  
   *//判断当前事务有没有挂起的连接*  
*   ***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());  
   \}  
\}

如果newTransaction为true才会释放连接资源，这个很好理解，这代表着所有操作都已经做完了。这块就是会把连接资源归还给连接池，然后解除ThreadLocal和连接的绑定关系。如果被挂起的事务对象不为空：

*//判断当前事务有没有挂起的连接*  
**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());  
\}

则需要恢复绑定关系

org.springframework.transaction.support.AbstractPlatformTransactionManager\#resume

**protected final void** resume(@Nullable Object transaction, @Nullable SuspendedResourcesHolder resourcesHolder)  
      **throws** TransactionException \{   
   **if** (resourcesHolder != **null**) \{   
      Object suspendedResources = resourcesHolder.**suspendedResources**;  
      **if** (suspendedResources != **null**) \{   
        ** doResume(transaction, suspendedResources);**  
      \}  
      List<TransactionSynchronization> suspendedSynchronizations = resourcesHolder.**suspendedSynchronizations**;  
      **if** (suspendedSynchronizations != **null**) \{   
         TransactionSynchronizationManager.*setActualTransactionActive*(resourcesHolder.**wasActive**);  
         TransactionSynchronizationManager.*setCurrentTransactionIsolationLevel*(resourcesHolder.**isolationLevel**);  
         TransactionSynchronizationManager.*setCurrentTransactionReadOnly*(resourcesHolder.**readOnly**);  
         TransactionSynchronizationManager.*setCurrentTransactionName*(resourcesHolder.**name**);  
         doResumeSynchronization(suspendedSynchronizations);  
      \}  
   \}  
\}

org.springframework.jdbc.datasource.DataSourceTransactionManager\#doResume

@Override  
**protected void** doResume(@Nullable Object transaction, Object suspendedResources) \{   
   TransactionSynchronizationManager.*bindResource*(obtainDataSource(), suspendedResources);  
\}

又重新建立了当前线程和连接对象的绑定关系，所以你下个事务再进来的时候就可以从绑定关系中获取到连接对象了。

**6.3、如果业务操作有异常就会回滚：**

**catch** (Throwable ex) \{   
   *// target invocation exception*  
*  ** //事务回滚*  
*   *completeTransactionAfterThrowing(txInfo, ex);  
   **throw** ex;  
\}

org.springframework.transaction.interceptor.TransactionAspectSupport\#completeTransactionAfterThrowing

**protected void** completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) \{   
   **if** (txInfo != **null** && txInfo.getTransactionStatus() != **null**) \{   
      **if** (**logger**.isTraceEnabled()) \{   
         **logger**.trace(**"Completing transaction for \["** \+ txInfo.getJoinpointIdentification() +  
               **"\] after exception: "** \+ ex);  
      \}  
      **if** (txInfo.**transactionAttribute** != **null** && txInfo.**transactionAttribute**.rollbackOn(ex)) \{   
         **try** \{   
           ** txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());**  
         \}

org.springframework.transaction.support.AbstractPlatformTransactionManager\#rollback

@Override  
**public final void** rollback(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;  
  ** processRollback(defStatus, false);**  
\}

org.springframework.transaction.support.AbstractPlatformTransactionManager\#processRollback

**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"**);  
            \}  
            status.rollbackToHeldSavepoint();  
         \}  
         *//都为PROPAGATION\_REQUIRED最外层事务统一回滚*  
*         ***else if** (status.isNewTransaction()) \{   
            **if** (status.isDebug()) \{   
               **logger**.debug(**"Initiating transaction rollback"**);  
            \}  
            doRollback(status);  
         \}

回滚一样要判断事务状态，如果为true才允许回滚，如果有回滚点则按照回滚点来回滚。

回滚一样会伴随着连接释放，逻辑跟提交是一样的，这里不再赘述

**finally** \{   
   cleanupAfterCompletion(status);  
\}

## **二、事务传播属性代码示例分析** ##

如果不清楚事务的不同传播属性的流转，建议可以采用伪代码的方式来分析：

### **1、测试代码如下** ###

com.chj.service.transaction.TransationServiceImpl\#transation

*//****TODO 开启了事务***  
@Transactional(propagation = Propagation.***REQUIRED***)  
@Override  
**public void** transation(ConsultConfigArea area, ZgGoods zgGoods) \{   
    **areaService**.addArea(area);  
    **goodsService**.addGoods(zgGoods);  
\}

com.chj.service.area.AreaServiceImpl\#addArea

@Transactional(propagation = Propagation.***REQUIRES\_NEW***)  
    @Override  
    **public int** addArea(ConsultConfigArea area) \{   
        **int** i = **commonMapper**.addArea(area);  
        **return** i;  
    \}  
\}

com.chj.service.goods.GoodsServiceImpl\#addGoods

@Transactional  
@Override  
**public void** addGoods(ZgGoods zgGoods) \{   
    **int** i = **commonMapper**.addGood(zgGoods);  
    **if**(**true**) **throw new** RuntimeException(**"yic"**);  
\}

### **2、业务场景分析** ###

业务场景分析，首先是transation()方法的事务，然后里面调用了addArea()方法和**addGoods****()，其中三个方法上面都有事务注解。**

**示例代码如下：**

transation方法

**createTransactionIfNecessary =** **开启事务**

try \{

**addArea****方法**

开启事务

Try\{

目标类 addArea 调用

\}catch(Throwable ex) \{

事务回滚? 否

throw ex;

commitTransactionAfterReturning （status.isNewTransaction()）

addArea方法提交事务？

注意：如果出现异常不会提交事务，因为提交的时候需要判断status.isNewTransaction()的状态是否为true（该状态只有事务切面第一次进来的时候为true），如果抛出异常会被外层的事务catch掉，然后回滚。

\---------------------------------------------------

**addGoods****方法**

开启事务

Try\{

目标类 addGoods 调用

Throw new RuntimeException();

\}catch(Throwable ex) \{

事务回滚?

throw ex;

commitTransactionAfterReturning

addGoods方法提交事务？否

注意：如果出现异常不会提交事务，如果抛出异常会被外层的事务catch掉，然后处理。

\}catch (Throwable ex) \{

completeTransactionAfterThrowing  = 事务回滚（真正的事务回滚操作）

throw ex;

transation方法提交事务

commitTransactionAfterReturning = 事务提交（真正的事务提交操作）

**场景一：事务传播属性都是用默认的PROPAGATION\_REQUIRED级别**

1）如果事务方法里面的addArea方法里面抛出异常

首先addArea方法里面跑出异常，该方法本身不会提交事务，也不会进行回滚操作；其次抛出的异常会被外层的事务catch到，然后进行真正的事务回滚操作。因为抛出了异常所有后面的代码自然就不会执行了，因此方法addGoods自然就不会执行。

2）如果事务方法里面的addGoods方法里面抛出异常

首先addArea方法正常执行，但是数据还没有真正提交（由最外层事务提交），其次第二个方法addGoods里面抛出异常，然后继续被最外层事务catch，最后进行回滚操作。这个时候事务会进行全部回滚，所以两个方法数据都会进行回滚操作。

**场景二：addArea事务传播属性为PROPAGATION\_REQUIRES\_NEW，其他都为默认**

1）如果事务方法里面的addArea方法里面抛出异常

两个方法都不会提交事务，然后事务进行回滚操作，方法一抛出异常后，同理异常会被外层事务拦截，然后进行回滚操作。

2）如果事务方法里面的addGoods方法里面抛出异常

执行结果：方法一事务提交成功，方法二事务回滚

分析：由于方法一使用了REQUIRES\_NEW事务传播属性，因此当方法一执行完毕后会将外层的事务进行挂起操作，然后新建一个事务进行提交操作；方法二由于抛出异常，因此和前面一样，抛出的异常被外层事务catch然后进行事务回滚。

**场景三：事务传播属性都是用PROPAGATION\_NESTED级别**

我们在业务方法addArea的业务处理逻辑里面自己添加异常处理，catch部分什么都不做，这种情况两个方法的事务都会提交成功。

**addArea****方法**

开启事务

Try\{

Try\{//业务里面自己处理异常

目标类 addArea 调用

Throw new RuntimeException();

\}catch()\{

//里面什么都不做

\}catch(Throwable ex) \{

事务回滚? 否

throw ex;

commitTransactionAfterReturning （status.isNewTransaction()）

addArea方法提交事务？

**备注：在分析事务的提交方法时候，我们得知事务传播属性****如果都是PROPAGATION\_REQUIRED，最外层的才会走进来统一提交，如果是PROPAGATION\_REQUIRES\_NEW，每一个事务都会进来****。**

org.springframework.transaction.support.AbstractPlatformTransactionManager\#processCommit

org.springframework.transaction.support.AbstractPlatformTransactionManager\#handleExistingTransaction

**boolean** newSynchronization = (getTransactionSynchronization() != ***SYNCHRONIZATION\_NEVER***);  
**return**** prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);**

## **三、注解事务和编程式事务** ##

注解事务是方法上面加了@Transactional 的事务，这种事务控制粒度不够细，如果方法 流程很长的话会产生连接占用问题，连接占用就会导致整个系统吞吐量下降。

### **1、注解事务** ###

**1.1、基于@Transactional的声明式事务管理**

除了基于命名空间的事务配置方式，Spring 2.x还引入了基于Annotation的方式，具体主要涉及@Transactional标注。@Transactional可以作用于接口、接口方法、类以及类方法上。当作用于 类上时，该类的所有public方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。

基于@Transactional的事务管理示例配置文件@Transactional(propagation = Propagation.REQUIRED)

**public boolean** transfer(Long fromId，Long toId，**double** amount) \{   
    **return** bankDao.transfer(fromId， toId， amount);  
\}

Spring使用BeanPostProcessor来处理Bean中的标注，因此我们需要在配置文件中作如下声明来激活该后处理Bean，启用后处理Bean的配置<tx:annotation-driven transactionmanager="transactionManager"/>与前面相似，transaction-manager属性的默认值是transactionManager，如果事务管理器Bean的名字即为该值，则可以省略该属性。

虽然@Transactional注解可以作用于接口、接口方法、类以及类方法上，但是Spring小组建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。另外，**@Transactional注解应该只被应用到public方法上，这是由Spring AOP的本质决定的。**如果你在protected、private或者默认可见性的方法上使用@Transactional注解，这将被忽略，也不会抛出任何异常。

<**bean** **id****="transactionManager"** **class****="org.springframework.jdbc.datasource.DataSourceTransactionManager"**>  
    <**property** **name****="dataSource"** **ref****="dataSource"**/>  
</**bean**>  
**  
<**tx****:annotation-driven** **transaction-manager****="transactionManager"**/>

注解事务由于隔离级别的不同，可能导致可重复读的问题，比如抢火车票这种，需要用到乐观锁，但是在重复抢票的时候由于是同一个连接对象，所以每次查询的数据是一样的。

@Transactional  
@Override  
**public int** getTicket() \{   
    *//****TODO 1、获取锁***  
***    ***List<ZgTicket> zgTickets = **commonMapper**.queryTicketById(**"12306"**);  
    Map lockmap = **new** HashMap();  
    lockmap.put(**"ticketId"**, **"12306"**);  
    lockmap.put(**"version"**, zgTickets.get(0).getVersion());  
    **int** i = **commonMapper**.updateLock(lockmap);  
    **if** (i > 0) \{   
        *//****TODO 抢票***  
***        ***ZgTicket zgTicket = zgTickets.get(0);  
        zgTicket.setTicketCount(2);  
        **int** i1 = **commonMapper**.updateTicket(zgTicket);  
    \} **else** \{   
        *//****TODO 继续抢***  
***        ***((TransationService) AopContext.*currentProxy*()).getTicket();  
    \}  
    **return** 0;  
\}

getTicket方法递归调用的时候，在可重复读的隔离级别下查询的数据是一样的，所以永远获取不到锁。

**1.2、基于<tx:advice命名空间的声明式事务管理**

**  
<**tx****:advice** **id****="userTxAdvice"** **transaction-manager****="transactionManager"**>  
    <**tx****:attributes**>  
        **  
*        *  
*        *<**tx****:method** **name****="saveTest"** **propagation****="REQUIRED"** **read-only****="false"**  
**                   ****rollback-for****="java.lang.RuntimeException"** **isolation****="DEFAULT"**/>  
        <**tx****:method** **name****="saveTest1"** **propagation****="NESTED"** **read-only****="false"**  
**                   ****rollback-for****="java.lang.RuntimeException"** **isolation****="DEFAULT"**/>  
        <**tx****:method** **name****="delete\*"** **propagation****="NESTED"** **read-only****="false"**  
**                   ****rollback-for****="java.lang.RuntimeException"**/>  
        <**tx****:method** **name****="update\*"** **propagation****="REQUIRED"** **read-only****="false"**  
**                   ****rollback-for****="java.lang.RuntimeException"**/>  
        <**tx****:method** **name****="check\*"** **propagation****="REQUIRED"** **read-only****="false"**  
**                   ****rollback-for****="java.lang.RuntimeException"**/>  
        <**tx****:method** **name****="print\*"** **propagation****="REQUIRED"** **read-only****="false"**  
**                   ****rollback-for****="java.lang.RuntimeException"**/>  
        <**tx****:method** **name****="\*"** **propagation****="REQUIRED"** **read-only****="false"** **isolation****="DEFAULT"**  
**                   ****rollback-for****="java.lang.RuntimeException"**/>  
    </**tx****:attributes**>  
</**tx****:advice**>  
<**aop****:config** **proxy-target-class****="false"**>  
    <**aop****:pointcut** **id****="pc"** **expression****="execution(public \* com.chj.service..\*.\*(..))"**/>  
    <**aop****:advisor** **pointcut-ref****="pc"** **advice-ref****="userTxAdvice"**/>  
</**aop****:config**>

基于命名空间和基于@Transactional的事务声明方式各有优缺点。

**基于****<tx>****的方式，**其优点是与切点表达式结合，功能强大，利用切点表达式，一个配置可以匹配多个方法；**而基于@Transactional的方式**必须在每一个需要使用事务的方法或者类上用@Transactional标注，尽管可能大多数事务的规则是一致的，但是对@Transactional而言，也无法重用，必须逐个指定。

另一方面，基于@Transactional的方式使用起来非常简单明了，没有学习成本。开发人员可以根据需要，任选其中一种使用，甚至也可以根据需要混合使用这两种方式。如果不是对遗留代码进行维护，则不建议再使用基于TransactionInterceptor以及基于TransactionProxyFactoryBean的声明式事务管理方式，但是，学习这两种方式非常有利于对底层实现的理解。 虽然上面共列举了四种声明式事务管理方式，但是这样的划分只是为了便于理解，其实后台的实现方式是一样的，只是用户使用的方式不同而已。

### **2、编程式事务** ###

**spring框架提供了两种编程式事务管理方式：**

·使用TransactionTemplate

·直接使用PlatformTransactionManager实现

**2.1、TransactionTemplate方式**

TransactionTemplate采用与其他spring模板相同的方法，它使用一种回调方法，使应用程序代码可以处理获取和释放事务资源，让开发人员更加专注于业务逻辑。

代码如下：

@Autowired  
**private** TransactionTemplate **transactionTemplate**;  
@Override  
**public int** getTicketModeOne() \{   
    Integer execute = **transactionTemplate**.execute(status -> \{   
        *//****TODO 1、获取锁***  
***        ***List<ZgTicket> zgTickets = **commonMapper**.queryTicketById(**"12306"**);  
        Map lockmap = **new** HashMap();  
        lockmap.put(**"ticketId"**, **"12306"**);  
        lockmap.put(**"version"**, zgTickets.get(0).getVersion());  
        **int** i = **commonMapper**.updateLock(lockmap);  
        **if** (i > 0) \{   
            *//****TODO 抢票***  
***            ***ZgTicket zgTicket = zgTickets.get(0);  
            zgTicket.setTicketCount(2);  
            **int** i1 = **commonMapper**.updateTicket(zgTicket);  
        \}  
        **return** i;  
    \});  
    **if** (execute == 0) \{   
        *//****TODO 继续抢***  
***        ***getTicketModeOne();  
    \}  
    **return** 0;  
\}

用编程式事务解决了这个问题，这个查询语句是在execute方法内，当这个方法执行完时就提交了事务，下次再进来时又是一个单独的新事务了。

编程式事务控制粒度更细，可以只关心需要事务控制的操作，如果不需要事务控制的代码可以不放execute方法内。

**2.2、PlatformTransactionManager方式**

也可以直接使用org.springframework.transaction.PlatformTransactionManager来管理事务，只需通过bean引用将正在使用的PlatformTransactionManager的实现传递给bean。然后使用TransactionDefinition和TransactionStatus对象来启动、回滚和提交事务。

自己手动控制事务代码如下：

@Autowired  
PlatformTransactionManager **platformTransactionManager**;  
**public void** xxx() \{   
    DefaultTransactionDefinition defaultTransactionDefinition = **new** DefaultTransactionDefinition();  
    defaultTransactionDefinition.setPropagationBehavior(0);  
    TransactionStatus transaction = **platformTransactionManager**.getTransaction(defaultTransactionDefinition);  
    **try** \{   
        System.***out***.println(**"业务代码"**);  
    \}**catch** (Exception e) \{   
        **platformTransactionManager**.rollback(transaction);  
    \}  
    **platformTransactionManager**.commit(transaction);  
\}

把控制代码可以写到切面中，跟业务代码解耦。

如果应用中只有很少量的事务操作，编程式事务管理通常是很好的选择。如果应用程序有大量的事务操作，则声明式事务管理通常是最优选择。它使事务不受业务逻辑的影响，并且在配置上也很简单。

spring4.2开始，事件的监听器可以被绑定到事务的某个阶段。注册常规的事件监听器是通过@EventListener注解完成的。如果要将其绑定到特定的事务中，可以使用@TransactionEventListener注解。当这样做时，默认情况下，监听器将被绑定到事务的提交阶段。

@Component  
**class** MyComponent \{   
    @TransactionEventListener  
    **public void** handleOrderCreatedEvent(CreationEvent<Order> creationEvent) \{   
        *//...*  
*    *\}  
\}

@TransactionEventListener注解公开了一个阶段属性，允许自定义监听器绑定到事务的某个阶段，包括BEFORE\_COMMIT、AFTER\_COMMIT(默认)、AFTER\_ROLLBACK、AFTER\_COMPLETION。如果没有事务正在运行，则不会调用监听器。可以通过将注解的fallbackExecution属性设置为true来覆盖该行为。

### **3、两种事务方式总结** ###

基于TransactionDefinition、PlatformTransactionManager、TransactionStatus编程式事务管理是Spring提供的最原始的方式，通常我们不会这么写，但是了解这种方式对理解Spring事务管理的本质有很大作用。 基于TransactionTemplate的编程式事务管理是对上一种方式的封装，使得编码更简单、清晰。

基于TransactionInterceptor的声明式事务是Spring声明式事务的基础，通常也不建议使用这种方式，但是与前面一样，了解这种方式对理解Spring声明式事务有很大作用。

基于TransactionProxyFactoryBean的声明式事务是上中方式的改进版本，简化的配置文件的书写，这是Spring早期推荐的声明式事务管理方式，但是在Spring 2.0中已经不推荐了。

**基于****<tx:advice****和命名空间的声明式事务管理是目前推荐的方式，**其最大特点是与Spring AOP结合紧密，可以充分利用切点表达式的强大支持，使得管理事务更加灵活。

**基于@Transactional的方式将声明式事务管理简化到了极致。**开发人员只需在配置文件中加上一行启用相关后处理Bean的配置，然后在需要实施事务管理的方法或者类上使用@Transactional指定事务规则即可实现事务管理，而且功能也不必其他方式逊色。