一个通用的DAO接口及其Hibernate3实现 (2)

 

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;   
 }   
}