`

利用过滤器对hibernate的session管理,实现session在线程范围内的共享

Hibernate 
阅读更多

hibernate中的Session关系到对数据库的增删查改等基本的数据存取操作.对Session进行有效的维护,就像是在jdbc编程中对JDBC collection的维护.
     在struts+hibernate的方案中,常常利用过滤器(Filter)对session进行管理,以实现session在线程范围内的共享.为什么仅仅实现线程内的共享,是因为,不能把session用于多线程,否则会出现意外.在线程范围内实现sesion的共享.避免了session的频繁的创建和销毁.我看到有的程序中,在单个方法内,打开session,执行.关闭session.这显然没有在一次会话中有效的利用session
     下面的方案是.通过建立一个过滤器,以实现对sesion的共享:

Java代码 复制代码
  1. package com.cs_oj.filter;   
  2.   
  3. import java.io.IOException;   
  4. import java.text.DateFormat;   
  5. import java.text.SimpleDateFormat;   
  6. import java.util.Date;   
  7.   
  8. import javax.servlet.Filter;   
  9. import javax.servlet.FilterChain;   
  10. import javax.servlet.FilterConfig;   
  11. import javax.servlet.ServletException;   
  12. import javax.servlet.ServletRequest;   
  13. import javax.servlet.ServletResponse;   
  14. import javax.servlet.http.HttpServletRequest;   
  15. import javax.servlet.http.HttpServletResponse;   
  16. import javax.servlet.http.HttpSession;   
  17.   
  18. import org.apache.commons.logging.Log;   
  19. import org.apache.commons.logging.LogFactory;   
  20. import org.hibernate.Session;   
  21. import org.hibernate.Transaction;   
  22.   
  23.   
  24. import com.cs_oj.data.dao.HibernateSessionFactory;   
  25.   
  26. public class HibernateSessionFilter implements Filter {   
  27.     private static final Log log = LogFactory.getLog(HibernateSessionFilter.class);   
  28.     public void destroy() {   
  29.         // TODO Auto-generated method stub   
  30.   
  31.     }   
  32.   
  33.     public void doFilter(ServletRequest arg0, ServletResponse arg1,   
  34.             FilterChain chain) throws IOException, ServletException {   
  35.         log.debug("HibernateSessionFilter start");   
  36.         Date date=new Date();   
  37.         DateFormat df=new SimpleDateFormat("yyyy-MM-dd '时间--'HH:mm:ss");   
  38.         System.out.println("----当前时间:"+df.format(date)+"----");   
  39.         System.out.println("----------HibernateSessionFilter start-----------");   
  40.   
  41. //利用HibernateSessionFactory, 得到当 前线程中的session对象..HibernateSessionFactory的代码利用了ThreadLocal模式..详见..HibernateSessionFactory   
  42.         Session session=HibernateSessionFactory.getSession();    
  43.         log.info("HibernateSessionFilter begin transaction");   
  44.         System.out.println("HibernateSessionFilter begin transaction");   
  45.        Transaction tx=session.beginTransaction();   //开始事务   
  46.            
  47.         log.debug("HibernateSessionFilter begin doChain");   
  48.         HttpServletResponse response=(HttpServletResponse)arg1;   
  49.         try{   
  50.             chain.doFilter(arg0, arg1);   
  51.                
  52.             log.debug("HibernateSessionFilter begin commit");   
  53.             //没有异常,则提交   
  54.             try{   
  55.                    
  56.                 System.out.println("HibernateSessionFilter begin commit");   
  57.                 tx.commit();   
  58.                 System.out.println("HibernateSessionFilter commit success");   
  59.                    
  60.             }   
  61.             catch(Exception e){   
  62.                    
  63.                 System.out.println("HibernateSessionFilter commit failed");   
  64.                 System.out.println("HibernateSessionFilter begin rollback() ");   
  65.                 try{   
  66.                     System.out.println("HibernateSessionFilter begin rollback() ");   
  67.                     tx.rollback();   
  68.                     System.out.println("HibernateSessionFilter rollback() success ");   
  69.                 }catch(RuntimeException ex){   
  70.                     System.out.println("HibernateSessionFilter   rollback() failed");   
  71.                 }   
  72.             }   
  73.         }catch (Exception e) {   
  74.             e.printStackTrace();   
  75.             System.out.println("chain.doFilter(arg0, arg1) exception accurs ");   
  76.             System.out.println("HibernateSessionFilter begin rollback() ");   
  77.             tx.rollback();   //出现异常,回滚   
  78.             //response.sendRedirect("error.jsp");   
  79.         }   
  80.         finally{   
  81.             log.debug("HibernateSessionFilter end doChain");   
  82.             System.out.println("HibernateSessionFilter begin close session");   
  83.            HibernateSessionFactory.closeSession();   
  84.             System.out.println("*********HibernateSessionFilter close session success*********");   
  85.             log.debug("HibernateSessionFilter begin close session");   
  86.             //System.out.println("session.isOpen()="+session.isOpen());   
  87.         }   
  88.   
  89.     }   
  90.   
  91. }  
package com.cs_oj.filter;

import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Session;
import org.hibernate.Transaction;


import com.cs_oj.data.dao.HibernateSessionFactory;

public class HibernateSessionFilter implements Filter {
    private static final Log log = LogFactory.getLog(HibernateSessionFilter.class);
    public void destroy() {
        // TODO Auto-generated method stub

    }

    public void doFilter(ServletRequest arg0, ServletResponse arg1,
            FilterChain chain) throws IOException, ServletException {
        log.debug("HibernateSessionFilter start");
        Date date=new Date();
        DateFormat df=new SimpleDateFormat("yyyy-MM-dd '时间--'HH:mm:ss");
        System.out.println("----当前时间:"+df.format(date)+"----");
        System.out.println("----------HibernateSessionFilter start-----------");

//利用HibernateSessionFactory, 得到当 前线程中的session对象..HibernateSessionFactory的代码利用了ThreadLocal模式..详见..HibernateSessionFactory
        Session session=HibernateSessionFactory.getSession(); 
        log.info("HibernateSessionFilter begin transaction");
        System.out.println("HibernateSessionFilter begin transaction");
       Transaction tx=session.beginTransaction();   //开始事务
        
        log.debug("HibernateSessionFilter begin doChain");
        HttpServletResponse response=(HttpServletResponse)arg1;
        try{
            chain.doFilter(arg0, arg1);
            
            log.debug("HibernateSessionFilter begin commit");
            //没有异常,则提交
            try{
                
                System.out.println("HibernateSessionFilter begin commit");
                tx.commit();
                System.out.println("HibernateSessionFilter commit success");
                
            }
            catch(Exception e){
                
                System.out.println("HibernateSessionFilter commit failed");
                System.out.println("HibernateSessionFilter begin rollback() ");
                try{
                    System.out.println("HibernateSessionFilter begin rollback() ");
                    tx.rollback();
                    System.out.println("HibernateSessionFilter rollback() success ");
                }catch(RuntimeException ex){
                    System.out.println("HibernateSessionFilter   rollback() failed");
                }
            }
        }catch (Exception e) {
            e.printStackTrace();
            System.out.println("chain.doFilter(arg0, arg1) exception accurs ");
            System.out.println("HibernateSessionFilter begin rollback() ");
            tx.rollback();   //出现异常,回滚
            //response.sendRedirect("error.jsp");
        }
        finally{
            log.debug("HibernateSessionFilter end doChain");
            System.out.println("HibernateSessionFilter begin close session");
           HibernateSessionFactory.closeSession();
            System.out.println("*********HibernateSessionFilter close session success*********");
            log.debug("HibernateSessionFilter begin close session");
            //System.out.println("session.isOpen()="+session.isOpen());
        }

    }

}

 

 

 

在web.xml文件中对上面的过滤器进行配置.

Xml代码 复制代码
  1. <filter>  
  2.     <filter-name>hibernateSession</filter-name>  
  3.     <filter-class>com.cs_oj.filter.HibernateSessionFilter</filter-class>  
  4. </filter>  
  5. <filter-mapping>  
  6.     <filter-name>hibernateSession</filter-name>  
  7.     <servlet-name>action</servlet-name>  
  8.       
  9. </filter-mapping>  
  10. <servlet>  
  11.     <servlet-name>action</servlet-name>  
  12.     <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>  
  13.     <init-param>.   
  14.     <init-param>  
  15.       <param-name>config</param-name>  
  16.       <param-value>/WEB-INF/struts-config.xml</param-value>  
  17.     </init-param>  
  18.     <init-param>  
  19.       <param-name>debug</param-name>  
  20.       <param-value>3</param-value>  
  21.     </init-param>  
  22.     <init-param>  
  23.       <param-name>detail</param-name>  
  24.       <param-value>3</param-value>  
  25.     </init-param>  
  26.     <load-on-startup>0</load-on-startup>  
  27. </servlet>  
  28. <servlet-mapping>  
  29.     <servlet-name>action</servlet-name>  
  30.     <url-pattern>*.do</url-pattern>  
  31. </servlet-mapping>   
<filter>
    <filter-name>hibernateSession</filter-name>
    <filter-class>com.cs_oj.filter.HibernateSessionFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>hibernateSession</filter-name>
    <servlet-name>action</servlet-name>
   
</filter-mapping>
<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>.
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <init-param>
      <param-name>debug</param-name>
      <param-value>3</param-value>
    </init-param>
    <init-param>
      <param-name>detail</param-name>
      <param-value>3</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

 

 

则对所有以.do作为后缀名的url,都会被过滤器过滤.在被过滤器过滤的action中,和业务层的方法内,只需要调用HibernateSessionFactory 的getSession()方法,得到当前线程内的session对象.用完session后,不要关闭session,而且,每次在用session进行添加和修改操作时,也不需要启动事务.

 

 

HibernateSessionFactory.java

 

Java代码 复制代码
  1. package com.cs_oj.data.dao;   
  2.   
  3. import org.hibernate.HibernateException;   
  4. import org.hibernate.Session;   
  5. import org.hibernate.cfg.Configuration;   
  6.   
  7.   
  8. public class HibernateSessionFactory {   
  9.   
  10.     /**   
  11.      * Location of hibernate.cfg.xml file.  
  12.      * Location should be on the classpath as Hibernate uses   
  13.      * #resourceAsStream style lookup for its configuration file.   
  14.      * The default classpath location of the hibernate config file is   
  15.      * in the default package. Use #setConfigFile() to update   
  16.      * the location of the configuration file for the current session.     
  17.      */  
  18.     private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";   
  19.     private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();   
  20.     private static Configuration configuration = new Configuration().configure();   
  21.     private static org.hibernate.SessionFactory sessionFactory;   
  22.     private static String configFile = CONFIG_FILE_LOCATION;   
  23.   
  24.     private HibernateSessionFactory() {   
  25.     }   
  26.        
  27.     /**  
  28.      * Returns the ThreadLocal Session instance. Lazy initialize  
  29.      * the <code>SessionFactory</code> if needed.  
  30.      *  
  31.      * @return Session  
  32.      * @throws HibernateException  
  33.      */  
  34.     public static Session getSession() throws HibernateException {   
  35.         Session session = threadLocal.get();   
  36.   
  37.         if (session == null || !session.isOpen()) {   
  38.             if (sessionFactory == null) {   
  39.                 rebuildSessionFactory();   
  40.             }   
  41.             session = (sessionFactory != null) ? sessionFactory.openSession()   
  42.                     : null;   
  43.             threadLocal.set(session);   
  44.         }   
  45.   
  46.         return session;   
  47.     }   
  48.   
  49.     /**  
  50.      * Rebuild hibernate session factory  
  51.      *  
  52.      */  
  53.     public static void rebuildSessionFactory() {   
  54.         try {   
  55.             //configuration.configure();   
  56.             sessionFactory = configuration.buildSessionFactory();   
  57.         } catch (Exception e) {   
  58.             System.err   
  59.                     .println("%%%% Error Creating SessionFactory %%%%");   
  60.             e.printStackTrace();   
  61.         }   
  62.     }   
  63.   
  64.     /**  
  65.      * Close the single hibernate session instance.  
  66.      *  
  67.      * @throws HibernateException  
  68.      */  
  69.     public static void closeSession() throws HibernateException {   
  70.         Session session = threadLocal.get();   
  71.         threadLocal.set(null);   
  72.   
  73.         if (session != null) {   
  74.             session.close();   
  75.         }   
  76.     }   
  77.   
  78.     /**  
  79.      * return session factory  
  80.      *  
  81.      */  
  82.     public static org.hibernate.SessionFactory getSessionFactory() {   
  83.         return sessionFactory;   
  84.     }   
  85.   
  86.     /**  
  87.      * return session factory  
  88.      *  
  89.      *    session factory will be rebuilded in the next call  
  90.      */  
  91.     public static void setConfigFile(String configFile) {   
  92.         HibernateSessionFactory.configFile = configFile;   
  93.         sessionFactory = null;   
  94.     }   
  95.   
  96.     /**  
  97.      * return hibernate configuration  
  98.      *  
  99.      */  
  100.     public static Configuration getConfiguration() {   
  101.         return configuration;   
  102.     }   
  103.   
  104. }  
分享到：
| tomcat内存溢出总结
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    精通 Hibernate：Java 对象持久化技术详解(第2版).part2

    　21.5 利用Hibernate的版本控制来实现乐观锁 　21.5.1 使用元素 　21.5.2 使用元素 　21.5.3 对游离对象进行版本检查 　21.5.4 强制更新版本 　21.6 实现乐观锁的其他方法 　21.7 小结 　21.8 思考题 第22章 管理...

    Hibernate实战(第2版 中文高清版)

    第一部分 从Hibernate和EJB 3.0开始 　第1章 理解对象/关系持久化　 　1.1 什么是持久化　 　1.1.1 关系数据库　 　1.1.2 理解SQL　 　1.1.3 在Java中使用SQL　 　1.1.4 面向对象应用程序中的持久化　 　1.2 范式不...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part4

    　21.5 利用Hibernate的版本控制来实现乐观锁 　21.5.1 使用元素 　21.5.2 使用元素 　21.5.3 对游离对象进行版本检查 　21.5.4 强制更新版本 　21.6 实现乐观锁的其他方法 　21.7 小结 　21.8 思考题 第22章 管理...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part3

    　21.5 利用Hibernate的版本控制来实现乐观锁 　21.5.1 使用元素 　21.5.2 使用元素 　21.5.3 对游离对象进行版本检查 　21.5.4 强制更新版本 　21.6 实现乐观锁的其他方法 　21.7 小结 　21.8 思考题 第22章 管理...

    精通 Hibernate：Java 对象持久化技术详解(第2版).part1.rar

    　21.5 利用Hibernate的版本控制来实现乐观锁 　21.5.1 使用元素 　21.5.2 使用元素 　21.5.3 对游离对象进行版本检查 　21.5.4 强制更新版本 　21.6 实现乐观锁的其他方法 　21.7 小结 　21.8 思考题 第22章 管理...

    hibernate 教程

    管理Session缓存 14.5. 查询缓存(Query Cache) 15. 工具箱指南 15.1. Schema 生成器（Schema Generation） 15.1.1. 对schema定制化(Customizing the schema) 15.1.2. 运行该工具 15.1.3. 属性...

    hibernate

    管理Session缓存 14.5. 查询缓存(Query Cache) 15. 工具箱指南 15.1. Schema 生成器（Schema Generation） 15.1.1. 对schema定制化(Customizing the schema) 15.1.2. 运行该工具 15.1.3. 属性...

    java开源包3

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    java开源包4

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    JAVA上百实例源码以及开源项目

    在有状态SessionBean中，用累加器，以对话状态存储起来，创建EJB对象，并将当前的计数器初始化，调用每一个EJB对象的count()方法，保证Bean正常被激活和钝化，EJB对象是用完毕，从内存中清除…… Java Socket 聊天...

    java开源包1

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    java开源包11

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    java开源包2

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    JAVA上百实例源码以及开源项目源代码

    在有状态SessionBean中，用累加器，以对话状态存储起来，创建EJB对象，并将当前的计数器初始化，调用每一个EJB对象的count()方法，保证Bean正常被激活和钝化，EJB对象是用完毕，从内存中清除…… Java Socket 聊天...

    java开源包6

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    java开源包5

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    java开源包10

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    java开源包8

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

    java开源包7

    利用Google:maps JSP标签库就能够在你的Web站点上实现GoogleMaps的所有功能而且不需要javascript或AJAX编程。它还能够与JSTL相结合生成数据库驱动的动态Maps。 OAuth 实现框架 Agorava Agorava 是一个实现了 OAuth ...

Magicbox
Global site tag (gtag.js) - Google Analytics