Spring+Hibernate实现的DAO层大众类[Java编程]

此EntityDao接口与EntityDaoImpl实现类,可代替了我们平常写的UserDao,NewsDao,CompanyDao等等,可直接供Service层调用.此中实现类的代码以下:

/**　
　 * Copyright 2009-1012 the original author or authors.
　 * My Blog site: http://www.blogjava.net/rongxh7
　 */

package rong.common.dao;
import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.stereotype.Repository;
import rong.common.utils.Pager;
import rong.util.MyHibernateDaoSupport;

/** *//**
　 * Dao层接口的实现类
　 * 很多人习惯按照不多的业务逻辑定义差别的DAO层接口,如UserDao,NewsDao,CompanyDao等等,
　 * 这样常常使得编码量非常宏大,并且带来了保护的艰难,因此,抽取此DAO层接口,收录大部份
　 * DAO层必须的办法,以供Service层调用.
　 * @author rongxinhua
　 * @version 1.0
　 * @param <T> 范型,指实体类
　 * @param <PK> 范型,指实体类主键的数据范例,如Integer,Long
　 * @see rong.common.dao.EntityDao
　 */

@Repository(value="entityDao")
public class EntityDaoImpl<T,PK extends Serializable> extends MyHibernateDaoSupport implements EntityDao<T, PK>{

　　　 /** *//**
　　　　 * 保存实体
　　　　 * 包含增添和改正
　　　　 * @param t 实体对象
　　　　 */
　　　 public void saveOrUpdate(T t){
　　　　　　　 getHibernateTemplate().saveOrUpdate(t);
　　　 }

　　　 /** *//**
　　　　 * 更新实体
　　　　 * 可用于增添、改正、删除操作
　　　　 * @param hql 更新的HQL语句
　　　　 * @param params 参数,可有项目或多项目,替换Hql中的"?"号
　　　　 */
　　　 public void update(final String hql,final Object params){
　　　　　　　 getHibernateTemplate().execute(new HibernateCallback(){

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Query query = session.createQuery(hql);
　　　　　　　　　　　　　　　 for(int i=0; i<params.length; i++){
　　　　　　　　　　　　　　　　　　　 query.setParameter(i, params[i]);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 query.executeUpdate();
　　　　　　　　　　　　　　　 return null;
　　　　　　　　　　　 }
　　　　　　　 });
　　　 }

　　　 /** *//**
　　　　 * 删除实体
　　　　 * @param t 实体对象
　　　　 */
　　　 public void delete(T t){
　　　　　　　 getHibernateTemplate().delete(t);
　　　 }

　　　 /** *//**
　　　　 * 删除实体
　　　　 * @param entityClass 实体类名
　　　　 * @param id 实体的ID
　　　　 */
　　　 public void delete(Class<T> entityClass,PK id){
　　　　　　　 getHibernateTemplate().delete(get(entityClass,id));
　　　 }

　　　 /** *//**
　　　　 * 单查实体
　　　　 * @param entityClass 实体类名
　　　　 * @param id 实体的ID
　　　　 * @return 实体对象
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public T get(Class<T> entityClass,PK id){
　　　　　　　 return (T)getHibernateTemplate().get(entityClass, id);
　　　 }

　　　 /** *//**
　　　　 * 查询全部记录列表
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 排序的参照属性
　　　　 * @param isAsc 排序方法
　　　　 * @param criterions 查询条件,可为0项或肆意多项目
　　　　 * @return 记录List集
　　　　 */
　　　 public List<T> findAll(final Class<T> entityClass,final String propertyName,final boolean isAsc,final Criterion criterions){
　　　　　　　 int firstResult = 0;
　　　　　　　 int maxResults = 0;　//设置为0,则表示查询全部记录
　　　　　　　 return findByCriteria(entityClass, propertyName, isAsc, firstResult, maxResults, criterions);
　　　 }

　　　 /** *//**
　　　　 * 查询列表
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 排序的参照属性
　　　　 * @param isAsc 排序方法,true表示升序,false表示降序,当propertyName赋值为null时,此参数无效
　　　　 * @param firstResult 开始记录序号
　　　　 * @param maxResults 最大记录数
　　　　 * @param criterions 查询条件,可有0项或肆意多项目
　　　　 * @return 记录List集
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public List<T> findByCriteria(final Class<T> entityClass,final String propertyName,final boolean isAsc,final int firstResult,final int maxResults,final Criterion criterions){
　　　　　　　 List<T> list = (List<T>)getHibernateTemplate().execute(new HibernateCallback(){

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Criteria criteria = session.createCriteria(entityClass);
　　　　　　　　　　　　　　　 //按属性条件查询
　　　　　　　　　　　　　　　 for(Criterion criterion : criterions){
　　　　　　　　　　　　　　　　　　　 criteria.add(criterion);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 //按某个属性排序
　　　　　　　　　　　　　　　 if(null != propertyName){
　　　　　　　　　　　　　　　　　　　 if(isAsc){
　　　　　　　　　　　　　　　　　　　　　　　 criteria.addOrder(Order.asc(propertyName));
　　　　　　　　　　　　　　　　　　　 }else{
　　　　　　　　　　　　　　　　　　　　　　　 criteria.addOrder(Order.desc(propertyName));
　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 //用于分页查询
　　　　　　　　　　　　　　　 if(maxResults != 0){
　　　　　　　　　　　　　　　　　　　 criteria.setFirstResult(firstResult);
　　　　　　　　　　　　　　　　　　　 criteria.setMaxResults(maxResults);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 List<T> list = criteria.list();
　　　　　　　　　　　　　　　 return list;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 return list;
　　　 }

　　　 /** *//**
　　　　 * 查询总记录数
　　　　 * @param entityClass 实体类名
　　　　 * @param criterions 查询条件,可有0项或肆意多项
　　　　 * @return 总记录数
　　　　 */
　　　 public int findCountsByCriteria(final Class<T> entityClass,final Criterion criterions){
　　　　　　　　　　　 int totalCounts = (Integer)getHibernateTemplate().execute(new HibernateCallback(){

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Criteria criteria = session.createCriteria(entityClass);
　　　　　　　　　　　　　　　 //按属性条件查询
　　　　　　　　　　　　　　　 for(Criterion criterion : criterions){
　　　　　　　　　　　　　　　　　　　 criteria.add(criterion);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 int totalCounts = criteria.list().size();
　　　　　　　　　　　　　　　 return totalCounts;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 return totalCounts;
　　　 }

　　　 /** *//**
　　　　 * 分页查询
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 排序参照属性
　　　　 * @param isAsc 排序方法,true表示升序,false表示降序,当propertyName赋值为null时,此参数无效
　　　　 * @param firstResult 开始记录序号
　　　　 * @param maxResults 最大记录数
　　　　 * @param criterions 查询条件,可为0项或肆意多项目
　　　　 * @return 封装List和totalCounts的Pager对象
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public Pager<T> findForPager(final Class<T> entityClass,final String propertyName,final boolean isAsc,final int firstResult,final int maxResults,final Criterion criterions){
　　　　　　　 int totalCounts = findCountsByCriteria(entityClass, criterions);
　　　　　　　 List<T> entityList = findByCriteria(entityClass, propertyName, isAsc, firstResult, maxResults, criterions);
　　　　　　　 Pager pager = new Pager();
　　　　　　　 pager.setTotalCounts(totalCounts);
　　　　　　　 pager.setEntityList(entityList);
　　　　　　　 return pager;
　　　 }

　　　 /** *//**
　　　　 * 按照属性值查询列表
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 属性名
　　　　 * @param value 属性值
　　　　 * @return List列表
　　　　 */
　　　 public List<T> findByProperty(Class<T> entityClass,String propertyName,Object value){
　　　　　　　 Criterion criterion = Restrictions.eq(propertyName, value);
　　　　　　　 List<T> list = findAll(entityClass, null, true, criterion);
　　　　　　　 return list;
　　　 }

　　　 /** *//**
　　　　 * 按照属性值查询单个对象
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 属性名
　　　　 * @param value 属性值
　　　　 * @return 实体对象
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public T findUniqueByProperty(final Class<T> entityClass,final String propertyName,final Object value){
　　　　　　　 T t = (T)getHibernateTemplate().execute(new HibernateCallback(){

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Criteria criteria = session.createCriteria(entityClass).add(Restrictions.eq(propertyName, value));
　　　　　　　　　　　　　　　 T t = (T)criteria.uniqueResult();
　　　　　　　　　　　　　　　 return t;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 return t;
　　　 }

　　　 /** *//**
　　　　 * 按照属性值查询实体能否存在
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 参照的属性名
　　　　 * @param value 属性值
　　　　 * @return 存在则返回true,不存在则返回false
　　　　 */
　　　 public boolean isPropertyExist(final Class<T> entityClass,final String propertyName,final Object value){
　　　　　　　 boolean isExist = (Boolean)getHibernateTemplate().execute(new HibernateCallback(){

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Criteria criteria = session.createCriteria(entityClass).add(Restrictions.eq(propertyName, value));
　　　　　　　　　　　　　　　 boolean isEmpty = criteria.list().isEmpty();
　　　　　　　　　　　　　　　 return ! isEmpty;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 return isExist;
　　　 }

　　　 /** *//**
　　　　 *
　　　　 * @param hql 查询语句
　　　　 * 用法如:可用于登录考证时,按照用户名、密码等信息查询用户
　　　　 * @param params 参数数组,替换HQL中的"?"号,可有0项目或多项
　　　　 * @return 唯一实体,返回null则表示不存在配置的实体
　　　　 * @exception 假如查询的后果集不惟一,则抛非常
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public T findUniqueByHql(final String hql, final Object params ){

　　　　　　　 T t = (T)getHibernateTemplate().execute(new HibernateCallback(){

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Query query = session.createQuery(hql);
　　　　　　　　　　　　　　　 for(int i=0; i<params.length; i++){
　　　　　　　　　　　　　　　　　　　 query.setParameter(i, params[i]);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 T t = (T)query.uniqueResult();
　　　　　　　　　　　　　　　 return t;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 return t;
　　　 }

　　　 /** *//**
　　　　 * 按HQL条件查询列表
　　　　 * @param hql 查询语句,支持衔接查询和多条件查询
　　　　 * @param params 参数数组,替换hql中的"?"号
　　　　 * @return 后果集List
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public List<T> findByHql(String hql,Object params){
　　　　　　　 List list = getHibernateTemplate().find(hql, params);
　　　　　　　 return list;
　　　 }

　　　 /** *//**
　　　　 * 按HQL分页查询
　　　　 * @param firstResult 开始记录号
　　　　 * @param maxResults 最大记录数
　　　　 * @param hql 查询语句,支持衔接查询和多条件查询
　　　　 * @param params 参数数组,替换餐hql中的"?"号
　　　　 * @return 封装List和total的Pager对象
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public Pager<T> findForPagerByHql(final int firstResult, final int maxResults, final String hql, final Object params){
　　　　　　　 Pager<T> pager = (Pager<T>)getHibernateTemplate().execute(new HibernateCallback(){

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Query query = session.createQuery(hql);
　　　　　　　　　　　　　　　 for(int position = 0; position < params.length; position ++){
　　　　　　　　　　　　　　　　　　　 query.setParameter(position, params[position]);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 int totalCounts = query.list().size();　//总记录数
　　　　　　　　　　　　　　　 //用于分页查询
　　　　　　　　　　　　　　　 if(maxResults > 0){
　　　　　　　　　　　　　　　　　　　 query.setFirstResult(firstResult);
　　　　　　　　　　　　　　　　　　　 query.setMaxResults(maxResults);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 List<T> list = query.list();
　　　　　　　　　　　　　　　 Pager<T> pager = new Pager<T>();
　　　　　　　　　　　　　　　 pager.setEntityList(list);
　　　　　　　　　　　　　　　 pager.setTotalCounts(totalCounts);
　　　　　　　　　　　　　　　 return pager;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 return pager;
　　　 }

}

文章根源:http://www.blogjava.net/rongxh7