1、Spring聲明式事務管理源碼解讀之事務提交 簡介：上次說到spring聲明式事務管理的事務開始部分，按流程來講，下面應該提交事務了， spring的聲明式事務管理其實是比較復雜的，事實上這種復雜性正是由于事務本身的復雜性導致的，如果能用兩三句話就把這部分內(nèi)容說清楚是不現(xiàn)實的，也是不成熟的，而我對這部分的理解也可能是不全面的，還是那句話，希望大家和我一起把本貼的質(zhì)量提交起來。 在下面的文章中，我講會多次提到第一篇文章，第一篇文章的地址是：/topic/87426 如果要理解事務提交的話，理解事務開始是一個前提條件,所以請先看第一篇文章，再來看這篇 如果

2、你仔細看下去，我想肯定是有很多收獲，因為我們確實能從spring的代碼和思想中學到很多東西。 正文： 其實俺的感覺就是事務提交要比事務開始復雜，看事務是否提交我們還是要回到TransactionInterceptor類的invoke方法 Java代碼 public Object invoke(MethodInvocation invocation) throws Throwable / Work out the target class: may be <code>null</code>. / The TransactionAttributeSource should

3、be passed the target class / as well as the method, which may be from an interface Class targetClass = (invocation.getThis() != null) ? invocation.getThis().getClass() : null; / Create transaction if necessary. TransactionInfo txInfo = createTransactionIfNecessary(invocation.getMethod(), targetClass

4、); 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 = ceed(); catch (Throwable ex) / target invocation exception doCloseTransactionAfterThrowing(txInfo, ex); throw ex;

5、finally doFinally(txInfo);/業(yè)務方法出棧后必須先執(zhí)行的一個方法 doCommitTransactionAfterReturning(txInfo); return retVal; public Object invoke(MethodInvocation invocation) throws Throwable / Work out the target class: may be <code>null</code>./ The TransactionAttributeSource should be passed the target cla

6、ss/ as well as the method, which may be from an interfaceClass targetClass = (invocation.getThis() != null) ? invocation.getThis().getClass() : null;/ Create transaction if necessary.TransactionInfo txInfo = createTransactionIfNecessary(invocation.getMethod(), targetClass);Object retVal = null;try /

7、 This is an around advice./ Invoke the next interceptor in the chain./ This will normally result in a target object being invoked.retVal = ceed();catch (Throwable ex) / target invocation exceptiondoCloseTransactionAfterThrowing(txInfo, ex);throw ex;finally doFinally(txInfo);/業(yè)務方法出棧后必須先

8、執(zhí)行的一個方法doCommitTransactionAfterReturning(txInfo);return retVal;其中的doFinally(txInfo)那一行很重要，也就是說不管如何，這個doFinally方法都是要被調(diào)用的，為什么它這么重要呢，舉個例子: 我們還是以propregation_required來舉例子吧，假設情況是這樣的，AService中有一個方法調(diào)用了BService中的，這兩個方法都處在事務體之中，他們的傳播途徑都是required。那么調(diào)用開始了，AService的方法首先入方法棧，并創(chuàng)建了TransactionInfo的實例，接著BService的方法入

9、棧，又創(chuàng)建了一個TransactionInfo的實例，而重點要說明的是TransactionInfo是一個自身關聯(lián)的內(nèi)部類，第二個方法入棧時，會給新創(chuàng)建的TransactionInfo的實例設置一個屬性，就是TransactionInfo對象中的private TransactionInfo oldTransactionInfo;屬性，這個屬性表明BService方法的創(chuàng)建的TransactionInfo對象是有一個old的transactionInfo對象的，這個oldTransactionInfo對象就是AService方法入棧時創(chuàng)建的TransactionInfo對象，我們還記得在cre

10、ateTransactionIfNecessary方法里有這樣一個方法吧： Java代碼 protected TransactionInfo createTransactionIfNecessary(Method method, Class targetClass) / We always bind the TransactionInfo to the thread, even if we didnt create / a new transaction here. This guarantees that the TransactionInfo stack / will be managed

11、 correctly even if no transaction was created by this aspect. txInfo.bindToThread(); return txInfo; 就是這個bindToThread()方法在作怪： private void bindToThread() / Expose current TransactionStatus, preserving any existing transactionStatus for / restoration after this transaction is complete. oldTransactionI

12、nfo = (TransactionInfo) currentTransactionInfo.get(); currentTransactionInfo.set(this); protected TransactionInfo createTransactionIfNecessary(Method method, Class targetClass) / We always bind the TransactionInfo to the thread, even if we didnt create/ a new transaction here. This guarantees that t

13、he TransactionInfo stack/ will be managed correctly even if no transaction was created by this aspect.txInfo.bindToThread();return txInfo;就是這個bindToThread()方法在作怪：private void bindToThread() / Expose current TransactionStatus, preserving any existing transactionStatus for/ restoration after this tran

14、saction is complete.oldTransactionInfo = (TransactionInfo) currentTransactionInfo.get();currentTransactionInfo.set(this);如果當前線程中已經(jīng)有了一個TransactionInfo，則拿出來放到新建的transactionInfo對象的oldTransactionInfo屬性中，然后再把新建的TransactionInfo設置到當前線程中。 這里有一個概念要搞清楚，就是TransactionInfo對象并不是表明事務狀態(tài)的對象，表明事務狀態(tài)的對象是TransactionStat

15、us對象，這個對象同樣是TransactionInfo的一個屬性（這一點，我在前面一篇文章中并沒有講清楚）。 接下來BService中的那個方法返回，那么該它退棧了，它退棧后要做的就是doFinally方法，即把它的oldTransactionInfo設置到當前線程中（這個TransactionInfo對象顯然就是AService方法入棧時創(chuàng)建的，怎么現(xiàn)在又要設置到線程中去呢，原因就是BService的方法出棧時并不提交事務，因為BService的傳播途徑是required，所以要把棧頂?shù)姆椒ㄋ鶆?chuàng)建transactioninfo給設置到當前線程中），即調(diào)用AService的方法時所創(chuàng)建的Tra

16、nsactionInfo對象。那么在AServie的方法出棧時同樣會設置TransactionInfo對象的oldTransactionInfo到當前線程，這時候顯然oldTransactionInfo是空的，但AService中的方法會提交事務，所以它的oldTransactionInfo也應該是空了。 在這個小插曲之后，么接下來就應該是到提交事務了，之前在AService的方法出棧時，我們拿到了它入棧時創(chuàng)建的TransactionInfo對象，這個對象中包含了AService的方法事務狀態(tài)。即TransactionStatus對象，很顯然，太顯然了，事務提交中的任何屬性都和事務開始時的創(chuàng)建

17、的對象息息相關，這個TransactionStatus對象哪里來的，我們再回頭看看createTransactionIfNessary方法吧： Java代碼 protected TransactionInfo createTransactionIfNecessary(Method method, Class targetClass) txInfo.newTransactionStatus(this.transactionManager.getTransaction(txAttr); protected TransactionInfo createTransactionIfNecessary(M

18、ethod method, Class targetClass) txInfo.newTransactionStatus(this.transactionManager.getTransaction(txAttr);再看看transactionManager.getTransaction(txAttr)方法吧： Java代碼 public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException else if (definition.getPropa

19、gationBehavior() = TransactionDefinition.PROPAGATION_REQUIRED | definition.getPropagationBehavior() = TransactionDefinition.PROPAGATION_REQUIRES_NEW | definition.getPropagationBehavior() = TransactionDefinition.PROPAGATION_NESTED) if (debugEnabled) logger.debug(Creating new transaction with name + d

20、efinition.getName() + ); doBegin(transaction, definition); boolean newSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER); return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);/注意這里的返回值，返回的就是一個TransactionStatus對象,這個對象表明了一個事務的狀態(tài)，比

21、如說是否是一個新的事務，事務是否已經(jīng)結(jié)束，等等，這個對象是非常重要的，在事務提交的時候還是會用到它的。 public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException else if (definition.getPropagationBehavior() = TransactionDefinition.PROPAGATION_REQUIRED |definition.getPropagationBehavior() = Transaction

22、Definition.PROPAGATION_REQUIRES_NEW |definition.getPropagationBehavior() = TransactionDefinition.PROPAGATION_NESTED) if (debugEnabled) logger.debug(Creating new transaction with name + definition.getName() + );doBegin(transaction, definition);boolean newSynchronization = (this.transactionSynchroniza

23、tion != SYNCHRONIZATION_NEVER);return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);/注意這里的返回值，返回的就是一個TransactionStatus對象,這個對象表明了一個事務的狀態(tài)，比如說是否是一個新的事務，事務是否已經(jīng)結(jié)束，等等，這個對象是非常重要的，在事務提交的時候還是會用到它的。 還有一點需要說明的是，AService的方法在執(zhí)行之前創(chuàng)建的transactionstatus確實是通過這個方法創(chuàng)建的，但是，BS

24、ervice的方法在執(zhí)行之前創(chuàng)建transactionstatus的方法就與這個不一樣了，下面會有詳解。 回顧了事務開始時所調(diào)用的方法之后，是不是覺得現(xiàn)在對spring如何處理事務越來越清晰了呢。由于這么幾個方法的調(diào)用，每個方法入棧之前它的事務狀態(tài)就已經(jīng)被設置好了。這個事務狀態(tài)就是為了在方法出棧時被調(diào)用而準備的。 讓我們再次回到BService中的方法出棧的那個時間段，看看spring都做了些什么，我們知道，后入棧的肯定是先出棧，BService中的方法后入棧，拿它肯定要先出棧了，它出棧的時候是要判斷是否要提交事務，釋放資源的，讓我們來看看TransactionInterceptor的invo

25、ke的最后那個方法doCommitTransactionAfterReturning： Java代碼 protected void doCommitTransactionAfterReturning(TransactionInfo txInfo) if (txInfo != null && txInfo.hasTransaction() if (logger.isDebugEnabled() logger.debug(Invoking commit for transaction on + txInfo.joinpointIdentification(); this.trans

26、actionMmit(txInfo.getTransactionStatus(); /瞧：提交事務時用到了表明事務狀態(tài)的那個TransactionStatus對象了。 protected void doCommitTransactionAfterReturning(TransactionInfo txInfo) if (txInfo != null && txInfo.hasTransaction() if (logger.isDebugEnabled() logger.debug(Invoking commit for transaction on + t

27、xInfo.joinpointIdentification();this.transactionMmit(txInfo.getTransactionStatus();/瞧：提交事務時用到了表明事務狀態(tài)的那個TransactionStatus對象了?？催@個方法的名字就知道spring是要在業(yè)務方法出棧時提交事務，貌似很簡單，但是事實是這樣的嗎？ 我們接著往下看。 Java代碼 public final void commit(TransactionStatus status) throws TransactionException DefaultTransactionStat

28、us defStatus = (DefaultTransactionStatus) status; if (defStatus.isCompleted() throw new IllegalTransactionStateException( Transaction is already completed - do not call commit or rollback more than once per transaction); if (defStatus.isLocalRollbackOnly() if (defStatus.isDebug() logger.debug(Transa

29、ctional code has requested rollback); processRollback(defStatus); return; if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly() if (defStatus.isDebug() logger.debug(Global transaction is marked as rollback-only but transactional code requested commit); processRollback(d

30、efStatus); throw new UnexpectedRollbackException( Transaction has been rolled back because it has been marked as rollback-only); processCommit(defStatus); public final void commit(TransactionStatus status) throws TransactionException DefaultTransactionStatus defStatus = (DefaultTransactionStatus) st

31、atus;if (defStatus.isCompleted() throw new IllegalTransactionStateException(Transaction is already completed - do not call commit or rollback more than once per transaction);if (defStatus.isLocalRollbackOnly() if (defStatus.isDebug() logger.debug(Transactional code has requested rollback);processRol

32、lback(defStatus);return;if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly() if (defStatus.isDebug() logger.debug(Global transaction is marked as rollback-only but transactional code requested commit);processRollback(defStatus);throw new UnexpectedRollbackException(Tra

33、nsaction has been rolled back because it has been marked as rollback-only);processCommit(defStatus);上面這段代碼就是transactionmanager中的commit，但是看上去，它又把自己的職責分配給別人了，從代碼里我們看到，如果事務已經(jīng)結(jié)束了就拋異常，如果事務是rollbackonly的，那么就rollback吧，但是按照正常流程，我們還是想來看一下，事務的提交，就是processCommit(status)這個方法吧。 Java代碼 private void processCommit(

34、DefaultTransactionStatus status) throws TransactionException try boolean beforeCompletionInvoked = false; try triggerBeforeCommit(status); triggerBeforeCompletion(status); beforeCompletionInvoked = true; if (status.hasSavepoint() if (status.isDebug() logger.debug(Releasing transaction savepoint); st

35、atus.releaseHeldSavepoint(); else if (status.isNewTransaction() /這個判斷非常重要，下面會詳細講解這個判斷的作用 if (status.isDebug() logger.debug(Initiating transaction commit); boolean globalRollbackOnly = status.isGlobalRollbackOnly(); doCommit(status); / Throw UnexpectedRollbackException if we have a global rollback-on

36、ly / marker but still didnt get a corresponding exception from commit. private void processCommit(DefaultTransactionStatus status) throws TransactionException try boolean beforeCompletionInvoked = false;try triggerBeforeCommit(status);triggerBeforeCompletion(status);beforeCompletionInvoked = true;if

37、 (status.hasSavepoint() if (status.isDebug() logger.debug(Releasing transaction savepoint);status.releaseHeldSavepoint();else if (status.isNewTransaction() /這個判斷非常重要，下面會詳細講解這個判斷的作用if (status.isDebug() logger.debug(Initiating transaction commit);boolean globalRollbackOnly = status.isGlobalRollbackOnl

38、y();doCommit(status);/ Throw UnexpectedRollbackException if we have a global rollback-only/ marker but still didnt get a corresponding exception from commit.我們注意到，在判斷一個事務是否是新事務之前還有一個status.hasSavepoint()的判斷，我認為這個判斷事實上就是嵌套事務的判斷，即判斷這個事務是否是嵌套事務，如果不是嵌套事務，則再判斷它是否是一個新事務，下面這段話就非常重要了，BService的中的方法是先出棧的，也就是說

39、在調(diào)用BService之前的創(chuàng)建的那個事務狀態(tài)對象在這里要先被判斷，但是由于在調(diào)用BService的方法之前已經(jīng)創(chuàng)建了一個Transaction和Session（假設我們使用的是hibernate3），這時候在創(chuàng)建第二個TransactionInfo（再強調(diào)一下吧，TransactionInfo并不是Transaction，Transaction是真正的事務對象，TransactionInfo只不過是一個輔助類而已，用來記錄一系列狀態(tài)的輔助類）的TransactionStatus的時候就會進入下面這個方法（當然在這之前會判斷一下當前線程中是否已經(jīng)有了一個SessionHolder對象，不清楚S

40、essionHolder作用的同學情況第一篇文章），這個方法其實應該放到第一篇文章中講的，但是想到如果不講事務提交就講這個方法好像沒有這么貼切，廢話少說，我們來看一下吧： Java代碼 private TransactionStatus handleExistingTransaction( TransactionDefinition definition, Object transaction, boolean debugEnabled) throws TransactionException if (definition.getPropagationBehavior() = Transact

41、ionDefinition.PROPAGATION_NEVER) throw new IllegalTransactionStateException( Transaction propagation never but existing transaction found); if (definition.getPropagationBehavior() = TransactionDefinition.PROPAGATION_NOT_SUPPORTED) if (debugEnabled) logger.debug(Suspending current transaction); Objec

42、t suspendedResources = suspend(transaction); boolean newSynchronization = (this.transactionSynchronization = SYNCHRONIZATION_ALWAYS); return newTransactionStatus( definition, null, false, newSynchronization, debugEnabled, suspendedResources); if (definition.getPropagationBehavior() = TransactionDefi

43、nition.PROPAGATION_REQUIRES_NEW) if (debugEnabled) logger.debug(Suspending current transaction, creating new transaction with name + definition.getName() + ); Object suspendedResources = suspend(transaction); doBegin(transaction, definition); boolean newSynchronization = (this.transactionSynchroniza

44、tion != SYNCHRONIZATION_NEVER); return newTransactionStatus( definition, transaction, true, newSynchronization, debugEnabled, suspendedResources); if (definition.getPropagationBehavior() = TransactionDefinition.PROPAGATION_NESTED) if (!isNestedTransactionAllowed() throw new NestedTransactionNotSuppo

45、rtedException( 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

46、within existing Spring-managed transaction, / through the SavepointManager API implemented by TransactionStatus. / Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization. DefaultTransactionStatus status = newTransactionStatus(definition, transaction, false, false, debugEnabled, nul

47、l); 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. doBegin(transaction, definition); boolean newSynchronizat

48、ion = (this.transactionSynchronization != SYNCHRONIZATION_NEVER); return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null); / Assumably PROPAGATION_SUPPORTS. if (debugEnabled) logger.debug(Participating in existing transaction); boolean newSynchronization =

49、(this.transactionSynchronization != SYNCHRONIZATION_NEVER); return newTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null); private TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)throws TransactionException if (definition.getPropagationBehavior() = TransactionDefin