ThreadLocal管理和获取Hibernate的Session对象

前几天在csdn论坛里面,经常有人问到,如果不用spring,单用hibernate如何来解决延迟加载的问题.

无论是立即加载还是延迟加载必须要连接数据库的,而在java中连接数据库是依赖java.sql.Connection,在hibernate中session就是Connection的一层高级封装,一个session对应了一个Connection,要实现延迟加载必须有session才行.而且要进行延迟加载还必须保证是同一个session才行,用另外一个session去延迟加载前一个session的代理对象是不行的.大家都知道Connection是使用过后必须要进行关闭的,那么我们如何保证一次http请求过程中,一直都使用一个session呢,即一个Connection呢.而且还要保证http请求结束后正确的关闭.

好,现在我们知道了我们要解决的问题

1.如何保证http请求结束后正确的关闭session

2.如何保证http请求过程中一直使用同一个session

第一个问题很容易想到,使用过滤器

[java]  view plain copy

1. public void doFilter(ServletRequest request, ServletResponse response,  
2.   
3.         FilterChain filterChain) {  
4.   
5.     try {  
6.   
7.         filterChain.doFilter(request, response);  
8.   
9.     } catch (IOException e) {  
10.   
11.         e.printStackTrace();  
12.   
13.     } catch (ServletException e) {  
14.   
15.         e.printStackTrace();  
16.   
17.     } finally {  
18.   
19.         try {  
20.   
21.             HibernateUtil.commitTransaction();  
22.   
23.         } catch (Exception e) {  
24.   
25.             HibernateUtil.rollbackTransaction();  
26.   
27.         } finally {  
28.   
29.             HibernateUtil.closeSession();  
30.   
31.         }  
32.   
33.     }  
34.   
35. }  

要解决第二个问题我们必须先搞清楚,http请求在java中是以什么样的机制实现的,在java中一个请求就是一个线程,像流行的web容器Tomcat等,往往都是采用线程池机制的也就是说有n个线程在池子里面,每当有http请求时,随机从线程池中取出一个线程对象去处理请求,实际上多次请求可能使用的是同一线程也可能不是,这是随机的.要保证整个请求中使用同一session最容易想到的就是把这个session绑定到线程上,在java中使用ThreadLocal可以轻松绑定变量,每个线程有一个自己的ThreadLocal,这个ThreadLocal会随线程的销毁一起销毁,既然是每个线程有一个那么多个线程间自然是不会有影响了,所以把session绑定在ThreadLocal里面是最好的选择了,

有关ThreadLocal的更多资料,大家可以百度或者参考

http://www-128.ibm.com/developerworks/cn/java/j-threads/index3.html

http://www.blogjava.net/jspark/archive/2006/08/01/61165.html

最后我把相关的代码发出来

[java]  view plain copy

1. import java.sql.SQLException;  
2.   
3. import org.hibernate.HibernateException;  
4.   
5. import org.hibernate.Session;  
6.   
7. import org.hibernate.SessionFactory;  
8.   
9. import org.hibernate.Transaction;  
10.   
11. import org.hibernate.cfg.Configuration;  
12.   
13. import java.sql.Connection;  
14.   
15. import org.apache.log4j.Logger;  
16.   
17. import java.io.File;  
18.   
19.   
20.   
21. /** 
22.  
23.  *  
24.  
25.  * <p> 
26.  
27.  * Title:Hibernate工具类 
28.  
29.  * </p> 
30.  
31.  *  
32.  
33.  * <p> 
34.  
35.  * 利用ThreadLocal 绑定 Hibernate 的session 
36.  
37.  * </p> 
38.  
39.  *  
40.  
41.  * @author 孙钰佳  
42.  
43.  * @mail sunyujia@yahoo.cn 
44.  
45.  * @version 1.0 
46.  
47.  */  
48.   
49. public class HibernateUtil {  
50.   
51.     /** 
52.  
53.      * Loger4j的logger 
54.  
55.      */  
56.   
57.     private static final Logger logger = Logger.getLogger(HibernateUtil.class);  
58.   
59.     /** 
60.  
61.      * 存储hibernate session的ThreadLocal 
62.  
63.      */  
64.   
65.     private static final ThreadLocal sessionThread = new ThreadLocal();  
66.   
67.     /** 
68.  
69.      * 存储事务的ThreadLocal 
70.  
71.      */  
72.   
73.     private static final ThreadLocal transactionThread = new ThreadLocal();  
74.   
75.     /** 
76.  
77.      * Hibernate 的 Session工厂 
78.  
79.      */  
80.   
81.     private static SessionFactory sessionFactory = null;  
82.   
83.   
84.   
85.     /** 
86.  
87.      * 初始化SessionFactory 
88.  
89.      *  
90.  
91.      * @param file 
92.  
93.      *            Hibernate配置文件 
94.  
95.      */  
96.   
97.     public static void initSessionFactory(File file) {  
98.   
99.         Configuration config = new Configuration();  
100.   
101.         config.configure(file);  
102.   
103.         sessionFactory = config.buildSessionFactory();  
104.   
105.     }  
106.   
107.   
108.   
109.     /** 
110.  
111.      * 获取当前线程绑定的session 
112.  
113.      *  
114.  
115.      * @return Session 
116.  
117.      * @throws HibernateException 
118.  
119.      */  
120.   
121.     public static Session getSession() {  
122.   
123.         Session s = (Session) sessionThread.get();  
124.   
125.         if (s == null) {  
126.   
127.             s = sessionFactory.openSession();  
128.   
129.             sessionThread.set(s);  
130.   
131.         } else {  
132.   
133.             Connection conn = s.connection();  
134.   
135.             try {  
136.   
137.                 if (conn == null || conn.isClosed()) {  
138.   
139.                     try {  
140.   
141.                         s.close();  
142.   
143.                     } catch (HibernateException e) {  
144.   
145.                         logger.warn("close session error:" + e.getMessage(), e);  
146.   
147.                     }  
148.   
149.                     s = sessionFactory.openSession();  
150.   
151.                     sessionThread.set(s);  
152.   
153.                 }  
154.   
155.             } catch (SQLException e) {  
156.   
157.                 throw new HibernateException(e);  
158.   
159.             }  
160.   
161.         }  
162.   
163.         return s;  
164.   
165.     }  
166.   
167.   
168.   
169.     /** 
170.  
171.      * 取得当前session的事务 
172.  
173.      *  
174.  
175.      * @return Transaction 
176.  
177.      */  
178.   
179.     public static Transaction transaction() {  
180.   
181.         Transaction transaction = (Transaction) transactionThread.get();  
182.   
183.         if (transaction == null) {  
184.   
185.             transaction = getSession().beginTransaction();  
186.   
187.             transactionThread.set(transaction);  
188.   
189.         }  
190.   
191.         return transaction;  
192.   
193.     }  
194.   
195.   
196.   
197.     /** 
198.  
199.      * 提交当前session的事务 
200.  
201.      */  
202.   
203.     public static void commitTransaction() {  
204.   
205.         Transaction transaction = (Transaction) transactionThread.get();  
206.   
207.         transactionThread.set(null);  
208.   
209.         if (transaction != null)  
210.   
211.             transaction.commit();  
212.   
213.     }  
214.   
215.   
216.   
217.     /** 
218.  
219.      * 回滚当前session的事务 
220.  
221.      */  
222.   
223.     public static void rollbackTransaction() {  
224.   
225.         Transaction tx = (Transaction) transactionThread.get();  
226.   
227.         transactionThread.set(null);  
228.   
229.         if (tx != null)  
230.   
231.             tx.rollback();  
232.   
233.     }  
234.   
235.   
236.   
237.     /** 
238.  
239.      * 关闭当前线程使用的session 
240.  
241.      */  
242.   
243.     public static void closeSession() {  
244.   
245.         Session session = (Session) sessionThread.get();  
246.   
247.         if (session != null) {  
248.   
249.             session.clear();  
250.   
251.             session.close();  
252.   
253.             sessionThread.set(null);  
254.   
255.         }  
256.   
257.     }  
258.   
259. }  

 

下面是一个调用的例子:

[java]  view plain copy

1. public static void main(String[] args) throws Exception {  
2.   
3.     HibernateUtil.initSessionFactory(new File(Test.class.getClassLoader()  
4.   
5.             .getResource("hibernate.cfg.xml").getFile()));  
6.   
7.     Session session = HibernateUtil.getSession();  
8.   
9.     HibernateUtil.transaction();  
10.   
11.     User u = new User();  
12.   
13.     u.setName("test");  
14.   
15.     session.save(u);  
16.   
17.     HibernateUtil.commitTransaction();  
18.   
19.     HibernateUtil.closeSession();  
20.   
21. }