OpenSessionInView与Hibernate事务处理机制

•  
  1. "openSessionInViewInterceptor"
  2. class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
  3. "sessionFactory">
  4. "sessionFactory"/>
  5.  
  6. "urlMapping"
  7. class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  8. "interceptors"> 
  9. "openSessionInViewInterceptor"/>
  10.  
  11. "mappings"> 
  12. ...
  13.  
  14. ...
  1. ...
  2. hibernateFilter
  3. org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
  4. singleSession
  5. true
  6. ...
  7. hibernateFilter
  8. *.do
  9. ...
  1. org.springframework.dao.InvalidDataAccessApiUsageException: Write operations
  2. are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into
  3. FlushMode.AUTO or remove 'readOnly' marker from transaction definition
  1. 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);
     }
     }
     
     
     
     
     
     
     
      
  2. protected Session getSession(SessionFactory sessionFactory)
     throws DataAccessResourceFailureException {
     Session session = SessionFactoryUtils.getSession(sessionFactory, true);
     session.setFlushMode(FlushMode.NEVER);
     return session;
     }
  3. protected void closeSession(Session session, SessionFactory sessionFactory)
     throws CleanupFailureDataAccessException {
     SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);
     }
  1. throws CleanupFailureDataAccessException {
  2. if (session == null ||
     TransactionSynchronizationManager.hasResource(sessionFactory)) {
  3. return;
  4. }
  5. logger.debug("Closing Hibernate session");
  6. try {
  7. session.close();
  8. }
  9. catch (JDBCException ex) {
  10. // SQLException underneath
  11. throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex.getSQLException());
  12. }
  13. catch (HibernateException ex) {
  14. throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex);
  15. }
  16. }
  1. 可能的解決方式有：
     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的事务控制。这就是常使用的方法：
  1.   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
               abstract="true">
             
             
             
                 
                     PROPAGATION_REQUIRED,readOnly
                     PROPAGATION_REQUIRED,readOnly
                     PROPAGATION_REQUIRED,readOnly
                     PROPAGATION_REQUIRED
                     PROPAGATION_REQUIRED
                     PROPAGATION_REQUIRED
                     PROPAGATION_REQUIRED
                 
             
         
  2.     
             
                 
             
         
  1. session.setFlushMode(FlushMode.AUTO);
  2. session.save(user);
  3. session.flush();

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

   

  OpenSessionInViewFilter配置

  很多人在使用OpenSessionInView过程中提及一个错误：

   

  看看OpenSessionInViewFilter里的几个方法

   

             关 于绑定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的情况：

       1.  public final void setSessionFactory(SessionFactory sessionFactory) {   

  2.      this.hibernateTemplate = new HibernateTemplate(sessionFactory);   

  3.  }   

  4.  protected final HibernateTemplate getHibernateTemplate() {   

  5.      return hibernateTemplate;   

  6.  }

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

  public abstract class BaseHibernateObjectDao extends HibernateDaoSupport

  implements BaseObjectDao {

       protected BaseEntityObject getByClassId(final long id) {

                  BaseEntityObject obj =(BaseEntityObject) getHibernateTemplate().execute(new HibernateCallback() {

                          public Object doInHibernate(Session session) throws HibernateException {

                                      return session.get(getPersistentClass(),new Long(id));

                          }

                  });

                  return obj;

        }

       public void save(BaseEntityObject entity) {

                    getHibernateTemplate().saveOrUpdate(entity);

       }

      public void remove(BaseEntityObject entity) {

                try {

                       getHibernateTemplate().delete(entity);

                } catch (Exception e) {

                        throw new FlexEnterpriseDataAccessException(e);

               }

       }

        public void refresh(final BaseEntityObject entity) {

                 getHibernateTemplate().execute(new HibernateCallback() {

                            public Object doInHibernate(Session session) throws HibernateException {

                                        session.refresh(entity);

                                        return null;

                            }

                 });

        }

       public void replicate(final Object entity) {

                  getHibernateTemplate().execute(new HibernateCallback() {

                            public Object doInHibernate(Session session)throws HibernateException {

                                        session.replicate(entity,ReplicationMode.OVERWRITE);

                                        return null;

                 }

                  });

        }

  }

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

    1. public Object execute(HibernateCallback action) throws DataAccessException {  

  2.    Session session = (!this.allowCreate ?  

  3.          SessionFactoryUtils.getSession(getSessionFactory(),  

  4.                false) :  

  5.          SessionFactoryUtils.getSession(getSessionFactory(), 

  6.                 getEntityInterceptor(), 

  7.                 getJdbcExceptionTranslator()));  

  8.     boolean existingTransaction =   

  9.         TransactionSynchronizationManager.hasResource(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绑定。

       public static void closeSessionIfNecessary(Session session, SessionFactory sessionFactory)

   

      在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为 Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有。

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

   

   

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

   

       尽 管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）