import java.io.*;
import java.util.*;

/**
 * 通用DAO，用于对象的持久化、查询（分页）
 *
 * @author SunHui
 *
 */
public interface Dao {
 /**
  * 保存（持久化）一个对象
  *
  * @param object
  *            要保存的对象
  */
 public void save(Object object);

 /**
  * 更新一个对象
  *
  * @param object
  *            要修改的对象
  */
 public void update(Object object);

 /**
  * 用语句更新记录
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            参数
  */
 public void updateByQuery(final String queryString,
   final Object[] parameters);

 /**
  * 删除一个对象
  *
  * @param object
  *            要删除的对象
  */
 public void delete(Object object);

 /**
  * 根据类型和对象id删除一个对象
  *
  * @param clazz
  *            类型
  * @param id
  *            对象id
  */
 public void delete(Class clazz, Serializable id);

 /**
  * 根据类型删除全部对象
  *
  * @param clazz
  *            类型
  * @return Integer
  */
 public Integer deleteAll(final Class clazz);

 /**
  * 根据查询和参数删除全部对象
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            参数
  * @return Integer
  */
 public Integer deleteByQuery(final String queryString,
   final Object[] parameters);

 /**
  * 获得某个类型的全部对象列表
  *
  * @param clazz
  *            类型
  * @return 对象集合
  */
 public List findAll(Class clazz);

 /**
  * 根据类型和对象id载入一个对象
  *
  * @param clazz
  *            类型
  * @param id
  *            对象id
  * @return 目标对象
  */
 public Object load(Class clazz, Serializable id);

 /**
  * 根据类型和对象id从数据库取得一个对象
  *
  * @param clazz
  *            类
  * @param id
  *            对象id
  * @return 目标对象
  */
 public Object get(Class clazz, Serializable id);

 /**
  * 根据查询语句和查询参数从数据库取得一个对象
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            参数
  * @return Object 单个对象
  */
 public Object get(final String queryString, final Object[] parameters);

 /**
  * 命名查询
  *
  * @param queryName
  *            命名查询语句
  * @return 对象列表
  */
 public List findByNamedQuery(final String queryName);

 /**
  * 依据单个参数做命名查询
  *
  * @param query
  *            命名查询语句
  * @param parameter
  *            单个查询参数
  * @return 对象列表
  */
 public List findByNamedQuery(final String queryString,
   final Object parameter);

 /**
  * 依据参数数组做命名查询
  *
  * @param query
  *            命名查询语句
  * @param parameters
  *            查询参数数组
  * @return 对象列表
  */
 public List findByNamedQuery(final String queryString,
   final Object[] parameters);

 /**
  * 查询全部
  *
  * @param query
  *            查询语句
  * @return 对象列表
  */
 public List find(final String queryString);

 /**
  * 带参数查询全部
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            查询参数
  * @return 对象列表
  */
 public List find(final String queryString, final Object[] parameters);

 /**
  * 分页查询
  *
  * @param queryString
  *            查询语句
  * @param parameters
  *            参数
  * @param pageInfo
  *            分页信息
  * @return List 对象列表
  */
 public List findPageByQuery(final String queryString,
   final Object[] parameters, final PageInfo pageInfo);

}

以下为Dao的Hibernate3实现

import java.io.*;
import java.util.*;

import org.hibernate.*;
import org.springframework.orm.hibernate3.*;
import org.springframework.orm.hibernate3.support.*;

/**
 * 通用DAO的Hibernate实现
 *
 * @author SunHui
 *
 */
public class DaoImpl extends HibernateDaoSupport implements Dao {

 public void save(Object object) {
  getHibernateTemplate().save(object);
 }

 public void update(Object object) {
  getHibernateTemplate().update(object);
 }

 public void updateByQuery(final String queryString, final Object[] parameters) {
  getHibernateTemplate().execute(new HibernateCallback() {
   public Object doInHibernate(Session session) {
    Query query = session.createQuery(queryString);
    if (parameters != null) {
     for (int i = 0; i < parameters.length; i++) {
      query.setParameter(i, parameters[i]);
     }
    }
    query.executeUpdate();
    return null;
   }
  });
 }

 public void delete(Object object) {
  getHibernateTemplate().delete(object);
 }

 public void delete(Class clazz, Serializable id) {
  getHibernateTemplate().delete(load(clazz, id));
 }

 public Integer deleteAll(final Class clazz) {
  return (Integer) getHibernateTemplate().execute(
    new HibernateCallback() {
     public Object doInHibernate(Session session) {
      Query query = session.createQuery("delete "
        + clazz.getName());
      return new Integer(query.executeUpdate());
     }
    });
 }

 public List findAll(Class clazz) {
  return getHibernateTemplate().find("from " + clazz.getName());
 }

 public Object load(Class clazz, Serializable id) {
  return getHibernateTemplate().load(clazz, id);
 }

 public Object get(Class clazz, Serializable id) {
  return getHibernateTemplate().get(clazz, id);
 }

 public List findByNamedQuery(final String queryName) {
  return getHibernateTemplate().findByNamedQuery(queryName);
 }

 public List findByNamedQuery(final String queryName, final Object parameter) {
  return getHibernateTemplate().findByNamedQuery(queryName, parameter);
 }

 public List findByNamedQuery(final String queryName, final Object[] parameters) {
  return getHibernateTemplate().findByNamedQuery(queryName, parameters);
 }

 public List find(final String queryString) {
  return getHibernateTemplate().find(queryString);
 }

 public List find(final String queryString, final Object[] parameters) {
  return getHibernateTemplate().find(queryString, parameters);
 }

 public List findPageByQuery(final String queryString, final Object[] parameters,
   final PageInfo pageInfo) {
  return (List) getHibernateTemplate().execute(new HibernateCallback() {
   public Object doInHibernate(Session session)
     throws HibernateException {
    Query query = session.createQuery(queryString);
    if (parameters != null) {
     for (int i = 0; i < parameters.length; i++) {
      query.setParameter(i, parameters[i]);
     }
    }
    ScrollableResults sr = query.scroll();
    sr.last();
    int totalCount = sr.getRowNumber();
    int startIndex = (pageInfo.getPageIndex() - 1) * pageInfo.getPageSize();
    query.setMaxResults(pageInfo.getPageSize());
    query.setFirstResult(startIndex);
    int totalRec = totalCount + 1;
    pageInfo.setTotalRec(totalRec);
    int totalPage = (totalRec % pageInfo.getPageSize() == 0) ? (totalRec / pageInfo.getPageSize())
      : (totalRec / pageInfo.getPageSize()) + 1;
    int[] pageNumbers = new int[totalPage];
    for (int i = 0; i < totalPage; i++) {
     pageNumbers[i] = (i + 1);
    }
    pageInfo.setPageNumbers(pageNumbers);
    pageInfo.setTotalPage(totalPage);
    pageInfo.setPageSize(pageInfo.getPageSize());
    pageInfo.setPageIndex(pageInfo.getPageIndex());
    pageInfo.setPrePage(pageInfo.getPageIndex() - 1);
    pageInfo.setNextPage(pageInfo.getPageIndex() + 1);
    return query.list();
   }
  }, true);
 }

 public Integer deleteByQuery(final String queryString, final Object[] parameters) {
  return (Integer) getHibernateTemplate().execute(
    new HibernateCallback() {
     public Object doInHibernate(Session session) {
      Query query = session.createQuery(queryString);
      if (parameters != null) {
       for (int i = 0; i < parameters.length; i++) {
        query.setParameter(i, parameters[i]);
       }
      }
      return new Integer(query.executeUpdate());
     }
    });
 }

 public Object get(final String queryString, final Object[] parameters) {
  List list = getHibernateTemplate().find(queryString, parameters);
  if (list != null && !list.isEmpty()) {
   return list.get(0);
  }
  return null;
 }
}

/**
 * 通用分页信息类，用于承载分页信息
 *
 * @author SunHui
 *
 */
public class PageInfo {
 /**
  * 总页数
  */
 private int totalPage = 1;

 /**
  * 前一页
  */
 private int prePage = 1;

 /**
  * 下一页
  */
 private int nextPage = 1;

 /**
  * 总记录数
  */
 private int totalRec = 0;

 /**
  * 默认每页记录数
  */
 private final int defaultPageSize = 10;

 /**
  * 每页记录数
  */
 private int pageSize = defaultPageSize;

 /**
  * 当前页码
  */
 private int pageIndex = 1;

 /**
  * 全部页码，从1开始
  */
 private int[] pageNumbers;

 public int getPageIndex() {
  return pageIndex;
 }

 public void setPageIndex(int pageIndex) {
  this.pageIndex = pageIndex > 0 ? pageIndex : 1;
 }

 public int getNextPage() {
  return nextPage;
 }

 public void setNextPage(int nextPage) {
  this.nextPage = nextPage > this.totalPage ? this.totalPage : nextPage;
 }

 public int getPageSize() {
  return pageSize;
 }

 public void setPageSize(int pageSize) {
  this.pageSize = pageSize > 0 ? pageSize : 10;
 }

 public int getPrePage() {
  return prePage;
 }

 public void setPrePage(int prePage) {
  this.prePage = prePage < 1 ? 1 : prePage;
 }

 public int getTotalPage() {
  return totalPage;
 }

 public void setTotalPage(int totalPage) {
  this.totalPage = totalPage > 0 ? totalPage : 1;
 }

 public int getTotalRec() {
  return totalRec;
 }

 public void setTotalRec(int totalRec) {
  this.totalRec = totalRec > -1 ? totalRec : 0;
 }

 public int[] getPageNumbers() {
  return pageNumbers;
 }

 public void setPageNumbers(int[] pageNumbers) {
  this.pageNumbers = pageNumbers;
 }
}