程序博客网 > itunes windows xp版

open session and Hibernate事务处理机制

来源：互联网 发布：itunes windows xp版 编辑：程序博客网 时间：2024/05/22 10:58

  在没有使用Spring提供的Open Session In View情况下，因需要在service(or Dao)层里把session关闭，所以lazy loading 为true的话，要在应用层内把关系集合都初始化，如 company.getEmployees()，否则Hibernate抛session already closed Exception;    Open Session In View提供了一种简便的方法，较好地解决了lazy loading问题.    
    它有两种配置方式OpenSessionInViewInterceptor和OpenSessionInViewFilter(具体参看SpringSide)，功能相同，只是一个在web.xml配置，另一个在application.xml配置而已。    
     Open Session In View在request把session绑定到当前thread期间一直保持hibernate session在open状态，使session在request的整个期间都可以使用，如在View层里PO也可以lazy loading数据，如 ${ company.employees }。当View 层逻辑完成后，才会通过Filter的doFilter方法或Interceptor的postHandle方法自动关闭session。
     OpenSessionInViewInterceptor配置

Xml代码
  1.      
  2. <beans>    
  3. <bean name="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">    
  4. <property name="sessionFactory">    
  5. <ref bean="sessionFactory"/>    
  6. </property>    
  7. </bean>    
  8. <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">    
  9. <property name="interceptors">    
  10. <list>    
  11. <ref bean="openSessionInViewInterceptor"/>    
  12. </list>    
  13. </property>    
  14. <property name="mappings">    
  15. ...    
  16. </property>    
  17. </bean> ... </beans>   


OpenSessionInViewFilter配置

Xml代码
  1.     
  2. <web-app>    
  3. ...    
  4. <filter>    
  5. <filter-name>hibernateFilter</filter-name>    
  6. <filter-class> org.springframework.orm.hibernate3.support.OpenSessionInViewFilter </filter-class>    
  7. <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->    
  8. <init-param>    
  9. <param-name>singleSession</param-name>    
  10. <param-value>true</param-value>    
  11. </init-param>    
  12. </filter> ... <filter-mapping>    
  13. <filter-name>hibernateFilter</filter-name>    
  14. <url-pattern>*.do</url-pattern>    
  15. </filter-mapping> ... </web-app>   


    很多人在使用OpenSessionInView过程中提及一个错误：
org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into FlushMode.AUTO or remove 'readOnly' marker from transaction definition
    看看OpenSessionInViewFilter里的几个方法

Java代码
  1.      
  2.   
  3. protected void doFilterInternal(HttpServletRequest request,    
  4.         HttpServletResponse response,   
  5.         FilterChain filterChain) throws ServletException, IOException {　   
  6.         SessionFactory sessionFactory = lookupSessionFactory();　   
  7.         logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");　   
  8.         Session session = getSession(sessionFactory);　   
  9.         TransactionSynchronizationManager.bindResource(　　   
  10.                 sessionFactory, new SessionHolder(session));　   
  11.         try {　　   
  12.             filterChain.doFilter(request, response);　   
  13.             }　   
  14.         finally {　   
  15.             TransactionSynchronizationManager.unbindResource(sessionFactory);　   
  16.         logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");　   
  17.         closeSession(session, sessionFactory);　   
  18.         }   
  19. }    
  20. protected Session getSession(SessionFactory sessionFactory)   
  21.                    throws DataAccessResourceFailureException {　   
  22.         Session session = SessionFactoryUtils.getSession(sessionFactory, true);　   
  23.         session.setFlushMode(FlushMode.NEVER);　   
  24.         return session;   
  25. }   
  26. protected void closeSession(Session session,    
  27.         SessionFactory sessionFactory)throws CleanupFailureDataAccessException {　   
  28.     SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);   
  29. }  


     关于绑定session的方式，通过看spring里TransactionSynchronizationManager的实现，发现：它维护一个 java.lang.ThreadLocal类型的resources，resources负责持有线程局部变量，这里resources持有的是一个 HashMap，通过TransactionSynchronizationManager.bindResource()方法在map里绑定和线程相关的所有变量到他们的标识上，包括如上所述的绑定在sessionFactory上的线程局部session。sessionHolder只不过是存放可以 hold一个session并可以和transtaction同步的容器。可以看到 OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。然后把该sessionFactory绑定到 TransactionSynchronizationManager，使request的整个过程都使用同一个session，在请求过后再接除该 sessionFactory的绑定，最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。绑定以后，就可以防止每次不会新开一个Session呢？看看HibernateDaoSupport的情况：

Java代码
  1.     
  2. public final void setSessionFactory(SessionFactory sessionFactory) {    
  3. this.hibernateTemplate = new HibernateTemplate(sessionFactory);    
  4. }     
  5. rotected final HibernateTemplate getHibernateTemplate() {   
  6. return hibernateTemplate;     
  7.            


     我们的DAO将使用这个template进行操作.

Java代码
  1.       
  2. public abstract class BaseHibernateObjectDao    
  3.                 extends HibernateDaoSupportimplements BaseObjectDao {        
  4. protected BaseEntityObject getByClassId(final long id) {                   
  5. BaseEntityObject obj =(BaseEntityObject)getHibernateTemplate().execute(new HibernateCallback() {                           
  6. public Object doInHibernate(Session session)    
  7.          throws HibernateException{                                       
  8.  return session.get(getPersistentClass(),new Long(id));                   
  9.        }                   
  10.     }   
  11. );                   
  12. return obj;         
  13. }        
  14. public void save(BaseEntityObject entity) {                     
  15.        getHibernateTemplate().saveOrUpdate(entity);        
  16. }        
  17. public void remove(BaseEntityObject entity) {                 
  18. try {                        
  19.        getHibernateTemplate().delete(entity);                 
  20. } catch (Exception e) {                         
  21.        throw new FlexEnterpriseDataAccessException(e);                
  22.        }         
  23. }          
  24. public void refresh(final BaseEntityObject entity) {                  
  25.        getHibernateTemplate().execute(new HibernateCallback(){                             
  26.             public Object doInHibernate(Session session)    
  27.            throws HibernateException   {                                   
  28.                  session.refresh(entity);                                         
  29.                  return null;                             
  30.             }                  
  31.        }   
  32.     );         
  33. }         
  34. public void replicate(final Object entity) {                   
  35.        getHibernateTemplate().execute(new HibernateCallback(){                             
  36.              public Object doInHibernate(Session session)   
  37.                            throws HibernateException{                                         
  38.                   session.replicate(entity,ReplicationMode.OVERWRITE);                    
  39.                   eturn null;                  
  40.              }                   
  41.       });         
  42.    }   
  43. }             

   
   而HibernateTemplate试图每次在execute之前去获得Session，执行完就力争关闭Session

Java代码
  1.      
  2. public Object execute(HibernateCallback action) throws DataAccessException {     
  3.        Session session = (!this.allowCreate)SessionFactoryUtils.getSession(getSessionFactory(),   
  4.                          false);        
  5.        SessionFactoryUtils.getSession(getSessionFactory(),   
  6.                                       getEntityInterceptor(),    
  7.                                       getJdbcExceptionTranslator()));        
  8.        boolean existingTransaction = TransactionSynchronizationManager.hasResource(   
  9.                                        getSessionFactory());      
  10.        if (!existingTransaction && getFlushMode() == FLUSH_NEVER) {      
  11.             session.setFlushMode(FlushMode.NEVER);     
  12. }         
  13. try {             
  14.      Object result = action.doInHibernate(session);              
  15.      flushIfNecessary(session, existingTransaction);              
  16.      return result;       
  17. }       
  18. catch (HibernateException ex) {             
  19. throw convertHibernateAccessException(ex);        
  20. }        
  21. finally {        
  22.     SessionFactoryUtils.closeSessionIfNecessary(     
  23.     session, getSessionFactory());        
  24.     }    
  25. }         


   而这个SessionFactoryUtils能否得到当前的session以及closeSessionIfNecessary是否真正关闭 session，取决于这个session是否用sessionHolder和这个sessionFactory在我们最开始提到的 TransactionSynchronizationManager绑定。     

Java代码
  1.      
  2. public static void closeSessionIfNecessary(Session session,    
  3.                                            SessionFactory sessionFactory)    
  4.                 throws CleanupFailureDataAccessException {    
  5.    if (session == null || TransactionSynchronizationManager.hasResource(sessionFactory)) {    
  6.                return;    
  7. }    
  8.         logger.debug("Closing Hibernate session");    
  9. try {    
  10.         session.close();    
  11. } catch (JDBCException ex) { // SQLException underneath   
  12.     throw new CleanupFailureDataAccessException("Could not close Hibernate session",    
  13.                                              ex.getSQLException());    
  14. } catch (HibernateException ex) {    
  15.     throw new CleanupFailureDataAccessException("Could not close Hibernate session",    
  16.               ex);    
  17.        }    
  18. }       


     在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为 Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有。
     可能的解決方式有：
1、将singleSession设为false，这样只要改web.xml，缺点是Hibernate Session的Instance可能会大增，使用的JDBC Connection量也会大增，如果Connection Pool的maxPoolSize设得太小，很容易就出问题。
2、在控制器中自行管理Session的FlushMode，麻烦的是每个有Modify的Method都要多几行程式。     
session.setFlushMode(FlushMode.AUTO);      
session.update(user);      
session.flush();
3、Extend OpenSessionInViewFilter，Override protected Session getSession(SessionFactory sessionFactory)，将FlushMode直接改为Auto。
4、让方法受Spring的事务控制。这就是常使用的方法： 采用spring的事务声明,使方法受transaction控制 

Xml代码
  1.       
  2. <bean id="baseTransaction" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"              
  3. abstract="true">            
  4. <property name="transactionManager" ref="transactionManager"/>            
  5. <property name="proxyTargetClass" value="true"/>            
  6. <property name="transactionAttributes">                
  7. <props>                    
  8. <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>                    
  9. <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>                    
  10. <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>                    
  11. <prop key="save*">PROPAGATION_REQUIRED</prop>                    
  12. <prop key="add*">PROPAGATION_REQUIRED</prop>                    
  13. <prop key="update*">PROPAGATION_REQUIRED</prop>                    
  14. <prop key="remove*">PROPAGATION_REQUIRED</prop>                
  15. </props>            
  16. </property>        
  17. </bean>        
  18. <bean id="userService" parent="baseTransaction">            
  19. <property name="target">                
  20. <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>            
  21. </property>        
  22. </bean>   


    对于上例，则以save,add,update,remove开头的方法拥有可写的事务，如果当前有某个方法，如命名为importExcel()，则因没有transaction而没有写权限，这时若方法内有insert,update,delete操作的话，则需要手动设置flush model为Flush.AUTO,如 session.setFlushMode(FlushMode.AUTO); session.save(user); session.flush();      
    尽管Open Session In View看起来还不错，其实副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal方法代码，这个方法实际上是被父类的doFilter调用的，因此，我们可以大约了解的OpenSessionInViewFilter调用流程: request(请求)->open session并开始transaction->controller->View(Jsp)->结束transaction并 close session.     
    一切看起来很正确，尤其是在本地开发测试的时候没出现问题，但试想下如果流程中的某一步被阻塞的话，那在这期间connection就一直被占用而不释放。最有可能被阻塞的就是在写Jsp这步，一方面可能是页面内容大，response.write的时间长，另一方面可能是网速慢，服务器与用户间传输时间久。当大量这样的情况出现时，就有连接池连接不足，造成页面假死现象。 Open Session In View是个双刃剑，放在公网上内容多流量大的网站请慎用。   另外：这样会产生一点危险性，毕竟把数据库访问的环境放到了表现层。（：用VO）                  
      Hibernate是对JDBC的轻量级对象封装，Hibernate本身是不具备Transaction处理功能的，Hibernate的 Transaction实际上是底层的JDBC Transaction的封装，或者是JTA Transaction的封装，下面我们详细的分析： 　　
      Hibernate可以配置为JDBCTransaction或者是JTATransaction，这取决于你在hibernate.properties中的配置:

引用

#hibernate.transaction.factory_classnet.sf.hibernate.transaction.JTATransactionFactory #hibernate.transaction.factory_classnet.sf.hibernate.transaction.JDBCTransactionFactory

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

引用
 
hibernate.transaction.factory_classnet.sf.hibernate.transaction.JTATransactionFactory


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

引用
  
#hibernate.transaction.factory_classnet.sf.hibernate.transaction.JTATransactionFactory #hibernate.transaction.factory_classnet.sf.hibernate.transaction.JDBCTransactionFactory 　　


     在下面的分析中我会给出原因。 　　
一、JDBC Transaction 　　
     看看使用JDBC Transaction的时候我们的代码例子：

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


     这是默认的情况，当你在代码中使用Hibernate的Transaction的时候实际上就是JDBCTransaction。那么JDBCTransaction究竟是什么东西呢？来看看源代码就清楚了： 　　Hibernate2.0.3源代码中的类net.sf.hibernate.transaction.JDBCTransaction:

Java代码
  1.      
  2. public void begin() throws HibernateException {    
  3. ...    
  4. if (toggleAutoCommit) session.connection().setAutoCommit(false);    
  5. ...    
  6. }　　  


     这是启动Transaction的方法，看到 connection().setAutoCommit(false) 了吗？是不是很熟悉？ 　　
     再来看

Java代码
  1.       
  2. public void commit() throws HibernateException {    
  3. ...    
  4. try {    
  5.  if (    
  6.  session.getFlushMode()!=FlushMode.NEVER )    
  7. session.flush();    
  8. try {    
  9. session.connection().commit();    
  10. committed = true;    
  11. }    
  12. ...    
  13. toggleAutoCommit();    
  14. } 　　  


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

Java代码
  1.       
  2. Connection conn = ...;                  
  3. <--- session = sf.openSession();    
  4. conn.setAutoCommit(false);      
  5. <--- tx = session.beginTransactioin();    
  6. ...    
  7. <--- ... conn.commit();                              
  8. <--- tx.commit();    
  9. (对应左边的两句) conn.setAutoCommit(true);    
  10. conn.close();                                 
  11. <--- 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.      
  2. javax.transaction.UserTransaction tx = new InitialContext().lookup("javax.transaction.UserTransaction");    
  3. Session s1 = sf.openSession();    
  4. ...    
  5. s1.flush();    
  6. s1.close();    
  7. ...    
  8. Session s2 = sf.openSession();    
  9. ...   
  10. s2.flush();    
  11. s2.close();   
  12. tx.commit();   


    这是标准的使用JTA的代码片断，Transaction是跨Session的，它的生命周期比Session要长。如果你在EJB中使用 Hibernate，那么是最简单不过的了，你什么Transaction代码统统都不要写了，直接在EJB的部署描述符上配置某某方法是否使用事务就可以了。 现在我们来分析一下JTATransaction的源代码，
net.sf.hibernate.transaction.JTATransaction:

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


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

Java代码
  1.      
  2. public void commit()    
  3. ...    
  4. ...    
  5. if (newTransaction)    
  6. ut.commit();   
  7.  ...   


    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的部署描述符里面配置
|---CMT(Container Managed Transaction) |
|---BMT(Bean Managed Transaction) |
|----JDBC Transaction |
|----JTA Transaction        
    关于session：
1.  servlet的session机制基于cookies,关闭浏览器的cookies则session失效即不能用网站的登录功能。
2.  Hibernate Session.      
       1>. session 清理缓存时，按照以下顺序执行SQL语句：            
session.save()的实体insert     
               实体的update            
               对集合的delete       
               集合元素的delete，update，insert            
               集合的insert            
session.delete()的先后，执行实体的delete       
       2>. 默认时，session在以下时间点清理缓存：               net.sf.hibernate.Transaction.commit():先清理缓存，再向数据库提交事务Session.find()或iterate()时，若缓存中持久化对象的属性发生了变化，就会先清缓存，以保证查询结果正确         
        3>.  Session的commit()和flush()的区别：
flush()只执行SQL语句，不提交事务；commit()先调用flush()，再提交事务       
        4>.  Session.setFlushMode()用于设定清理缓存的时间点：
清理缓存的模式 Session的查询方法 Session.commit() Session.flush() FlushMode.AUTO 清理清理清理 FlushMode.COMMIT 不清理清理清理 FlushMode.NEVER 不清理不清理清

itunes windows xp版 itunes windows xp版
原创粉丝点击
热门IT博客
淘宝试用报告哪里看淘宝试用报告哪里看
js文件上传原理js文件上传原理
javascript 提交表单
python入门要多久
易众联读卡器软件
网络大专报名条件
阿里云怎么解绑手机号
零售业软件
什么是软件销售
淮安java培训机构
nginx static 配置
蒙古入侵日本知乎
python三元表达式
文件传输助手软件下载
js获取下拉框所有值
越南 社会主义 知乎
网络信号屏蔽器原理
淘宝新锐卖家审核标准
多多理财靠谱吗 知乎
软考程序员考什么
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 表示声音 雪落下的声音 手机听筒声音小 手机听筒声音小怎么办 表示声音词语 詹雯婷声音辨识度 梦想声音第三季 形容声音成语 电脑没有声音怎么办 形容声音词语 aabb表示声音 用嗓过度声音嘶哑 唱吧声音小怎么办 iphone听筒声音小怎么办 手机话筒声音小怎么调 唱歌声音小怎么办 手机声音小是怎么回事 声音是纵波还是横波 手机麦克风声音小 怎样使声音更好听 耳朵听不见声音怎么回事 电脑主机声音好大 耳鸣听不到声音怎么办 鬼跳有声音吗 耳鸣声音越来越大 我能听见你声音 猫叫声音驱赶老鼠mp3 手机耳机声音小 听见您的声音 翟潇闻的声音 声音音效大全 中国好 中国好歌声 手机变声软件哪个好 中国好生音 什么的叫声 什么的响声 台电平板电脑声音小 红米note2听筒声音小 说话时耳朵有声音 为什么耳朵有声音

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里