Hibernate通用的baseDao

 转自 http://zhenjw.javaeye.com/blog/190997

Hibernate通用的baseDao

IBaseDao

Java代码

1. /** 
2.  *  
3.  */  
4.   
5. package zhenjw.hibernate.dao;  
6.   
7. import java.util.Collection;  
8. import java.util.List;  
9.   
10. import org.hibernate.Session;  
11.   
12. /** 
13.  * @author zhenjw 
14.  *  
15.  */  
16. public interface IBaseDao {  
17.   
18.     /** 
19.      * 功能：获得数据库连接的Session 
20.      *  
21.      * @return Session 
22.      */  
23.     public Session getSession();  
24.   
25.     /** 
26.      * 功能：根据hql语句得到记录总数 
27.      *  
28.      * @param strhql 
29.      * @return int 
30.      */  
31.     public int getTotalCount(String strhql);  
32.   
33.     /** 
34.      * 功能：根据sql语句得到记录总数 
35.      *  
36.      * @param strsql 
37.      * @return int 
38.      */  
39.     public int getTotalCountBySql(String strsql);  
40.   
41.     /** 
42.      * 功能：根据hql语句得到记录总数 
43.      *  
44.      * @param strhql 
45.      * @param obj 
46.      * @return int 
47.      */  
48.     public int getTotalCount(String strhql, Object obj);  
49.       
50.        
51.     /** 
52.      * 功能：根据hql语句得到记录总数 
53.      * @param strhql 
54.      * @param params 
55.      * @return int 
56.      */  
57.     public int getTotalCount(String strhql, List params);  
58.       
59.     /** 
60.      * 功能：根据sql语句得到记录总数 
61.      * @param strsql 
62.      * @param param 
63.      * @return 
64.      */  
65.     public int getTotalCountBySql(String strsql, List params);  
66.       
67.        
68.        
69.     /** 
70.      * 功能：增加记录 
71.      *  
72.      * @param entity 
73.      */  
74.     public void create(Object entity);  
75.   
76.     /** 
77.      * 功能：修改记录 
78.      *  
79.      * @param entity 
80.      */  
81.     public void update(Object entity);  
82.   
83.     /** 
84.      * 功能：删除记录 
85.      *  
86.      * @param entity 
87.      */  
88.     public void delete(Object entity);  
89.   
90.     /** 
91.      * 功能：删除数据 
92.      *  
93.      * @param clazz 
94.      * @param id 
95.      */  
96.     public void delete(Class clazz, long id);  
97.   
98.     /** 
99.      * 功能：批量删除数据 
100.      *  
101.      * @param clazz 
102.      * @param id 
103.      */  
104.     public void batchDelete(Class clazz, long[] id);  
105.   
106.     /** 
107.      * 功能：删除表中的所有的记录 
108.      *  
109.      * @param clazz 
110.      */  
111.     public void deleteAll(Class clazz);  
112.   
113.     /** 
114.      * 功能：删除记录集中的所有的记录 
115.      *  
116.      * @param entities 
117.      */  
118.     public void deleteAll(Collection entities);;  
119.   
120.     /** 
121.      * 功能：通过主键查询记录 
122.      *  
123.      * @param clazz 
124.      * @param id 
125.      * @return Object 
126.      */  
127.   
128.     public Object getByPk(Class clazz, int id);  
129.   
130.     /** 
131.      * 功能：通过主键查询记录 
132.      *  
133.      * @param clazz 
134.      * @param id 
135.      * @return Object 
136.      */  
137.     public Object getByPk(Class clazz, long id);  
138.   
139.     /** 
140.      * 功能：通过主键查询记录 
141.      *  
142.      * @param clazz 
143.      * @param id 
144.      * @return Object 
145.      */  
146.     public Object getByPk(Class clazz, String id);  
147.   
148.     /** 
149.      * 功能：通过关键字和值来进行查询 
150.      *  
151.      * @param clazz 
152.      * @param keyName 
153.      * @param keyValue 
154.      * @return 得到的Object是List 
155.      */  
156.     public Object loadByPk(Class clazz, String keyName, Object keyValue);  
157.   
158.     /** 
159.      * 功能：根据hql查询记录 
160.      *  
161.      * @param strhql 
162.      * @return List 
163.      */  
164.     public List find(String strhql);  
165.   
166.     /** 
167.      * 功能：根据hql查询记录 
168.      *  
169.      * @param strhql 
170.      * @param param 
171.      * @return List 
172.      */  
173.     public List find(String strhql, Object param);  
174.   
175.     /** 
176.      * 功能：根据hql查询记录 
177.      *   
178.      * @param strhql 
179.      * @param name 
180.      * @param param 
181.      * @return List 
182.      */  
183.     public List findByNamedParam(String strhql, String name, Object param);  
184.   
185.       
186.     /** 
187.      * 功能：SQL查询 
188.      * @param strsql 
189.      * @return 
190.      */  
191.     public List findBySql(String strsql);  
192.       
193.     /** 
194.      * 功能：查询符合条件的记录。 
195.      * @param strsql 
196.      * @param params 
197.      * @return 
198.      */  
199.     public List findBySql(String strsql,List params);    
200.     
201.     /** 
202.      * 功能：分页查询 
203.      *  
204.      * @param pageNo 
205.      * @param pageSize 
206.      * @param strhql 
207.      * @return List 
208.      */  
209.     public List query(int pageNo, int pageSize, String strhql);  
210.   
211.     /** 
212.      * 功能：分页查询 
213.      *  
214.      * @param pageNo 
215.      * @param pageSize 
216.      * @param queryString 
217.      * @param obj 
218.      * @return List 
219.      */  
220.     public List query(int pageNo, int pageSize, String strhql, Object obj);  
221.       
222.       
223.     /** 
224.      * 功能：分页查询 
225.      * @param pageNo 
226.      * @param pageSize 
227.      * @param strhql 
228.      * @param params 
229.      * @return 
230.      */  
231.     public List query(int pageNo, int pageSize, String strhql, List params );  
232.   
233.    
234.       
235.     /** 
236.      * 功能：分页查询 
237.      *  
238.      * @param pageNo 
239.      * @param pageSize 
240.      * @param strsql 
241.      * @return List 
242.      */  
243.     public List queryBySql(int pageNo, int pageSize, String strsql);   
244.   
245.     /** 
246.      * 功能：分页查询 
247.      * @param pageNo 
248.      * @param pageSize 
249.      * @param strsql 
250.      * @param params 
251.      * @return 
252.      */  
253.     public List queryBySql(int pageNo, int pageSize, String strsql, List params) ;  
254.       
255.        
256.     /** 
257.      * 功能：执行SQL语句，主要是更新与删除记录的SQL语句，不需要返回值的 
258.      *  
259.      * @param strsql 
260.      */  
261.     public void excuteSql(String strsql);  
262.       
263. }  

/**
 * 
 */

package zhenjw.hibernate.dao;

import java.util.Collection;
import java.util.List;

import org.hibernate.Session;

/**
 * @author zhenjw
 * 
 */
public interface IBaseDao {

	/**
	 * 功能：获得数据库连接的Session
	 * 
	 * @return Session
	 */
	public Session getSession();

	/**
	 * 功能：根据hql语句得到记录总数
	 * 
	 * @param strhql
	 * @return int
	 */
	public int getTotalCount(String strhql);

	/**
	 * 功能：根据sql语句得到记录总数
	 * 
	 * @param strsql
	 * @return int
	 */
	public int getTotalCountBySql(String strsql);

	/**
	 * 功能：根据hql语句得到记录总数
	 * 
	 * @param strhql
	 * @param obj
	 * @return int
	 */
	public int getTotalCount(String strhql, Object obj);
	
	 
	/**
	 * 功能：根据hql语句得到记录总数
	 * @param strhql
	 * @param params
	 * @return int
	 */
	public int getTotalCount(String strhql, List params);
	
	/**
	 * 功能：根据sql语句得到记录总数
	 * @param strsql
	 * @param param
	 * @return
	 */
	public int getTotalCountBySql(String strsql, List params);
	
	 
	 
	/**
	 * 功能：增加记录
	 * 
	 * @param entity
	 */
	public void create(Object entity);

	/**
	 * 功能：修改记录
	 * 
	 * @param entity
	 */
	public void update(Object entity);

	/**
	 * 功能：删除记录
	 * 
	 * @param entity
	 */
	public void delete(Object entity);

	/**
	 * 功能：删除数据
	 * 
	 * @param clazz
	 * @param id
	 */
	public void delete(Class clazz, long id);

	/**
	 * 功能：批量删除数据
	 * 
	 * @param clazz
	 * @param id
	 */
	public void batchDelete(Class clazz, long[] id);

	/**
	 * 功能：删除表中的所有的记录
	 * 
	 * @param clazz
	 */
	public void deleteAll(Class clazz);

	/**
	 * 功能：删除记录集中的所有的记录
	 * 
	 * @param entities
	 */
	public void deleteAll(Collection entities);;

	/**
	 * 功能：通过主键查询记录
	 * 
	 * @param clazz
	 * @param id
	 * @return Object
	 */

	public Object getByPk(Class clazz, int id);

	/**
	 * 功能：通过主键查询记录
	 * 
	 * @param clazz
	 * @param id
	 * @return Object
	 */
	public Object getByPk(Class clazz, long id);

	/**
	 * 功能：通过主键查询记录
	 * 
	 * @param clazz
	 * @param id
	 * @return Object
	 */
	public Object getByPk(Class clazz, String id);

	/**
	 * 功能：通过关键字和值来进行查询
	 * 
	 * @param clazz
	 * @param keyName
	 * @param keyValue
	 * @return 得到的Object是List
	 */
	public Object loadByPk(Class clazz, String keyName, Object keyValue);

	/**
	 * 功能：根据hql查询记录
	 * 
	 * @param strhql
	 * @return List
	 */
	public List find(String strhql);

	/**
	 * 功能：根据hql查询记录
	 * 
	 * @param strhql
	 * @param param
	 * @return List
	 */
	public List find(String strhql, Object param);

	/**
	 * 功能：根据hql查询记录
	 *  
	 * @param strhql
	 * @param name
	 * @param param
	 * @return List
	 */
	public List findByNamedParam(String strhql, String name, Object param);

	
	/**
	 * 功能：SQL查询
	 * @param strsql
	 * @return
	 */
	public List findBySql(String strsql);
	
	/**
	 * 功能：查询符合条件的记录。
	 * @param strsql
	 * @param params
	 * @return
	 */
	public List findBySql(String strsql,List params);  
  
	/**
	 * 功能：分页查询
	 * 
	 * @param pageNo
	 * @param pageSize
	 * @param strhql
	 * @return List
	 */
	public List query(int pageNo, int pageSize, String strhql);

	/**
	 * 功能：分页查询
	 * 
	 * @param pageNo
	 * @param pageSize
	 * @param queryString
	 * @param obj
	 * @return List
	 */
	public List query(int pageNo, int pageSize, String strhql, Object obj);
	
	
	/**
	 * 功能：分页查询
	 * @param pageNo
	 * @param pageSize
	 * @param strhql
	 * @param params
	 * @return
	 */
	public List query(int pageNo, int pageSize, String strhql, List params );

 
	
	/**
	 * 功能：分页查询
	 * 
	 * @param pageNo
	 * @param pageSize
	 * @param strsql
	 * @return List
	 */
	public List queryBySql(int pageNo, int pageSize, String strsql); 

	/**
	 * 功能：分页查询
	 * @param pageNo
	 * @param pageSize
	 * @param strsql
	 * @param params
	 * @return
	 */
	public List queryBySql(int pageNo, int pageSize, String strsql, List params) ;
	
	 
	/**
	 * 功能：执行SQL语句，主要是更新与删除记录的SQL语句，不需要返回值的
	 * 
	 * @param strsql
	 */
	public void excuteSql(String strsql);
	
}

BaseDao

Java代码

1. /** 
2.  *  
3.  */  
4. package zhenjw.hibernate.dao;  
5.   
6. import java.util.Collection;  
7. import java.util.Iterator;  
8. import java.util.List;  
9.   
10. import org.apache.log4j.Logger;  
11. import org.hibernate.Query;  
12. import org.hibernate.SQLQuery;  
13. import org.hibernate.Session;  
14. import org.hibernate.SessionFactory;  
15. import org.hibernate.Transaction;  
16. import org.hibernate.criterion.Restrictions;  
17.   
18. import zhenjw.hibernate.HibernateSessionFactory;  
19.   
20.   
21. /** 
22.  * @author zhenjw 
23.  * 
24.  */  
25. public class BaseDao implements IBaseDao {  
26.       
27.     private Logger logger = Logger.getLogger(this.getClass());  
28.   
29.     // private Messages Messages=new Messages();  
30.   
31.     private String databeaseError = Messages  
32.             .getString("BaseDao.databeaseError");  
33.   
34.     private SessionFactory sessionFactory;  
35.       
36.   
37.     /* (non-Javadoc) 
38.      * @see zhenjw.hibernate.dao.IBaseDao#batchDelete(java.lang.Class, long[]) 
39.      */  
40.     public void batchDelete(Class clazz, long[] id) {  
41.         // TODO Auto-generated method stub  
42.           
43.         String strId = "";  
44.           
45.         for (int i = 0; i < id.length; i++) {  
46.               
47.             if (i > 0)  
48.                   
49.                 strId += ", " + id[i];  
50.               
51.             else  
52.                   
53.                 strId = "" + id[i];  
54.               
55.         }  
56.         logger.debug("batchDelete(Class, long[])  id[]={" + strId + "}");  
57.           
58.         for (int i = 0; i < id.length; i++) {  
59.               
60.             this.delete(clazz, id[i]);  
61.               
62.         }  
63.   
64.   
65.     }  
66.   
67.     /* (non-Javadoc) 
68.      * @see zhenjw.hibernate.dao.IBaseDao#create(java.lang.Object) 
69.      */  
70.     public void create(Object entity) {  
71.         // TODO Auto-generated method stub  
72.           
73.         Session session = null;  
74.           
75.         Transaction tr = null;  
76.           
77.         boolean commitflag=false;  
78.           
79.         try {  
80.             session = this.getSession();  
81.               
82.             tr = session.beginTransaction();   
83.               
84.             session.save(entity);  
85.               
86.             tr.commit();  
87.               
88.             commitflag=true;  
89.               
90.             session.flush();  
91.               
92.             session.clear();  
93.               
94.             // super.getHibernateTemplate().save(entity);  
95.               
96.             logger.debug("保存" + entity.getClass().getName() + " 的实例到数据库成功！");  
97.   
98.         } catch (Exception e) {   
99.               
100.                   
101.             String error = Messages.getString("BaseDao.create.saveError");  
102.               
103.             logger.debug("保存" + entity.getClass().getName() + " 的实例到数据库 ,"  
104.                         + error, e);  
105.               
106.             e.printStackTrace();  
107.               
108.             throw new DaoException(error);  
109.               
110.         } finally {  
111.               
112.             if(!commitflag)  
113.             {  
114.                 try{  
115.                       
116.                     if (tr != null)  
117.                           
118.                         tr.rollback();  
119.                       
120.                 }catch(Exception e1)  
121.                 {  
122.                           
123.                     logger.debug("事务",e1);  
124.                       
125.                 }  
126.             }  
127.               
128.             this.closeSession(session);  
129.   
130.         }  
131.   
132.   
133.     }  
134.   
135.     /* (non-Javadoc) 
136.      * @see zhenjw.hibernate.dao.IBaseDao#delete(java.lang.Object) 
137.      */  
138.     public void delete(Object entity) {  
139.         // TODO Auto-generated method stub  
140.           
141.         logger.debug("delete(Object) entity.class="  
142.                 + entity.getClass().getName());   
143.           
144.         Session session = null;  
145.           
146.         Transaction tr = null;  
147.           
148.         boolean commitflag=false;  
149.           
150.         try {  
151.   
152.             session = this.getSession();  
153.               
154.             tr = session.getTransaction();  
155.               
156.             tr.begin();  
157.               
158.             session.delete(entity);  
159.               
160.             tr.commit();  
161.               
162.             commitflag=true;  
163.               
164.             session.flush();  
165.               
166.             session.clear();  
167.   
168.         } catch (Exception e) {  
169.               
170.             if (tr != null)  
171.                   
172.                 tr.rollback();  
173.               
174.             String Error = Messages.getString("BaseDao.delete.Error");  
175.   
176.             logger.debug(Error + " Class=" + entity.getClass().getName(), e);  
177.               
178.             throw new DaoException(Error);  
179.         } finally {  
180.               
181.             if(!commitflag)  
182.             {  
183.                 try  
184.                 {  
185.                     if (tr != null)  
186.                           
187.                         tr.rollback();  
188.                       
189.                 }catch(Exception e)  
190.                 {  
191.                     e.printStackTrace();  
192.                 }  
193.             }  
194.               
195.             this.closeSession(session);  
196.               
197.         }  
198.   
199.     }  
200.   
201.     /* (non-Javadoc) 
202.      * @see zhenjw.hibernate.dao.IBaseDao#delete(java.lang.Class, long) 
203.      */  
204.     public void delete(Class clazz, long id) {  
205.         // TODO Auto-generated method stub  
206.           
207.         logger.debug("ClassName=" + clazz.getName() + "  ,id=" + id);  
208.           
209.         try {  
210.   
211.             Object entity = this.getByPk(clazz, id);  
212.               
213.             if (entity != null)  
214.                   
215.                 this.delete(entity);  
216.               
217.             else  
218.                   
219.                 logger.debug(clazz.getName() + " 的关键字为 " + id + "  的对象不存在 ");  
220.   
221.         } catch (Exception e) {  
222.               
223.             logger.debug("  delete(Class, long)  excute is error  . Error="  
224.                     + e.toString());  
225.               
226.             throw new DaoException(Messages.getString("BaseDao.delete.Error"));  
227.   
228.         }  
229.   
230.     }  
231.   
232.     /* (non-Javadoc) 
233.      * @see zhenjw.hibernate.dao.IBaseDao#deleteAll(java.lang.Class) 
234.      */  
235.     public void deleteAll(Class clazz) {  
236.         // TODO Auto-generated method stub  
237.           
238.         logger.debug("deleteAll(Class) ClassName=" + clazz.getName());   
239.           
240.         Session session = null;  
241.           
242.         Transaction tr = null;  
243.           
244.         boolean commitflag=false;  
245.   
246.         try {  
247.                           
248.             session = this.getSession();  
249.               
250.             tr = session.beginTransaction();  
251.               
252.             Query query = session.createQuery(" delete   from "  
253.                     + clazz.getName());  
254.               
255.             query.executeUpdate();  
256.               
257.             tr.commit();  
258.               
259.             commitflag=true;  
260.               
261.             session.flush();  
262.               
263.         } catch (Exception e) {   
264.               
265.             String Error = Messages.getString("BaseDao.delete.Error");  
266.               
267.             logger.debug("从数据库中删除" + clazz.getName() + "的所有实例失败！", e);  
268.               
269.             throw new DaoException(Error);  
270.               
271.         } finally {  
272.               
273.             if(!commitflag)  
274.             {  
275.                 try  
276.                 {  
277.                     if (tr != null)  
278.                           
279.                         tr.rollback();  
280.                       
281.                 }catch(Exception e)  
282.                 {  
283.                     e.printStackTrace();  
284.                 }  
285.             }  
286.               
287.             this.closeSession(session);  
288.               
289.         }  
290.   
291.     }  
292.   
293.     /* (non-Javadoc) 
294.      * @see zhenjw.hibernate.dao.IBaseDao#deleteAll(java.util.Collection) 
295.      */  
296.     public void deleteAll(Collection entities) {  
297.         // TODO Auto-generated method stub  
298.           
299.         Session session = null;  
300.           
301.         Transaction tr = null;  
302.           
303.         boolean commitflag=false;  
304.           
305.         try {  
306.               
307.             session = this.getSession();  
308.               
309.             tr = session.beginTransaction();  
310.               
311.             Iterator ite = entities.iterator();  
312.               
313.   
314.             while (ite.hasNext())  
315.                   
316.                 session.delete(ite.next());  
317.               
318.             // super.getHibernateTemplate().deleteAll(entities);  
319.             tr.commit();  
320.               
321.             commitflag=true;  
322.               
323.             session.flush();  
324.               
325.   
326.         } catch (Exception e) {   
327.               
328.             String error = Messages.getString("BaseDao.deleteAll.Error");  
329.               
330.             logger.debug(error, e);  
331.               
332.             throw new DaoException(error);  
333.               
334.         } finally {  
335.               
336.             if(!commitflag)  
337.             {  
338.                 try  
339.                 {  
340.                     if (tr != null)  
341.                           
342.                         tr.rollback();  
343.                       
344.                 }catch(Exception e)  
345.                 {  
346.                     e.printStackTrace();  
347.                 }  
348.             }  
349.               
350.             this.closeSession(session);  
351.               
352.         }  
353.           
354.           
355.   
356.     }  
357.   
358.     /* (non-Javadoc) 
359.      * @see zhenjw.hibernate.dao.IBaseDao#excuteSql(java.lang.String) 
360.      */  
361.     public void excuteSql(String strsql) {  
362.         // TODO Auto-generated method stub  
363.           
364.         logger.debug("excuteSql(String) strsql=" + strsql);  
365.           
366.         Session session = null;  
367.           
368.         Transaction tr = null;  
369.           
370.         boolean commitflag=false;  
371.           
372.         try {  
373.               
374.             session = this.getSession();  
375.               
376.             tr = session.beginTransaction();  
377.               
378.             SQLQuery query = session.createSQLQuery(strsql);  
379.               
380.               
381.             query.executeUpdate();  
382.               
383.             tr.commit();  
384.               
385.             commitflag=true;  
386.               
387.             session.flush();  
388.               
389.             // super.getHibernateTemplate().update(entity);  
390.   
391.         } catch (Exception e) {  
392.               
393.                
394.               
395.             String Error = Messages.getString("BaseDao.excuteSql.Error");  
396.               
397.             logger.debug(Error, e);  
398.               
399.             throw new DaoException(Error);  
400.               
401.         } finally {  
402.               
403.             if(!commitflag)  
404.             {  
405.                 try  
406.                 {  
407.                     if (tr != null)  
408.                           
409.                         tr.rollback();  
410.                       
411.                 }catch(Exception e)  
412.                 {  
413.                     e.printStackTrace();  
414.                 }  
415.             }  
416.               
417.             this.closeSession(session);  
418.               
419.         }  
420.    
421.           
422.   
423.     }  
424.   
425.     /* (non-Javadoc) 
426.      * @see zhenjw.hibernate.dao.IBaseDao#find(java.lang.String) 
427.      */  
428.     public List find(String strhql) {  
429.         // TODO Auto-generated method stub  
430.           
431.         List result = null;  
432.           
433.         logger.debug("find(String) queryString=" + strhql);  
434.           
435.         Session session = null;  
436.           
437.         try {  
438.               
439.             // result = super.getHibernateTemplate().find(queryString);  
440.               
441.             session = this.getSession();  
442.               
443.             Query query = session.createQuery(strhql);  
444.               
445.             result = query.list();  
446.   
447.         } catch (Exception e) {  
448.               
449.             logger.debug("执行数据库中查询时失败,语句为：" + strhql, e);  
450.               
451.             throw new DaoException(databeaseError);  
452.               
453.         } finally {  
454.               
455.             this.closeSession(session);  
456.               
457.         }  
458.           
459.         return result;   
460.     }  
461.   
462.     /* (non-Javadoc) 
463.      * @see zhenjw.hibernate.dao.IBaseDao#find(java.lang.String, java.lang.Object) 
464.      */  
465.     public List find(String strhql, Object param) {  
466.         // TODO Auto-generated method stub  
467.           
468.         logger.debug("find(String, Object) queryString=" + strhql  
469.                 + " ,param=" + param);  
470.   
471.         List result = null;  
472.           
473.         Session session = null;  
474.           
475.         try {  
476.   
477.             session = this.getSession();  
478.               
479.             Query query = session.createQuery(strhql);  
480.               
481.             query.setParameter(0, param);  
482.               
483.             result = query.list();  
484.   
485.             // result = super.getHibernateTemplate().find(queryString, param);  
486.   
487.         } catch (Exception e) {  
488.               
489.             logger.debug(databeaseError, e);  
490.               
491.             throw new DaoException(databeaseError);  
492.   
493.         } finally {  
494.               
495.             this.closeSession(session);  
496.               
497.         }  
498.           
499.         return result;  
500.            
501.     }  
502.   
503.     /* (non-Javadoc) 
504.      * @see zhenjw.hibernate.dao.IBaseDao#findByNamedParam(java.lang.String, java.lang.String, java.lang.Object) 
505.      */  
506.     public List findByNamedParam(String strhql, String name, Object param) {  
507.         // TODO Auto-generated method stub  
508.   
509.   
510.         logger.debug("findByNamedParam(String, String, Object) strhql="  
511.                 + strhql + "name=" + name + " ,param=" + param);  
512.   
513.         List result = null;  
514.           
515.         Session session = null;  
516.           
517.         try {  
518.             session = this.getSession();  
519.               
520.             Query query = session.createQuery(strhql);  
521.               
522.             query.setParameter(name, param);  
523.               
524.             result = query.list();  
525.   
526.             // result =  
527.             // super.getHibernateTemplate().findByNamedParam(queryString,  
528.             // name, param);  
529.   
530.         } catch (Exception e) {  
531.               
532.             logger.debug(databeaseError, e);  
533.               
534.             throw new DaoException(databeaseError);  
535.   
536.         } finally {  
537.               
538.             this.closeSession(session);  
539.               
540.         }  
541.           
542.         return result;  
543.           
544.     }  
545.   
546.     /* (non-Javadoc) 
547.      * @see zhenjw.hibernate.dao.IBaseDao#findBySql(java.lang.String) 
548.      */  
549.     public List findBySql(String strsql) {  
550.         // TODO Auto-generated method stub  
551.           
552.         logger.debug("exceuteSQL(String) strsql=" + strsql);  
553.           
554.         System.out.println(strsql);  
555.           
556.         Session session = null;  
557.           
558.         List result=null;  
559.           
560.           
561.         try {  
562.               
563.             session = this.getSession();   
564.               
565.             SQLQuery query = session.createSQLQuery(strsql);  
566.               
567.             result=query.list();  
568.               
569.             // super.getHibernateTemplate().update(entity);  
570.   
571.         } catch (Exception e) {   
572.               
573.             String Error = Messages.getString("BaseDao.exceuteSQL.Error");  
574.               
575.             logger.debug(Error, e);  
576.               
577.             throw new DaoException(Error);  
578.               
579.         } finally {  
580.               
581.             this.closeSession(session);  
582.               
583.         }  
584.           
585.         return result;  
586.     }  
587.   
588.     /* (non-Javadoc) 
589.      * @see zhenjw.hibernate.dao.IBaseDao#findBySql(java.lang.String, java.util.List) 
590.      */  
591.     public List findBySql(String strsql, List params) {  
592.         // TODO Auto-generated method stub  
593.   
594.         String paramnameArray="";   
595.            
596.         if(params!=null)  
597.         {  
598.               
599.             for (int i = 0; i < params.size(); i++) {  
600.                       
601.                     if (i > 0)  
602.                           
603.                         paramnameArray += " , " + params.get(i);  
604.                       
605.                     else  
606.                           
607.                         paramnameArray = ""+params.get(i);  
608.                       
609.             }  
610.           
611.         }  
612.           
613.         logger.debug("excuteSql(String, List) strsql="+strsql+" , List="+paramnameArray);  
614.           
615.         System.out.println(strsql);  
616.           
617.         List result =null;  
618.           
619.         Session session = null;  
620.           
621.         try {   
622.               
623.             session = this.getSession();  
624.               
625.               
626.             SQLQuery query = session.createSQLQuery(strsql);  
627.               
628.             if(params!=null)  
629.             {  
630.                 for (int i = 0; i < params.size(); i++) {  
631.                                           
632.                     query.setParameter(i, params.get(i));  
633.                       
634.                 }   
635.             }  
636.               
637.             result  = query.list();  
638.   
639.         } catch (Exception e) {  
640.               
641.             String error = Messages.getString("BaseDao.findBySql.Error");  
642.               
643.             logger.debug(error, e);  
644.               
645.             e.printStackTrace();  
646.               
647.             throw new DaoException(error);  
648.               
649.         } finally {  
650.               
651.             this.closeSession(session);  
652.               
653.         }  
654.           
655.         return result;    
656.           
657.     }  
658.   
659.     /* (non-Javadoc) 
660.      * @see zhenjw.hibernate.dao.IBaseDao#getByPk(java.lang.Class, int) 
661.      */  
662.     public Object getByPk(Class clazz, int id) {  
663.         // TODO Auto-generated method stub  
664.   
665.   
666.         logger.debug("getByPk(Class, Integer) class=" + clazz.getName()  
667.                 + " , ID=" + id);  
668.           
669.         Object result = null;  
670.           
671.         Session session = null;  
672.           
673.         try {  
674.               
675.             session = this.getSession();  
676.               
677.             result = session.get(clazz, new Integer(id));             
678.   
679.         } catch (Exception e) {  
680.               
681.             logger.debug(databeaseError, e);  
682.               
683.             throw new DaoException(databeaseError);  
684.               
685.         } finally {  
686.               
687.             this.closeSession(session);  
688.               
689.         }  
690.   
691.         return result;  
692.           
693.     }  
694.   
695.     /* (non-Javadoc) 
696.      * @see zhenjw.hibernate.dao.IBaseDao#getByPk(java.lang.Class, long) 
697.      */  
698.     public Object getByPk(Class clazz, long id) {  
699.         // TODO Auto-generated method stub  
700.   
701.         logger.debug("getByPk(Class, Long) Class=" + clazz.getName() + ",id="  
702.                 + id);  
703.           
704.         Object result = null;  
705.           
706.         Session session = null;  
707.           
708.         try {  
709.             session = this.getSession();  
710.               
711.             result = session.get(clazz, new Long(id));  
712.               
713.             // (Object) super.getHibernateTemplate().get(clazz, id);  
714.   
715.         } catch (Exception e) {  
716.               
717.             logger.debug(databeaseError, e);  
718.               
719.             throw new DaoException(databeaseError);  
720.               
721.         } finally {  
722.               
723.             this.closeSession(session);  
724.               
725.         }  
726.   
727.         return result;  
728.     }  
729.   
730.     /* (non-Javadoc) 
731.      * @see zhenjw.hibernate.dao.IBaseDao#getByPk(java.lang.Class, java.lang.String) 
732.      */  
733.     public Object getByPk(Class clazz, String id) {  
734.         // TODO Auto-generated method stub  
735.   
736.         logger.debug("getByPk(Class, String) Class=" + clazz.getName() + ",id="  
737.                 + id);  
738.           
739.         Object result = null;  
740.           
741.         Session session = null;  
742.           
743.         try {  
744.   
745.             session = this.getSession();  
746.               
747.             result = session.get(clazz, id);  
748.               
749.             // result = (Object) super.getHibernateTemplate().get(clazz, id);  
750.   
751.         } catch (Exception e) {  
752.               
753.             logger.debug(databeaseError, e);  
754.               
755.             throw new DaoException(databeaseError);  
756.               
757.         } finally {  
758.               
759.             this.closeSession(session);  
760.               
761.         }  
762.   
763.         return result;  
764.           
765.     }  
766.   
767.     /* (non-Javadoc) 
768.      * @see zhenjw.hibernate.dao.IBaseDao#getSession() 
769.      */  
770.     public Session getSession() {  
771.         // TODO Auto-generated method stub  
772.           
773.         return HibernateSessionFactory.getSession();  
774.           
775.     }  
776.   
777.     /* (non-Javadoc) 
778.      * @see zhenjw.hibernate.dao.IBaseDao#getTotalCount(java.lang.String) 
779.      */  
780.     public int getTotalCount(String strhql) {  
781.         // TODO Auto-generated method stub  
782.   
783.         logger.debug("getTotalCount() strhql=" + strhql);  
784.           
785.         int result = 0;  
786.           
787.         Session session = null;  
788.           
789.         try {  
790.               
791.             String strsql = this.getQueryTotalCountString(strhql);  
792.               
793.             session = this.getSession();  
794.               
795.             Query query = session.createQuery(strsql);  
796.               
797.             List list = query.list();  
798.               
799.             result = this.getNum(list);  
800.               
801.         } catch (Exception e) {  
802.   
803.             logger.debug(databeaseError, e);  
804.               
805.             throw new DaoException(databeaseError);  
806.               
807.         } finally {  
808.               
809.             this.closeSession(session);  
810.               
811.         }  
812.           
813.         return result;  
814.           
815.     }  
816.   
817.     /* (non-Javadoc) 
818.      * @see zhenjw.hibernate.dao.IBaseDao#getTotalCount(java.lang.String, java.lang.Object) 
819.      */  
820.     public int getTotalCount(String strhql, Object obj) {  
821.         // TODO Auto-generated method stub  
822.           
823.         logger.debug("getTotalCount(String,Object)  strhql=" + strhql  
824.                 + "" + obj.getClass().getName());  
825.   
826.         int result = 0;  
827.           
828.         Session session = null;  
829.           
830.         try {  
831.               
832.             String strsql = this.getQueryTotalCountString(strhql);  
833.               
834.             //System.out.println(strsql);  
835.               
836.             logger.debug("strsql="+strsql);  
837.               
838.             session = this.getSession();  
839.               
840.             Query query = session.createQuery(strsql);  
841.               
842.             List list = query.setProperties(obj).list();   
843.                   
844.             result = this.getNum(list);  
845.               
846.   
847.         } catch (Exception e) {  
848.               
849.             String error = Messages.getString("BaseDao.getTotalCount.Error");  
850.               
851.             logger.debug(error, e);  
852.               
853.             e.printStackTrace();  
854.               
855.             throw new DaoException(error);  
856.               
857.         } finally {  
858.               
859.             this.closeSession(session);  
860.               
861.         }  
862.           
863.         return result;  
864.     }  
865.   
866.     /* (non-Javadoc) 
867.      * @see zhenjw.hibernate.dao.IBaseDao#getTotalCount(java.lang.String, java.util.List) 
868.      */  
869.     public int getTotalCount(String strhql, List params) {  
870.         // TODO Auto-generated method stub  
871.           
872.         String paramnameArray="";   
873.            
874.         if(params!=null)  
875.         {  
876.               
877.             for (int i = 0; i < params.size(); i++) {  
878.                       
879.                     if (i > 0)  
880.                           
881.                         paramnameArray += " , " + params.get(i);  
882.                       
883.                     else  
884.                           
885.                         paramnameArray = ""+params.get(i);  
886.                       
887.             }  
888.           
889.         }  
890.           
891.         logger.debug("getTotalCount(String, List) strhql="+strhql+" , List="+paramnameArray);  
892.           
893.           
894.         int result = 0;  
895.           
896.         Session session = null;  
897.           
898.         try {  
899.               
900.             String strquery = this.getQueryTotalCountString(strhql);  
901.               
902.             //System.out.println(strsql);  
903.               
904.             session = this.getSession();  
905.               
906.             logger.debug("strquery=="+strquery);  
907.               
908.             Query query = session.createQuery(strquery);  
909.               
910.             if(params!=null)  
911.             {  
912.                 for (int i = 0; i < params.size(); i++) {  
913.                                           
914.                     query.setParameter(i, params.get(i));  
915.                       
916.                 }   
917.             }  
918.               
919.             List list = query.list();  
920.   
921.             result = this.getNum(list);  
922.               
923.   
924.         } catch (Exception e) {  
925.               
926.             String error = Messages.getString("BaseDao.getTotalCount.Error");  
927.               
928.             logger.debug(error, e);  
929.               
930.             e.printStackTrace();  
931.               
932.             throw new DaoException(error);  
933.               
934.         } finally {  
935.               
936.             this.closeSession(session);  
937.               
938.         }  
939.           
940.         return result;    
941.     }  
942.   
943.     /* (non-Javadoc) 
944.      * @see zhenjw.hibernate.dao.IBaseDao#getTotalCountBySql(java.lang.String) 
945.      */  
946.     public int getTotalCountBySql(String strsql) {  
947.         // TODO Auto-generated method stub  
948.           
949.         logger.debug("getTotalCountBySql(String) strsql=" + strsql);  
950.           
951.         int result = 0;  
952.           
953.         Session session = null;  
954.           
955.         try {  
956.               
957.             strsql = this.getQueryTotalCountString(strsql);  
958.               
959.             session = this.getSession();   
960.               
961.             logger.debug("strsql=="+strsql);  
962.               
963.             List list=session.createSQLQuery(strsql).list();  
964.                
965.             result = this.getNum(list);  
966.               
967.         } catch (Exception e) {  
968.   
969.             logger.debug(databeaseError, e);  
970.               
971.             throw new DaoException(databeaseError);  
972.               
973.         } finally {  
974.               
975.             this.closeSession(session);  
976.               
977.         }  
978.           
979.         return result;  
980.            
981.     }  
982.   
983.     /* (non-Javadoc) 
984.      * @see zhenjw.hibernate.dao.IBaseDao#getTotalCountBySql(java.lang.String, java.util.List) 
985.      */  
986.     public int getTotalCountBySql(String strsql, List params) {  
987.         // TODO Auto-generated method stub  
988.           
989.         String paramnameArray="";   
990.            
991.         if(params!=null)  
992.         {  
993.               
994.             for (int i = 0; i < params.size(); i++) {  
995.                       
996.                     if (i > 0)  
997.                           
998.                         paramnameArray += " , " + params.get(i);  
999.                       
1000.                     else  
1001.                           
1002.                         paramnameArray = ""+params.get(i);  
1003.                       
1004.             }  
1005.           
1006.         }  
1007.           
1008.         logger.debug("getTotalCountBySql(String, List) strsql="+strsql+" , List="+paramnameArray);  
1009.           
1010.           
1011.         int result = 0;  
1012.           
1013.         Session session = null;  
1014.           
1015.         try {  
1016.               
1017.             strsql = this.getQueryTotalCountString(strsql);  
1018.               
1019.             logger.debug("strsql=="+strsql);  
1020.               
1021.             session = this.getSession();  
1022.               
1023.             SQLQuery query = session.createSQLQuery(strsql);  
1024.               
1025.             if(params!=null)  
1026.             {  
1027.                 for (int i = 0; i < params.size(); i++) {  
1028.                                           
1029.                     query.setParameter(i, params.get(i));  
1030.                       
1031.                 }   
1032.             }  
1033.               
1034.             List list = query.list();  
1035.   
1036.             result = this.getNum(list);  
1037.               
1038.   
1039.         } catch (Exception e) {  
1040.               
1041.             String error = Messages.getString("BaseDao.getTotalCount.Error");  
1042.               
1043.             logger.debug(error, e);  
1044.               
1045.             e.printStackTrace();  
1046.               
1047.             throw new DaoException(error);  
1048.               
1049.         } finally {  
1050.               
1051.             this.closeSession(session);  
1052.               
1053.         }  
1054.           
1055.         return result;  
1056.            
1057.     }  
1058.   
1059.     /* (non-Javadoc) 
1060.      * @see zhenjw.hibernate.dao.IBaseDao#loadAll(java.lang.String) 
1061.      */  
1062.     public List loadAll(String strhql) {  
1063.         // TODO Auto-generated method stub  
1064.         return this.find(strhql);  
1065.     }  
1066.   
1067.     /* (non-Javadoc) 
1068.      * @see zhenjw.hibernate.dao.IBaseDao#loadByPk(java.lang.Class, java.lang.String, java.lang.Object) 
1069.      */  
1070.     public Object loadByPk(Class clazz, String keyName, Object keyValue) {  
1071.         // TODO Auto-generated method stub  
1072.           
1073.         Object result = null;  
1074.           
1075.         String query = "from " + clazz.getName() + "  where " + keyName + "=? ";  
1076.           
1077.         logger.debug("loadByPk(Class, String, Object) queryString=" + query  
1078.                 + "  ,keyValue=" + keyValue);  
1079.           
1080.         Session session = null;  
1081.           
1082.         try {  
1083.   
1084.             session = this.getSession();  
1085.           
1086.             result = session.createCriteria(clazz).add(  
1087.                     Restrictions.eq(keyName, keyValue)).list();  
1088.               
1089.   
1090.         } catch (Exception e) {  
1091.               
1092.             logger.debug(databeaseError, e);  
1093.               
1094.             throw new DaoException(databeaseError);  
1095.               
1096.         } finally {  
1097.               
1098.             this.closeSession(session);  
1099.               
1100.         }  
1101.           
1102.         return result;        
1103.           
1104.     }  
1105.   
1106.     /* (non-Javadoc) 
1107.      * @see zhenjw.hibernate.dao.IBaseDao#query(int, int, java.lang.String) 
1108.      */  
1109.     public List query(int pageNo, int pageSize, String strhql) {  
1110.         // TODO Auto-generated method stub  
1111.   
1112.         logger.debug("query(int, int, String) pageNo=" + pageNo + ",pageSize="  
1113.                 + pageSize + " ,strhql=" + strhql);  
1114.   
1115.         List result = null;  
1116.           
1117.         Session session = null;  
1118.           
1119.         try {  
1120.             session = this.getSession();  
1121.               
1122.             Query query = session.createQuery(strhql);  
1123.             //System.out.println(queryString);  
1124.               
1125.             if (pageNo > 0 && pageSize > 0) {  
1126.                   
1127.                 query.setFirstResult((pageNo - 1) * pageSize);  
1128.                   
1129.                 query.setMaxResults(pageSize);  
1130.             }  
1131.               
1132.             result = query.list();  
1133.               
1134.             //System.out.println()  
1135.         } catch (Exception e) {  
1136.               
1137.             logger.debug(databeaseError, e);  
1138.               
1139.             throw new DaoException(databeaseError);  
1140.               
1141.         } finally {  
1142.               
1143.             this.closeSession(session);  
1144.               
1145.         }  
1146.           
1147.         return result;  
1148.     }  
1149.   
1150.     /* (non-Javadoc) 
1151.      * @see zhenjw.hibernate.dao.IBaseDao#query(int, int, java.lang.String, java.lang.Object) 
1152.      */  
1153.     public List query(int pageNo, int pageSize, String strhql, Object obj) {  
1154.         // TODO Auto-generated method stub  
1155.   
1156.         logger.debug("query(int, int, String, Object) pageNo=" + pageNo  
1157.                 + ",pageSize=" + pageSize + "strhql="+strhql+"  ,obj"  
1158.                 + obj.getClass().getName());  
1159.           
1160.         List result = null;  
1161.           
1162.         Session session = null;  
1163.           
1164.         try {  
1165.               
1166.             session = this.getSession();  
1167.               
1168.             Query query = session.createQuery(strhql);  
1169.               
1170.             query.setProperties(obj);  
1171.               
1172.             if (pageNo > 0 && pageSize > 0) {  
1173.                   
1174.                 query.setFirstResult((pageNo - 1) * pageSize);  
1175.                   
1176.                 query.setMaxResults(pageSize);  
1177.                   
1178.             }  
1179.               
1180.             result = query.list();  
1181.               
1182.         } catch (Exception e) {  
1183.               
1184.             logger.debug(databeaseError, e);  
1185.               
1186.             throw new DaoException(databeaseError);  
1187.               
1188.         } finally {  
1189.               
1190.             this.closeSession(session);  
1191.               
1192.         }  
1193.           
1194.         return result;  
1195.           
1196.     }  
1197.   
1198.     /* (non-Javadoc) 
1199.      * @see zhenjw.hibernate.dao.IBaseDao#query(int, int, java.lang.String, java.util.List) 
1200.      */  
1201.     public List query(int pageNo, int pageSize, String strhql, List params) {  
1202.         // TODO Auto-generated method stub  
1203.   
1204.         logger.debug("query(int, int, String, Object) pageNo=" + pageNo + ",pageSize=" + pageSize + ",strhql="+strhql);       
1205.           
1206.         String paramnameArray="";  
1207.           
1208.         if(params!=null)  
1209.         {  
1210.               
1211.             for (int i = 0; i < params.size(); i++) {  
1212.                       
1213.                     if (i > 0)  
1214.                           
1215.                         paramnameArray += " , " + params.get(i);  
1216.                       
1217.                     else  
1218.                           
1219.                         paramnameArray = ""+params.get(i);  
1220.                       
1221.             }  
1222.           
1223.         }  
1224.           
1225.         logger.debug("params="+params);  
1226.           
1227.         List result = null;  
1228.           
1229.         Session session = null;  
1230.           
1231.         try {  
1232.               
1233.             session = this.getSession();  
1234.               
1235.             Query query = session.createQuery(strhql);  
1236.               
1237.             if(params!=null)  
1238.             {  
1239.                 for (int i = 0; i < params.size(); i++) {  
1240.                                           
1241.                     query.setParameter(i, params.get(i));  
1242.                       
1243.                 }   
1244.             }  
1245.               
1246.             if (pageNo > 0 && pageSize > 0) {  
1247.                   
1248.                 query.setFirstResult((pageNo - 1) * pageSize);  
1249.                   
1250.                 query.setMaxResults(pageSize);  
1251.                   
1252.             }  
1253.               
1254.             result = query.list();  
1255.               
1256.         } catch (Exception e) {  
1257.               
1258.             logger.debug(databeaseError, e);  
1259.               
1260.             throw new DaoException(databeaseError);  
1261.               
1262.         } finally {  
1263.               
1264.             this.closeSession(session);  
1265.               
1266.         }  
1267.           
1268.         return result;   
1269.           
1270.     }  
1271.   
1272.     /* (non-Javadoc) 
1273.      * @see zhenjw.hibernate.dao.IBaseDao#queryBySql(int, int, java.lang.String) 
1274.      */  
1275.     public List queryBySql(int pageNo, int pageSize, String strsql) {  
1276.         // TODO Auto-generated method stub  
1277.   
1278.   
1279.         logger.debug("query(int, int, String) pageNo=" + pageNo + ",pageSize="  
1280.                 + pageSize + " ,strsql=" + strsql);  
1281.   
1282.         List result = null;  
1283.           
1284.         Session session = null;  
1285.           
1286.         try {  
1287.               
1288.             session = this.getSession();              
1289.               
1290.             SQLQuery query = session.createSQLQuery(strsql);  
1291.               
1292.             if (pageNo > 0 && pageSize > 0) {  
1293.                   
1294.                 query.setFirstResult((pageNo - 1) * pageSize);  
1295.                   
1296.                 query.setMaxResults(pageSize);  
1297.                   
1298.             }  
1299.               
1300.             result = query.list();  
1301.               
1302.         } catch (Exception e) {  
1303.               
1304.             logger.debug(databeaseError, e);  
1305.               
1306.             throw new DaoException(databeaseError);  
1307.               
1308.         } finally {  
1309.               
1310.             this.closeSession(session);  
1311.               
1312.         }  
1313.           
1314.         return result;   
1315.           
1316.     }  
1317.   
1318.     /* (non-Javadoc) 
1319.      * @see zhenjw.hibernate.dao.IBaseDao#queryBySql(int, int, java.lang.String, java.util.List) 
1320.      */  
1321.     public List queryBySql(int pageNo, int pageSize, String strsql, List params) {  
1322.         // TODO Auto-generated method stub  
1323.   
1324.         logger.debug("query(int, int, String, Object) pageNo=" + pageNo + ",pageSize=" + pageSize + " , strsql="+strsql);         
1325.           
1326.         String paramnameArray="";  
1327.           
1328.         if(params!=null)  
1329.         {  
1330.               
1331.             for (int i = 0; i < params.size(); i++) {  
1332.                       
1333.                     if (i > 0)  
1334.                           
1335.                         paramnameArray += " , " + params.get(i);  
1336.                       
1337.                     else  
1338.                           
1339.                         paramnameArray = ""+params.get(i);  
1340.                       
1341.             }  
1342.           
1343.         }  
1344.           
1345.         logger.debug("params="+params);  
1346.           
1347.         List result = null;  
1348.           
1349.         Session session = null;  
1350.           
1351.         try {  
1352.               
1353.             session = this.getSession();  
1354.               
1355.             SQLQuery query = session.createSQLQuery(strsql);  
1356.               
1357.             if(params!=null)  
1358.             {  
1359.                 for (int i = 0; i < params.size(); i++) {  
1360.                                           
1361.                     query.setParameter(i, params.get(i));  
1362.                       
1363.                 }   
1364.             }  
1365.               
1366.             if (pageNo > 0 && pageSize > 0) {  
1367.                   
1368.                 query.setFirstResult((pageNo - 1) * pageSize);  
1369.                   
1370.                 query.setMaxResults(pageSize);  
1371.                   
1372.             }  
1373.               
1374.             result = query.list();  
1375.               
1376.         } catch (Exception e) {  
1377.               
1378.             logger.debug(databeaseError, e);  
1379.               
1380.             throw new DaoException(databeaseError);  
1381.               
1382.         } finally {  
1383.               
1384.             this.closeSession(session);  
1385.               
1386.         }  
1387.         return result;   
1388.           
1389.     }  
1390.   
1391.     /* (non-Javadoc) 
1392.      * @see zhenjw.hibernate.dao.IBaseDao#update(java.lang.Object) 
1393.      */  
1394.     public void update(Object entity) {  
1395.         // TODO Auto-generated method stub  
1396.           
1397.         logger.debug("update(Object) entity.class="  
1398.                 + entity.getClass().getName());  
1399.           
1400.         Session session = null;  
1401.           
1402.         Transaction tr = null;  
1403.           
1404.         try {  
1405.             session = this.getSession();  
1406.               
1407.             tr = session.beginTransaction();  
1408.               
1409.             session.update(entity);  
1410.               
1411.             tr.commit();  
1412.               
1413.             session.flush();  
1414.               
1415.             session.clear();  
1416.               
1417.             // super.getHibernateTemplate().update(entity);  
1418.   
1419.         } catch (Exception e) {  
1420.               
1421.             if (tr != null)  
1422.                   
1423.                 tr.rollback();  
1424.               
1425.             String Error = Messages.getString("BaseDao.update.Error");  
1426.               
1427.             logger.debug(Error, e);  
1428.               
1429.             throw new DaoException(Error);  
1430.               
1431.         } finally {  
1432.               
1433.             this.closeSession(session);  
1434.               
1435.         }  
1436.   
1437.     }  
1438.       
1439.     /** 
1440.      * 功能：关闭session 
1441.      * @param session 
1442.      */  
1443.     protected void closeSession(Session session) {  
1444.   
1445.         if (session != null && session.isOpen())  
1446.               
1447.             session.close();  
1448.           
1449.         session = null;  
1450.           
1451.     }  
1452.       
1453.     /** 
1454.      * 功能：得到查询记录总数的语句（包含sql与hql） 
1455.      * @param queryString 
1456.      * @return 
1457.      */  
1458.     private String getQueryTotalCountString(String queryString) {  
1459.   
1460.         int form_index = queryString.indexOf("from ");  
1461.           
1462.         int orderby_index = queryString.indexOf(" order by ");  
1463.           
1464.         if (form_index < 0) {  
1465.               
1466.             throw new DaoException(Messages  
1467.                     .getString("BaseDao.getTotalCount.notFromkeyword"));  
1468.           
1469.         }  
1470.           
1471.         String strsql = " select count(*) ";  
1472.           
1473.         if (orderby_index > -1) {  
1474.               
1475.             strsql = strsql + queryString.substring(form_index, orderby_index);  
1476.   
1477.         } else {  
1478.               
1479.             strsql = strsql + queryString.substring(form_index);  
1480.         }  
1481.   
1482.         return strsql;  
1483.     }  
1484.       
1485.     /** 
1486.      * 功能：得到记录数的方法 
1487.      * @param list 
1488.      * @return 
1489.      */  
1490.     protected int getNum(List list)  
1491.     {  
1492.           
1493.         int result=0;  
1494.           
1495.         if (list != null || list.size() > 0)   
1496.               
1497.             result = Integer.parseInt(list.get(0).toString());  
1498.           
1499.          return result;  
1500.     }  
1501.       
1502.   
1503.   
1504. }