hibernate的后缀形式dao

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

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.scmhr.oa.common.dao.Dao;
import com.scmhr.oa.common.model.Page;

public class DaoImpl<T extends Dao<?, ?, ?>, U, ID extends Serializable> extends
		HibernateDaoSupport implements Dao<T, U, ID> {
	protected static final int MAX_BAT_ROW = 10; // 批量操作每次提交记录数
	private DetachedCriteria criteria;
	protected Class<U> entityClass;

	@SuppressWarnings("unchecked")
	protected Class<U> getEntityClass() {
		if(this.entityClass == null) {
			this.entityClass = (Class<U>)((ParameterizedType)getClass().getGenericSuperclass())
					.getActualTypeArguments()[1];
		}
		return this.entityClass;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T newQuery() {
		criteria = DetachedCriteria.forClass(getEntityClass());
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<U> list() {
		return this.getHibernateTemplate().findByCriteria(criteria);
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<U> listPage(int start, int size) {
		return this.getHibernateTemplate().findByCriteria(criteria, start, size);
	}

	@Override
	public Integer count() {
		criteria.setProjection(Projections.rowCount());
		return Integer.parseInt(this.getHibernateTemplate().findByCriteria(criteria).get(0)
				.toString());
	}

	@SuppressWarnings("unchecked")
	@Override
	public U singleResult() {
		List<U> list = this.getHibernateTemplate().findByCriteria(criteria);
		if(list == null || list.size() <= 0) {
			return null;
		}
		return (U)list.get(0);
	}

	@SuppressWarnings("unchecked")
	@Override
	public T findById(ID id) {
		criteria.add(Restrictions.idEq(id));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T findBy(String property, Object value) {
		criteria.add(Restrictions.eq(property, value));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T findLike(String property, Object value) {
		criteria.add(Restrictions.like(property, value));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T between(String property, Object start, Object end) {
		criteria.add(Restrictions.between(property, start, end));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T lt(String property, Object value) {
		criteria.add(Restrictions.lt(property, value));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T gt(String property, Object value) {
		criteria.add(Restrictions.gt(property, value));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T le(String property, Object value) {
		criteria.add(Restrictions.le(property, value));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T ge(String property, Object value) {
		criteria.add(Restrictions.ge(property, value));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T isNull(String property) {
		criteria.add(Restrictions.isNull(property));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T isNotNull(String property) {
		criteria.add(Restrictions.isNotNull(property));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T in(String property, List<Object> values) {
		criteria.add(Restrictions.in(property, values));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T in(String property, Object[] os) {
		criteria.add(Restrictions.in(property, os));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T desc(String property) {
		criteria.addOrder(Order.desc(property));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T asc(String property) {
		criteria.addOrder(Order.asc(property));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public ID save(U entity) {
		return (ID)this.getHibernateTemplate().save(entity);
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<U> save(final List<U> entities) {
		List<U> list = (List<U>)this.getHibernateTemplate().execute(
				new HibernateCallback<Object>() {
					@Override
					public Object doInHibernate(Session session) throws HibernateException,
							SQLException {
						int count = 0;
						Iterator<U> it = entities.iterator();
						while(it.hasNext()) {
							session.save(it.next());
							count++;
							// 10次操作一次，跟缓存大小相关，若这个数字太大，怕缓存溢出，太小，效率低
							if(count % MAX_BAT_ROW == 0) {
								session.flush();
								session.clear();
							}
						}
						return entities;
					}
				});
		return list;
	}

	@Override
	public void delete(U entity) {
		this.getHibernateTemplate().delete(entity);
	}

	@Override
	public void deleteById(ID id) {
		this.getHibernateTemplate().delete(this.getHibernateTemplate().get(getEntityClass(), id));
	}

	@Override
	public void delete(final List<U> entities) {
		this.getHibernateTemplate().execute(new HibernateCallback<Object>() {
			@Override
			public Object doInHibernate(Session session) throws HibernateException, SQLException {
				int count = 0;
				Iterator<U> it = entities.iterator();
				while(it.hasNext()) {
					session.delete(it.next());
					count++;
					if(count % MAX_BAT_ROW == 0) {
						session.flush();
						session.clear();
					}
				}
				return count;
			}
		});
	}

	@Override
	public void deleteByIds(final List<ID> ids) {
		this.getHibernateTemplate().execute(new HibernateCallback<Object>() {
			@Override
			public Object doInHibernate(Session session) throws HibernateException, SQLException {
				int count = 0;
				Iterator<ID> it = ids.iterator();
				while(it.hasNext()) {
					Object obj = session.get(getEntityClass(), it.next());
					session.delete(obj);
					count++;
					if(count % MAX_BAT_ROW == 0) {
						session.flush();
						session.clear();
					}
				}
				return count;
			}
		});
	}

	@Override
	public void update(U entity) {
		this.getHibernateTemplate().update(entity);
	}

	@Override
	public void update(final List<U> entities) {
		this.getHibernateTemplate().execute(new HibernateCallback<Object>() {
			@Override
			public Object doInHibernate(Session session) throws HibernateException, SQLException {
				int count = 0;
				Iterator<U> it = entities.iterator();
				while(it.hasNext()) {
					session.update(it.next());
					count++;
					if(count % MAX_BAT_ROW == 0) {
						session.flush();
						session.clear();
					}
				}
				return entities;
			}
		});
	}

	@Override
	public Page<U> findByPage(final int pageNo, final int pageSize) {
		final DetachedCriteria detachedCriteria = this.criteria;
		Page<U> page = this.getHibernateTemplate().execute(new HibernateCallback<Page<U>>() {
			@SuppressWarnings("unchecked")
			@Override
			public Page<U> doInHibernate(Session session) throws HibernateException, SQLException {
				Criteria criteria = detachedCriteria.getExecutableCriteria(session);
				int totalCount = ((Long)criteria.setProjection(Projections.rowCount())
						.uniqueResult()).intValue(); // 总行数
				criteria.setProjection(null); // 这里需要重新设置
				// 只返回根对象，不加此限制结果将返回数组，包含根对象与关联对象
				criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
				if(pageNo > 0) {
					int maxResults = pageSize;
					if(pageSize < 1) {
						maxResults = 1;
					}
					int firstResult = (pageNo - 1) * maxResults;
					criteria.setFirstResult(firstResult); // 设置首条记录的位置
					criteria.setMaxResults(maxResults); // 设置查询的记录数
				}
				List<U> list = criteria.list();
				Page<U> page = new Page<U>(pageNo, pageSize, totalCount, list); // 构造分页对象
				return page;
			}
		});
		return page;
	}

	@Override
	public List<U> findAll() {
		List<U> list = this.getHibernateTemplate().loadAll(getEntityClass());
		return list;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T notIn(String property, List<Object> values) {
		criteria.add(Restrictions.not(Restrictions.in(property, values)));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T notIn(String property, Object[] os) {
		criteria.add(Restrictions.not(Restrictions.in(property, os)));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	public T join(String associationPath, String alias) {
		criteria.createAlias(associationPath, alias);
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T leftJoin(String associationPath, String alias) {
		criteria.createAlias(associationPath, alias, CriteriaSpecification.LEFT_JOIN);
		return (T)this;
	}

	@Override
	public Object[] groupBy(String property) {
		criteria.setProjection(Projections.groupProperty(property));
		return this.getHibernateTemplate().findByCriteria(criteria).toArray();
	}

	@Override
	public Integer sum(String property) {
		criteria.setProjection(Projections.sum(property));
		return Integer.parseInt(this.getHibernateTemplate().findByCriteria(criteria).get(0)
				.toString());
	}

	@Override
	public Object max(String property) {
		criteria.setProjection(Projections.max(property));
		return this.getHibernateTemplate().findByCriteria(criteria).get(0);
	}

	@Override
	public Object min(String property) {
		criteria.setProjection(Projections.min(property));
		return this.getHibernateTemplate().findByCriteria(criteria).get(0);
	}

	@SuppressWarnings("unchecked")
	@Override
	public T ne(String property, Object value) {
		criteria.add(Restrictions.ne(property, value));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T in(String property, Collection<?> values) {
		criteria.add(Restrictions.in(property, values));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T notIn(String property, Collection<?> values) {
		criteria.add(Restrictions.not(Restrictions.in(property, values)));
		return (T)this;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T sql(String sql) {
		criteria.add(Restrictions.sqlRestriction(sql));
		return (T)this;
	}
}