基于hibernate的泛型Dao框架-优快云博客

本文链接：https://blog.youkuaiyun.com/oceandeep1984/article/details/83813917

转载至http://llying.iteye.com/blog/406058

这个东西是一年前弄的，不过一直没用到，里面有些东西已经记不太清了，还好注释应该可以看懂。
目的是希望设计一个基于hibernate的泛型Dao框架
推荐一个J2EE的群：46176507

首先创建一个java项目GenericDao

我们创建一个包com.hb.generic.dao
该包用来作为我们的基础dao包
首先我们创建一个针对单个实体操作的泛型EntityDao<T>接口。

Java代码

/**
* @author llying
* @company qm
*/
public interface EntityDao<T> {
T get(Serializable id);
List<T> getAll();
void save(T newInstance);
void remove(T transientObject);
void removeById(Serializable id);
String getIdName(Class clazz);
}

/**
 * @author llying
 * @company qm
 */
public interface EntityDao<T> {
	
	T get(Serializable id);
	
	List<T> getAll();
	
	void save(T newInstance);
	
	void remove(T transientObject);
	
	void removeById(Serializable id);
	
	String getIdName(Class clazz);
}

用于定义针对单个实体的CRUD操作。
接着我们在定义一个接口类HibernateCallback，定义一个回调接口。

Java代码

import org.hibernate.Session;
/**
* @author llying
* @company qm
*/
public interface HibernateCallback {
Object doInHibernate(Session session);
}

import org.hibernate.Session;
/**
 * @author llying
 * @company qm
 */
public interface HibernateCallback {
	Object doInHibernate(Session session);
}

接下来我们定义一个com.hb.generic.dao.utils包，
该包的目的是用于防治一些常用方法的抽取，该包中的一些类是我平时的收集和积累。
我们这里只对关键类进行说明
BeanUtils :工具类，通过反射机制对对象进行存取值
GenericUtils:工具类，取得类中的泛型类型
里面基本上都有都有注释
我们在com.hb.generic.dao.support包下创建一个分页类（不做具体介绍，基本上分页都差不多）
我们需要在com.hb.generic.dao包下创建HibernateDaoHandler接口

Java代码

import org.hibernate.Session;
/**
* @author llying
* @company qm
*/
public interface HibernateDaoHandler {
Session getSession();
}

import org.hibernate.Session;
/**
 * @author llying
 * @company qm
 */
public interface HibernateDaoHandler {
	Session getSession();
}

在用户使用的时候需要实现该接口获取session
接下来我们会创建HibernateDaoSupport类
Dao的基类：提供分页函数和若干便捷查询方法，并对返回值作了泛型类型转换.

Java代码

package com.hb.generic.dao;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.impl.CriteriaImpl.OrderEntry;
import com.hb.generic.dao.support.Page;
import com.hb.generic.dao.utils.Assert;
import com.hb.generic.dao.utils.BeanUtils;
/**
* Dao的基类.
*
* 提供分页函数和若干便捷查询方法，并对返回值作了泛型类型转换.
* @author llying
* @company qm
*/
public abstract class HibernateDaoSupport<T> implements HibernateDaoHandler {
private static final Log log = LogFactory.getLog(HibernateDaoSupport.class);
public Object execute(HibernateCallback action){
Assert.notNull(action, "Callback object 对象不能为 Null ");
Session session = getSession();
Transaction tr = session.beginTransaction();
Object result = action.doInHibernate(session);
tr.commit();
session.close();
return result;
}
/**
* 获取全部的对象
* @param <T>
* @param entityClass 对象类型
* @return
*/
@SuppressWarnings("unchecked")
public <T>List<T> getAll(final Class<T> entityClass) {
return (List<T>)execute(new HibernateCallback(){
public Object doInHibernate(Session session) {
Criteria criteria = session.createCriteria(entityClass);
return criteria.list();
}
});
}
/**
* 获取全部对象，带排序功能
* @param <T>
* @param entityClass 实体对象
* @param orderBy　排序字段
* @param isAsc 升序或降序
* @return
*/
@SuppressWarnings({ "hiding", "hiding", "unchecked" })
public <T> List <T> getAll(final Class<T> entityClass,final String orderBy,final boolean isAsc){
Assert.hasText(orderBy);
return (List<T>) execute(new HibernateCallback(){
public Object doInHibernate(Session session) {
if (isAsc)
return session.createCriteria(entityClass).addOrder(Order.asc(orderBy)).list();
return session.createCriteria(entityClass).addOrder(Order.desc(orderBy)).list();
}
});
}
/**
* 保存对象
* @param newInstance
*/
@SuppressWarnings("unused")
public void saveOrUpdate(final T newInstance){
execute(new HibernateCallback(){
public Object doInHibernate(Session session) {
session.saveOrUpdate(newInstance);
return null;
}
});
}
/**
* 删除对象
* @param transientObject
*/
public void remove(final T transientObject) {
execute(new HibernateCallback(){
public Object doInHibernate(Session session) {
session.delete(transientObject);
return null;
}
});
}
/**
*
* @param entityClass
* @param id
*/
public void removeById(Class<T> entityClass, Serializable id) {
remove( get(entityClass, id));
}
/**
* 根据Id获取对象。
* @param <T>
* @param entityClass
* @param id 实体Id
* @return 实体对象
*/
@SuppressWarnings({ "hiding", "unchecked" })
public <T> T get(final Class<T> entityClass,final Serializable id) {
return (T) execute(new HibernateCallback(){
public Object doInHibernate(Session session) {
return session.get(entityClass, id);
}
});
}
/**
* 创建一个Query对象。
* @param hql
* @param values
* @return
*/
public Query createQuery(String hql,Object...values){
Assert.hasText(hql);
Query query = getSession().createQuery(hql);
for(int i = 0;i<values.length;i++){
query.setParameter(i, values[i]);
}
return query;
}
/**
* 创建Criteria对象。
* @param <T>
* @param entityClass
* @param criterions
* @return
*/
public <T>Criteria createCriteria(Class<T> entityClass,Criterion...criterions){
Criteria criteria = getSession().createCriteria(entityClass);
for(Criterion c:criterions){
criteria.add(c);
}
return criteria;
}
/**
* 创建Criteria对象，有排序功能。
* @param <T>
* @param entityClass
* @param orderBy
* @param isAsc
* @param criterions
* @return
*/
public <T>Criteria createCriteria(Class<T> entityClass,String orderBy,boolean isAsc,Criterion...criterions){
Assert.hasText(orderBy);
Criteria criteria = createCriteria(entityClass,criterions);
if(isAsc){
criteria.addOrder(Order.asc(orderBy));
}else{
criteria.addOrder(Order.desc(orderBy));
}
return criteria;
}
/**
* 根据hql查询
* @param hql
* @param values
* @return
*/
public List find(final String hql,final Object...values){
Assert.hasText(hql);
return createQuery(hql, values).list();
/* return (List) execute(new HibernateCallback(){
public Object doInHibernate(Session session) {
Query query = session.createQuery(hql);
for(int i = 0;i<values.length;i++){
query.setParameter(i, values[i]);
}
return query.list();
}
});*/
}
/**
* 根据属性名和属性值查询.
*
* @return
*/
public <T>List<T> findBy(Class<T> entityClass,String propertyName,Object value){
Assert.hasText(propertyName);
return createCriteria(entityClass, Restrictions.eq(propertyName, value)).list();
}
/**
* 根据属性名和属性值查询. 有排序
* @param <T>
* @param entityClass
* @param propertyName
* @param value
* @param orderBy
* @param isAsc
* @return
*/
public <T>List<T> findBy(Class<T> entityClass,String propertyName,Object value,String orderBy,boolean isAsc){
Assert.hasText(propertyName);
Assert.hasText(orderBy);
return createCriteria(entityClass, orderBy, isAsc, Restrictions.eq(propertyName, value)).list();
}
/**
* 根据属性名和属性值查询且要求对象唯一.
*
* @return 符合条件的唯一对象.
*/
public <T>T findUniqueBy(Class<T> entityClass,String propertyName,Object value){
Assert.hasText(propertyName);
return (T)createCriteria(entityClass, Restrictions.eq(propertyName, value)).uniqueResult();
}
/**
* 分页通过hql进行
* @param hql
* @param pageNo
* @param pageSize
* @param values
* @return
*/
public Page pagedQuery(String hql,int pageNo,int pageSize,Object...values){
Assert.hasText(hql);
Assert.isTrue(pageNo>=1);
String countQueryString = "select count(*)" + removeSelect(removeOrders(hql));
System.out.println(countQueryString);
List countList = find(countQueryString, values);
long totalCount = (Long) countList.get(0);
System.out.println(totalCount);
if(totalCount<1){
return new Page();
}
int startIndex = Page.getStartOfPage(pageNo, pageSize);
Query query = createQuery(hql,values);
List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();
return new Page(startIndex,totalCount,pageSize,list);
}
/**
* 分页通过criteria
* @param criteria
* @param pageNo
* @param pageSize
* @return
*/
public Page pagedQuery(Criteria criteria,int pageNo,int pageSize){
Assert.notNull(criteria);
Assert.isTrue(pageNo>=1);
CriteriaImpl criteriaImpl = (CriteriaImpl) criteria;
//先把Projection和OrderBy条件取出来,清空两者来执行Count操作
Projection projection = criteriaImpl.getProjection();
List<CriteriaImpl.OrderEntry> orderEntitys = null;
try {
orderEntitys=(List<OrderEntry>) BeanUtils.forceGetProperty(criteriaImpl, "orderEntries");
BeanUtils.forceSetProperty(criteriaImpl, "orderEntries", new ArrayList());
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
//取得总的数据数
long totalCount = (Long) criteria.setProjection(Projections.rowCount()).uniqueResult();
//将之前的Projection和OrderBy条件重新设回去
criteria.setProjection(projection);
if (projection == null) {
criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
}
try {
BeanUtils.forceSetProperty(criteriaImpl, "orderEntries", orderEntitys);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
if(totalCount<1)
return new Page();
int startIndex = Page.getStartOfPage(pageNo, pageSize);
List data = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();
return new Page( startIndex, totalCount, pageSize, data);
}
/**
* 分页查询函数
* @param entityClass
* @param pageNo
* @param pageSize
* @param criterions
* @return
*/
public Page pagedQuery(Class<T> entityClass,int pageNo,int pageSize,Criterion...criterions){
Criteria criteria = createCriteria(entityClass, criterions);
return pagedQuery(criteria, pageNo, pageSize);
}
/**
* 分页查询带排序
* @param entityClass
* @param pageNo
* @param pageSize
* @param orderBy
* @param isAsc
* @param criterions
* @return
*/
public Page pagedQuery(Class<T> entityClass,int pageNo,int pageSize,String orderBy,boolean isAsc,Criterion...criterions){
Criteria criteria = createCriteria(entityClass, orderBy, isAsc, criterions);
return pagedQuery(criteria, pageNo, pageSize);
}
/**
* 去除hql的select子句。
* @param hql
* @return
* @see #pagedQuery(String,int,int,Object[])
*/
private static String removeSelect(String hql){
Assert.hasText(hql);
int beginPos = hql.toLowerCase().indexOf("from");
Assert.isTrue(beginPos!=-1,hql);
return hql.substring(beginPos);
}
/**
* 去除hql的orderBy子句。
* @param hql
* @return
* @see #pagedQuery(String,int,int,Object[])
*/
private static String removeOrders(String hql) {
Assert.hasText(hql);
Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(hql);
StringBuffer sb = new StringBuffer();
while (m.find()) {
m.appendReplacement(sb, "");
}
m.appendTail(sb);
return sb.toString();
}
}

package com.hb.generic.dao;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.impl.CriteriaImpl.OrderEntry;

import com.hb.generic.dao.support.Page;
import com.hb.generic.dao.utils.Assert;
import com.hb.generic.dao.utils.BeanUtils;

/**
 * Dao的基类.
 * 
 * 提供分页函数和若干便捷查询方法，并对返回值作了泛型类型转换.
 * @author llying
 * @company qm
 */
public abstract class HibernateDaoSupport<T> implements HibernateDaoHandler {

	private static final Log log = LogFactory.getLog(HibernateDaoSupport.class);
	public Object execute(HibernateCallback action){
		Assert.notNull(action, "Callback object 对象不能为 Null ");
		Session session = getSession();
		Transaction tr = session.beginTransaction();
		Object result = action.doInHibernate(session);
		tr.commit();
		session.close();
		return result;
	}
	
	/**
	 * 获取全部的对象
	 * @param <T>
	 * @param entityClass 对象类型
	 * @return 
	 */
	@SuppressWarnings("unchecked")
	public <T>List<T> getAll(final Class<T> entityClass) {
		return (List<T>)execute(new HibernateCallback(){
			public Object doInHibernate(Session session) {
				Criteria criteria = session.createCriteria(entityClass);
				return criteria.list();
			}
		});
	}
	
	/**
	 * 获取全部对象，带排序功能
	 * @param <T>
	 * @param entityClass 实体对象
	 * @param orderBy　排序字段
	 * @param isAsc 升序或降序
	 * @return
	 */
	@SuppressWarnings({ "hiding", "hiding", "unchecked" })
	public <T> List <T> getAll(final Class<T> entityClass,final String orderBy,final boolean isAsc){
		Assert.hasText(orderBy);
		return (List<T>) execute(new HibernateCallback(){

			public Object doInHibernate(Session session) {
				
				if (isAsc)
					return session.createCriteria(entityClass).addOrder(Order.asc(orderBy)).list();
				return session.createCriteria(entityClass).addOrder(Order.desc(orderBy)).list();
			}
			
		});

	}
	/**
	 * 保存对象
	 * @param newInstance
	 */
	@SuppressWarnings("unused")
	public void saveOrUpdate(final T newInstance){
		execute(new HibernateCallback(){
			public Object doInHibernate(Session session) {
				session.saveOrUpdate(newInstance);
				return null;
			}
		});
	}
	/**
	 * 删除对象
	 * @param transientObject
	 */
	public void remove(final T transientObject) {
		execute(new HibernateCallback(){
			public Object doInHibernate(Session session) {
				session.delete(transientObject);
				return null;
			}
			
		});
	}
	

	
	/**
	 * 
	 * @param entityClass
	 * @param id
	 */
	public void removeById(Class<T> entityClass, Serializable id) {
		remove( get(entityClass, id));
	}
	
	/**
	 * 根据Id获取对象。
	 * @param <T>
	 * @param entityClass
	 * @param id 实体Id
	 * @return 实体对象
	 */
	@SuppressWarnings({ "hiding", "unchecked" })
	public <T> T get(final Class<T> entityClass,final Serializable id) {
		return (T) execute(new HibernateCallback(){
			public Object doInHibernate(Session session) {
				return session.get(entityClass, id);
			}
		});
	}
	
	/**
	 * 创建一个Query对象。
	 * @param hql
	 * @param values
	 * @return
	 */
	public Query createQuery(String hql,Object...values){
		Assert.hasText(hql);
		Query query = getSession().createQuery(hql);
		for(int i = 0;i<values.length;i++){
			query.setParameter(i, values[i]);
		}
		return query;
	}
	
	/**
	 * 创建Criteria对象。
	 * @param <T>
	 * @param entityClass
	 * @param criterions
	 * @return
	 */
	public <T>Criteria createCriteria(Class<T> entityClass,Criterion...criterions){
		Criteria criteria = getSession().createCriteria(entityClass);
		for(Criterion c:criterions){
			criteria.add(c);
		}
		return criteria;
	}
	/**
	 * 创建Criteria对象，有排序功能。
	 * @param <T>
	 * @param entityClass
	 * @param orderBy
	 * @param isAsc
	 * @param criterions
	 * @return
	 */
	public <T>Criteria createCriteria(Class<T> entityClass,String orderBy,boolean isAsc,Criterion...criterions){
		Assert.hasText(orderBy);
		Criteria criteria = createCriteria(entityClass,criterions);
		if(isAsc){
			criteria.addOrder(Order.asc(orderBy));
		}else{
			criteria.addOrder(Order.desc(orderBy));
		}
		return criteria;
	}
	
	/**
	 * 根据hql查询
	 * @param hql
	 * @param values
	 * @return
	 */
	public List find(final String hql,final Object...values){
		Assert.hasText(hql);
		
		return createQuery(hql, values).list();
		
/*		return (List) execute(new HibernateCallback(){

			public Object doInHibernate(Session session) {
				Query query = session.createQuery(hql);
				for(int i = 0;i<values.length;i++){
					query.setParameter(i, values[i]);
				}
				return query.list();
			}
			
		});*/
	}
	
	/**
	 * 根据属性名和属性值查询.
	 *
	 * @return
	 */
	public <T>List<T> findBy(Class<T> entityClass,String propertyName,Object value){
		Assert.hasText(propertyName);
		return createCriteria(entityClass, Restrictions.eq(propertyName, value)).list();
	}
	
	/**
	 * 根据属性名和属性值查询. 有排序
	 * @param <T>
	 * @param entityClass
	 * @param propertyName
	 * @param value
	 * @param orderBy
	 * @param isAsc
	 * @return
	 */
	public <T>List<T> findBy(Class<T> entityClass,String propertyName,Object value,String orderBy,boolean isAsc){
		Assert.hasText(propertyName);
		Assert.hasText(orderBy);
		return createCriteria(entityClass, orderBy, isAsc, Restrictions.eq(propertyName, value)).list();
	}
	
	/**
	 * 根据属性名和属性值 查询 且要求对象唯一.
	 *
	 * @return 符合条件的唯一对象.
	 */
	public <T>T findUniqueBy(Class<T> entityClass,String propertyName,Object value){
		Assert.hasText(propertyName);
		return (T)createCriteria(entityClass, Restrictions.eq(propertyName, value)).uniqueResult();
	}
	/**
	 * 分页 通过hql进行
	 * @param hql
	 * @param pageNo
	 * @param pageSize
	 * @param values
	 * @return
	 */
	public Page pagedQuery(String hql,int pageNo,int pageSize,Object...values){
		Assert.hasText(hql);
		Assert.isTrue(pageNo>=1);
		String countQueryString = "select count(*)" + removeSelect(removeOrders(hql));
		System.out.println(countQueryString);
		List countList = find(countQueryString, values);
		long totalCount =  (Long) countList.get(0);
		System.out.println(totalCount);
		if(totalCount<1){
			return new Page();
		}
		int startIndex = Page.getStartOfPage(pageNo, pageSize);
		Query query = createQuery(hql,values);
		List list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();
		return new Page(startIndex,totalCount,pageSize,list);
	}
	/**
	 * 分页 通过criteria
	 * @param criteria
	 * @param pageNo
	 * @param pageSize
	 * @return
	 */
	public Page pagedQuery(Criteria criteria,int pageNo,int pageSize){
		Assert.notNull(criteria);
		Assert.isTrue(pageNo>=1);
		CriteriaImpl criteriaImpl = (CriteriaImpl) criteria;
		
		//先把Projection和OrderBy条件取出来,清空两者来执行Count操作
		Projection projection = criteriaImpl.getProjection();
		List<CriteriaImpl.OrderEntry> orderEntitys = null;
		try {
			orderEntitys=(List<OrderEntry>) BeanUtils.forceGetProperty(criteriaImpl, "orderEntries");
			BeanUtils.forceSetProperty(cr