open session and Hibernate事务处理机制

转载 2006年06月14日 22:15:00

在没有使用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的事务控制。这就是常使用的方法:

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

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

  2.     <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();

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

 


 

 


 

 

        Hibernate是对JDBC的轻量级对象封装,Hibernate本身是不具备Transaction处理功能的,Hibernate的Transaction实际上是底层的JDBC Transaction的封装,或者是JTA Transaction的封装,下面我们详细的分析:

  Hibernate可以配置为JDBCTransaction或者是JTATransaction,这取决于你在hibernate.properties中的配置:

#hibernate.transaction.factory_class
net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class
net.sf.hibernate.transaction.JDBCTransactionFactory

  如果你什么都不配置,默认情况下使用JDBCTransaction,如果你配置为:

hibernate.transaction.factory_class
net.sf.hibernate.transaction.JTATransactionFactory

  将使用JTATransaction,不管你准备让Hibernate使用JDBCTransaction,还是JTATransaction,我的忠告就是什么都不配,将让它保持默认状态,如下:

#hibernate.transaction.factory_class
net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class
net.sf.hibernate.transaction.JDBCTransactionFactory

  在下面的分析中我会给出原因。

  一、JDBC Transaction

  看看使用JDBC Transaction的时候我们的代码例子:

Session session = sf.openSession();
Transaction tx = session.beginTransactioin();
...
session.flush();
tx.commit();
session.close();
  这是默认的情况,当你在代码中使用Hibernate的Transaction的时候实际上就是JDBCTransaction。那么JDBCTransaction究竟是什么东西呢?来看看源代码就清楚了:

  Hibernate2.0.3源代码中的类

  net.sf.hibernate.transaction.JDBCTransaction:

public void begin() throws HibernateException {
...
if (toggleAutoCommit) session.connection().setAutoCommit(false);
...
}
  这是启动Transaction的方法,看到 connection().setAutoCommit(false) 了吗?是不是很熟悉?

  再来看

public void commit() throws HibernateException {
...
try {
if ( session.getFlushMode()!=FlushMode.NEVER ) session.flush();
try {
session.connection().commit();
committed = true;
}
...
toggleAutoCommit();
}

  这是提交方法,看到connection().commit() 了吗?下面就不用我多说了,这个类代码非常简单易懂,通过阅读使我们明白Hibernate的Transaction都在干了些什么?我现在把用Hibernate写的例子翻译成JDBC,大家就一目了然了:

Connection conn = ...;               <--- session = sf.openSession();
conn.setAutoCommit(false);   <--- tx = session.beginTransactioin();
... <--- ...
conn.commit();                           <--- tx.commit(); (对应左边的两句)
conn.setAutoCommit(true);
conn.close();                              <--- session.close();

  看明白了吧,Hibernate的JDBCTransaction根本就是conn.commit而已,根本毫无神秘可言,只不过在Hibernate中,Session打开的时候,就会自动conn.setAutoCommit(false),不像一般的JDBC,默认都是true,所以你最后不写commit也没有关系,由于Hibernate已经把AutoCommit给关掉了,所以用Hibernate的时候,你在程序中不写Transaction的话,数据库根本就没有反应。 

 二、JTATransaction

如果你在EJB中使用Hibernate,或者准备用JTA来管理跨Session的长事务,那么就需要使用JTATransaction,先看一个例子:

javax.transaction.UserTransaction tx = new InitialContext().lookup("javax.transaction.UserTransaction");

Session s1 = sf.openSession();
...
s1.flush();
s1.close();
...

Session s2 = sf.openSession();
...
s2.flush();
s2.close();

tx.commit();


这是标准的使用JTA的代码片断,Transaction是跨Session的,它的生命周期比Session要长。如果你在EJB中使用Hibernate,那么是最简单不过的了,你什么Transaction代码统统都不要写了,直接在EJB的部署描述符上配置某某方法是否使用事务就可以了。

现在我们来分析一下JTATransaction的源代码, net.sf.hibernate.transaction.JTATransaction:

public void begin(InitialContext context, ...
...
ut = (UserTransaction) context.lookup(utName);
...


看清楚了吗? 和我上面写的代码 tx = new Initial Context?().lookup("javax.transaction.UserTransaction"); 是不是完全一样?

public void commit() ...
...
if (newTransaction) ut.commit();
...


JTATransaction的控制稍微复杂,不过仍然可以很清楚的看出来Hibernate是如何封装JTA的Transaction代码的。

但是你现在是否看到了什么问题? 仔细想一下,Hibernate Transaction是从Session中获得的,tx = session.beginTransaction(),最后要先提交tx,然后再session.close,这完全符合JDBC的Transaction的操作顺序,但是这个顺序是和JTA的Transactioin操作顺序彻底矛盾的!!! JTA是先启动Transaction,然后启动Session,关闭Session,最后提交Transaction,因此当你使用JTA的Transaction的时候,那么就千万不要使用Hibernate的Transaction,而是应该像我上面的JTA的代码片断那样使用才行。

总结:
1、在JDBC上使用Hibernate

必须写上Hibernate Transaction代码,否则数据库没有反应。此时Hibernate的Transaction就是Connection.commit而已

2、在JTA上使用Hibernate

写JTA的Transaction代码,不要写Hibernate的Transaction代码,否则程序会报错

3、在EJB上使用Hibernate

什么Transactioin代码都不要写,在EJB的部署描述符里面配置

|---CMT(Container Managed Transaction)
|
|---BMT(Bean Managed Transaction)
|
|----JDBC Transaction
|
|----JTA Transaction

 


 

 


 

关于session:

1.  servlet的session机制基于cookies,关闭浏览器的cookies则session失效即不能用网站的登录功能。

2.  Hibernate Session.

      1>. session 清理缓存时,按照以下顺序执行SQL语句:

            session.save()的实体insert                                                                                                                                         

            实体的update

            对集合的delete

            集合元素的delete,update,insert

            集合的insert

            session.delete()的先后,执行实体的delete

       2>. 默认时,session在以下时间点清理缓存:

              net.sf.hibernate.Transaction.commit():先清理缓存,再向数据库提交事务                                                          

              Session.find()或iterate()时,若缓存中持久化对象的属性发生了变化,就会先清缓存,以保证查询结果正确

 

       3>.  Session的commit()和flush()的区别:flush()只执行SQL语句,不提交事务;commit()先调用flush(),再提交事务

       4>.  Session.setFlushMode()用于设定清理缓存的时间点。

清理缓存的模式 Session的查询方法 Session.commit() Session.flush()
FlushMode.AUTO 清理 清理 清理
FlushMode.COMMIT 不清理 清理 清理
FlushMode.NEVER 不清理 不清理 清理

           

相关文章推荐

Open Session and Hibernate事物处理机制

在没有使用Spring提供的Open Session In View情况下,因需要在service(or Dao)层里把session关闭,所以lazy loading 为true的话,要在应用层内把...

Hibernate的事务处理机制

Hibernate是对JDBC的轻量级对象封装,Hibernate本身是不具备Transaction处理功能的,Hibernate的Transaction实际上是底层的JDBC Transaction...

Hibernate的事务处理机制

原帖:http://www.enet.com.cn/article/2008/0115/A20080115110261.shtml Hibernate是对JDBC的轻量级对象封装,Hibernate...

Spring 对hibernate事务处理的实现过程(2) spring怎么获取hibernate使用的session并开启事务的

具体获取session 和开启事务的代码在HibernateTransactionManager中 先看看开启事务的调用过程,最开始的TransactionInterceptor.invoke(Met...

C# 事务处理机制

  • 2010-09-08 18:33
  • 152KB
  • 下载

浅析PostgreSQL事务处理机制

  • 2016-07-05 13:55
  • 1.29MB
  • 下载

Hibernate的事务处理和二级缓存

事务的特性: 事务有严格的定义,需要同时满足4个特性,即原子性、一致性、隔离性、持久性。这4个特性通常称为ACID特性,具体如下: ·原子性(Atomic):表示将事务中所做的操作捆绑成一个不可分割的...

JDBC事务处理机制探秘

  • 2012-04-10 09:55
  • 19KB
  • 下载

浅析PostgreSQL事务处理机制

  • 2016-07-13 19:48
  • 1.31MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)