hibernatedao:奋斗两天 终于开发了自己的DAO层公共类(Spring+Hibernate实现)

/**　
　* 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 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( HibernateCallback{

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Query query = session.createQuery(hql);
　　　　　　　　　　　　　　　 for( i=0; i<params.length; i){
　　　　　　　　　　　　　　　　　　　 query.Parameter(i, params[i]);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 query.executeUpdate;
　　　　　　　　　　　　　　　 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
　　　　 * @ 实体对象
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public T get(Class<T> entityClass,PK id){
　　　　　　　 (T)getHibernateTemplate.get(entityClass, id);
　　　 }
　　　
　　　 /** *//**
　　　　 * 查询全部记录列表
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 排序参照属性
　　　　 * @param isAsc 排序方式
　　　　 * @param criterions 查询条件,可为0项或任意多项目
　　　　 * @ 记录List集
　　　　 */
　　　 public List<T> findAll(final Class<T> entityClass,final String propertyName,final boolean isAsc,final Criterion criterions){
　　　　　　　 firstResult = 0;
　　　　　　　 maxResults = 0;　　　　　　　 //设置为0,则表示查询全部记录
　　　　　　　 findByCriteria(entityClass, propertyName, isAsc, firstResult, maxResults, criterions);
　　　 }
　　　
　　　 /** *//**
　　　　 * 查询列表
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 排序参照属性
　　　　 * @param isAsc 排序方式,true表示升序,false表示降序,当propertyName赋值为null时,此参数无效
　　　　 * @param firstResult 开始记录序号
　　　　 * @param maxResults 最大记录数
　　　　 * @param criterions 查询条件,可有0项或任意多项目
　　　　 * @ 记录List集
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public List<T> findByCriteria(final Class<T> entityClass,final String propertyName,final boolean isAsc,final firstResult,final maxResults,final Criterion criterions){
　　　　　　　 List<T> list = (List<T>)getHibernateTemplate.execute( HibernateCallback{

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Criteria criteria = session.createCriteria(entityClass);
　　　　　　　　　　　　　　　 //按属性条件查询
　　　　　　　　　　　　　　　 for(Criterion criterion : criterions){
　　　　　　　　　　　　　　　　　　　 criteria.add(criterion);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 //按某个属性排序
　　　　　　　　　　　　　　　 (null != propertyName){
　　　　　　　　　　　　　　　　　　　 (isAsc){
　　　　　　　　　　　　　　　　　　　　　　　 criteria.addOrder(Order.asc(propertyName));
　　　　　　　　　　　　　　　　　　　 }{
　　　　　　　　　　　　　　　　　　　　　　　 criteria.addOrder(Order.desc(propertyName));
　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 //用于分页查询
　　　　　　　　　　　　　　　 (maxResults != 0){
　　　　　　　　　　　　　　　　　　　 criteria.FirstResult(firstResult);
　　　　　　　　　　　　　　　　　　　 criteria.MaxResults(maxResults);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 List<T> list = criteria.list;
　　　　　　　　　　　　　　　 list;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 list;
　　　 }
　　　
　　　 /** *//**
　　　　 * 查询总记录数
　　　　 * @param entityClass 实体类名
　　　　 * @param criterions 查询条件,可有0项或任意多项
　　　　 * @ 总记录数
　　　　 */
　　　 public findCountsByCriteria(final Class<T> entityClass,final Criterion criterions){
　　　　　　　　　　　 totalCounts = (Integer)getHibernateTemplate.execute( HibernateCallback{

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Criteria criteria = session.createCriteria(entityClass);
　　　　　　　　　　　　　　　 //按属性条件查询
　　　　　　　　　　　　　　　 for(Criterion criterion : criterions){
　　　　　　　　　　　　　　　　　　　 criteria.add(criterion);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 totalCounts = criteria.list.size;
　　　　　　　　　　　　　　　 totalCounts;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 totalCounts;
　　　 }
　　　
　　　
　　　 /** *//**
　　　　 * 分页查询
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 排序参照属性
　　　　 * @param isAsc 排序方式,true表示升序,false表示降序,当propertyName赋值为null时,此参数无效
　　　　 * @param firstResult 开始记录序号
　　　　 * @param maxResults 最大记录数
　　　　 * @param criterions 查询条件,可为0项或任意多项目
　　　　 * @ 封装List和totalCountsPager对象
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public Pager<T> findForPager(final Class<T> entityClass,final String propertyName,final boolean isAsc,final firstResult,final maxResults,final Criterion criterions){
　　　　　　　 totalCounts = findCountsByCriteria(entityClass, criterions);
　　　　　　　 List<T> entityList = findByCriteria(entityClass, propertyName, isAsc, firstResult, maxResults, criterions);
　　　　　　　 Pager pager = Pager;
　　　　　　　 pager.TotalCounts(totalCounts);
　　　　　　　 pager.EntityList(entityList);
　　　　　　　 pager;
　　　 }
　　　
　　　 /** *//**
　　　　 * 根据属性值查询列表
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 属性名
　　　　 * @param value 属性值
　　　　 * @ 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);
　　　　　　　 list;
　　　 }
　　　
　　　 /** *//**
　　　　 * 根据属性值查询单个对象
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 属性名
　　　　 * @param value 属性值
　　　　 * @ 实体对象
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public T findUniqueByProperty(final Class<T> entityClass,final String propertyName,final Object value){
　　　　　　　 T t = (T)getHibernateTemplate.execute( HibernateCallback{

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Criteria criteria = session.createCriteria(entityClass).add(Restrictions.eq(propertyName, value));
　　　　　　　　　　　　　　　 T t = (T)criteria.uniqueResult;
　　　　　　　　　　　　　　　 t;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 t;
　　　 }
　　　
　　　 /** *//**
　　　　 * 根据属性值查询实体是否存在
　　　　 * @param entityClass 实体类名
　　　　 * @param propertyName 参照属性名
　　　　 * @param value 属性值
　　　　 * @ 存在则返回true,不存在则返回false
　　　　 */
　　　 public boolean isPropertyExist(final Class<T> entityClass,final String propertyName,final Object value){
　　　　　　　 boolean isExist = (Boolean)getHibernateTemplate.execute( HibernateCallback{

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Criteria criteria = session.createCriteria(entityClass).add(Restrictions.eq(propertyName, value));
　　　　　　　　　　　　　　　 boolean isEmpty = criteria.list.isEmpty;
　　　　　　　　　　　　　　　 ! isEmpty;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 isExist;
　　　 }
　　　
　　　 /** *//**
　　　　 *
　　　　 * @param hql 查询语句
　　　　 * 使用方法如:可用于登录验证时根据用户名、密码等信息查询用户
　　　　 * @param params 参数,代替HQL中"?"号,可有0项目或多项
　　　　 * @ 唯实体返回null则表示不存在配置实体
　　　　 * @exception 如果查询结果集不唯,则抛异常
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public T findUniqueByHql(final String hql, final Object params ){
　　　　　　　
　　　　　　　 T t = (T)getHibernateTemplate.execute( HibernateCallback{

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Query query = session.createQuery(hql);
　　　　　　　　　　　　　　　 for( i=0; i<params.length; i){
　　　　　　　　　　　　　　　　　　　 query.Parameter(i, params[i]);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 T t = (T)query.uniqueResult;
　　　　　　　　　　　　　　　 t;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 t;
　　　 }
　　　
　　　 /** *//**
　　　　 * 按HQL条件查询列表
　　　　 * @param hql 查询语句,支持连接查询和多条件查询
　　　　 * @param params 参数,代替hql中"?"号
　　　　 * @ 结果集List
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public List<T> findByHql(String hql,Object params){
　　　　　　　 List list = getHibernateTemplate.find(hql, params);
　　　　　　　 list;
　　　 }
　　　
　　　 /** *//**
　　　　 * 按HQL分页查询
　　　　 * @param firstResult 开始记录号
　　　　 * @param maxResults 最大记录数
　　　　 * @param hql 查询语句,支持连接查询和多条件查询
　　　　 * @param params 参数,代替餐hql中"?"号
　　　　 * @ 封装List和totalPager对象
　　　　 */
　　　 @SuppressWarnings("unchecked")
　　　 public Pager<T> findForPagerByHql(final firstResult, final maxResults, final String hql, final Object params){
　　　　　　　 Pager<T> pager = (Pager<T>)getHibernateTemplate.execute( HibernateCallback{

　　　　　　　　　　　 public Object doInHibernate(Session session)
　　　　　　　　　　　　　　　　　　　 throws HibernateException, SQLException {
　　　　　　　　　　　　　　　 Query query = session.createQuery(hql);
　　　　　　　　　　　　　　　 for( position = 0; position < params.length; position ){
　　　　　　　　　　　　　　　　　　　 query.Parameter(position, params[position]);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 totalCounts = query.list.size;　　　 //总记录数
　　　　　　　　　　　　　　　 //用于分页查询
　　　　　　　　　　　　　　　 (maxResults > 0){
　　　　　　　　　　　　　　　　　　　 query.FirstResult(firstResult);
　　　　　　　　　　　　　　　　　　　 query.MaxResults(maxResults);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 List<T> list = query.list;
　　　　　　　　　　　　　　　 Pager<T> pager = Pager<T>;
　　　　　　　　　　　　　　　 pager.EntityList(list);
　　　　　　　　　　　　　　　 pager.TotalCounts(totalCounts);
　　　　　　　　　　　　　　　 pager;
　　　　　　　　　　　 }
　　　　　　　 });
　　　　　　　 pager;
　　　 }
　　　

}

延伸阅读

• 2009-1-15-- hibernate实例:第一个成功的Hibernate例子01
• 2008-12-19-- hibernate对象映射:Hibernate中重要对象
• 2009-1-15-- strutshibernate:Struts+Spring+Hibernate快速入门
• 2009-1-15-- hibernate配置文件:Hibernate配置要点详谈
• 2009-1-15-- hibernate:hibernate3学习笔记(十 2)｜Component
• 2009-1-15-- hibernate:hibernate3学习笔记( 2十 3)｜进阶特性(一)
• 2009-1-15-- strutshibernate:让Struts和Hibernate顺利协同工作
• 2009-1-8-- springhibernate:spring+hibernate+osworkflow组合的一点改进
• 2009-1-8-- hibernate:Weblogic81和Hibernate的集成问题
• 2009-1-15-- hibernate事务:Hibernate的事务和并发02