generichibernatedao.java

wmoa办公自动化系统 小型的JAVA项目 功能包括审批流 消息发布等

package com.dudu.moa.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.orm.jpa.support.JpaDaoSupport;
import org.springframework.util.Assert;

/**
 * 泛化DAO基类,所有DAO原则上都应该继承此类
 * 
 * 用户可扩展此类,定制自己项目中的DAO基类.
 * 
 * @param <T> DAO访问的entity类
 * @param <PK> DAO访问的entity的主键类
 * 
 * @see JpaDaoSupport
 * 
 * @author denglq
 */
@SuppressWarnings("unchecked")
public class GenericHibernateDao<T, PK extends Serializable> extends HibernateDaoSupport {

	protected final Log log = LogFactory.getLog(getClass());

	protected Class<T> entityClass;

	protected String className;

	public GenericHibernateDao() {
		// 通过范型反射，取得在子类中定义的entityClass.
		this.entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
		className = entityClass.getSimpleName();
	}

	public void save(T entity) {
		Assert.notNull(entity);
		log.debug("saving " + className + "instance : [" + entity + "]");
		getHibernateTemplate().save(entity);
		log.debug("save successful");
	}

	public T update(T entity) {
		Assert.notNull(entity);
		log.debug("updating " + className + " instance : [" + entity + "]");
		T result = (T)getHibernateTemplate().save(entity);
		log.debug("update successful");
		return result;
	}

	public void delete(T entity) {
		Assert.notNull(entity);
		log.debug("deleting " + className + " instance : [" + entity + "]");
		getHibernateTemplate().delete(entity);
		log.debug("delete successful");
	}

	public void delete(final PK id) {
		Assert.notNull(id);
		getHibernateTemplate().delete(get(id));
	}
	
	public void deleteAll(List <PK>ids) {
		Assert.notNull(ids);
		getHibernateTemplate().deleteAll(ids);
	}

	/**
	 * @return id对应的Entity.如果id不存在,返回Null.
	 */
	public T get(final PK id) {
		Assert.notNull(id);
		log.debug("finding " + className + " instance with id: " + id);
		return (T) getHibernateTemplate().get(entityClass, id);
	}

	/**
	 * 根据属性查找对象.
	 * 
	 * @param propertyName 属性名
	 * @param value 属性值
	 * @param rowStartIdxAndCount 可选的分页参数.第一个参数为起始的记录,第二个参数为返回的对象数量.
	 * 
	 * eg.
	 * <code>
	 * findByProperty("country","china");      //查找属性值country为china的对象，返回所有对象.
	 * findByProperty("country","china",0,10); //查找属性值country为china的对象，返回第1-10个符合的对象.
	 * </code>
	 */
	public List<T> findByProperty(final String propertyName, final Object value, final int... rowStartIdxAndCount) {
		Assert.hasLength(propertyName);
		log.info("finding " + className + " instance with property: " + propertyName + " , value: " + value);

		final String queryString = "select model from " + className + " model where model." + propertyName + "= ?";
		log.debug(queryString);
		int rowStartIdx = 0;
		int rowCount = 0;
		if (rowStartIdxAndCount != null && rowStartIdxAndCount.length > 0) {
			rowStartIdx = Math.max(0, rowStartIdxAndCount[0]);
			if (rowStartIdxAndCount.length > 1)
				rowCount = Math.max(0, rowStartIdxAndCount[1]);
		}

		return findPaged(queryString, rowStartIdx, rowCount, value);
	}

	/**
	 * 根据属性查找唯一对象.
	 * 
	 * @return 唯一对象.如果不存在符合条件的结果,返回Null,如果有多个对象符合条件,抛出异常.
	 * 
	 * @param propertyName 属性名
	 * @param value 属性值
	 */
	public T findUniqueByProperty(final String propertyName, final Object value) {
		return uniqueResult(findByProperty(propertyName, value));
	}

	/**
	 * 获取全部对象.
	 * 
	 * @param rowStartIdxAndCount 可选的分页参数.第一个参数为起始的记录,第二个参数为返回的对象数量.
	 * 
	 * eg.
	 * <code>
	 * findAll();     //返回所有对象.
	 * findAll(0,10); //返回第1-10个对象.
	 * </code>
	 */
	public List<T> findAll(final int... rowStartIdxAndCount) {
		log.info("finding all " + className + " instances");
		final String queryString = "select model from " + className + " model";
		int rowStartIdx = 0;
		int rowCount = 0;
		if (rowStartIdxAndCount != null && rowStartIdxAndCount.length > 0) {
			rowStartIdx = Math.max(0, rowStartIdxAndCount[0]);
			if (rowStartIdxAndCount.length > 1)
				rowCount = Math.max(0, rowStartIdxAndCount[1]);
		}

		return findPaged(queryString, rowStartIdx, rowCount);
	}

	/**
	 * 直接使用查询语句查询. 
	 * 
	 * @param values 任意数量的参数.
	 */
	public List find(final String queryString, final Object... values) {
		Assert.hasLength(queryString);
		return getHibernateTemplate().find(queryString, values);
	}

	/**
	 * 直接使用查询语句查询,带分页参数.
	 * 
	 * @param rowStartIdx 起始的记录,如不想设定，可设为-1.
	 * @param rowCount 返回的记录数,如不想设定，可设为-1.
	 * @param values 任意数量的参数.
	 */
	public List findPaged(final String queryString, final int rowStartIdx, final int rowCount, final Object... values) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				Query query = session.createQuery(queryString);

				if (values != null)
					for (int i = 0; i < values.length; i++)
						query.setParameter(i, values[i]);
				
				if (rowStartIdx > 0)
					query.setFirstResult(rowStartIdx);
				if (rowCount > 0)
					query.setMaxResults(rowCount);

				return query.list();
			}
		});
	}

	/**
	 * 直接使用查询语句查询,返回唯一对象
	 * 
	 * @param values 任意数量的参数.
	 * @return 唯一对象.如果不存在符合条件的结果,返回NULL,如果有多个对象符合条件，抛出异常.
	 */
	public Object findUnique(final String queryString, final Object... values) {
		Assert.hasLength(queryString);
		return uniqueResult(getHibernateTemplate().find(queryString, values));
	}

	/**
	 * 取得entity的class.
	 */
	public Class<T> getEntityClass() {
		return entityClass;
	}

	/**
	 * 取出列表的第一个对象.
	 * 如果列表为空返回Null,如果有多于一个对象,抛出异常.
	 */
	private static <E> E uniqueResult(Collection<E> results) {
		if (results == null || results.isEmpty())
			return null;
		if (results.size() > 1)
			throw new IllegalArgumentException("the Collection size is larger than 1");
		return results.iterator().next();
	}

}