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

最新推荐文章于 2024-08-25 21:18:14 发布

yjw916622874

最新推荐文章于 2024-08-25 21:18:14 发布

阅读量441

点赞数

文章标签： hibernate dao parameters integer object null

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/yjw916622874/article/details/7949539

版权

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

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。