hibernate 操作基类

1. package com.shop.base;
3. import org.hibernate.*;
4. import org.hibernate.criterion.Criterion;
5. import org.hibernate.criterion.Example;
7. import java.sql.Connection;
8. import java.sql.PreparedStatement;
9. import java.sql.SQLException;
10. import java.util.List;
11. import java.io.Serializable;
13. /**
14.  * HiberNate操作基类
15.  * @author Administrator
16.  *
17.  */
18. public abstract class BaseHibernateDao {
19.     
20.     /**
21.      * 加载指定Id的对象到Session缓存中,
22.      * 如果指定的记录不存在.则返回null.
23.      * @param clz
24.      *      类名
25.      * @param id
26.      *      表示实现这个接口的类可以序列化
27.      * @return
28.      *      对象
29.      */
30.     protected Object getObject(Class clz,Serializable id){
31.         Object object=null;
32.         Session session = HibernateSessionFactory.getSession();
33.         Transaction tx = null;
34.         try{
35.             tx = session.beginTransaction();
36.             //加载指定的对象
37.             object=session.get(clz, id);
38.             tx.commit();
39.         }catch(Exception e){
40.             if(tx!=null){
41.                 tx.rollback();
42.             }
43.             e.printStackTrace();
44.         }finally{
45.             HibernateSessionFactory.closeSession();
46.         }
47.         return object;
48.     }
49.     
50.     /**
51.      * 加载指定Id的对象到Session缓存中,
52.      * 如果指定的记录不存在.则抛出异常.
53.      * @param clz
54.      *      类名
55.      * @param id
56.      *      表示实现这个接口的类可以序列化 
57.      * @return
58.      *      对象
59.      */
60.     protected Object loadObject(Class clz,Serializable id){
61.         Object object = null;
62.         Session session = HibernateSessionFactory.getSession();
63.         Transaction tx = null;
64.         try {
65.             tx = session.beginTransaction();
66.             object = session.load(clz, id);
67.             tx.commit();
68.         } catch (Exception e) {
69.             if(tx!=null){
70.                 tx.rollback();
71.             }
72.             e.printStackTrace();
73.         }finally{
74.             
75.         }
76.         return object;
77.         
78.     }
79.     /**
80.      * 添加对象
81.      * @param item
82.      *          对象
83.      */
84.     protected boolean addObject(Object item){
85.         boolean mark = false;
86.         Session session = HibernateSessionFactory.getSession();
87.         Transaction tx = null;
88.         try{
89.             tx=session.beginTransaction();
90.             session.save(item);
91.             tx.commit();
92.             mark = true;
93.         }catch(Exception e){
94.             if(null!=tx){
95.                 tx.rollback();
96.             }
97.             e.printStackTrace();
98.         }finally{
99.             HibernateSessionFactory.closeSession();
100.         }
101.         return mark;
102.     }
103.     
104.     /**
105.      * 更新对象
106.      * @param item
107.      *          对象
108.      */
109.     protected boolean updateObject(Object item){
110.         boolean mark = false;
111.         Session session = HibernateSessionFactory.getSession();
112.         Transaction tx=null;
113.         try{
114.             tx=session.beginTransaction();
115.             session.update(item);
116.             tx.commit();
117.         }catch(Exception e){
118.             if(null!=null){
119.                 tx.rollback();
120.             }
121.             e.printStackTrace();
122.         }finally{
123.             HibernateSessionFactory.closeSession();
124.         }
125.         return mark;
126.     }
128.     /**
129.      * 执行SQL语句,执行非查询操作
130.      * @param sql
131.      *          sql语句
132.      */
133.     protected boolean updateObjectSQL(String sql){
134.         boolean mark = false;
135.         Connection connection = null;
137.         try{
138.             connection = HibernateSessionFactory.getSession().connection();
139.             PreparedStatement pstm = connection.prepareStatement(sql);
140.             pstm.executeUpdate();
141.             mark=true;
142.         }catch(Exception e){
143.             e.printStackTrace();
144.         }finally{
145.             try {
146.                 connection.close();
147.             } catch (SQLException e) {
148.                 e.printStackTrace();
149.             }
150.         }
151.         return mark;
152.     }
153.     
154.     /**
155.      * 删除对象
156.      * @param clz
157.      *      类
158.      * @param id
159.      *      表示实现这个接口的类可以序列化
160.      */
161.     protected boolean deleteObject(Class clz,Serializable id){
162.         boolean mark = false;
163.         Transaction tx = null;
164.         Session session = HibernateSessionFactory.getSession();
165.         try{
166.             tx=session.beginTransaction();
167.             //启用getOjbect()方法,装载指定ID的对象到内存中
168.             session.delete(this.getObject(clz, id));
169.             tx.commit();
170.         }catch(Exception e){
171.             if(null!=tx){
172.                 tx.rollback();
173.             }
174.             e.printStackTrace();
175.         }finally{
176.             HibernateSessionFactory.closeSession();
177.         }
178.         return mark;
179.     }
180.     
181.     /**
182.      * 动态查询(QBC查询)
183.      * @param clz
184.      *      要查询的类
185.      * @param condition
186.      *      查询类的条件
187.      * @return
188.      * 
189.      *      Example接口的静态方法create()创建一个Criterion对象,它代表
190.      *      按照样板对象的属性来比较查询条件.不常用.一个典型的应用是在查询窗口中
191.      *      让用户输入一系列的查询条件.然后返回匹配对象.
192.      *      把所有不为null值的condition作为查询条件
193.      */
194.     protected List searchObject(Class clz,Object condition){
195.         List results = null;
196.         Session session = HibernateSessionFactory.getSession();
197.         Transaction tx = null;
198.         try{
199.              tx=session.beginTransaction();
200.              results=session.createCriteria(clz)//QBC查询
201.                     .add(Example.create(condition))
202.                     .list();
203.              tx.commit();
204.             //Example接口的静态方法create()创建一个Criterion对象,它代表
205.             //按照样板对象的属性来比较查询条件.不常用.一个典型的应用是在查询窗口中
206.             //让用户输入一系列的查询条件.然后返回匹配对象.
207.         }catch(RuntimeException re){
208.             if(null!=tx){
209.                 tx.rollback();
210.             }
211.             re.printStackTrace();
212.         }finally{
213.             HibernateSessionFactory.closeSession();
214.         }
215.         return results;
216.     }
217.     
218.     /**
219.      * QBC查询
220.      * @param clz
221.      *      要查询的类
222.      * @param criterion
223.      *      查询条件
224.      * @return
225.      */
226.     protected List searchObjectQBC(Class clz,Criterion criterion){
227.         List results = null;
228.         Session session = HibernateSessionFactory.getSession();
229.         Transaction tx = null;
230.         try{
231.             tx=session.beginTransaction();
232.             results=session.createCriteria(clz)
233.                     .add(criterion)
234.                     .list();
235.             tx.commit();
236.         }catch(RuntimeException re){
237.             if(null!=tx){
238.                 tx.rollback();
239.             }
240.             re.printStackTrace();
241.         }finally{
242.             HibernateSessionFactory.closeSession();
243.         }
244.         return results;
245.     }
246.     
247.     /**
248.      * HQL查询
249.      * @param hql
250.      *      HQL查询语句
251.      * @return
252.      */
253.     protected List searchObjectHQL(String hql){
254.         List results = null;
255.         Session session=HibernateSessionFactory.getSession();
256.         Transaction tx= null;
257.         try {
258.             tx=session.beginTransaction();
259.             Query query = session.createQuery(hql);
260.             results=query.list();
261.             tx.commit();
262.         } catch (Exception e) {
263.             if(null!=tx){
264.                 tx.rollback();
265.             }
266.             e.printStackTrace();
267.         }finally{
268.             HibernateSessionFactory.closeSession();         
269.         }
270.         return results;
271.     }
273.     /**
274.      * HQL查询
275.      * @param hql
276.      *      HQL查询语句
277.      *      带条件参数
278.      * @return
279.      */
280.     protected List searchObjectHQLWithParam(String hql,Object[] conditions){
281.         List results = null;
282.         Session session=HibernateSessionFactory.getSession();
283.         Transaction tx= null;
284.         try {
285.             tx=session.beginTransaction();
286.             Query query = session.createQuery(hql);
287.     
288.                 for (int i = 0; i < conditions.length; i++) {
289.                     query.setParameter(i, conditions[i]);
290.                 }
291.             
292.             results=query.list();
293.             tx.commit();
294.         } catch (Exception e) {
295.             if(null!=tx){
296.                 tx.rollback();
297.             }
298.             e.printStackTrace();
299.         }finally{
300.             HibernateSessionFactory.closeSession();         
301.         }
302.         return results;
303.     }
304.     
305.     /**
306.      * SQL查询
307.      * @param sql
308.      *      SQL查询语句
309.      * @return
310.      */ 
311.     protected  List searchObjectSQL(String sql) {
312.         List results = null;
313.         Session session=HibernateSessionFactory.getSession();
314.         Transaction tx= null;
315.         try {
316.             tx=session.beginTransaction();
317.             Query query = session.createSQLQuery(sql);
318.             results=query.list();
319.             tx.commit();
320.         } catch (Exception e) {
321.             if(null!=tx){
322.                 tx.rollback();
323.             }
324.             e.printStackTrace();
325.         }finally{
326.             HibernateSessionFactory.closeSession();         
327.         }
328.         return results;     
329.     }
330.     
331.     /**
332.      * 执行hql语句,得到单个值
333.      * @param hql
334.      *      hql语句
335.      * @return
336.      */
337.     protected Object getUniqueObjectHQL(String hql,Object[] conditions ){
338.         Object results = null;
339.         Session session=HibernateSessionFactory.getSession();
340.         Transaction tx= null;
341.         try {
342.             tx=session.beginTransaction();
343.             Query query = session.createQuery(hql);
344.             
345.             for (int i = 0; i < conditions.length; i++) {
346.                 query.setParameter(i, conditions[i]);
347.             }       
348.             
349.             results=query.uniqueResult();
350.             tx.commit();
351.         } catch (Exception e) {
352.             if(null!=tx){
353.                 tx.rollback();
354.             }
355.             e.printStackTrace();
356.         }finally{
357.             HibernateSessionFactory.closeSession();         
358.         }
359.         return results; 
360.     }
361.     
362.     /**
363.      * 执行sql语句,得到单个值
364.      * @param sql
365.      *      sql语句
366.      * @return
367.      */
368.     protected Object getUniqueObjectSQL(String sql){
369.         Object results = null;
370.         Session session=HibernateSessionFactory.getSession();
371.         Transaction tx= null;
372.         try {
373.             tx=session.beginTransaction();
374.             Query query = session.createSQLQuery(sql);
375.             results=query.uniqueResult();
376.             tx.commit();
377.         } catch (Exception e) {
378.             if(null!=tx){
379.                 tx.rollback();
380.             }
381.             e.printStackTrace();
382.         }finally{
383.             HibernateSessionFactory.closeSession();         
384.         }
385.         return results; 
386.     }
387. }