万能DAO

首先，先看下类图：（在这篇文章已经发过了http://lym6520.iteye.com/admin/blogs/421504）
我补充了Query层来存放hql或sql，如下：


现在我们来看下IBaseDao.java文件：

Java代码  

1. package lym.dao.base.hibernate;   
2.   
3. import java.io.Serializable;   
4. import java.util.Collection;   
5. import java.util.List;   
6.   
7. import lym.dao.obj.AbstractHandleObj;   
8.   
9. import org.hibernate.type.Type;   
10.   
11. /**  
12.  * 基础Dao接口,定义通用的操作  
13.  * @author 林元脉  
14.  * @version v1.1 2009/07/17  
15.  *  
16.  */  
17. public interface IBaseDao {   
18.   
19.     /**  
20.      * 对于返回列表的方法，通过调用我来实现返回记录数的控制，  
21.      * 设置返回记录数，若top为0不设置  
22.      */  
23.     public void setMaxResults(int top);   
24.        
25.     /**  
26.      * 保存AbstractHandleObj实体  
27.      * @param hobj 继承AbstractHandleObj抽象类的实体  
28.      * @return Serializable 主键  
29.      */  
30.     public Serializable save(AbstractHandleObj hobj);   
31.        
32.     /**  
33.      * 更新AbstractHandleObj实体  
34.      * @param hobj 继承AbstractHandleObj抽象类的实体    
35.      */  
36.     public void update(AbstractHandleObj hobj);   
37.        
38.     /**  
39.      * 保存或更新AbstractHandleObj实体  
40.      * @param hobj 继承AbstractHandleObj抽象类的实体  
41.      */  
42.     public void saveOrUpdate(AbstractHandleObj hobj);   
43.        
44.     /**  
45.      * 保存或跟新实体集合Collection<AbstractHandleObj>  
46.      * 若实体已经存（根据主键判断）在则更新实体，则保存实体  
47.      * @param hobjList 继承AbstractHandleObj抽象类的实体集合  
48.      */  
49.     public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList);   
50.        
51.     /**  
52.      * 删除AbstractHandleObj实体  
53.      * @param hobj 继承AbstractHandleObj抽象类的实体  
54.      */  
55.     public void delete(AbstractHandleObj hobj);   
56.        
57.     /**  
58.      * 删除Collection<AbstractHandleObj>集合实体  
59.      * @param hobjList 继承AbstractHandleObj抽象类的实体集合  
60.      */  
61.     public void deleteAll(Collection<AbstractHandleObj> hobjList);   
62.        
63.     /**  
64.      * 根据主键值获得继承AbstractHandleObj的实体  
65.      * @param entityName 继承AbstractHandleObj抽象类的实体名称(注：包含包名)  
66.      * @param id 实体主键  
67.      * @return AbstractHandleObj  
68.      */  
69.     public AbstractHandleObj findByID(String entityName, String id);   
70.        
71.     /**  
72.      * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型  
73.      * @param hql HQL查询语句  
74.      * @return List<AbstractHandleObj>  
75.      */  
76.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql);   
77.        
78.     /**  
79.      * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型  
80.      * @param hql HQL查询语句  
81.      * @param obj 查询参数，匹配站位符?  
82.      * @return List<AbstractHandleObj>  
83.      */  
84.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj);   
85.        
86.     /**  
87.      * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型  
88.      * @param hql HQL查询语句  
89.      * @param objs 查询参数数组，按顺序匹配站位符?  
90.      * @return List<AbstractHandleObj>  
91.      */  
92.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs);   
93.        
94.     /**  
95.      * 根据hql语句查找某些列，返回List<Object[]>类型  
96.      * @param hql HQL查询语句  
97.      * @return List<Object[]>  
98.      */  
99.     public List<Object[]> findColsByHqlQuery(String hql);   
100.        
101.     /**  
102.      * 根据hql语句查找某些列，返回List<Object[]>类型  
103.      * @param hql HQL查询语句  
104.      * @param obj 查询参数，匹配站位符?  
105.      * @return List<Object[]>  
106.      */  
107.     public List<Object[]> findColsByHqlQuery(String hql, Object obj);   
108.        
109.     /**  
110.      * 根据hql语句查找某些列，返回List<Object[]>类型  
111.      * @param hql HQL查询语句  
112.      * @param objs 查询参数数组，按顺序匹配站位符?  
113.      * @return List<Object[]>  
114.      */  
115.     public List<Object[]> findColsByHqlQuery(String hql, Object[] objs) ;   
116.        
117.     /**  
118.      * 根据hql语句查找某些列，返回List<Object>类型  
119.      * @param hql HQL查询语句  
120.      * @return List<Object>  
121.      */  
122.     public List<Object> findColByHqlQuery(String hql) ;   
123.        
124.     /**  
125.      * 根据hql语句查找某些列，返回List<Object>类型  
126.      * @param hql HQL查询语句  
127.      * @param obj 查询参数，匹配站位符?  
128.      * @return List<Object>  
129.      */  
130.     public List<Object> findColByHqlQuery(String hql, Object obj);   
131.        
132.     /**  
133.      * 根据hql语句查找某些列，返回List<Object>类型  
134.      * @param hql HQL查询语句  
135.      * @param objs 查询参数数组，按顺序匹配站位符?  
136.      * @return List<Object>  
137.      */  
138.     public List<Object> findColByHqlQuery(String hql, Object[] objs);   
139.        
140.     /**  
141.      * 根据hql语句查找某些列，返回List<String[]>类型,支持分页  
142.      * @param hql HQL查询语句  
143.      * @param start 查找记录数其实位置（从0开始）  
144.      * @param reCount  要返回的记录数（页显示记录数）  
145.      * @return List<Object[]>  
146.      */  
147.     public List<Object[]> findColsByHqlQuerySupportPaging(String hql, int start, int reCount);   
148.        
149.     /**  
150.      * 根据hql语句查找某些列，返回List<String[]>类型,支持分页  
151.      * @param hql HQL查询语句  
152.      * @param objs 查询参数数组，按顺序匹配站位符?  
153.      * @param types  查询参数类型数组，按顺序对应objs中的参数类型  
154.      *          注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等  
155.      * @param start 查找记录数其实位置（从0开始）  
156.      * @param reCount  要返回的记录数（页显示记录数）  
157.      * @return List<Object[]>  
158.      */  
159.     public List<Object[]> findColsByHqlQuerySupportPaging(String hql, Object[] objs,   
160.             Type[] types, int start, int reCount);   
161.        
162.     /**  
163.      * 根据hql语句查找，获得记录数  
164.      * 例如：select count(*) from T  
165.      * @param hql HQL查询语句  
166.      * @return long  
167.      */  
168.     public long getRecordCountByHqlQuery(String hql) ;   
169.        
170.     /**  
171.      * 根据hql语句查找，获得记录数  
172.      * 例如：select count(*) from T where ...  
173.      * @param hql HQL查询语句  
174.      * @param obj 查询参数，匹配站位符?  
175.      * @return long  
176.      */  
177.     public long getRecordCountByHqlQuery(String hql, Object obj) ;   
178.        
179.     /**  
180.      * 根据hql语句查找，获得记录数  
181.      * 例如：select count(*) from T where ...  
182.      * @param hql  
183.      * @param objs 查询参数数组，按顺序匹配站位符?  
184.      * @return long  
185.      */  
186.     public long getRecordCountByHqlQuery(String hql, Object[] objs) ;   
187.        
188.     /**  
189.      * 执行更新update/删除delete操作  
190.      * @param hql  
191.      * @return int 更新数量/删除数量  
192.      */  
193.     public int executeHqlQuery(String hql) ;   
194.        
195.     /**  
196.      * 执行更新update/删除delete操作  
197.      * @param hql  
198.      * @param obj 查询参数，匹配站位符?  
199.      * @return int 更新数量/删除数量  
200.      */  
201.     public int executeHqlQuery(String hql, Object obj);   
202.        
203.     /**  
204.      * 执行更新update/删除delete操作  
205.      * @param hql  
206.      * @param objs 查询参数数组，按顺序匹配站位符?  
207.      * @return int 更新数量/删除数量  
208.      */  
209.     public int executeHqlQuery(String hql, Object[] objs) ;   
210.        
211.     /**  
212.      * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页  
213.      * @param hql HQL查询语句  
214.      * @param start 查找记录数其实位置（从0开始）  
215.      * @param reCount  要返回的记录数（页显示记录数）  
216.      * @return  List<AbstractHandleObj>  
217.      */  
218.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql,    
219.             int start, int reCount);    
220.        
221.     /**  
222.      * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页  
223.      * @param hql HQL查询语句  
224.      * @param objs 查询参数数组，按顺序匹配站位符?  
225.      * @param types  查询参数类型数组，按顺序对应objs中的参数类型  
226.      *          注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等  
227.      * @param start 查找记录数其实位置（从0开始）  
228.      * @param reCount  要返回的记录数（页显示记录数）  
229.      * @return List<AbstractHandleObj>  
230.      */  
231.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, Object[] objs,   
232.             Type[] types, int start, int reCount) ;   
233.        
234.     /**  
235.      * 支持SQL查询，根据sql语句查找某些列，返回List<String[]>类型  
236.      * @param sql SQL查询语句  
237.      * @return List<Object[]>  
238.      */  
239.     public List<Object[]> findColsBySqlQuery(String sql) ;   
240.        
241.     /**  
242.      * 支持SQL查询，根据sql语句查找某列，返回List<Object>类型  
243.      * @param sql SQL查询语句  
244.      * @return List<Object>  
245.      */  
246.     public List<Object> findColBySqlQuery(String sql) ;   
247.        
248.     /**  
249.      * 支持SQL操作，执行sql语句update/delete/存储过程  
250.      * @param sql SQL语句  
251.      * @return int  
252.      */  
253.     public int executeSqlQuery(String sql) ;   
254.        
255. }  

package lym.dao.base.hibernate;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

import lym.dao.obj.AbstractHandleObj;

import org.hibernate.type.Type;

/**
 * 基础Dao接口,定义通用的操作
 * @author 林元脉
 * @version v1.1 2009/07/17
 *
 */
public interface IBaseDao {

	/**
	 * 对于返回列表的方法，通过调用我来实现返回记录数的控制，
	 * 设置返回记录数，若top为0不设置
	 */
	public void setMaxResults(int top);
	
	/**
	 * 保存AbstractHandleObj实体
	 * @param hobj 继承AbstractHandleObj抽象类的实体
	 * @return Serializable 主键
	 */
	public Serializable save(AbstractHandleObj hobj);
	
	/**
	 * 更新AbstractHandleObj实体
	 * @param hobj 继承AbstractHandleObj抽象类的实体  
	 */
	public void update(AbstractHandleObj hobj);
	
	/**
	 * 保存或更新AbstractHandleObj实体
	 * @param hobj 继承AbstractHandleObj抽象类的实体
	 */
	public void saveOrUpdate(AbstractHandleObj hobj);
	
	/**
	 * 保存或跟新实体集合Collection<AbstractHandleObj>
	 * 若实体已经存（根据主键判断）在则更新实体，则保存实体
	 * @param hobjList 继承AbstractHandleObj抽象类的实体集合
	 */
	public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList);
	
	/**
	 * 删除AbstractHandleObj实体
	 * @param hobj 继承AbstractHandleObj抽象类的实体
	 */
	public void delete(AbstractHandleObj hobj);
	
	/**
	 * 删除Collection<AbstractHandleObj>集合实体
	 * @param hobjList 继承AbstractHandleObj抽象类的实体集合
	 */
	public void deleteAll(Collection<AbstractHandleObj> hobjList);
	
	/**
	 * 根据主键值获得继承AbstractHandleObj的实体
	 * @param entityName 继承AbstractHandleObj抽象类的实体名称(注：包含包名)
	 * @param id 实体主键
	 * @return AbstractHandleObj
	 */
	public AbstractHandleObj findByID(String entityName, String id);
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
	 * @param hql HQL查询语句
	 * @return List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql);
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql) ;
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql, Object[] objs);
	
	/**
	 * 根据hql语句查找某些列，返回List<String[]>类型,支持分页
	 * @param hql HQL查询语句
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuerySupportPaging(String hql, int start, int reCount);
	
	/**
	 * 根据hql语句查找某些列，返回List<String[]>类型,支持分页
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @param types  查询参数类型数组，按顺序对应objs中的参数类型
	 * 			注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuerySupportPaging(String hql, Object[] objs,
			Type[] types, int start, int reCount);
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T
	 * @param hql HQL查询语句
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql) ;
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T where ...
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql, Object obj) ;
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T where ...
	 * @param hql
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql) ;
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @param obj 查询参数，匹配站位符?
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql, Object obj);
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页
	 * @param hql HQL查询语句
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return  List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, 
			int start, int reCount); 
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @param types  查询参数类型数组，按顺序对应objs中的参数类型
	 * 			注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, Object[] objs,
			Type[] types, int start, int reCount) ;
	
	/**
	 * 支持SQL查询，根据sql语句查找某些列，返回List<String[]>类型
	 * @param sql SQL查询语句
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsBySqlQuery(String sql) ;
	
	/**
	 * 支持SQL查询，根据sql语句查找某列，返回List<Object>类型
	 * @param sql SQL查询语句
	 * @return List<Object>
	 */
	public List<Object> findColBySqlQuery(String sql) ;
	
	/**
	 * 支持SQL操作，执行sql语句update/delete/存储过程
	 * @param sql SQL语句
	 * @return int
	 */
	public int executeSqlQuery(String sql) ;
	
}

看下实现类BaseDaoImpl.java：

Java代码  

1. package lym.dao.base.hibernate;   
2.   
3. import java.io.Serializable;   
4. import java.sql.SQLException;   
5. import java.util.ArrayList;   
6. import java.util.Collection;   
7. import java.util.List;   
8.   
9. import lym.dao.obj.AbstractHandleObj;   
10.   
11. import org.hibernate.HibernateException;   
12. import org.hibernate.Query;   
13. import org.hibernate.Session;   
14. import org.hibernate.type.Type;   
15. import org.springframework.orm.hibernate3.HibernateCallback;   
16. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;   
17.   
18.   
19.   
20. /**  
21.  * 基础Dao接口,实现通用操作  
22.  * @author 林元脉  
23.  * @version v1.1 2009/07/17  
24.  *  
25.  */  
26. public class BaseDaoImpl extends HibernateDaoSupport implements IBaseDao {   
27.        
28.        
29.     /**  
30.      * 对于返回列表的方法，通过调用我来实现返回记录数的控制，  
31.      * 设置返回记录数，若top为0不设置  
32.      */  
33.     public void setMaxResults(int top){    
34.         if(top > 0){   
35.             getHibernateTemplate().setMaxResults(top);   
36.         }          
37.     }   
38.        
39.     public Serializable save(AbstractHandleObj hobj){   
40.         return getHibernateTemplate().save(hobj);          
41.     }   
42.   
43.     public void update(AbstractHandleObj hobj) {   
44.         getHibernateTemplate().update(hobj);           
45.        
46.     }   
47.        
48.     public void saveOrUpdate(AbstractHandleObj hobj) {   
49.         getHibernateTemplate().saveOrUpdate(hobj);   
50.            
51.     }   
52.            
53.     public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList) {   
54.         getHibernateTemplate().saveOrUpdateAll(hobjList);                  
55.     }   
56.        
57.     public void delete(AbstractHandleObj hobj) {   
58.         getHibernateTemplate().delete(hobj);               
59.     }   
60.        
61.     public void deleteAll(Collection<AbstractHandleObj> hobjList) {   
62.         getHibernateTemplate().deleteAll(hobjList);        
63.     }   
64.        
65.     public AbstractHandleObj findByID(String entityName, String id)   
66.         {   
67.         return (AbstractHandleObj) getHibernateTemplate().get(entityName, id);             
68.     }   
69.        
70.     @SuppressWarnings("unchecked")     
71.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql)    
72.         {      
73.         List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();   
74.         resultList = getHibernateTemplate().find(hql);   
75.         return resultList;   
76.     }   
77.   
78.     @SuppressWarnings("unchecked")     
79.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj)    
80.         {          
81.         List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();   
82.         resultList = getHibernateTemplate().find(hql, obj);   
83.         return resultList;             
84.     }   
85.   
86.     @SuppressWarnings("unchecked")     
87.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs)    
88.         {          
89.         List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();   
90.         resultList = getHibernateTemplate().find(hql, objs);   
91.         return resultList;         
92.     }      
93.        
94.     @SuppressWarnings("unchecked")     
95.     public List<Object[]> findColsByHqlQuery(String hql)    
96.         {          
97.         List<Object[]> resultList = getHibernateTemplate().find(hql);   
98.         return resultList;         
99.     }   
100.   
101.     @SuppressWarnings("unchecked")     
102.     public List<Object[]> findColsByHqlQuery(String hql, Object obj)    
103.         {          
104.         List<Object[]> resultList = getHibernateTemplate().find(hql, obj);   
105.         return resultList;   
106.     }   
107.   
108.     @SuppressWarnings("unchecked")     
109.     public List<Object[]> findColsByHqlQuery(String hql, Object[] objs)   
110.         {          
111.         List<Object[]> resultList = getHibernateTemplate().find(hql, objs);   
112.         return resultList;         
113.     }   
114.        
115.     @SuppressWarnings("unchecked")     
116.     public List<Object> findColByHqlQuery(String hql)    
117.         {          
118.         List<Object> resultList = getHibernateTemplate().find(hql);   
119.         return resultList;   
120.     }   
121.   
122.     @SuppressWarnings("unchecked")     
123.     public List<Object> findColByHqlQuery(String hql, Object obj)    
124.         {          
125.         List<Object> resultList = getHibernateTemplate().find(hql, obj);   
126.         return resultList;         
127.     }   
128.   
129.     @SuppressWarnings("unchecked")     
130.     public List<Object> findColByHqlQuery(String hql, Object[] objs)    
131.         {          
132.         List<Object> resultList = getHibernateTemplate().find(hql, objs);   
133.         return resultList;         
134.     }   
135.        
136.     @SuppressWarnings("unchecked")     
137.     public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,final int start,    
138.             final int reCount) {   
139.         List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){   
140.             public Object doInHibernate(Session session)   
141.                     throws HibernateException, SQLException {   
142.                 Query query = session.createQuery(hql);   
143.                 query.setFirstResult(start);   
144.                 query.setMaxResults(reCount);   
145.                    
146.                 return query.list();   
147.             }                  
148.         });   
149.         return resultList;         
150.     }   
151.        
152.     @SuppressWarnings("unchecked")     
153.     public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,   
154.             final Object[] objs, final Type[] types, final int start, final int reCount)    
155.             {   
156.         List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){   
157.                 public Object doInHibernate(Session session)   
158.                         throws HibernateException, SQLException {   
159.                     Query query = session.createQuery(hql);   
160.                     /*设置参数*/  
161.                     query.setParameters(objs, types);   
162.                     query.setFirstResult(start);   
163.                     query.setMaxResults(reCount);   
164.                        
165.                     return query.list();   
166.                 }                  
167.             });   
168.             return resultList;         
169.     }   
170.        
171.     public long getRecordCountByHqlQuery(String hql) {   
172.         long recordCount = (Long) getHibernateTemplate().find(hql).get(0);   
173.         return recordCount;        
174.     }   
175.        
176.     public long getRecordCountByHqlQuery(String hql, Object obj) {   
177.         long recordCount = (Long) getHibernateTemplate().find(hql, obj).get(0);   
178.         return recordCount;        
179.     }   
180.        
181.     public long getRecordCountByHqlQuery(String hql, Object[] objs) {   
182.         long recordCount = (Long) getHibernateTemplate().find(hql, objs).get(0);   
183.         return recordCount;        
184.     }   
185.        
186.     public int executeHqlQuery(String hql) {   
187.         return getHibernateTemplate().bulkUpdate(hql);             
188.     }   
189.        
190.     public int executeHqlQuery(String hql, Object obj) {   
191.         return getHibernateTemplate().bulkUpdate(hql, obj);   
192.     }   
193.   
194.     public int executeHqlQuery(String hql, Object[] objs) {   
195.         return getHibernateTemplate().bulkUpdate(hql, objs);               
196.     }   
197.   
198.     @SuppressWarnings("unchecked")   
199.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql,   
200.             final int start, final int reCount) {   
201.         List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){   
202.                 public Object doInHibernate(Session session)   
203.                         throws HibernateException, SQLException {   
204.                     Query query = session.createQuery(hql);   
205.                     query.setFirstResult(start);   
206.                     query.setMaxResults(reCount);   
207.                        
208.                     return query.list();   
209.                 }                  
210.             });   
211.             return resultList;         
212.     }   
213.   
214.     @SuppressWarnings("unchecked")   
215.     public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql, final Object[] objs,   
216.             final Type[] types, final int start, final int reCount) {   
217.         List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){   
218.                 public Object doInHibernate(Session session)   
219.                         throws HibernateException, SQLException {   
220.                     Query query = session.createQuery(hql);   
221.                     /*设置参数*/  
222.                     query.setParameters(objs, types);   
223.                     query.setFirstResult(start);   
224.                     query.setMaxResults(reCount);   
225.                        
226.                     return query.list();   
227.                 }                  
228.             });   
229.             return resultList;     
230.     }   
231.   
232.     @SuppressWarnings("unchecked")     
233.     public List<Object[]> findColsBySqlQuery(final String sql) {         
234.         List<Object[]> resultList = new ArrayList<Object[]>();             
235.         Session session = getHibernateTemplate().getSessionFactory().openSession();   
236.         resultList = session.createSQLQuery(sql).list();   
237.         session.close();   
238.         return resultList;         
239.     }   
240.   
241.     @SuppressWarnings("unchecked")     
242.     public List<Object> findColBySqlQuery(String sql) {          
243.         List<Object> resultList = new ArrayList<Object>();             
244.         Session session = getHibernateTemplate().getSessionFactory().openSession();   
245.         resultList = session.createSQLQuery(sql).list();   
246.         session.close();   
247.         return resultList;         
248.     }   
249.        
250.     public int executeSqlQuery(final String sql) {         
251.         int result = 0;   
252.         Session session = getHibernateTemplate().getSessionFactory().openSession();   
253.         result = session.createSQLQuery(sql).executeUpdate();   
254.         session.close();   
255.         return result;         
256.     }   
257. }  

package lym.dao.base.hibernate;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import lym.dao.obj.AbstractHandleObj;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.type.Type;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;



/**
 * 基础Dao接口,实现通用操作
 * @author 林元脉
 * @version v1.1 2009/07/17
 *
 */
public class BaseDaoImpl extends HibernateDaoSupport implements IBaseDao {
	
	
	/**
	 * 对于返回列表的方法，通过调用我来实现返回记录数的控制，
	 * 设置返回记录数，若top为0不设置
	 */
	public void setMaxResults(int top){	
		if(top > 0){
			getHibernateTemplate().setMaxResults(top);
		}		
	}
	
	public Serializable save(AbstractHandleObj hobj){
		return getHibernateTemplate().save(hobj);		
	}

	public void update(AbstractHandleObj hobj) {
		getHibernateTemplate().update(hobj);		
	
	}
	
	public void saveOrUpdate(AbstractHandleObj hobj) {
		getHibernateTemplate().saveOrUpdate(hobj);
		
	}
		
	public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList) {
		getHibernateTemplate().saveOrUpdateAll(hobjList);				
	}
	
	public void delete(AbstractHandleObj hobj) {
		getHibernateTemplate().delete(hobj);			
	}
	
	public void deleteAll(Collection<AbstractHandleObj> hobjList) {
		getHibernateTemplate().deleteAll(hobjList);		
	}
	
	public AbstractHandleObj findByID(String entityName, String id)
		{
		return (AbstractHandleObj) getHibernateTemplate().get(entityName, id);			
	}
	
	@SuppressWarnings("unchecked")	
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql) 
		{	
		List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
		resultList = getHibernateTemplate().find(hql);
		return resultList;
	}

	@SuppressWarnings("unchecked")	
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj) 
		{		
		List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
		resultList = getHibernateTemplate().find(hql, obj);
		return resultList;			
	}

	@SuppressWarnings("unchecked")	
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs) 
		{		
		List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
		resultList = getHibernateTemplate().find(hql, objs);
		return resultList;		
	}	
	
	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuery(String hql) 
		{		
		List<Object[]> resultList = getHibernateTemplate().find(hql);
		return resultList;		
	}

	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuery(String hql, Object obj) 
		{		
		List<Object[]> resultList = getHibernateTemplate().find(hql, obj);
		return resultList;
	}

	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuery(String hql, Object[] objs)
		{		
		List<Object[]> resultList = getHibernateTemplate().find(hql, objs);
		return resultList;		
	}
	
	@SuppressWarnings("unchecked")	
	public List<Object> findColByHqlQuery(String hql) 
		{		
		List<Object> resultList = getHibernateTemplate().find(hql);
		return resultList;
	}

	@SuppressWarnings("unchecked")	
	public List<Object> findColByHqlQuery(String hql, Object obj) 
		{		
		List<Object> resultList = getHibernateTemplate().find(hql, obj);
		return resultList;		
	}

	@SuppressWarnings("unchecked")	
	public List<Object> findColByHqlQuery(String hql, Object[] objs) 
		{		
		List<Object> resultList = getHibernateTemplate().find(hql, objs);
		return resultList;		
	}
	
	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,final int start, 
			final int reCount) {
		List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session.createQuery(hql);
				query.setFirstResult(start);
				query.setMaxResults(reCount);
				
				return query.list();
			}				
		});
		return resultList;		
	}
	
	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,
			final Object[] objs, final Type[] types, final int start, final int reCount) 
			{
		List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
				public Object doInHibernate(Session session)
						throws HibernateException, SQLException {
					Query query = session.createQuery(hql);
					/*设置参数*/
					query.setParameters(objs, types);
					query.setFirstResult(start);
					query.setMaxResults(reCount);
					
					return query.list();
				}				
			});
			return resultList;		
	}
	
	public long getRecordCountByHqlQuery(String hql) {
		long recordCount = (Long) getHibernateTemplate().find(hql).get(0);
		return recordCount;		
	}
	
	public long getRecordCountByHqlQuery(String hql, Object obj) {
		long recordCount = (Long) getHibernateTemplate().find(hql, obj).get(0);
		return recordCount;		
	}
	
	public long getRecordCountByHqlQuery(String hql, Object[] objs) {
		long recordCount = (Long) getHibernateTemplate().find(hql, objs).get(0);
		return recordCount;		
	}
	
	public int executeHqlQuery(String hql) {
		return getHibernateTemplate().bulkUpdate(hql);			
	}
	
	public int executeHqlQuery(String hql, Object obj) {
		return getHibernateTemplate().bulkUpdate(hql, obj);
	}

	public int executeHqlQuery(String hql, Object[] objs) {
		return getHibernateTemplate().bulkUpdate(hql, objs);			
	}

	@SuppressWarnings("unchecked")
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql,
			final int start, final int reCount) {
		List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
				public Object doInHibernate(Session session)
						throws HibernateException, SQLException {
					Query query = session.createQuery(hql);
					query.setFirstResult(start);
					query.setMaxResults(reCount);
					
					return query.list();
				}				
			});
			return resultList;		
	}

	@SuppressWarnings("unchecked")
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql, final Object[] objs,
			final Type[] types, final int start, final int reCount) {
		List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
				public Object doInHibernate(Session session)
						throws HibernateException, SQLException {
					Query query = session.createQuery(hql);
					/*设置参数*/
					query.setParameters(objs, types);
					query.setFirstResult(start);
					query.setMaxResults(reCount);
					
					return query.list();
				}				
			});
			return resultList;	
	}

	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsBySqlQuery(final String sql) {		
		List<Object[]> resultList = new ArrayList<Object[]>();			
		Session session = getHibernateTemplate().getSessionFactory().openSession();
		resultList = session.createSQLQuery(sql).list();
		session.close();
		return resultList;		
	}

	@SuppressWarnings("unchecked")	
	public List<Object> findColBySqlQuery(String sql) {		
		List<Object> resultList = new ArrayList<Object>();			
		Session session = getHibernateTemplate().getSessionFactory().openSession();
		resultList = session.createSQLQuery(sql).list();
		session.close();
		return resultList;		
	}
	
	public int executeSqlQuery(final String sql) {		
		int result = 0;
		Session session = getHibernateTemplate().getSessionFactory().openSession();
		result = session.createSQLQuery(sql).executeUpdate();
		session.close();
		return result;		
	}
}

现在我来说说抽象类AbstractHandleObj.java的作用，先看下代码，其实也就一个抽象类，空类！

Java代码  

1. package lym.dao.obj;   
2.   
3. /**  
4.  * 抽象类，为了实现通用基础Dao而定义的，  
5.  * 让实体来继承(需要返回的对象也继承他)  
6.  * @author 林元脉  
7.  * @version v1.0 2009/07/05  
8.  *  
9.  */  
10. public abstract class AbstractHandleObj {   
11.   
12. }