open session and Hibernate事务处理机制

最新推荐文章于 2019-12-05 15:58:39 发布

birdme007

最新推荐文章于 2019-12-05 15:58:39 发布

阅读量911

点赞数

分类专栏： Struts2+Spring2+hibernate3 文章标签： session hibernate resources object interceptor exception

Struts2+Spring2+hibernate3 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

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

关于绑定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)


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

     
     
      
          }
     
     

     
     
      
        }

在这个过程中，若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的事务控制。这就是常使用的方法：