OpenSessionInViewFilter 的配置及替代方案

古城微笑少年丶 2022-08-06 13:15 121阅读 0赞

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

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

Java代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

1.   
2.  <filter> 
3.      <filter-name>openSessionInViewFilter</filter-name> 
4.      <filter-class>        org.springframework.orm.hibernate3.support.OpenSessionInViewFilter 
5.      </filter-class> 
6.   
7.       <init-param> 
8.         <param-name>singleSession</param-name> 
9.         <param-value>true</param-value>  
10.      </init-param>  
11.  
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>

<filter>
        <filter-name>openSessionInViewFilter</filter-name>
        <filter-class>        org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
        </filter-class>
    
         <init-param>
           <param-name>singleSession</param-name>
           <param-value>true</param-value> 
         </init-param> 
    
     <init-param>
         <param-name>sessionFactoryBean</param-name>
       <param-value>sessionFactory</param-value>
      </init-param> 
    </filter>
    <filter-mapping>
        <filter-name>openSessionInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

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

Java代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

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. \}

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
    
    public class XxxDAO extends HibernateDaoSupport {
    
        public void save(Xxx transientInstance) {
            try {
                getHibernateTemplate().save(transientInstance);
            } catch (RuntimeException re) {
                throw re;
            }
        }
    }

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代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

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. \}

protected void doFilterInternal(HttpServletRequest request,HttpServletResponse response,FilterChain filterChain)
     throws ServletException, IOException {
     
    　SessionFactory sessionFactory = lookupSessionFactory(); 
    　logger.debug("Opening Hibernate Session in OpenSessionInViewFilter"); 
    　Session session = getSession(sessionFactory); 
    　TransactionSynchronizationManager.bindResource( 
    　sessionFactory, new SessionHolder(session)); 
    
      try {
     
        filterChain.doFilter(request, response);
     
      } 
      finally {
     
    　  TransactionSynchronizationManager.unbindResource(sessionFactory); 
       logger.debug("Closing Hibernate Session in OpenSessionInViewFilter"); 
       closeSession(session, sessionFactory);
     
    　}
     
    }

Java代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

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. \}

protected Session getSession(SessionFactory sessionFactory)
     
    throws DataAccessResourceFailureException {
     
    Session session = SessionFactoryUtils.getSession(sessionFactory, true);
     
    　 session.setFlushMode(FlushMode.NEVER);
     
    　 return session;
     
    }

Java代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

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

protected void closeSession(Session session, SessionFactory sessionFactory)
     
    throws CleanupFailureDataAccessException {
     
    　 SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);
     
    }

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

Java代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

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.

public static void closeSessionIfNecessary(Session session, SessionFactory  sessionFactory) 
     
    throws CleanupFailureDataAccessException { 
     
    if (session == null ||
     
    TransactionSynchronizationManager.hasResource(sessionFactory)) {
     
    return; 
     
    } 
     
    logger.debug("Closing Hibernate session");
     
    try { 
     
    session.close(); 
     
    } 
     
    catch (JDBCException ex) {
     
    // SQLException underneath 
     
    throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex.getSQLException()); 
     
    } 
     
    catch (HibernateException ex) {
     
    throw new CleanupFailureDataAccessException("Could not close Hibernate session",  ex); 
     
    }
     
    }

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

解决：

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

Xml代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

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.

<bean id="baseTransaction"
     
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
     
    abstract="true">
     
    <property name="transactionManager" ref="transactionManager"/>
     
    <property name="proxyTargetClass" value="true"/>
     
    <property name="transactionAttributes">
     
    <props>
     
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
     
    <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
     
    <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
     
    <prop key="save*">PROPAGATION_REQUIRED</prop>
     
    <prop key="add*">PROPAGATION_REQUIRED</prop>
     
    <prop key="update*">PROPAGATION_REQUIRED</prop>
     
    <prop key="remove*">PROPAGATION_REQUIRED</prop>
     
    </props>
     
    </property>
     
    </bean> 
     
    <bean id="userService" parent="baseTransaction"> 
    <property name="target">
     
    <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>
     
    </property>
     
    </bean>

对于上例，则以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代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

1.    
2.  lt;init-param>   
3.  <param-name>flushMode</param-name>    
4.  <param-value>AUTO</param-value>    
5.  </init-param>

<init-param>  
      <param-name>flushMode</param-name>   
      <param-value>AUTO</param-value>   
      </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][http_www.javaeye.com_topic_15057]  
  
　　2. OpenSessionInView的效率问题  
　　这个问题也有人在论坛提出过，Robbin曾经做过具体的测试，可以具体参考一下下面这个帖子： [ http://www.javaeye.com/topic/17501][http_www.javaeye.com_topic_17501]  
  
　　3. 由于使用了OpenSessionInView模式后造成了内存和数据库连接问题  
　　这个问题是我在生产环境中碰到的一个问题。由于使用了OpenSessionInView模式，Session的生命周期变得非常长。虽然解决了Lazy Load的问题，但是带来的问题就是Hibernate的一级缓存，也就是Session级别的缓存的生命周期会变得非常长，那么如果你在你的Service层做大批量的数据操作时，其实这些数据会在缓存中保留一份，这是非常耗费内存的。还有一个数据库连接的问题，存在的原因在于由于数据库的Connection是和Session绑在一起的，所以，Connection也会得不到及时的释放。因而当系统出现业务非常繁忙，而计算量又非常大的时候，往往数据连接池的连接数会不够。这个问题我至今非常头痛，因为有很多客户对数据连接池的数量会有限制，不会给你无限制的增加下去。  
  
　　4. 使用了OpenSessionInView模式以后取数据的事务问题  
　　在使用了OpenSessionInView以后，其实事务的生命周期比Session的生命周期来得短，就以为着，其实有相当一部分的查询是不被纳入到事务的范围内的，此时是否会读到脏数据？这个问题我至今不敢确认，有经验的朋友请指教一下。

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

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

在application.xml配置

Xml代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

1.   
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>

<filter>
        <filter-name>openSessionInViewFilter</filter-name>
        <filter-class>
            org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
        </filter-class>
    </filter>
    <filter-mapping>
        <filter-name>openSessionInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

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

感谢：

[http://www.cnblogs.com/children/archive/2010/05/01/1725419.html][http_www.cnblogs.com_children_archive_2010_05_01_1725419.html]

OpenSessionInViewFilter作用及配置：[http://www.yybean.com/opensessioninviewfilter-role-and-configuration][http_www.yybean.com_opensessioninviewfilter-role-and-configuration]；

OpenSessionInView详解：[http://www.javaeye.com/topic/32001][http_www.javaeye.com_topic_32001]

[http://schnauzer.iteye.com/blog/160024][http_schnauzer.iteye.com_blog_160024]

[icon_copy.gif]: http://justsee.iteye.com/images/icon_copy.gif
[_icon_copy.gif]: http://justsee.iteye.com/blog/1174999#
[icon_star.png]: http://justsee.iteye.com/images/icon_star.png
[spinner.gif]: /images/20220806/ba015541b3fc48049bcf8d91915b3031.png
[http_www.javaeye.com_topic_15057]: http://www.javaeye.com/topic/15057
[http_www.javaeye.com_topic_17501]: http://www.javaeye.com/topic/17501
[http_www.cnblogs.com_children_archive_2010_05_01_1725419.html]: http://www.cnblogs.com/children/archive/2010/05/01/1725419.html
[http_www.yybean.com_opensessioninviewfilter-role-and-configuration]: http://www.yybean.com/opensessioninviewfilter-role-and-configuration
[http_www.javaeye.com_topic_32001]: http://www.javaeye.com/topic/32001
[http_schnauzer.iteye.com_blog_160024]: http://schnauzer.iteye.com/blog/160024