2. 程式人生 > >淺談Spring宣告式事務管理ThreadLocal和JDKProxy

淺談Spring宣告式事務管理ThreadLocal和JDKProxy

阿新 • • 發佈：2019-02-12
寫這篇文章的目的，為了使大家更好的理解和摸清事務的規律，希望對新手學習事務這塊內容時有所幫助。

   在我們開發一個應用時，很多時候我們的一個業務操作會對資料庫進行多次操作，有時候我們需要保證這麼一系列的操作要麼全部成功，要麼全部失敗，其實這個這個概念就是我們今天要談論的事務。
  
   現在我們開發應用一般都採用三層結構，如果我們控制事務的程式碼都放在DAO(DataAccessObject)物件中，在DAO物件的每個方法當中去開啟事務和關閉事務，當Service物件在呼叫DAO時，如果只調用一個DAO，那我們這樣實現則效果不錯，但往往我們的Service會呼叫一系列的DAO對資料庫進行多次操作，那麼，這個時候我們就無法控制事務的邊界了，因為實際應用當中，我們的Service呼叫的DAO的個數是不確定的，可根據需求而變化，而且還可能出現Service呼叫Service的情況，看來手工來控制事務對於一個稍微嚴謹一點的系統來說完全是不現實的。

   那麼現在我們有什麼好的解決辦法嗎？還記得EJB引以為傲的宣告式事務嗎，雖然它現在已經慢慢沒落，但是它的思想被後人所吸取，我們的Spring框架是一個輕量級框架，它同樣的實現了宣告式事務的支援，使我們能夠通過配置及可插拔的方式的完成整個應用的事務的管理。

  
   談到Sping事務，我們今天要說到的一個東東是ThreadLocal，早在JDK 1.2的版本中就提供java.lang.ThreadLocal,ThreadLocal為解決多執行緒程式的併發問題提供了一種新的思路。簡單的說，ThreadLocal是為每個執行緒儲存一份變數，各個執行緒訪問自己對應的變數，所以我們就可以不使用synchronized關鍵字同樣可以實現執行緒同步，要了解關於ThreadLocal的詳細資訊，請參看
http://hi.baidu.com/cjjic02/blog/item/1ba41813aabde8886438dbe5.html


為了簡單明瞭，今天我們先拋開AOP，還是先用手工的方式通過ThreadLocal來管理連線，廢話不多說，先來看程式碼
TransactionHelper
Java程式碼  收藏程式碼
  1. package com.hwadee.demo;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.sql.Connection;  
  5. import java.sql.DriverManager;  
  6. import
     java.sql.SQLException;  
  7. import java.util.Properties;  
  8. publicfinalclass TransactionHelper {  
  9.     //使用ThreadLocal持有當前執行緒的資料庫連線
  10.     privatefinalstatic ThreadLocal<Connection> connection_holder = new ThreadLocal<Connection>();  
  11.     //連線配置，來自connection.properties
  12.     privatefinalstatic Properties connectionProp = 
    new Properties();  
  13.     static{       
  14.         //載入配置檔案
  15.         InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("connection.properties");  
  16.         try {  
  17.             connectionProp.load(is);  
  18.             is.close();  
  19.             //載入驅動程式
  20.             Class.forName(connectionProp.getProperty("driverClassName"));  
  21.         } catch (IOException e) {  
  22.              thrownew RuntimeException(e.getMessage(),e);  
  23.         }catch(ClassNotFoundException e){  
  24.             thrownew RuntimeException("驅動未找到",e);  
  25.         }  
  26.     }  
  27.     //獲取當前執行緒中的資料庫連線
  28.     privatestatic Connection getCurrentConnection()  
  29.     {  
  30.         Connection conn = connection_holder.get();  
  31.         if(conn == null){  
  32.             conn =  createNotAutoCommitConnection();              
  33.             connection_holder.set(conn);  
  34.         }  
  35.         return conn;  
  36.     }  
  37.     //執行SQL語句
  38.     publicstaticint executeNonQuery(String sql) throws SQLException{  
  39.         Connection conn = getCurrentConnection();  
  40.         return conn.createStatement().executeUpdate(sql);  
  41.     }  
  42.     //提交事務
  43.     publicstaticvoid commit(){  
  44.         Connection conn = getCurrentConnection();  
  45.         try {  
  46.             conn.commit();  
  47.             conn.close();  
  48.             connection_holder.set(null);  
  49.         } catch (SQLException e) {  
  50.             thrownew RuntimeException(e.getMessage(),e);  
  51.         }  
  52.     }  
  53.     //回滾事務
  54.     publicstaticvoid rollback(){  
  55.         Connection conn = getCurrentConnection();  
  56.         try {  
  57.             conn.rollback();  
  58.             conn.close();  
  59.             connection_holder.set(null);  
  60.         } catch (SQLException e) {  
  61.             thrownew RuntimeException(e.getMessage(),e);  
  62.         }  
  63.     }  
  64.     //建立一個不自動Commit的資料庫連線
  65.     privatestatic Connection createNotAutoCommitConnection() {  
  66.         try {  
  67.             Connection conn = DriverManager.getConnection(connectionProp.getProperty("url")+";databaseName="+ connectionProp.getProperty("databaseName")  
  68.                     ,connectionProp.getProperty("username")  
  69.                     ,connectionProp.getProperty("password"));  
  70.             conn.setAutoCommit(false);  
  71.             return conn;  
  72.         } catch (SQLException e) {  
  73.              thrownew RuntimeException(e.getMessage(),e);  
  74.         }  
  75.     }     
  76. }  

這個類實現了基本的連線管理與執行SQL語句的方法，可以在多執行緒環境下執行


程式入口
Java程式碼  收藏程式碼
  1. package com.hwadee.demo;  
  2. import java.sql.SQLException;  
  3. publicclass MainModule {  
  4.     publicstaticvoid main(String[] args) {          
  5.         try{  
  6.             insert1();  
  7.             insert2();  
  8.             //方法1和2都無異常，提交事務,任何一個方法出現異常都將導致事務回滾。
  9.             TransactionHelper.commit();  
  10.         }catch(SQLException e){           
  11.             TransactionHelper.rollback();  
  12.             thrownew RuntimeException(e.getMessage(),e);  
  13.         }catch(RuntimeException e){            
  14.             TransactionHelper.rollback();  
  15.             thrownew RuntimeException(e.getMessage(),e);  
  16.         }  
  17.     }  
  18.     staticvoid insert1() throws SQLException{        
  19.         String sql = "insert into department values(1,'市場部')";  
  20.         TransactionHelper.executeNonQuery(sql);        
  21.     }  
  22.     staticvoid insert2() throws SQLException{        
  23.         String sql = "insert into department values(2,'研發部')";  
  24.         TransactionHelper.executeNonQuery(sql);   
  25.         //throw new RuntimeException("回滾");     
  26.     }  
  27. }  



連線字串配置，請將此檔案放入classpath根目錄中
connection.properties
Java程式碼  收藏程式碼
  1. url=jdbc:sqlserver://localhost:1433
  2. databaseName=pubs  
  3. username=sa  
  4. password=password  
  5. driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver  



建表語句
Sql程式碼  收藏程式碼
  1. USE [pubs]  
  2. go  
  3. CREATETABLE [Department](  
  4.     [DEPT_ID] [int] primarykey,  
  5.     [DEPT_NAME] [varchar](50)  
  6. )  
  7. GO  



   好了現在執行這個應用，可以正常的插入兩條資料，接下來，取消insert2方法裡面的註釋，再執行看看效果。
Java程式碼  收藏程式碼
  1. staticvoid insert2() throws SQLException{        
  2.         String sql = "insert into department values(2,'研發部')";  
  3.         TransactionHelper.executeNonQuery(sql);   
  4.         thrownew RuntimeException("回滾");         
  5.     }  


很重要的一點是要想實現事務，我們必須用同一個資料庫連線執行這些語句，最終才能做到統一的提交和回滾。
我們可以這樣假設
insert1和insert2為不同DAO的方法
仔細觀察，我們的insert1和insert2並沒有負責開啟連線和關閉連線。而是間接的呼叫TransactionHelper.executeNonQuery(sql);
這樣使我們執行的所有方法都是使用同一個連線進行資料庫操作。

   其實這個例子只是想告訴大家要實現宣告式事務的一部分內容，這個例子只能實現簡單的單事務模型，要實現更復雜的事務傳播模型如巢狀等，還需要我們使用更多的技術，如AOP等等。先寫到這裡，希望對大家有所幫助！

   感謝大家的支援，應為最近在比較忙，一直沒有更新此貼，週末終於有時間可以繼續來完成這篇文章了。
   
    前面我們講到了ThreadLocal管理連線，當然這麼一點內容確實和Spring的宣告式事務沒有多大聯絡，前面的例子還是由我們自己在管理事務的起點和終點，但大多數時候我們在編寫一個業務邏輯時並不能確定事務的邊界，而卻隨著系統越發複雜化，之前的一個事務可能會作為另一個業務邏輯的子事務，那要做到事務原子性，我們就根本沒辦法在程式碼裡面去寫事務控制的邏輯，我們需要一種能夠靈活的配置的方式來管理事務，這樣，我們只需要在配置檔案裡面配哪些物件的哪些方法需要事務，而且可以配置事務的傳播特性。

這裡簡要的看看事務傳播特性
Spring在TransactionDefinition介面中7種類型的事務傳播行為，它們規定了事務方法和事務方法發生巢狀呼叫時事務如何進行傳播：

1.PROPAGATION_REQUIRED
如果當前沒有事務，就新建一個事務，如果已經存在一個事務中，加入到這個事務中。這是最常見的選擇。

2.PROPAGATION_SUPPORTS
支援當前事務，如果當前沒有事務，就以非事務方式執行。

3.PROPAGATION_MANDATORY
使用當前的事務，如果當前沒有事務，就丟擲異常。

4.PROPAGATION_REQUIRES_NEW
新建事務，如果當前存在事務，把當前事務掛起。

5.PROPAGATION_NOT_SUPPORTED
以非事務方式執行操作，如果當前存在事務，就把當前事務掛起。

6.PROPAGATION_NEVER
以非事務方式執行，如果當前存在事務，則丟擲異常。

7.PROPAGATION_NESTED
如果當前存在事務，則在巢狀事務內執行。如果當前沒有事務，則執行與PROPAGATION_REQUIRED類似的操作。

   我們看到了上面的定義的7中事務傳播特性，那麼Spring到底是如何來實現事務傳播特性呢？Proxy，使用Proxy，我們為所有需要實現事務的物件建立一個代理物件，代理物件能夠在目標物件的方法被呼叫的前後，加入事務判斷的邏輯，這樣子就可以實現事務傳播特性，這就是我們下面要講的AOP。在Java下實現AOP最常用的兩種方案分別為JDK動態代理和CGLib動態代理，它們各有優勢。下面簡單的對比一下。

JDK動態代理                    |                CGlib動態代理
JDK原生支援                    |                需要第三方庫
只能針對介面代理                |               可以針對介面和類進行代理
建立代理的速度快                |             建立代理速度慢
代理物件效能一般                |             代理物件效能很好

  根據上面的這些特性，總結如下，對於Singleton的代理物件或者具有例項池的代理，因為無須頻繁建立代理物件，比較適合用CGLib動態代理技術，反之適合用JDK動態代理技術。
順便要提一點，由於CGLib採用動態建立子類的方式生成代理，所以不能對目標類中的final方法進行代理。

   這裡我們來看一個JDK動態代理實現Required事務的例子，程式碼比較多，需要大家一點點耐心，先來看看程式碼。

介面 DAO 使用JDK動態代理必須要有介面
Java程式碼  收藏程式碼
  1. package com.hwadee.demo.aop;  
  2. publicinterface DAO {  
  3.     void doWork();  
  4. }  


實現類 DAOImpl1
Java程式碼  收藏程式碼
  1. package com.hwadee.demo.aop;  
  2. import java.sql.SQLException;  
  3. import com.hwadee.demo.TransactionHelper;  
  4. publicclass DAOImpl1 implements DAO {  
  5.     publicvoid doWork() {  
  6.         System.out.println(this.getClass().getName() + "." + "doWork  Invoke");  
  7.         String sql = "insert into department values(1,'市場部')";  
  8.         try {  
  9.             TransactionHelper.executeNonQuery(sql);  
  10.         } catch (SQLException e) {  
  11.             thrownew RuntimeException(e.getMessage(), e);  
  12.         }  
  13.         // 呼叫dao2
  14.         DAO dao2 = (DAO) BeanFactory.getBean("dao2");  
  15.         dao2.doWork();  
  16.     }  
  17. }  


實現類 DAOImpl2
Java程式碼  收藏程式碼
  1. package com.hwadee.demo.aop;  
  2. import java.sql.SQLException;  
  3. import com.hwadee.demo.TransactionHelper;  
  4. publicclass DAOImpl2 implements DAO {  
  5.     publicvoid doWork() {  
  6.         System.out.println(this.getClass().getName() + "." + "doWork  Invoke");  
  7.         String sql = "insert into department values(2,'研發部')";  
  8.         try {  
  9.             TransactionHelper.executeNonQuery(sql);  
  10.         } catch (SQLException e) {  
  11.             thrownew RuntimeException(e.getMessage(), e);  
  12.         }  
  13.         //throw new RuntimeException("回滾");
  14.     }  
  15. }  


修改過後的 TransactionHelper
Java程式碼  收藏程式碼
  1. package com.hwadee.demo;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.sql.Connection;  
  5. import java.sql.DriverManager;  
  6. import java.sql.SQLException;  
  7. import java.util.Properties;  
  8. publicfinalclass TransactionHelper {  
  9.     // 使用ThreadLocal持有當前執行緒的資料庫連線
  10.     privatefinalstatic ThreadLocal<Connection> connection_holder = new ThreadLocal<Connection>();  
  11.     // 當前是否處於事務環境
  12.     privatefinalstatic ThreadLocal<Boolean> existsTransaction = new ThreadLocal<Boolean>() {  
  13.         @Override
  14.         protected Boolean initialValue() {  
  15.             return Boolean.FALSE;  
  16.         }  
  17.     };  
  18.     // 是否必須回滾
  19.     privatefinalstatic ThreadLocal<Boolean> rollbackOnly = new ThreadLocal<Boolean>() {  
  20.         @Override
  21.         protected Boolean initialValue() {  
  22.             return Boolean.FALSE;  
  23.         }  
  24.     };  
  25.     // 連線配置，來自connection.properties
  26.     privatefinalstatic Properties connectionProp = new Properties();  
  27.     static {  
  28.         // 載入配置檔案
  29.         InputStream is = Thread.currentThread().getContextClassLoader()  
  30.                 .getResourceAsStream("connection.properties");  
  31.         try {  
  32.             connectionProp.load(is);  
  33.             is.close();  
  34.             // 載入驅動程式
  35.             Class.forName(connectionProp.getProperty("driverClassName"));  
  36.         } catch (IOException e) {  
  37.             thrownew RuntimeException(e.getMessage(), e);  
  38.         } catch (ClassNotFoundException e) {  
  39.             thrownew RuntimeException("驅動未找到", e);  
  40.         }  
  41.     }  
  42.     /** 
  43.      * 是否必須回滾 
  44.      */
  45.     publicstaticboolean isRollbackOnly() {  
  46.         return rollbackOnly.get();  
  47.     }  
  48.     /** 
  49.      * 設定當前事務環境的回滾狀態 
  50.      */
  51.     publicstaticvoid setRollbackOnly(boolean flag) {  
  52.         rollbackOnly.set(flag);  
  53.     }  
  54.     /** 
  55.      * 當前是否存在事務 
  56.      */
  57.     publicstaticboolean existsTransaction() {  
  58.         return existsTransaction.get();  
  59.     }  
  60.     // 設定當前事務環境
  61.     privatestaticvoid setExistsTransaction(boolean flag) {  
  62.         existsTransaction.set(flag);  
  63.     }  
  64.     /** 
  65.      * 開始一個事務 
  66.      */
  67.     publicstaticvoid beginTransaction() {  
  68.         Connection conn = createNotAutoCommitConnection();  
  69.         connection_holder.set(conn);  
  70.         setExistsTransaction(Boolean.TRUE);  
  71.     }  
  72.     // 獲取當前執行緒中的資料庫連線
  73.     privatestatic Connection getCurrentConnection() {  
  74.         return connection_holder.get();  
  75.     }  
  76.     // 執行SQL語句
  77.     publicstaticint executeNonQuery(String sql) throws SQLException {  
  78.         Connection conn = getCurrentConnection();  
  79.         return conn.createStatement().executeUpdate(sql);  
  80.     }  
  81.     /** 
  82.      * 提交事務 
  83.      */
  84.     publicstaticvoid commit() {  
  85.         Connection conn = getCurrentConnection();  
  86.         try {  
  87.             conn.commit();  
  88.             conn.close();  
  89.             connection_holder.set(null);  
  90.             setExistsTransaction(Boolean.FALSE);  
  91.         } catch (SQLException e) {  
  92.             thrownew RuntimeException(e.getMessage(), e);  
  93.         }  
  94.     }  
  95.     /** 
  96.      * 回滾事務 
  97.      */
  98.     publicstaticvoid rollback() {  
  99.         Connection conn = getCurrentConnection();  
  100.         try {  
  101.             conn.rollback();  
  102.             conn.close();  
  103.             connection_holder.set(null);  
  104.             setExistsTransaction(Boolean.FALSE);  
  105.         } catch (SQLException e) {  
  106.             thrownew RuntimeException(e.getMessage(), e);  
  107.         }  
  108.     }  
  109.     // 建立一個不自動Commit的資料庫連線
  110.     privatestatic Connection createNotAutoCommitConnection() {  
  111.         try {  
  112.             Connection conn = DriverManager.getConnection(connectionProp  
  113.                     .getProperty("url")  
  114.                     + ";databaseName="
  115.                     + connectionProp.getProperty("databaseName"),  
  116.                     connectionProp.getProperty("username"), connectionProp  
  117.                             .getProperty("password"));  
  118.             conn.setAutoCommit(false);  
  119.             return conn;  
  120.         } catch (SQLException e) {  
  121.             thrownew RuntimeException(e.getMessage(), e);  
  122.         }  
  123.     }  
  124. }  


RequiredTransactionInterceptor 事務攔截器
Java程式碼  收藏程式碼
  1. package com.hwadee.demo.aop;  
  2. import java.lang.reflect.InvocationHandler;  
  3. import java.lang.reflect.InvocationTargetException;  
  4. import java.lang.reflect.Method;  
  5. import com.hwadee.demo.TransactionHelper;  
  6. /** 
  7.  * 事務攔截器 代理物件執行介面的任意方法都會被攔截 對方法的呼叫交由本類的 invoke 方法處理 
  8.  */
  9. publicclass RequiredTransactionInterceptor implements InvocationHandler {  
  10.     // 目標物件
  11.     private Object target;  
  12.     // 在構造方法中傳入目標物件
  13.     public RequiredTransactionInterceptor(Object target) {  
  14.         this.target = target;  
  15.     }  
  16.     /** 
  17.      * 在代理物件呼叫介面方法時的請求會被此方法攔截 
  18.      *  
  19.      * @param proxy 
  20.      *            代理物件 
  21.      * @param method 
  22.      *            目標物件當前呼叫的方法 
  23.      * @param args 
  24.      *            呼叫此方法時傳遞的引數 
  25.      */
  26.     public Object invoke(Object proxy, Method method, Object[] args)  
  27.             throws Throwable {  
  28.         // 在目標方法被呼叫前織入的邏輯,此處以Required傳播屬性為例
  29.         // 判斷當前的事務環境，是開始一個新事務還是加入已有的事務
  30.         boolean existsTransaction = TransactionHelper.existsTransaction();  
  31.         if (existsTransaction == false) {  
  32.             TransactionHelper.beginTransaction();  
  33.             System.out.println("當前事務環境還沒有事務，開啟一個新事務");  
  34.         } else {  
  35.             System.out.println("當前事務環境已存在事務，加入事務");  
  36.         }  
  37.         // 目標方法的返回值
  38.         Object result = null;  
  39.         // 此處才真正呼叫目標物件的方法
  40.         try {  
  41.             result = method.invoke(target, args);  
  42.         } catch (InvocationTargetException e) {  
  43.             // 捕獲呼叫目標異常，如果目標異常是執行時異常則設定回滾標誌
  44.             Throwable cause = e.getCause();  
  45.             if (cause instanceof RuntimeException) {  
  46.                 TransactionHelper.setRollbackOnly(true);  
  47.                 System.out.println("出現執行時異常，事務環境被設定為必須回滾");  
  48.             } else {  
  49.                 System.out.println("出現非執行時異常，忽略");  
  50.             }  
  51.         }  
  52.         // 在目標方法被呼叫後織入的邏輯
  53.         System.out.println("判斷當前的事務環境，是應該提交事務還是回滾事務");  
  54.         if (existsTransaction == false
  55.                 && TransactionHelper.isRollbackOnly() == false) {  
  56.             TransactionHelper.commit();  
  57.             System.out.println("事務已提交");  
  58.         } elseif (existsTransaction == false
  59.                 && TransactionHelper.isRollbackOnly() == true) {  
  60.             TransactionHelper.rollback();  
  61.             System.out.println("事務已回滾");  
  62.         } elseif (existsTransaction == true) {  
  63.             System.out.println("子事務忽略事務提交或回滾");  
  64.         }  
  65.         System.out.println("=============================");  
  66.         return result;  
  67.     }  
  68. }  


BeanFactory  Bean工廠，負責建立代理物件
Java程式碼  收藏程式碼
  1. package com.hwadee.demo.aop;  
  2. import java.lang.reflect.Proxy;  
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5. /** 
  6.  * 模擬Spring BeanFactory 最簡化的實現 
  7.  *  
  8.  * 預設會建立兩個Bean dao1 dao2 
  9.  *  
  10.  * 它們都是經過了代理過後的物件 
  11.  */
  12. publicclass BeanFactory {  
  13.     // Bean容器
  14.     privatefinalstatic Map<String, Object> beanContainer = new HashMap<String, Object>();  
  15.     // 初始化建立兩個代理物件
  16.     static {  
  17.         DAO dao1 = new DAOImpl1();  
  18.         Object dao1Proxy = createTransactionProxy(dao1);  
  19.         beanContainer.put("dao1", dao1Proxy);  
  20.         DAO dao2 = new DAOImpl2();  
  21.         Object dao2Proxy = createTransactionProxy(dao2);  
  22.         beanContainer.put("dao2", dao2Proxy);  
  23.     }  
  24.     // 建立代理物件
  25.     privatestatic Object createTransactionProxy(Object target) {  
  26.         // 使用 Proxy.newProxyInstance 方法建立一個代理物件
  27.         Object proxy = Proxy.newProxyInstance(target.getClass()  
  28.                 .getClassLoader(), target.getClass().getInterfaces(),  
  29.                 new RequiredTransactionInterceptor(target));  
  30.         return proxy;  
  31.     }  
  32.     // 獲取Bean
  33.     publicstatic Object getBean(String id) {  
  34.         return beanContainer.get(id);  
  35.     }  
  36. }  


MainModule  程式入口
Java程式碼  收藏程式碼
  1. package com.hwadee.demo.aop;  
  2. publicclass MainModule {  
  3.     publicstaticvoid main(String[] args) {  
  4.         DAO dao1 = (DAO) BeanFactory.getBean("dao1");  
  5.         // 呼叫dao1，doa1的doWork方法內又呼叫了dao2
  6.         dao1.doWork();        
  7.     }  
  8. }  


   好了，現在我們可以執行一下這個應用，記得先把資料庫裡已有的記錄清空。
看看控制檯輸出的內容
Xml程式碼  收藏程式碼
  1. 當前事務環境還沒有事務，開啟一個新事務  
  2. com.hwadee.demo.aop.DAOImpl1.doWork  Invoke  
  3. 當前事務環境已存在事務，加入事務  
  4. com.hwadee.demo.aop.DAOImpl2.doWork  Invoke  
  5. 判斷當前的事務環境，是應該提交事務還是回滾事務  
  6. 子事務忽略事務提交或回滾  
  7. =============================  
  8. 判斷當前的事務環境，是應該提交事務還是回滾事務  
  9. 事務已提交  
  10. =============================  


接下來，把DAOImpl2中這段程式碼的註釋取消掉，再次執行此應用，記得先清空資料庫資料
Java程式碼  收藏程式碼
  1. //throw new RuntimeException("回滾");


再來看控制檯輸出的內容
Xml程式碼  收藏程式碼
  1. 當前事務環境還沒有事務，開啟一個新事務  
  2. com.hwadee.demo.aop.DAOImpl1.doWork  Invoke  
  3. 當前事務環境已存在事務，加入事務  
  4. com.hwadee.demo.aop.DAOImpl2.doWork  Invoke  
  5. 出現執行時異常，事務環境被設定為必須回滾  
  6. 判斷當前的事務環境，是應該提交事務還是回滾事務  
  7. 子事務忽略事務提交或回滾  
  8. =============================  
  9. 判斷當前的事務環境，是應該提交事務還是回滾事務  
  10. 事務已回滾  
  11. =============================  


  朋友們，這不就是Required事務傳播模型嗎，離Spring的宣告式事務已經不遠了，附上最新的程式碼。歡迎拍磚！待續！

相關推薦

淺談Spring宣告式事務管理ThreadLocal和JDKProxy

寫這篇文章的目的，為了使大家更好的理解和摸清事務的規律，希望對新手學習事務這塊內容時有所幫助。    在我們開發一個應用時，很多時候我們的一個業務操作會對資料庫進行多次操作，有時候我們需要保證這麼一系列的操作要麼全部成功，要麼全部失敗，其實這個這個概念就是我們今天要談論的事務。       現在我們開發應用

第十二講：12，spring宣告式事務管理-註解式

1，複製專案spring404 ，改名spring404-3。修改BankServiceImpl類，添加註解，package com.cruise.service.impl;import org.springframework.transaction.annotation.Tra

第十一講：11.spring宣告式事務管理-xml方式

1，複製專案spring404 ，改名spring404-2，修改BankServiceImpl類，刪除宣告式事務的程式碼。宣告式事務管理的方式缺點是，事務程式碼嚴重嵌入邏輯程式碼中 package com.cruise.service.impl; import org.springframewor

spring宣告式事務管理方式( 基於tx和aop名字空間的xml配置[email&#

轉自：https://www.cnblogs.com/niceyoo/p/8732891.html 1. 宣告式事務管理分類 宣告式事務管理也有兩種常用的方式， 一種是基於tx和aop名字空間的xml配置檔案，另一種就是基於@Transactional註解。 顯然基於註解的方式更簡單

Spring宣告式事務管理、事務的傳播行為xml配置

 1. <tx:method name="insert*" propagation="REQUIRED" />中name的值是ServiceImpl中各個要加入事物管理的方法的方法名。 <!-- 事務管理： Spring宣告式事務管理 。

spring宣告式事務管理：基於註解的方式

1）在spring.xml中配置事務管理器DataSourceTransactionManager，<bean id="txManager" class="org.springframework.

Spring宣告式事務管理及事務巢狀

一>  事務配置 Spring動態代理的一個重要特徵是，它是針對介面的，所以我們的dao要通過動態代理來讓spring接管事務，就必須在dao前面抽象出一個介面，當然如果沒有這樣的介面，那麼spring會使用CGLIB來解決問題。     一般地，使用Spri

Spring宣告式事務管理原始碼解析

核心介面 1. PlatformTransactionManager：事務管理器頂級介面：各持久化框架要想接入Spring的事務管理，必須自行提供該介面實現 2. TransactionDefinition：事務的屬性頂級介面：其實現類封裝事務隔離級別、

Spring宣告式事務管理與配置介紹

一、Spring宣告式事務配置的五種方式 前段時間對Spring的事務配置做了比較深入的研究，在此之間對Spring的事務配置雖說也配置過，但是一直沒有一個清楚的認識。通過這次的學習發覺Spring的事務配置只要把思路理清，還是比較好掌握的。 總結如下： Sprin

spring 宣告式事務管理註解方式實現

使用註解實現Spring的宣告式事務管理，更加簡單！ 步驟：          1） 必須引入Aop相關的jar檔案          2） bean.xml中指定註解方式實現宣告式事務管理以及應用的事務管理器類          3）在需要新增事務控制的地方，寫上: @T

淺談spring事務管理的2種方式：程式設計式事務管理和宣告式事務管理；以及@Transactional(rollbackFor=Exception.class)註解用法

事務的概念，以及特性： 百度百科介紹： ->資料庫事務(Database Transaction) ，是指作為單個邏輯工作單元執行的一系列操作，要麼完全地執行，要麼完全地不執行。 事務處理可以確保除非事務性單元內的所有操作都成功完成，否則不會永久更新面向資料的資源。通過

Java程式設計師從笨鳥到菜鳥之（八十）細談Spring（九）spring+hibernate宣告式事務管理詳解

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

使用註解實現Spring的宣告式事務管理

使用註解實現Spring的宣告式事務管理，更加簡單！ 步驟：          1） 必須引入Aop相關的jar檔案          2） b

spring事物配置，宣告式事務管理和基於@Transactional註解的使用

spring支援程式設計式事務管理和宣告式事務管理兩種方式。         程式設計式事務管理使用TransactionTemplate或者直接使用底層的PlatformTransactionManager。對於程式設計式事務管理，spring推薦使用Transactio

9.spring：事務管理（下）:宣告式事務管理

宣告式事務管理  sprin的宣告式事務是管理AOP技術實現的事務管理，其本質是是對方法前後進行攔截，然後 在目標方法開始之前建立或者加入一個事務，在執行完成目標方法之後根據執行情況提交或者回滾事務。   宣告式事務管理優點：不需要通過程式設計的方式管理事務，因而不需要在業務邏輯程

spring事務管理之四：宣告式事務管理：使用事務註解的方式

事務註解的方式，相對xml的方式來說，有優點，無需配置需要事務的業務方法的切點和事務屬性。但是也有缺點，就是需要在每個需要事務的業務方法上加上一個註解@Transaction，否則事務不會生效。 這裡沿用之前spring事務管理的程式碼： pom.xml依賴部分： <depen

spring事務管理之三：宣告式事務管理：使用xml配置檔案的方式

這種方式是開發中常見的一種方式：利用aop的思想，將需要事務管理的業務方法通過xml配置的方式，將事務管理加在該類的相關方法上。這種方法的優點是，一次xml配置，後期不用關心業務類增加或者減少，通過xml中配置的匹配資訊，會去找業務類所在的包和方法，然後加上事務。 重點是配置<tx:a

spring事務管理之二：宣告式事務管理：使用代理方式

spring宣告式事務管理，分為三種方式,分別是： 1、使用代理類TransactionProxyFactoryBean的方式 2、使用aspectj+xml配置的方式 3、使用事務註解的方式 其中後面兩種是比較常用的，使用xml和註解的方式。 這裡介紹使用代理類Transa

全面分析 Spring 的程式設計式事務管理及宣告式事務管理

Spring 事務屬性分析 事務管理對於企業應用而言至關重要。它保證了使用者的每一次操作都是可靠的，即便出現了異常的訪問情況，也不至於破壞後臺資料的完整性。就像銀行的自助取款機，通常都能正常為客戶服務，但是也難免遇到操作過程中機器突然出故障的情況，此時，事務就必須確保出

全面分析 Spring 的程式設計式事務管理及宣告式事務管理(1)

也許你會奇怪，為什麼介面只提供了獲取屬性的方法，而沒有提供相關設定屬性的方法。其實道理很簡單，事務屬性的設定完全是程式設計師控制的，因此程式設計師可以自定義任何設定屬性的方法，而且儲存屬性的欄位也沒有任何要求。唯一的要求的是，Spring 進行事務操作的時候，通過呼叫以上介面提供的方法必須能夠返回事務相關的