Spring事務管理器的應對 



   Spring抽象的DAO體系兼容多種數據訪問技術，它們各有特色，各有千秋。像Hibernate是非常優秀的ORM實現方案，但對底層SQL的控制不太方便；而iBatis則通過模板化技術讓你方便地控制SQL，但沒有Hibernate那樣高的開發效率；自由度最高的當然是直接使用Spring JDBC了，但它也是底層的，靈活的代價是代碼的繁復。很難說哪種數據訪問技術是最優秀的，只有在某種特定的場景下才能給出答案。所以在一個應用中，往往采用多個數據訪問技術：一般是兩種，一種采用ORM技術框架，而另一種采用偏JDBC的底層技術，兩者珠聯璧合，形成聯合軍種，共同御敵。 
   但是，這種聯合軍種如何應對事務管理的問題呢？我們知道Spring為每種數據訪問技術提供了相應的事務管理器，難道需要分別為它們配置對應的事務管理器嗎？它們到底是如何協作和工作的呢？這些層出不窮的問題往往壓制了開發人員使用聯合軍種的想法。 
   其實，在這個問題上，我們低估了Spring事務管理的能力。如果你采用了一個高端ORM技術（Hibernate、JPA、JDO），同時采用一個JDBC技術（Spring JDBC、iBatis），由于前者的會話（Session）是對后者連接（Connection）的封裝，Spring會“足夠智能地”在同一個事務線程讓前者的會話封裝后者的連接。所以，我們只要直接采用前者的事務管理器就可以了。表10-1給出了混合數據訪問技術框架所對應的事務管理器。 
序    號混合數據訪問技術框架事務管理器
1Hibernate+ Spring JDBC或iBatisorg.springframework.orm.hibernate3.HibernateTransactionManager
2JPA+Spring JDBC或iBatisorg.springframework.orm.jpa.JpaTransactionManager
3JDO+Spring JDBC或iBatisorg.springframework.orm.jdo.JdoTransactionManager


Hibernate+Spring JDBC混合框架的事務管理 


   由于一般不會出現同時使用多個ORM框架的情況（如Hibernate+JPA），我們不擬對此命題展開論述，只重點研究ORM框架+JDBC框架的情況。Hibernate+Spring JDBC可能是被使用得最多的組合，本節我們通過實例觀察事務管理的運作情況。 
Java代碼  收藏代碼
  1. package com.baobaotao.mixdao;  
  2.   
  3. …  
  4.   
  5. @Service("userService")  
  6. public class UserService extends BaseService {  
  7.     @Autowired  
  8.     private HibernateTemplate hibernateTemplate;  
  9.   
  10.     @Autowired  
  11.     private ScoreService scoreService;  
  12.   
  13.     public void logon(String userName) {  
  14.          
  15.         //①通過Hibernate技術訪問數據  
  16.         System.out.println("before updateLastLogonTime()..");  
  17.         updateLastLogonTime(userName);  
  18.         System.out.println("end updateLastLogonTime()..");  
  19.           
  20.         //②通過JDBC技術訪問數據  
  21.         System.out.println("before scoreService.addScore()..");  
  22.         scoreService.addScore(userName, 20);  
  23.         System.out.println("end scoreService.addScore()..");  
  24.     }  
  25.       
  26.     public void updateLastLogonTime(String userName) {  
  27.         User user = hibernateTemplate.get(User.class,userName);  
  28.         user.setLastLogonTime(System.currentTimeMillis());  
  29.         hibernateTemplate.update(user);  
  30.   
  31.         //③這句很重要，請看下文的分析  
  32.         hibernateTemplate.flush();  
  33.     }  
  34. }  

  在①處，使用Hibernate操作數據，而在②處調用ScoreService#addScore()，該方法內部使用Spring JDBC操作數據。 
  在③處，我們顯式調用了flush()方法，將Session中的緩存同步到數據庫中（即馬上向數據庫發送一條更新記錄的SQL語句）。之所以要顯式執行flush()方法，原因是在默認情況下，Hibernate對數據的更改只是記錄在一級緩存中，要等到事務提交或顯式調用flush()方法時才會將一級緩存中的數據同步到數據庫中，而提交事務的操作發生在   logon()方法返回前。如果所有針對數據庫的更改操作都使用Hibernate，這種數據同步的延遲機制并不會產生任何問題。但是，我們在logon()方法中同時采用了Hibernate和Spring JDBC混合數據訪問技術，Spring JDBC無法自動感知Hibernate一級緩存，所以如果不及時調用flush()方法將記錄數據更改的一級緩存同步到數據庫中，則②處通過Spring JDBC進行數據更改的結果將被Hibernate一級緩存中的更改覆蓋掉，因為Hibernate一級緩存要等到logon()方法返回前才同步到數據庫！ 
   ScoreService使用Spring JDBC數據訪問技術，其代碼如下所示： 
Java代碼  收藏代碼
  1. package com.baobaotao.mixdao;  
  2.   
  3. import org.springframework.beans.factory.annotation.Autowired;  
  4. import org.springframework.jdbc.core.JdbcTemplate;  
  5. import org.springframework.stereotype.Service;  
  6. import org.apache.commons.dbcp.BasicDataSource;  
  7.   
  8. @Service("scoreService")  
  9. public class ScoreService extends BaseService{  
  10.   
  11.     @Autowired  
  12.     private JdbcTemplate jdbcTemplate;  
  13.   
  14.     public void addScore(String userName, int toAdd) {  
  15.         String sql = "UPDATE t_user u SET u.score = u.score + ? WHERE user_name =?";  
  16.         jdbcTemplate.update(sql, toAdd, userName);  
  17.         BasicDataSource basicDataSource = (BasicDataSource) jdbcTemplate.getDataSource();  
  18.         //①查看此處數據庫激活的連接數量  
  19.         System.out.println("[scoreUserService.addScore]激活連接數量："  
  20.                          +basicDataSource.getNumActive());  
  21.     }  
  22. }  

   Spring關鍵的配置文件代碼如下所示： 
Xml代碼  收藏代碼
  1. …  
  2. <!--①使用Hibernate事務管理器 -->  
  3. <bean id="hiberManager"  
  4.       class="org.springframework.orm.hibernate3.HibernateTransactionManager"  
  5.       p:sessionFactory-ref="sessionFactory"/>  
  6.   
  7. <!--②使UserService及ScoreService的公用方法都擁有事務 -->  
  8. <aop:config proxy-target-class="true">  
  9.     <aop:pointcut id="serviceJdbcMethod"  
  10.                   expression="within(com.baobaotao.mixdao.BaseService+)"/>  
  11.     <aop:advisor pointcut-ref="serviceJdbcMethod"  
  12.                  advice-ref="hiberAdvice"/>  
  13. </aop:config>  
  14. <tx:advice id="hiberAdvice" transaction-manager="hiberManager">  
  15.     <tx:attributes>  
  16.         <tx:method name="*"/>  
  17.     </tx:attributes>  
  18. </tx:advice>  
  19.   
  20. /beans>  

啟動Spring容器，執行UserService#logon()方法，可以查看到如下的執行日志： 
引用
before userService.logon().. 

①在執行userService.logon()后，Spring開啟一個事務 
Creating new transaction with name [com.baobaotao.mixdao.UserService.logon]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT 
opened session at timestamp: 13009379637 
Opened new Session [org.hibernate.impl.SessionImpl@c5f468] for Hibernate transaction 
… 
Exposing Hibernate transaction as JDBC transaction [jdbc:mysql://localhost:3306/sampledb, UserName=root@localhost, MySQL-AB JDBC Driver] 
before userService.updateLastLogonTime().. 

②userService.updateLastLogonTime()執行時自動綁定到①處開啟的Session中 
Found thread-bound Session for HibernateTemplate 
loading entity: [com.baobaotao.User#tom] 
about to open PreparedStatement (open PreparedStatements: 0, globally: 0) 
… 
about to close PreparedStatement (open PreparedStatements: 1, globally: 1) 
Not closing pre-bound Hibernate Session after HibernateTemplate 
end updateLastLogonTime().. 

before scoreService.addScore().. 

③scoreService.addScore()執行時綁定到①處開啟的Session中，并加入其所對應的事務中 
Found thread-bound Session [org.hibernate.impl.SessionImpl@c5f468] for Hibernate 
transaction 
Participating in existing transaction 
… 
SQL update affected 1 rows 

④此時數據源只打開了一個連接 
[scoreUserService.addScore]激活連接數量：1 
end scoreService.addScore().. 
Initiating transaction commit 

⑤提交Hibernate的事務，它將觸發一級緩存到數據庫的同步 
Committing Hibernate transaction on Session [org.hibernate.impl.SessionImpl@c5f468] 
commit 
processing flush-time cascades 
dirty checking collections 
Flushed: 0 insertions, 0 updates, 0 deletions to 1 objects 
Flushed: 0 (re)creations, 0 updates, 0 removals to 0 collections 
listing entities: 
com.baobaotao.User{lastLogonTime=1300937963882, score=10, userName=tom, password=123456} 
re-enabling autocommit 

⑥提效Session底層所綁定的JDBC Connection所對應的事務 
committed JDBC Connection 
transaction completed on session with on_close connection release mode; be sure to close the session to release JDBC resources! 
Closing Hibernate Session [org.hibernate.impl.SessionImpl@c5f468] after transaction 
Closing Hibernate Session 
releasing JDBC connection [ (open PreparedStatements: 0, globally: 0) (open ResultSets: 0, globally: 0)] 
transaction completed on session with on_close connection release mode; be sure to close the session to release JDBC resources! 
after userService.logon().. 


   仔細觀察這段輸出日志，在①處UserService#logon()開啟一個新的事務。②處的UserService# updateLastLogonTime() 綁定到事務上下文的Session中。③處ScoreService#addScore()方法加入到①處開啟的事務上下文中。④處的輸出是ScoreService #addScore()方法內部的輸出信息，匯報此時數據源激活的連接數為1，這清楚地告訴我們Hibernate和JDBC這兩種數據訪問技術在同一事務上下文中“共用”一個連接。在⑤處，提交Hibernate事務，接著在⑥處觸發調用底層的Connection提交事務。 
   從以上的運行結果，我們可以得出這樣的結論：使用Hibernate事務管理器后，可以混合使用Hibernate和Spring JDBC數據訪問技術，它們將工作于同一事務上下文中。但是使用Spring JDBC訪問數據時，Hibernate的一級或二級緩存得不到同步，此外，一級緩存延遲數據同步機制可能會覆蓋Spring JDBC數據更改的結果。 
   由于混合數據訪問技術方案存在“事務同步而緩存不同步”的情況，所以最好用Hibernate進行讀寫操作，而只用Spring JDBC進行讀操作。如用Spring JDBC進行簡要列表的查詢，而用Hibernate對查詢出的數據進行維護。 
   如果確實要同時使用Hibernate和Spring JDBC讀寫數據，則必須充分考慮到Hibernate緩存機制引發的問題：必須整體分析數據維護邏輯，根據需要及時調用Hibernate的flush()方法，以免覆蓋Spring JDBC的更改，在Spring JDBC更改數據庫時，維護Hibernate的緩存。由于方法調用順序的不同都可能影響數據的同步性，因此很容易發生問題，這會極大提高數據訪問程序的復雜性。所以筆者鄭重建議不要同時使用Spring JDBC和Hibernate對數據進行寫操作。 
   可以將以上結論推廣到其他混合數據訪問技術的方案中，如Hibernate+iBatis、JPA+Spring JDBC、JDO+Spring JDBC等。