我是靠谱客的博主 真实手链,最近开发中收集的这篇文章主要介绍hibernate- Transaction,觉得挺不错的,现在分享给大家,希望可以做个参考。

概述

Hibernate是对JDBC的轻量级对象封装,Hibernate本身是不具备Transaction处理功能的,Hibernate的Transaction实际上是底层的JDBC Transaction的封装,或者是JTA Transaction的封装,下面我们详细的分析: 

Hibernate可以配置为JDBCTransaction或者是JTATransaction,这取决于你在hibernate.properties中的配置: 

引用
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory 
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory


如果你什么都不配置,默认情况下使用JDBCTransaction,如果你配置为: 

引用
hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory


将使用JTATransaction 

不管你准备让Hibernate使用JDBCTransaction,还是JTATransaction,我的忠告就是什么都不配,将让它保持默认状态,如下:

引用
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory 
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory


在下面的分析中我会给出原因。 

一、JDBC Transaction 

看看使用JDBC Transaction的时候我们的代码例子: 

Java代码   收藏代码
  1. Session session = sf.openSession();;  
  2. Transaction tx = session.beginTransactioin();;  
  3. ...  
  4. session.flush();;  
  5. tx.commit();;  
  6. session.close();;  


这是默认的情况,当你在代码中使用Hibernate的Transaction的时候实际上就是JDBCTransaction。那么JDBCTransaction究竟是什么东西呢?来看看源代码就清楚了: 

Hibernate2.0.3源代码中的类
Java代码   收藏代码
  1. net.sf.hibernate.transaction.JDBCTransaction:  
  2.   
  3. public void begin(); throws HibernateException {  
  4.       
  5.     log.debug("begin");;      
  6.     try {  
  7.         toggleAutoCommit = session.connection();.getAutoCommit();;  
  8.         if (toggleAutoCommit); session.connection();.setAutoCommit(false);;  
  9.     }  
  10.     catch (SQLException e); {  
  11.         log.error("Begin failed", e);;  
  12.         throw new TransactionException("Begin failed with SQL exception: ", e);;  
  13.     }     
  14.     begun = true;  
  15. }  

这是启动Transaction的方法,看到 connection().setAutoCommit(false) 了吗?是不是很熟悉? 

再来看 

Java代码   收藏代码
  1. public void commit(); throws HibernateException {     
  2.     if (!begun); throw new TransactionException("Transaction not successfully started");;     
  3.     log.debug("commit");;     
  4.     try {  
  5.         if ( session.getFlushMode();!=FlushMode.NEVER ); session.flush();;  
  6.         try {  
  7.             session.connection();.commit();;  
  8.             committed = true;  
  9.         }  
  10.         catch (SQLException e); {  
  11.             log.error("Commit failed", e);;  
  12.             throw new TransactionException("Commit failed with SQL exception: ", e);;  
  13.         }  
  14.     }  
  15.     finally {  
  16.         session.afterTransactionCompletion();;  
  17.     }  
  18.     toggleAutoCommit();;  
  19. }  

这是提交方法,看到connection().commit() 了吗?下面就不用我多说了,这个类代码非常简单易懂,通过阅读使我们明白Hibernate的Transaction都在干了些什么?我现在把用Hibernate写的例子翻译成JDBC,大家就一目了然了: 

Java代码   收藏代码
  1. Connection conn = ...;         <---   session = sf.openSession();;  
  2.   
  3. conn.setAutoCommit(false);;     <---   tx = session.beginTransactioin();;  
  4.   
  5. ...                            <---   ...  
  6.   
  7. conn.commit();;                 <---   tx.commit();; (对应左边的两句);  
  8. conn.setAutoCommit(true);;  
  9.   
  10. conn.close();;                  <---   session.close();;  

看明白了吧,Hibernate的JDBCTransaction根本就是conn.commit而已,根本毫无神秘可言,只不过在Hibernate中,Session打开的时候,就会自动conn.setAutoCommit(false),不像一般的JDBC,默认都是true,所以你最后不写commit也没有关系,由于Hibernate已经把AutoCommit给关掉了,所以用Hibernate的时候,你在程序中不写Transaction的话,数据库根本就没有反应。 


二、JTATransaction 

如果你在EJB中使用Hibernate,或者准备用JTA来管理跨Session的长事务,那么就需要使用JTATransaction,先看一个例子: 

Java代码   收藏代码
  1. javax.transaction.UserTransaction tx = new InitialContext();.lookup("javax.transaction.UserTransaction");;  
  2.   
  3. Session s1 = sf.openSession();;  
  4. ...  
  5. s1.flush();;  
  6. s1.close();;  
  7.   
  8. ...  
  9.   
  10. Session s2 = sf.openSession();;  
  11. ...  
  12. s2.flush();;  
  13. s2.close();;  
  14.   
  15. tx.commit();;  

这是标准的使用JTA的代码片断,Transaction是跨Session的,它的生命周期比Session要长。如果你在EJB中使用Hibernate,那么是最简单不过的了,你什么Transaction代码统统都不要写了,直接在EJB的部署描述符上配置某某方法是否使用事务就可以了。 

现在我们来分析一下JTATransaction的源代码, net.sf.hibernate.transaction.JTATransaction: 

Java代码   收藏代码
  1. public void begin(InitialContext context, ...  
  2.   ...  
  3.   ut = (UserTransaction); context.lookup(utName);;  
  4.   ...  

看清楚了吗? 和我上面写的代码 tx = new InitialContext().lookup("javax.transaction.UserTransaction"); 是不是完全一样? 

Java代码   收藏代码
  1. public void commit(); ...  
  2.   ...  
  3.   if (newTransaction); ut.commit();;  
  4.   ...  
  
JTATransaction的控制稍微复杂,不过仍然可以很清楚的看出来Hibernate是如何封装JTA的Transaction代码的。 

但是你现在是否看到了什么问题? 仔细想一下,Hibernate Transaction是从Session中获得的,tx = session.beginTransaction(),最后要先提交tx,然后再session.close,这完全符合JDBC的Transaction的操作顺序,但是这个顺序是和JTA的Transactioin操作顺序彻底矛盾的!!! JTA是先启动Transaction,然后启动Session,关闭Session,最后提交Transaction,因此当你使用JTA的Transaction的时候,那么就千万不要使用Hibernate的Transaction,而是应该像我上面的JTA的代码片断那样使用才行。 

总结: 

1、在JDBC上使用Hibernate 

必须写上Hibernate Transaction代码,否则数据库没有反应。此时Hibernate的Transaction就是Connection.commit而已 

2、在JTA上使用Hibernate 

写JTA的Transaction代码,不要写Hibernate的Transaction代码,否则程序会报错 

3、在EJB上使用Hibernate 

什么Transactioin代码都不要写,在EJB的部署描述符里面配置 


Java代码   收藏代码
  1. |---CMT(Container Managed Transaction);  
  2. |  
  3. |---BMT(Bean Managed Transaction);  
  4.         |  
  5.         |----JDBC Transaction  
  6.         |  
  7.         |----JTA Transaction  



robbin: 
你说“Hibernate的JDBCTransaction根本就是conn.commit而已,根本毫无神秘可言,只不过在Hibernate中,Session打开的时候,就会自动conn.setAutoCommit(false),不像一般的JDBC,默认都是true,所以你最后不写commit也没有关系,由于Hibernate已经把AutoCommit给关掉了,所以用Hibernate的时候,你在程序中不写Transaction的话,数据库根本就没有反应” 
但sf.opengSession()时,并没有setAutoCommit(false),我想问的是,如果不编写任何事务代码,如: 
Java代码   收藏代码
  1. Session s = sf.openSession();;  
  2. ......  
  3. s.close();;  
数据库会不会有反应(此时应该是默认AutoCommit为true)。 

另外,我想问一下: 
1. s.flush()是不是必须的 
2. s.close()是不是一定要关闭 
比如你上面提到的: 
Java代码   收藏代码
  1. javax.transaction.UserTransaction tx = new InitialContext();.lookup("javax.transaction.UserTransaction");;   
  2.   
  3. Session s1 = sf.openSession();;   
  4. ...   
  5. s1.flush();;   
  6. s1.close();;   
  7.   
  8. ...   
  9.   
  10. Session s2 = sf.openSession();;   
  11. ...   
  12. s2.flush();;   
  13. s2.close();;   
  14.   
  15. tx.commit();;  


s1不关闭,使用s2进行操作的代码中使用s1可不可以(我觉得这样更加节约资源,不需要反复的连接、关闭) 



引用
但sf.opengSession()时,并没有setAutoCommit(false),我想问的是,如果不编写任何事务代码,如: 
Session s = sf.openSession(); 
...... 
s.close(); 
数据库会不会有反应(此时应该是默认AutoCommit为true)。


不会有反应。在sf.openSession() 创建Session实例的时候,就已经调用了conn.setAutoCommit(false)了。 


引用
另外,我想问一下: 
1. s.flush()是不是必须的 
2. s.close()是不是一定要关闭


s.flush不是必须的,s.close()会调用一次s.flush() 

s.close()正常情况下应该关闭,除非你是用ThreadLocal管理Session。 


引用
s1不关闭,使用s2进行操作的代码中使用s1可不可以(我觉得这样更加节约资源,不需要反复的连接、关闭)


在这个例子中看不出来JTA的作用。 
假设 
Java代码   收藏代码
  1. Class A  {  
  2.   find(); {  
  3.     Session s1 = sf.openSession();;   
  4.     ...   
  5.     s1.flush();;   
  6.     s1.close();;   
  7.   }  
  8. }  


Java代码   收藏代码
  1. Class B  {  
  2.   find(); {  
  3.     Session s2 = sf.openSession();;   
  4.     ...   
  5.     s2.flush();;   
  6.     s2.close();;   
  7.   }  
  8. }  


Java代码   收藏代码
  1. Main {  
  2.   
  3.   tx = ...;  
  4.   A.find();;  
  5.   B.find();;  
  6.   tx.commit();;  
  7. }  
转自:http://www.iteye.com/topic/264

最后

以上就是真实手链为你收集整理的hibernate- Transaction的全部内容,希望文章能够帮你解决hibernate- Transaction所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错,欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供,作为学习参考使用,或来自网络收集整理,版权属于原作者所有。
点赞(49)

评论列表共有 0 条评论

立即
投稿
返回
顶部