我的万能dao 设计源码，请大家多多指教！-优快云博客

本文介绍了一种基于Spring和Hibernate的通用DAO设计方法，并详细展示了IBaseDao接口及其实现类BaseDaoImpl的具体功能，包括增删改查、分页查询等操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

首先，先看下类图：（在这篇文章已经发过了[url]http://lym6520.iteye.com/admin/blogs/421504[/url]）
我补充了Query层来存放hql或sql，如下：
[img]http://lym6520.iteye.com/upload/attachment/123871/35fdf67e-ce9d-3a65-a1ae-0cc6de00ac48.png[/img]

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


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：


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的作用，先看下代码，其实也就一个抽象类，空类！


package lym.dao.obj;

/**
 * 抽象类，为了实现通用基础Dao而定义的，
 * 让实体来继承(需要返回的对象也继承他)
 * @author 林元脉
 * @version v1.0 2009/07/05
 *
 */
public abstract class AbstractHandleObj {

}

建立这个抽象类的目的，其实就是让实体继承，或者返回对象继承他，这样就可以通过dao对实体进行操作，这也是使用这个dao对实体进行操作的前提条件！当然，如果不继承的话你也可以

因为我们项目使用的是spring+hibernate开发的，所以配置的话：


   <bean id="baseDao" class="lym.dao.base.hibernate.BaseDaoImpl">
   		<!--注入sessionFactory-->
 		<property name="sessionFactory" ref="sessionFactory"></property>
   </bean>

我想目前存在的缺点是对命名参数的支持，大家给补上吧！