hibernate3学习笔记(六)｜Session管理

 请注意，在hibernate中SessionFactory是被设计成线程安全(Thread-safe)的,遗憾的是，Session却线程不安全。

这就意味着:有可能多个线程共享并操作同一个Session从而很容易使数据混乱。

解决的办法如下：（其实hibernate的文档中早已经提过了）

新建HibernateUtil类：

1. import org.apache.commons.logging.Log;
2. import org.apache.commons.logging.LogFactory;
3. import org.hibernate.*;
4. import org.hibernate.cfg.*;
6. public class HibernateUtil {
7.     private static Log log = LogFactory.getLog(HibernateUtil.class);
8.     private static final SessionFactory sessionFactory;
10.     static {
11.         try {
12.             // Create the SessionFactory
13.             sessionFactory = new Configuration().configure()
14.                                                 .buildSessionFactory();
15.         } catch (Throwable ex) {
16.             // Make sure you log the exception, as it might be swallowed
17.             log.error("Initial SessionFactory creation failed.", ex);
18.             throw new ExceptionInInitializerError(ex);
19.         }
20.     }
22.     public static final ThreadLocal session = new ThreadLocal();
24.     public static Session currentSession() {
25.         Session s = (Session) session.get();
27.         // Open a new Session, if this Thread has none yet
28.         if (s == null) {
29.             s = sessionFactory.openSession();
30.             session.set(s);
31.         }
33.         return s;
34.     }
36.     public static void closeSession() {
37.         Session s = (Session) session.get();
39.         if (s != null) {
40.             s.close();
41.         }
43.         session.set(null);
44.     }
45. }

这样，在程序中可这样调用：

1. Session session = HibernateUtil.currentSession();
2. User user = (User) session.load(User.class, new Integer(1));
3. System.out.println(user.getName());
4. HibernateUtil.closeSession();

在web应用中，可以借由Filter来进行session管理。在需要session的时候开启session，在request结束之后关闭session。

HibernateSessionUtil.java

1. import java.io.Serializable;
3. import net.sf.hibernate.HibernateException;
4. import net.sf.hibernate.Session;
5. import net.sf.hibernate.SessionFactory;
6. import net.sf.hibernate.Transaction;
8. public class HibernateSessionUtil implements Serializable
9. {
10.     public static final ThreadLocal tLocalsess = new ThreadLocal();
12.     public static final ThreadLocal tLocaltx = new ThreadLocal();
14.     /*
15.      * getting the thread-safe session for using
16.      */
17.     public static Session currentSession(){
18.         Session session = (Session) tLocalsess.get();
20.         //open a new one, if none can be found.
21.         try{
22.             if (session == null){
23.                 session = openSession();
24.                 tLocalsess.set(session);
25.             }
26.         }catch (HibernateException e){
27.             throw new InfrastructureException(e);
28.         }
29.         return session;
30.     }
32.     /*
33.      * closing the thread-safe session
34.      */
35.     public static void closeSession(){
37.         Session session = (Session) tLocalsess.get();
38.         tLocalsess.set(null);
39.         try{
40.             if (session != null && session.isOpen()){
41.                 session.close();
42.             }
44.         }catch (HibernateException e){
45.             throw new InfrastructureException(e);
46.         }
47.     }
49.     /*
50.      * begin the transaction
51.      */
52.     public static void beginTransaction(){
53.         Transaction tx = (Transaction) tLocaltx.get();
54.         try{
55.             if (tx == null){
56.                 tx = currentSession().beginTransaction();
57.                 tLocaltx.set(tx);
58.             }
59.         }catch (HibernateException e){
60.             throw new InfrastructureException(e);
61.         }
62.     }
64.     /*
65.      * close the transaction
66.      */
67.     public static void commitTransaction(){
68.         Transaction tx = (Transaction) tLocaltx.get();
69.         try{
70.             if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack())
71.                 tx.commit();
72.             tLocaltx.set(null);
73.         }catch (HibernateException e){
74.             throw new InfrastructureException(e);
75.         }
76.     }
78.     /*
79.      * for rollbacking
80.      */
81.     public static void rollbackTransaction(){
82.         Transaction tx = (Transaction) tLocaltx.get();
83.         try{
84.             tLocaltx.set(null);
85.             if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){
86.                 tx.rollback();
87.             }
88.         }catch (HibernateException e){
89.             throw new InfrastructureException(e);
90.         }
91.     }
93.     private static Session openSession() throws HibernateException{
94.         return getSessionFactory().openSession();
95.     }
97.     private static SessionFactory getSessionFactory() throws HibernateException{
98.         return SingletonSessionFactory.getInstance();
99.     }
100. }

filter中则：

1. public class HibernateSessionCloser implements Filter{
3.     protected FilterConfig filterConfig = null;
5.     public void init(FilterConfig filterConfig)throws ServletException{
6.     this.filterConfig = filterConfig;
7.     }
8.     
9.     public void destroy(){
10.         this.filterConfig = null;
11.     }    
13.     public void doFilter(ServletRequest request, ServletResponse response,
14.                          FilterChain chain)
15.     throws IOException, ServletException {
16.         try{
17.             chain.doFilter(request, response);
18.         }
19.         finally{
20.             try{
21.                 HibernateSessionUtil.commitTransaction();
22.             }catch (InfrastructureException e){
23.                 HibernateSessionUtil.rollbackTransaction();
24.             }finally{
25.                 HibernateSessionUtil.closeSession();
26.             }   
27.         }
29.     }
30. }

然后在操作数据库前加上

HibernateSessionUtil.beginTransaction();
HibernateSessionUtil.currentSession();//取得Session