hibernategenericdao.java

自己封装的基于spring,hibernate的DAO基类

package org.xxxplatform.core.commons;

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

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.MatchMode;
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.xxxplatform.core.Constants;
import org.xxxplatform.core.commons.support.Page;
import org.xxxplatform.core.utils.BeanUtils;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.util.Assert;

/**
 * 范型的HibernateDao 基类 对返回值作了泛型转换.并提供分页函数和若干便捷查询方法.
 * 
 * @author yyy
 */
@SuppressWarnings("unchecked")
public class HibernateGenericDao extends HibernateDaoSupport {
	/**
	 * 查询得到主键为id的对象
	 * 
	 */
	public <T> T get(Class<T> entityClass, Serializable id) {
		T o = (T) getHibernateTemplate().get(entityClass, id);
		if (o == null)
			throw new ObjectRetrievalFailureException(entityClass, id);
		return o;
	}

	/**
	 * 查询得到该类的所有对象
	 * 
	 */
	public <T> List<T> get(Class<T> entityClass) {
		return getHibernateTemplate().loadAll(entityClass);
	}

	/**
	 * 保存对象
	 * 
	 */
	public void save(Object o) {
		getHibernateTemplate().saveOrUpdate(o);
	}

	/**
	 * Insert对象到数据库
	 * 
	 */
	public void insert(Object o) {
		getHibernateTemplate().save(o);
	}

	/**
	 * 刷新对象
	 * 
	 * @author yyy
	 */
	public void refresh(Object o) {
		getHibernateTemplate().refresh(o, LockMode.READ);
	}

	/**
	 * 从Session中移走对象
	 * 
	 * @author yyy
	 */
	public void evict(Object o) {
		getHibernateTemplate().evict(o);
	}

	/**
	 * 提交Session中的对象
	 * 
	 * @author yyy
	 */
	public void flush() {
		getHibernateTemplate().flush();
	}

	/**
	 * 清除Session中的对象
	 * 
	 * @author yyy
	 */
	public void clear() {
		getHibernateTemplate().clear();
	}

	/**
	 * 批量保存对象入库
	 * 
	 * @author yyy
	 */
	public void batchInsert(final List objects) {
		Assert.notNull(objects);
		getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException {
				int max = objects.size();
				for (int i = 0; i < max; i++) {
					session.save(objects.get(i));
					if ((i != 0 && i % Constants.DEFAULT_BATCH_SIZE == 0) || i == max - 1) {
						session.flush();
						session.clear();
					}
				}
				return null;
			}
		});
	}

	/**
	 * 批量保存对象入库
	 * 
	 * @author yyy
	 */
	public void batchSave(final List objects) {
		Assert.notNull(objects);
		getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException {
				int max = objects.size();
				for (int i = 0; i < max; i++) {
					session.saveOrUpdate(objects.get(i));
					if ((i != 0 && i % Constants.DEFAULT_BATCH_SIZE == 0) || i == max - 1) {
						session.flush();
						session.clear();
					}
				}
				return null;
			}
		});
	}

	/**
	 * 批量删除对象
	 * 
	 * @author yyy
	 */
	public void batchRemove(final List objects) {
		Assert.notNull(objects);
		getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException {
				int max = objects.size();
				for (int i = 0; i < max; i++) {
					session.refresh(objects.get(i));
					session.delete(objects.get(i));
					if (i % Constants.DEFAULT_BATCH_SIZE == 0) {
						session.flush();
						session.clear();
					}
				}
				return null;
			}
		});
	}

	/**
	 * 删除对象
	 * 
	 * @auth yyy
	 */
	public void remove(Object o) {
		getHibernateTemplate().delete(o);
	}

	public void remove(Collection c) {
		getHibernateTemplate().deleteAll(c);
	}

	/**
	 * 按id删除对象
	 * 
	 * @auth yyy
	 */
	public <T> void remove(Class<T> entityClass, Serializable id) {
		remove(get(entityClass, id));
	}

	/**
	 * hql查询.
	 * 
	 * @param values
	 *          可变参数 用户可以如下四种方式使用 dao.find(hql) dao.find(hql,arg0);
	 *          dao.find(hql,arg0,arg1); dao.find(hql,new Object[arg0,arg1,arg2])
	 */
	public List find(String hql, Object... values) {
		if (values.length == 0)
			return getHibernateTemplate().find(hql);
		else
			return getHibernateTemplate().find(hql, values);
	}

	/**
	 * 对参数名和参数值进行验证。 params以","分割,params分割的个数必须和values的个数相同。
	 * 
	 * @author yyy
	 */
	protected void validateParamsAndValues(String params, Object... values) {
		Assert.notNull(params);
		Assert.notEmpty(values);
		Assert.isTrue(params.split(",").length == values.length, "this params'length must be equal to this values' length");
	}

	/**
	 * 命名参数查询 params以","分割,params分割的个数必须和values的个数相同。
	 * 
	 * @author yyy
	 */
	public List findByNamedParam(String hsql, String params, Object... values) {
		validateParamsAndValues(params, values);
		return getHibernateTemplate().findByNamedParam(hsql, params.split(","), values);
	}

	/**
	 * 根据属性名和属性值查询对象.
	 * 
	 * @return 符合条件的唯一对象
	 */
	public <T> T findUnique(Class<T> entityClass, String params, Object... values) {
		validateParamsAndValues(params, values);
		Criteria criteria = getEntityCriteria(entityClass);

		String[] paramNames = params.split(",");
		for (int i = 0; i < paramNames.length; i++) {
			criteria.add(Restrictions.eq(paramNames[i], values[i]));
		}
		return (T) criteria.uniqueResult();
	}

	/**
	 * 根据属性名和属性值查询对象.
	 * 
	 * @return 符合条件的对象列表
	 */
	public <T> List<T> findEqual(Class<T> entityClass, String params, Object... values) {
		validateParamsAndValues(params, values);
		Criteria criteria = getEntityCriteria(entityClass);

		String[] paramNames = params.split(",");
		for (int i = 0; i < paramNames.length; i++) {
			criteria.add(Restrictions.eq(paramNames[i], values[i]));
		}
		return criteria.list();
	}

	/**
	 * 根据属性名和属性值以Like AnyWhere方式查询对象.
	 */
	public <T> List<T> findLike(Class<T> entityClass, String params, String values) {
		Assert.notNull(params);
		Assert.notNull(values);
		Criteria criteria = getEntityCriteria(entityClass);

		String[] paramNames = params.split(",");
		String[] paramValues = values.split(",");
		Assert.isTrue(paramNames.length == paramValues.length && paramNames.length > 0);
		for (int i = 0; i < paramNames.length; i++) {
			criteria.add(Restrictions.like(paramNames[i], paramValues[i], MatchMode.ANYWHERE));