关闭

OpenSessionInViewFilter 的配置及替代方案

1625人阅读 评论(0) 收藏 举报
分类:

Spring 为我们提供了一个叫做 OpenSessionInViewFilter 的过滤器,他是标准的 Servlet Filter 所以我们把它按照规范配置到 web.xml 中方可使用。使用中我们必须配合使用 Spring 的 HibernateDaoSupport 来进行开发,也就是说,我们的dao层的类都要继承于 HibernateDaoSupport,从中由 Spring 来控制 Hibernate 的 Session 在请求来的时候开启,走的时候关闭,保证了我们访问数据对象时的稳定性。

  1. 在 web.xml 中加入对应过滤器配置文件

 

Java代码  收藏代码
  1. <!-- Spring的OpenSessionInView实现 -->  
  2. <filter>  
  3.     <filter-name>openSessionInViewFilter</filter-name>  
  4.     <filter-class>        org.springframework.orm.hibernate3.support.OpenSessionInViewFilter  
  5.     </filter-class>  
  6. <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView 。所以默认可以不写-->  
  7.      <init-param>  
  8.        <param-name>singleSession</param-name>  
  9.        <param-value>true</param-value>   
  10.      </init-param>   
  11. <!--   
  12. 指定org.springframework.orm.hibernate3.LocalSessionFactoryBean在spring配置文件中的名称,默认值为sessionFactory。 如果LocalSessionFactoryBean在spring中的名称不是sessionFactory,该参数一定要指定,否则会出现找不到sessionFactory的例外。所以默认可以不写  
  13. -->  
  14.  <init-param>  
  15.      <param-name>sessionFactoryBean</param-name>  
  16.    <param-value>sessionFactory</param-value>  
  17.   </init-param>   
  18. </filter>  
  19. <filter-mapping>  
  20.     <filter-name>openSessionInViewFilter</filter-name>  
  21.     <url-pattern>/*</url-pattern>  
  22. </filter-mapping>  
 

 2. 在我们访问持久层数据是使用 Spring 为我们的 HibernateDaoSupport 的支持,并使用其中的对应方法操作我们的持久层数据

 

Java代码  收藏代码
  1. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
  2.   
  3. public class XxxDAO extends HibernateDaoSupport {  
  4.   
  5.     public void save(Xxx transientInstance) {  
  6.         try {  
  7.             getHibernateTemplate().save(transientInstance);  
  8.         } catch (RuntimeException re) {  
  9.             throw re;  
  10.         }  
  11.     }  
  12. }  
 

 

OpenSessionInViewFilter的主要功能是用来把一个Hibernate Session和一次完整的请求过程对应的线程相绑定。Open Session In View在request把session绑定到当前thread期间一直保持hibernate session在open状态,使session在request的整个期间都可以使用,如在View层里PO也可以lazy loading数据,如 ${ company.employees }。当View 层逻辑完成后,才会通过Filter的doFilter方法或Interceptor的postHandle方法自动关闭session。

  很多人在使用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. protected void doFilterInternal(HttpServletRequest request,HttpServletResponse response,FilterChain filterChain)  
  2.  throws ServletException, IOException {  
  3.    
  4.  SessionFactory sessionFactory = lookupSessionFactory();   
  5.  logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");   
  6.  Session session = getSession(sessionFactory);   
  7.  TransactionSynchronizationManager.bindResource(   
  8.  sessionFactory, new SessionHolder(session));   
  9.   
  10.   try {  
  11.    
  12.     filterChain.doFilter(request, response);  
  13.    
  14.   }   
  15.   finally {  
  16.    
  17.    TransactionSynchronizationManager.unbindResource(sessionFactory);   
  18.    logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");   
  19.    closeSession(session, sessionFactory);  
  20.    
  21.  }  
  22.    
  23. }  
 

 

 

Java代码  收藏代码
  1. protected Session getSession(SessionFactory sessionFactory)  
  2.    
  3. throws DataAccessResourceFailureException {  
  4.    
  5. Session session = SessionFactoryUtils.getSession(sessionFactory, true);  
  6.    
  7.   session.setFlushMode(FlushMode.NEVER);  
  8.    
  9.   return session;  
  10.    
  11. }   
 

 

 

Java代码  收藏代码
  1. protected void closeSession(Session session, SessionFactory sessionFactory)  
  2.    
  3. throws CleanupFailureDataAccessException {  
  4.    
  5.   SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);  
  6.    
  7. }  
 

 

 

 可以看到OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。然后把该sessionFactory绑定到 TransactionSynchronizationManager,使request的整个过程都使用同一个session,在请求过后再解除该 sessionFactory的绑定,最后closeSessionIfNecessary根据该 session是否已和transaction绑定来决定是否关闭session。在这个过程中,若HibernateTemplate 发现自当前session有不是readOnly的transaction,就会获取到FlushMode.AUTO Session,使方法拥有写权限。

 

Java代码  收藏代码
  1. public static void closeSessionIfNecessary(Session session, SessionFactory  sessionFactory)   
  2.    
  3. throws CleanupFailureDataAccessException {   
  4.    
  5. if (session == null ||  
  6.    
  7. TransactionSynchronizationManager.hasResource(sessionFactory)) {  
  8.    
  9. return;   
  10.    
  11. }   
  12.    
  13. logger.debug("Closing Hibernate session");  
  14.    
  15. try {   
  16.    
  17. session.close();   
  18.    
  19. }   
  20.    
  21. catch (JDBCException ex) {  
  22.    
  23. // SQLException underneath   
  24.    
  25. throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex.getSQLException());   
  26.    
  27. }   
  28.    
  29. catch (HibernateException ex) {  
  30.    
  31. throw new CleanupFailureDataAccessException("Could not close Hibernate session",  ex);   
  32.    
  33. }  
  34.    
  35. }   
  36.    

也即是,如果有不是readOnly的transaction就可以由Flush.NEVER转为Flush.AUTO,拥有 insert,update,delete操作权限,如果没有transaction,并且没有另外人为地设flush model的话,则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限,没受保护的则没有。

解决:

 

采用spring的事务声明,使方法受transaction控制

 

Xml代码  收藏代码
  1. <bean id="baseTransaction"  
  2.    
  3. class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"  
  4.    
  5. abstract="true">  
  6.    
  7. <property name="transactionManager" ref="transactionManager"/>  
  8.    
  9. <property name="proxyTargetClass" value="true"/>  
  10.    
  11. <property name="transactionAttributes">  
  12.    
  13. <props>  
  14.    
  15. <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
  16.    
  17. <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  18.    
  19. <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>  
  20.    
  21. <prop key="save*">PROPAGATION_REQUIRED</prop>  
  22.    
  23. <prop key="add*">PROPAGATION_REQUIRED</prop>  
  24.    
  25. <prop key="update*">PROPAGATION_REQUIRED</prop>  
  26.    
  27. <prop key="remove*">PROPAGATION_REQUIRED</prop>  
  28.    
  29. </props>  
  30.    
  31. </property>  
  32.    
  33. </bean>   
  34.    
  35. <bean id="userService" parent="baseTransaction">   
  36. <property name="target">  
  37.    
  38. <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>  
  39.    
  40. </property>  
  41.    
  42. </bean>  
  43.    

对于上例,则以save,add,update,remove开头的方法拥有可写的事务,如果当前有某个方法,如命名为importExcel(),则因没有transaction而没有写权限,这时若方法内有insert,update,delete操作的话,则需要手动设置flush model为Flush.AUTO,如

1  session.setFlushMode(FlushMode.AUTO);

2  session.save(user);

3  session.flush();

 

或可以

在web.xml中过滤器openSession修改初始参数:

Java代码  收藏代码
  1. <!-- 在项目中使用Spring+Hibernate的时候,会开启OpenSessionInViewFilter来阻止延迟加载的错误,但是在我们开启OpenSessionInViewFilter这个过滤器的时候FlushMode就已经被默认设置为了MANUAL,如果FlushMode是MANUAL或NEVEL,在操作过程中 hibernate会将事务设置为readonly,所以在增加、删除或修改操作过程中-->   
  2. lt;init-param>    
  3.  <param-name>flushMode</param-name>     
  4.  <param-value>AUTO</param-value>     
  5.  </init-param>  
 

 

  从上述代码其实可以得到一些对我们的开发有帮助的结论: 
  1)如果使用了OpenSessionInView模式,那么Spring会帮助你管理Session的开和关,从而你在你的DAO中通过HibernateDaoSupport拿到的getSession()方法,都是绑定到当前线程的线程安全的Session,即拿即用,最后会由Filter统一关闭。 
  2)由于拿到的Hibernate的Session被设置了session.setFlushMode(FlushMode.NEVER); 所以,除非你直接调用session.flush(),否则Hibernate session无论何时也不会flush任何的状态变化到数据库。因此,数据库事务的配置非常重要。(我们知道,在调用org.hibernate.Transaction.commit()的时候会触发session.flush())我曾经见过很多人在使用OpenSessionInView模式时,都因为没有正确配置事务,导致了底层会抛出有关FlushMode.NEVER的异常。


  总结:

  OpenSessionInView这个模式使用比较简单,也成为了大家在Web开发中经常使用的方法,不过它有时候会带来一些意想不到的问题,这也是在开发中需要注意的。 
  1. 在Struts+Spring+Hibernate环境中,由于配置的问题导致的模式失效这个问题以前论坛曾经讨论过,可以参考一下下面这个帖子:http://www.javaeye.com/topic/15057 

  2. OpenSessionInView的效率问题 
  这个问题也有人在论坛提出过,Robbin曾经做过具体的测试,可以具体参考一下下面这个帖子: http://www.javaeye.com/topic/17501 

  3. 由于使用了OpenSessionInView模式后造成了内存和数据库连接问题 
  这个问题是我在生产环境中碰到的一个问题。由于使用了OpenSessionInView模式,Session的生命周期变得非常长。虽然解决了Lazy Load的问题,但是带来的问题就是Hibernate的一级缓存,也就是Session级别的缓存的生命周期会变得非常长,那么如果你在你的Service层做大批量的数据操作时,其实这些数据会在缓存中保留一份,这是非常耗费内存的。还有一个数据库连接的问题,存在的原因在于由于数据库的Connection是和Session绑在一起的,所以,Connection也会得不到及时的释放。因而当系统出现业务非常繁忙,而计算量又非常大的时候,往往数据连接池的连接数会不够。这个问题我至今非常头痛,因为有很多客户对数据连接池的数量会有限制,不会给你无限制的增加下去。 

  4. 使用了OpenSessionInView模式以后取数据的事务问题 
  在使用了OpenSessionInView以后,其实事务的生命周期比Session的生命周期来得短,就以为着,其实有相当一部分的查询是不被纳入到事务的范围内的,此时是否会读到脏数据?这个问题我至今不敢确认,有经验的朋友请指教一下。 


  最后提一下OpenSessionInView模式的一些替代方案,

1

可以使用OpenSessionInViewInterceptor来代替这个Filter,此时可以使用Spring的AOP配置,将这个Interceptor配置到你所需要的层次上去。

在application.xml配置

Xml代码  收藏代码
  1. <!-- Spring的OpenSessionInView实现 -->  
  2. <filter>  
  3.     <filter-name>openSessionInViewFilter</filter-name>  
  4.     <filter-class>  
  5.         org.springframework.orm.hibernate3.support.OpenSessionInViewFilter  
  6.     </filter-class>  
  7. </filter>  
  8. <filter-mapping>  
  9.     <filter-name>openSessionInViewFilter</filter-name>  
  10.     <url-pattern>/*</url-pattern>  
  11. </filter-mapping>  
 

2

使用最古老的Hibernate.initialize()方法进行初始化了。

 

感谢:

http://www.cnblogs.com/children/archive/2010/05/01/1725419.html

 OpenSessionInViewFilter作用及配置:http://www.yybean.com/opensessioninviewfilter-role-and-configuration

OpenSessionInView详解:http://www.javaeye.com/topic/32001

http://schnauzer.iteye.com/blog/160024

 

0
0
查看评论

spring-boot 完美解决:could not initialize proxy - no Session

spring-boot 完美解决:could not initialize proxy - no Session
  • zhangjq520
  • zhangjq520
  • 2016-12-19 15:35
  • 3458

Spring使用OpenSessionInViewFilter解决Hibernate的lazy延时加载问题

Spring为我们解决最让人头痛的难题之一,Hibernate的Session的关闭与开启问题。 当hibernate+spring配合使用的时候,如果设置了lazy=true,那么在读取数据的时候,当读取了父数据后,hibernate会自动关闭session,这样,当要使用子
  • guoquanyou
  • guoquanyou
  • 2011-08-18 13:34
  • 9192

Spring使用OpenSessionInViewFilter解决Hibernate的lazy延时加载问题

Spring为我们解决最让人头痛的难题之一,Hibernate的Session的关闭与开启问题。 当hibernate+spring配合使用的时候,如果设置了lazy=true,那么在读取数据的时候,当读取了父数据后,hibernate会自动关闭session,这样,当要使用子数据的时候,系统会抛...
  • z69183787
  • z69183787
  • 2014-05-22 14:50
  • 1500

Hibernate延迟加载与opensessioninviewFilter

hibernate延迟加载: 一个person对应多个school,使用hibernate处理关联关系: T_PERSON表: id name age 1 person1 11     T_SCHOOL表: id schoolName personId...
  • a19881029
  • a19881029
  • 2012-08-31 17:11
  • 17287

OpenSessionInViewFilter 的配置及作用

Spring为我们解决Hibernate的Session的关闭与开启问题。 Hibernate 允许对关联对象、属性进行延迟加载,但是必须保证延迟加载的操作限于同一个 Hibernate Session 范围之内进行。如果 Service 层返回一个启用了延迟加载功能的领域对象给 Web 层,当 W...
  • sunsea08
  • sunsea08
  • 2009-09-12 09:58
  • 60445

spring 的OpenSessionInViewFilter简介

假设在你的应用中Hibernate是通过spring 来管理它的session.如果在你的应用中没有使用OpenSessionInViewFilter或者OpenSessionInViewInterceptor。session会在transaction结束后关闭。如果你采用了spring的声明式事务...
  • fooe84
  • fooe84
  • 2006-04-27 17:34
  • 17739

OpenSessionInViewFilter的作用及原理

Hibernate 允许对关联对象、属性进行延迟加载,但是必须保证延迟加载的操作限于同一个 Hibernate Session 范围之内进行。如果 Service 层返回一个启用了延迟加载功能的领域对象给 Web 层,当 Web 层访问到那些需要延迟加载的数据时,由于加载领域对象的 Hibernat...
  • ggibenben1314
  • ggibenben1314
  • 2015-05-31 16:53
  • 4315

【Spring】--OpenSessionInViewFilter 的配置及作用

Hibernate为我们封装了对数据库的操作,可以通过实体映射来关联数据库。在加载数据时,Hibernate对关联对象、属性进行延迟加载,延迟加载可以提升性能,使用的时候才进行加载。但是这样就存在一个问题,必须保证延迟加载的操作限于同一个 Hibernate Session 范围之内进行。如果 ...
  • u013036278
  • u013036278
  • 2016-09-25 16:55
  • 1635

OpenSessionInViewFilter在web.xml中的配置

1.如果使用HibernateTemplate,默认Session在使用后会关闭,如果使用load延迟加载获得Proxy对象后,就无法在前台获取数据。 2.OpenSessionInViewFilter的作用是延长hibernate中Session的生命周期到页面,使用Proxy时获取数据。 3...
  • zft1045911520
  • zft1045911520
  • 2017-03-05 14:29
  • 854

Spring 4.16: OpenSessionInViewFilter 的配置及作用

spring为我们解决hibernate的Session的关闭与开启问题。Hibernate 允许对关联对象、属性进行延迟加载,但是必须保证延迟加载的操作限于同一个 Hibernate Session 范围之内进行。如果 Service 层返回一个启用了延迟加载功能的领域对象给 Web 层,当 We...
  • FANGAOHUA200
  • FANGAOHUA200
  • 2016-12-12 20:27
  • 602
    个人资料
    • 访问:9380813次
    • 积分:78637
    • 等级:
    • 排名:第21名
    • 原创:264篇
    • 转载:2877篇
    • 译文:3篇
    • 评论:800条
    文章分类
    最新评论