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

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