Spring事務的傳播行爲和隔離級別

7個傳播行爲，4個隔離級別， 

Spring事務的傳播行爲和隔離級別 [ transaction behavior  and isolated  level ]2007 -08 -01 16 :33事務的傳播行爲和隔離級別 [ transaction behavior  and isolated  level ]

Spring中事務的定義：
1、Propagation ：
　　key屬性肯定代理應該給哪一個方法增長事務行爲。這樣的屬性最重要的部份是傳播行爲。有如下選項可供使用：
PROPAGATION_REQUIRED - -支持當前事務，若是當前沒有事務，就新建一個事務。這是最多見的選擇。 
PROPAGATION_SUPPORTS - -支持當前事務，若是當前沒有事務，就以非事務方式執行。 
PROPAGATION_MANDATORY - -支持當前事務，若是當前沒有事務，就拋出異常。 
PROPAGATION_REQUIRES_NEW - -新建事務，若是當前存在事務，把當前事務掛起。 
PROPAGATION_NOT_SUPPORTED - -以非事務方式執行操做，若是當前存在事務，就把當前事務掛起。 
PROPAGATION_NEVER - -以非事務方式執行，若是當前存在事務，則拋出異常。 

不少人看到事務的傳播行爲屬性都不甚瞭解，我昨晚看了j2ee without ejb的時候，看到這裏也不瞭解，甚至從新翻起數據庫系統的教材書，可是也沒有找到對這個的分析。今天搜索，找到一篇極好的分析文章，雖然這篇文章是重點分析PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRED_NESTED的
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
  
 
 
 
解惑  spring 嵌套事務 
/** 
* @date 2006-11-24 
* @note 轉載自http://www.javaeye.com/topic/35907?page=1
*/ 
* * * * * * * *TransactionDefinition 接口定義 * * * * * * * * * * * * * * * * * * *
/** 
      * Support a current transaction, create a new one if none exists. 
      * Analogous to EJB transaction attribute of the same name. 
      * 
This is typically the default setting of a transaction definition. 
      */ 
      int PROPAGATION_REQUIRED  = 0 ; 
  
      /** 
      * Support a current transaction, execute non-transactionally if none exists. 
      * Analogous to EJB transaction attribute of the same name. 
      * 

Note: For transaction managers with transaction synchronization, 
      * PROPAGATION_SUPPORTS is slightly different from no transaction at all, 
      * as it defines a transaction scopp that synchronization will apply for. 
      * As a consequence, the same resources (JDBC Connection, Hibernate Session, etc) 
      * will be shared for the entire specified scope. Note that this depends on 
      * the actual synchronization configuration of the transaction manager. 
      * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization 
      */ 
      int PROPAGATION_SUPPORTS  = 1 ; 
  
      /** 
      * Support a current transaction, throw an exception if none exists. 
      * Analogous to EJB transaction attribute of the same name. 
      */ 
      int PROPAGATION_MANDATORY  = 2 ; 
  
      /** 
      * Create a new transaction, suspend the current transaction if one exists. 
      * Analogous to EJB transaction attribute of the same name. 
      * 

Note: Actual transaction suspension will not work on out-of-the-box 
      * on all transaction managers. This in particular applies to JtaTransactionManager, 
      * which requires the javax.transaction.TransactionManager to be 
      * made available it to it (which is server-specific in standard J2EE). 
      * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager 
      */ 
      int PROPAGATION_REQUIRES_NEW  = 3 ; 
  
      /** 
      * Execute non-transactionally, suspend the current transaction if one exists. 
      * Analogous to EJB transaction attribute of the same name. 
      * 

Note: Actual transaction suspension will not work on out-of-the-box 
      * on all transaction managers. This in particular applies to JtaTransactionManager, 
      * which requires the javax.transaction.TransactionManager to be 
      * made available it to it (which is server-specific in standard J2EE). 
      * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager 
      */ 
      int PROPAGATION_NOT_SUPPORTED  = 4 ; 
  
      /** 
      * Execute non-transactionally, throw an exception if a transaction exists. 
      * Analogous to EJB transaction attribute of the same name. 
      */ 
      int PROPAGATION_NEVER  = 5 ; 
  
      /** 
      * Execute within a nested transaction if a current transaction exists, 
      * behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB. 
      * 

Note: Actual creation of a nested transaction will only work on specific 
      * transaction managers. Out of the box, this only applies to the JDBC 
      * DataSourceTransactionManager when working on a JDBC 3.0 driver. 
      * Some JTA providers might support nested transactions as well. 
      * @see org.springframework.jdbc.datasource.DataSourceTransactionManager 
      */ 
      int PROPAGATION_NESTED  = 6 ; 

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
在這篇文章裏，他用兩個嵌套的例子輔助分析，我這裏直接引用了。
* * * * * * * * * * * * * * * * * * * *sample * * * * * * * * * * * * * * * * * * * * * * *
ServiceA  { 
       
      /** 
      * 事務屬性配置爲 PROPAGATION_REQUIRED 
      */ 
      void methodA ( )  { 
         ServiceB .methodB ( ) ; 
      } 
  
} 
  
ServiceB  { 
       
      /** 
      * 事務屬性配置爲 PROPAGATION_REQUIRED 
      */ 
      void methodB ( )  { 
      } 
       
} 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1： PROPAGATION_REQUIRED 
加入當前正要執行的事務不在另一個事務裏，那麼就起一個新的事務 
好比說，ServiceB .methodB的事務級別定義爲PROPAGATION_REQUIRED , 那麼因爲執行ServiceA .methodA的時候， 
ServiceA .methodA已經起了事務，這時調用ServiceB .methodB，ServiceB .methodB看到本身已經運行在ServiceA .methodA 
的事務內部，就再也不起新的事務。而假如ServiceA .methodA運行的時候發現本身沒有在事務中，他就會爲本身分配一個事務。 
這樣，在ServiceA .methodA或者在ServiceB .methodB內的任何地方出現異常，事務都會被回滾。即便ServiceB .methodB的事務已經被 
提交，可是ServiceA .methodA在接下來fail要回滾，ServiceB .methodB也要回滾 

2： PROPAGATION_SUPPORTS 
若是當前在事務中，即以事務的形式運行，若是當前再也不一個事務中，那麼就以非事務的形式運行 


3： PROPAGATION_MANDATORY 
必須在一個事務中運行。也就是說，他只能被一個父事務調用。不然，他就要拋出異常 

4： PROPAGATION_REQUIRES_NEW 
這個就比較繞口了。 好比咱們設計ServiceA .methodA的事務級別爲PROPAGATION_REQUIRED，ServiceB .methodB的事務級別爲PROPAGATION_REQUIRES_NEW， 
那麼當執行到ServiceB .methodB的時候，ServiceA .methodA所在的事務就會掛起，ServiceB .methodB會起一個新的事務，等待ServiceB .methodB的事務完成之後， 
他才繼續執行。他與PROPAGATION_REQUIRED 的事務區別在於事務的回滾程度了。由於ServiceB .methodB是新起一個事務，那麼就是存在 
兩個不一樣的事務。若是ServiceB .methodB已經提交，那麼ServiceA .methodA失敗回滾，ServiceB .methodB是不會回滾的。若是ServiceB .methodB失敗回滾， 
若是他拋出的異常被ServiceA .methodA捕獲，ServiceA .methodA事務仍然可能提交。 

5： PROPAGATION_NOT_SUPPORTED 
當前不支持事務。好比ServiceA .methodA的事務級別是PROPAGATION_REQUIRED ，而ServiceB .methodB的事務級別是PROPAGATION_NOT_SUPPORTED ， 
那麼當執行到ServiceB .methodB時，ServiceA .methodA的事務掛起，而他以非事務的狀態運行完，再繼續ServiceA .methodA的事務。 

6： PROPAGATION_NEVER 
不能在事務中運行。假設ServiceA .methodA的事務級別是PROPAGATION_REQUIRED， 而ServiceB .methodB的事務級別是PROPAGATION_NEVER ， 
那麼ServiceB .methodB就要拋出異常了。 

7： PROPAGATION_NESTED 
理解Nested的關鍵是savepoint。他與PROPAGATION_REQUIRES_NEW的區別是，PROPAGATION_REQUIRES_NEW另起一個事務，將會與他的父事務相互獨立， 
而Nested的事務和他的父事務是相依的，他的提交是要等和他的父事務一塊提交的。也就是說，若是父事務最後回滾，他也要回滾的。 
而Nested事務的好處是他有一個savepoint。 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
ServiceA  { 

/** 
* 事務屬性配置爲 PROPAGATION_REQUIRED 
*/ 
void methodA ( )  { 
try  { 
//savepoint 

ServiceB .methodB ( ) ;  //PROPAGATION_NESTED 級別 

}  catch  (SomeException )  { 
// 執行其餘業務, 如 ServiceC.methodC(); 

} 
} 

} 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
也就是說ServiceB .methodB失敗回滾，那麼ServiceA .methodA也會回滾到savepoint點上，ServiceA .methodA能夠選擇另一個分支，好比 
ServiceC .methodC，繼續執行，來嘗試完成本身的事務。 
可是這個事務並無在EJB標準中定義。 

2、Isolation  Level (事務隔離等級 ) : 
一、Serializable：最嚴格的級別，事務串行執行，資源消耗最大； 
二、REPEATABLE READ：保證了一個事務不會修改已經由另外一個事務讀取但未提交（回滾）的數據。避免了「髒讀取」和「不可重複讀取」的狀況，可是帶來了更多的性能損失。 
三、READ COMMITTED :大多數主流數據庫的默認事務等級，保證了一個事務不會讀到另外一個並行事務已修改但未提交的數據，避免了「髒讀取」。該級別適用於大多數系統。 
四、Read Uncommitted：保證了讀取過程當中不會讀取到非法數據。隔離級別在於處理多事務的併發問題。 
咱們知道並行能夠提升數據庫的吞吐量和效率，可是並非全部的併發事務均可以併發運行，這須要查看數據庫教材的可串行化條件判斷了。 
這裏就不闡述。 
咱們首先說併發中可能發生的3中不討人喜歡的事情 
1：  Dirty reads - -讀髒數據。也就是說，好比事務A的未提交（還依然緩存）的數據被事務B讀走，若是事務A失敗回滾，會致使事務B所讀取的的數據是錯誤的。 
2： non -repeatable reads - -數據不可重複讀。好比事務A中兩處讀取數據 -total -的值。在第一讀的時候，total是100，而後事務B就把total的數據改爲200，事務A再讀一次，結果就發現，total居然就變成200了，形成事務A數據混亂。 
3： phantom reads - -幻象讀數據，這個和non -repeatable reads類似，也是同一個事務中屢次讀不一致的問題。可是non -repeatable reads的不一致是由於他所要取的數據集被改變了（好比total的數據），可是phantom reads所要讀的數據的不一致卻不是他所要讀的數據集改變，而是他的條件數據集改變。好比Select account . id where account . name = "ppgogo*" ,第一次讀去了6個符合條件的id，第二次讀取的時候，因爲事務b把一個賬號的名字由 "dd"改爲 "ppgogo1"，結果取出來了7個數據。  Dirty reads non -repeatable reads phantom reads 
Serializable 不會 不會 不會 
REPEATABLE  READ 不會 不會 會 
READ COMMITTED 不會 會 會 
Read Uncommitted 會 會 會 





3、readOnly 
事務屬性中的readOnly標誌表示對應的事務應該被最優化爲只讀事務。

這是一個最優化提示。在一些狀況下，一些事務策略可以起到顯著的最優化效果，例如在使用Object /Relational映射工具（如：Hibernate或TopLink）時避免dirty checking（試圖「刷新」）。

4、Timeout 

在事務屬性中還有定義「timeout」值的選項，指定事務超時爲幾秒。在JTA中，這將被簡單地傳遞到J2EE服務器的事務協調程序，並據此獲得相應的解釋。