open session and Hibernate事务处理机制

在没有使用Spring提供的Open Session In View情况下,因需要在service(or Dao)层里把session关闭,所以lazy loading true的话,要在应用层内把关系集合都初始化,如 company.getEmployees(),否则Hibernatesession already closed Exception;     Open Session In View提供了一种简便的方法,较好地解决了lazy loading问题.

    它有两种配置方式OpenSessionInViewInterceptorOpenSessionInViewFilter(具体参看SpringSide),功能相同,只是一个在web.xml配置,另一个在application.xml配置而已。

     Open Session In Viewrequestsession绑定到当前thread期间一直保持hibernate sessionopen状态,使sessionrequest的整个期间都可以使用,如在View层里PO也可以lazy loading数据,如 ${ company.employees }。当View 层逻辑完成后,才会通过FilterdoFilter方法或InterceptorpostHandle方法自动关闭session



   
   
OpenSessionInViewInterceptor配置
  1. <beans>
  2.    <bean name="openSessionInViewInterceptor"
  3. class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
  4.      <property name="sessionFactory">
  5.        <ref bean="sessionFactory"/>
  6.      </property>
  7.    </bean>
  8.    <bean id="urlMapping"
  9. class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  10.      <property name="interceptors">
  11.        <list>
  12.          <ref bean="openSessionInViewInterceptor"/>
  13.        </list>
  14.      </property>
  15.      <property name="mappings">
  16.      ...
  17.      </property>
  18.    </bean>
  19. ...
  20. </beans>

   
   
OpenSessionInViewFilter配置
  1. <web-app>
  2. ...
  3.    <filter>
  4.      <filter-name>hibernateFilter</filter-name>
  5.      <filter-class>
  6.        org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
  7.      </filter-class>
  8.      <!-- singleSession默认为true,若设为false则等于没用OpenSessionInView -->
  9.      <init-param>
  10.        <param-name>singleSession</param-name>
  11.        <param-value>true</param-value>
  12.      </init-param>
  13.    </filter>
  14. ...
  15.    <filter-mapping>
  16.      <filter-name>hibernateFilter</filter-name>
  17.      <url-pattern>*.do</url-pattern>
  18.    </filter-mapping>
  19. ...
  20. </web-app>

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


   
   
  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

看看OpenSessionInViewFilter里的几个方法


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

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


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

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

  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的事务控制。这就是常使用的方法:
 
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值