程序博客网 > pdf阅读器软件下载

OpenSessionInViewFilter 的配置及替代方案

来源：互联网 发布：pdf阅读器软件下载 编辑：程序博客网 时间：2024/05/21 12:46

OpenSessionInViewFilter 的配置及替代方案

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

 


=========================================华丽分割线=================================================================

OpenSessionInViewFilter原理以及为什么要用OpenSessionInViewF

OpenSessionInViewFilter原理以及为什么要用OpenSessionInViewFilter

 

 

struts2 里面OpenSessionInViewFilter

一定要写在最上面 下面有讲解

---------------------------------------------------------------

1、说说为什么使用lazy

当使用Hibernate中的one-to-many、many-to one、many-to-many关系映射的时候，一个对象中会包含一个或多个Set来关联其他的对象。例如：user-groups，当程序取user 对象时，如果一个用户有多个自定义组，那么程序将把组的信息也读取出来，在log中可以看到两个sql的输出。但是在页面的显示上，也许并不需要显示这个用户相关组的信息，这样系统的消耗就白白浪费了，于是hibernate提供了lazy（延迟加载）的方法来避免这一情况的发生，我们只需要在 user.hbm.xml中设置lazy=true，就能实现延迟加载。

代码

 

<set name="groupses" table="usergroups" catalog="many" cascade="save-update" lazy="true">  
            <key>   
                <column name="userid" length="32" not-null="true" />   
            </key>   
            <many-to-many entity-name="com.example.model.Groups">   
                <column name="groupid" length="32" not-null="true" />   
            </many-to-many>   
        </set>  


2、说说为什么使用OpenSessionInView

当hibernate+spring配合使用的时候，如果设置了lazy=true,那么在读取数据的时候，当读取了父数据后，hibernate会自动关闭session，这样，当要使用子数据的时候，系统会抛出lazyinit的错误，这时就需要使用spring提供的 OpenSessionInViewFilter,

OpenSessionInViewFilter主要是保持Session状态知道request将全部页面发送到客户端，这样就可以解决延迟加载带来的问题

3、说说Webwork中使用OpenSessionInView的注意事项

web.xml中的配置要注意先后顺序，OpenSessionInViewFilter要在struts2的filter前面，（这个是为什么呢？）否则系统会报错。

代码

 

<filter>   
        <filter-name>opensession</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>sessionFactoryBeanName</param-name>   
            <param-value>mySessionFactory</param-value>     
        </init-param>   
    </filter>   
         
    <filter>   
        <filter-name>webwork</filter-name>   
        <filter-class>com.opensymphony.webwork.dispatcher.FilterDispatcher</filter-class>  
    </filter>   
         <filter-mapping>   
      <filter-name>opensession</filter-name>   
      <url-pattern>/*</url-pattern>     
    </filter-mapping>   
    <filter-mapping>   
        <filter-name>webwork</filter-name>   
        <url-pattern>/*</url-pattern>   
    </filter-mapping>  


对于OpenSessionInView的配置中，singleSession应该设置为true（在哪儿设置呢？），表示一个request只能打开一个 session，如果设置为false的话，session可以被打开多个，这时在update、delete的时候会出现打开多个session的异常。

用了OpenSessionInView的缺点：

但是当设置为true的时候，系统的性能会因为用户的网络状况受到影响，当request在生成页面完成后，session才会被释放，所以如果用户的网络状况比较差，那么连接池中的链接会迟迟不被回收，造成内存增加，系统性能受损。但是如果不用这种方法的话，lazy模式有体现不出它的优点，用？不用？两难啊


在没有使用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配置而已。

    OpenSessionInView在request把session绑定到当前thread期间一直保持hibernate session在open状态，使session在request的整个期间都可以使用，如在View层里PO也可以lazy loading数据，如 ${ company.employees }。当View 层逻辑完成后，才会通过Filter的doFilter方法或Interceptor的postHandle方法自动关闭session。


OpenSessionInViewInterceptor配置

 

<beans>

 

<bean name="openSessionInViewInterceptor"

 

class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">

 

<property name="sessionFactory">

 

<ref bean="sessionFactory"/>

 

</property>

 

</bean>

 

<bean id="urlMapping"

 

class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

 

<property name="interceptors">

 

<list>

 

<ref bean="openSessionInViewInterceptor"/>

 

</list>

 

</property>

 

<property name="mappings">

 

...

 

</property>

 

</bean>

 

...

 

</beans>

 


OpenSessionInViewFilter配置

 

<web-app>

 

...

 

<filter>

 

<filter-name>hibernateFilter</filter-name>

 

<filter-class>

 

org.springframework.orm.hibernate3.support.OpenSessionInViewFilter

 

</filter-class>

 

<!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->

 

<init-param>

 

<param-name>singleSession</param-name>

 

<param-value>true</param-value>

 

</init-param>

 

</filter>

 

...

 

<filter-mapping>

 

<filter-name>hibernateFilter</filter-name>

 

<url-pattern>*.do</url-pattern>

 

</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里的几个方法

 

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);

　}

}

 

 

protected Session getSession(SessionFactory sessionFactory)

throws DataAccessResourceFailureException {

　Session session = SessionFactoryUtils.getSession(sessionFactory, true);

　session.setFlushMode(FlushMode.NEVER);

　return session;

}

 

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，使方法拥有写权限。

 

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控制

 

<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,如

 

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是个双刃剑，放在公网上内容多流量大的网站请慎用。



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

由于OpenSessionInViewFilter把session绑在当前线程上，导致session的生命周期比事务要长，这期间所有事务性操作都在复用这同一个session，由此产生了一些“怪问题”：

1.出现如下错误：

     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 在把session绑在当前线程上的时候,会把session的flush mode 设为FlushMode.NEVER，因此，如果某个方法没有事务或者有只读事务，则不能对session做insert,update,delete操作，除非事先把session的flush mode手动设为auto

方案：

1、将singleSession设为false，这样只要改 web.xml，缺点是Hibernate Session的Instance可能会大增，使用的JDBC Connection量也会大增，如果Connection Pool的maxPoolSize设得太小，很容易就出问题。<!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->

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的事务控制（service和配置文件对应）


0 0
pdf阅读器软件下载 pdf阅读器软件下载
原创粉丝点击
热门IT博客
美工刀片的莫氏硬度美工刀片的莫氏硬度
windows更新过程中关闭windows更新过程中关闭
阿里云9元建站教程
淘宝tbc是什么意思
抢报名的软件
汽车检测软件
淘宝网店售后服务简介
snip软件下载
linux dhcp option 67
云计算 教育行业
雅克比矩阵的意义
缺少对象 js
通话音量增大软件
淘宝怎么推广自己的店铺
刺客信条枭雄 知乎
淘宝买药品怎么付款
多线程池java爬虫
数据分析培训班哪个好
wp怎么下载软件
php高级工程师是什么
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 利美狗粮 狗粮狗粮 冠邦狗粮 狗粮品种 狗粮的选择 狗粮厂家 晒狗粮 狗粮什么意思 疯狂小狗狗粮 猫可以吃狗粮吗 猫可以吃狗粮 猫能吃狗粮吗 哪个牌子的狗粮比较好 什么牌子的狗粮好 狗粮什么牌子好 幼犬狗粮什么牌子好 狗粮什么牌子好还便宜 泰迪狗粮什么牌子好 什么牌子狗粮 进口狗粮排行榜 狗粮买什么牌子的好 天然粮狗粮什么牌子好 边牧狗粮排行榜 狗粮哪个牌子好 狗粮多少钱一斤 皇家狗粮旗舰店 国产天然狗粮排行榜 天然粮狗粮排名 狗粮品牌排名 泰迪狗粮排行榜 天然狗粮哪个牌子好 狗粮排行榜价格表 比瑞吉狗粮怎么样 海洋之星狗粮 吃狗粮是什么意思 疯狂的小狗狗粮怎么样 阿拉斯加狗粮 幼犬狗粮怎么喂 什么狗粮比较好 耐威克狗粮怎么样 什么牌子狗粮好

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