HibernateDao.java

http://my.oschina.net/lizy/blog/526769

/**

 * Copyright (c) 2005-2010 springside.org.cn

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * 

 * $Id: HibernateDao.java 1205 2010-09-09 15:12:17Z calvinxiu $

 */

package com.dao.hibernate;



import java.io.Serializable;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;



import org.apache.commons.lang.StringUtils;

import org.apache.commons.lang.math.NumberUtils;

import org.hibernate.Criteria;

import org.hibernate.Query;

import org.hibernate.SessionFactory;

import org.hibernate.criterion.CriteriaSpecification;

import org.hibernate.criterion.Criterion;

import org.hibernate.criterion.Disjunction;

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.hibernate.transform.ResultTransformer;

import org.springframework.util.Assert;



import com.dao.hibernate.PropertyFilter.MatchType;

import com.utils.ReflectionUtils;



/**

 * 封装SpringSide扩展功能的Hibernat DAO泛型基类.

 * 

 * 扩展功能包括分页查询,按属性过滤条件列表查询. 可在Service层直接使用,也可以扩展泛型DAO子类使用,见两个构造函数的注释.

 * 

 * @param <T>

 *            DAO操作的对象类型

 * @param <PK>

 *            主键类型

 * 

 * @author calvin

 */

public class HibernateDao<T, PK extends Serializable> extends

 SimpleHibernateDao<T, PK> {

 /**

  * 用于Dao层子类的构造函数. 通过子类的泛型定义取得对象类型Class. eg. public class UserDao extends

  * HibernateDao<User, Long>{ }

  */

 public HibernateDao() {

 super();

 }



 /**

  * 用于省略Dao层, Service层直接使用通用HibernateDao的构造函数. 在构造函数中定义对象类型Class. eg.

  * HibernateDao<User, Long> userDao = new HibernateDao<User,

  * Long>(sessionFactory, User.class);

  */

 public HibernateDao(final SessionFactory sessionFactory,

 final Class<T> entityClass) {

 super(sessionFactory, entityClass);

 }



 // -- 分页查询函数 --//



 /**

  * 分页获取全部对象.

  */

 public Page<T> getAll(final Page<T> page) {

 return findPage(page);

 }



 /**

  * 按HQL分页查询.

  * 

  * @param page

  *            分页参数. 注意不支持其中的orderBy参数.

  * @param hql

  *            hql语句.

  * @param values

  *            数量可变的查询参数,按顺序绑定.

  * 

  * @return 分页查询结果, 附带结果列表及所有查询输入参数.

  */

 public Page<T> findPage(final Page<T> page, final String hql,

 final Object... values) {

 Assert.notNull(page, "page不能为空");



 Query q = createQuery(hql, values);



 if (page.isAutoCount()) {

 long totalCount = countHqlResult(hql, values);

 page.setTotalCount(totalCount);

 }



 setPageParameterToQuery(q, page);



 List result = q.list();

 page.setResult(result);

 return page;

 }



 /**

  * 按HQL分页查询.

  * 

  * @param page

  *            分页参数. 注意不支持其中的orderBy参数.

  * @param hql

  *            hql语句.

  * @param values

  *            命名参数,按名称绑定.

  * 

  * @return 分页查询结果, 附带结果列表及所有查询输入参数.

  */

 @SuppressWarnings("unchecked")

 public Page<T> findPage(final Page<T> page, final String hql,

 final Map<String, ?> values) {

 Assert.notNull(page, "page不能为空");



 Query q = createQuery(hql, values);



 if (page.isAutoCount()) {

 long totalCount = countHqlResult(hql, values);

 page.setTotalCount(totalCount);

 }



 setPageParameterToQuery(q, page);



 List result = q.list();

 page.setResult(result);

 return page;

 }



 /**

  * 按Criteria分页查询.

  * 

  * @param page

  *            分页参数.

  * @param criterions

  *            数量可变的Criterion.

  * 

  * @return 分页查询结果.附带结果列表及所有查询输入参数.

  */

 @SuppressWarnings("unchecked")

 public Page<T> findPage(final Page<T> page, final Criterion... criterions) {

 Assert.notNull(page, "page不能为空");



 Criteria c = createCriteria(criterions);



 if (page.isAutoCount()) {

 long totalCount = countCriteriaResult(c);

 page.setTotalCount(totalCount);

 }

 

 if(page.getPageNo() > page.getTotalPages()) {

 page.setPageNo(NumberUtils.toInt(Long.toString(page.getTotalPages())));

 }

 

 setPageParameterToCriteria(c, page);



 List result = c.list();

 page.setResult(result);

 return page;

 }



 /**

  * 设置分页参数到Query对象,辅助函数.

  */

 protected Query setPageParameterToQuery(final Query q, final Page<T> page) {



 Assert.isTrue(page.getPageSize() > 0, "Page Size must larger than zero");



 // hibernate的firstResult的序号从0开始

 q.setFirstResult(page.getFirst() - 1);

 q.setMaxResults(page.getPageSize());

 return q;

 }



 /**

  * 设置分页参数到Criteria对象,辅助函数.

  */

 protected Criteria setPageParameterToCriteria(final Criteria c,

 final Page<T> page) {



 Assert.isTrue(page.getPageSize() > 0, "Page Size must larger than zero");



 // hibernate的firstResult的序号从0开始

 c.setFirstResult(page.getFirst() - 1);

 c.setMaxResults(page.getPageSize());



 if (page.isOrderBySetted()) {

 String[] orderByArray = StringUtils.split(page.getOrderBy(), ',');

 String[] orderArray = StringUtils.split(page.getOrder(), ',');



 Assert.isTrue(orderByArray.length == orderArray.length,

 "分页多重排序参数中,排序字段与排序方向的个数不相等");



 for (int i = 0; i < orderByArray.length; i++) {

 if (Page.ASC.equals(orderArray[i])) {

 c.addOrder(Order.asc(orderByArray[i]));

 } else {

 c.addOrder(Order.desc(orderByArray[i]));

 }

 }

 }

 return c;

 }



 /**

  * 执行count查询获得本次Hql查询所能获得的对象总数.

  * 

  * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.

  */

 protected long countHqlResult(final String hql, final Object... values) {

 String countHql = prepareCountHql(hql);



 try {

 Long count = findUnique(countHql, values);

 return count;

 } catch (Exception e) {

 throw new RuntimeException("hql can't be auto count, hql is:"

 + countHql, e);

 }

 }



 /**

  * 执行count查询获得本次Hql查询所能获得的对象总数.

  * 

  * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.

  */

 protected long countHqlResult(final String hql, final Map<String, ?> values) {

 String countHql = prepareCountHql(hql);



 try {

 Long count = findUnique(countHql, values);

 return count;

 } catch (Exception e) {

 throw new RuntimeException("hql can't be auto count, hql is:"

 + countHql, e);

 }

 }



 private String prepareCountHql(String orgHql) {

 String fromHql = orgHql;

 // select子句与order by子句会影响count查询,进行简单的排除.

 fromHql = "from " + StringUtils.substringAfter(fromHql, "from");

 fromHql = StringUtils.substringBefore(fromHql, "order by");



 String countHql = "select count(*) " + fromHql;

 return countHql;

 }



 /**

  * 执行count查询获得本次Criteria查询所能获得的对象总数.

  */

 @SuppressWarnings("unchecked")

 protected long countCriteriaResult(final Criteria c) {

 CriteriaImpl impl = (CriteriaImpl) c;



 // 先把Projection、ResultTransformer、OrderBy取出来,清空三者后再执行Count操作

 Projection projection = impl.getProjection();

 ResultTransformer transformer = impl.getResultTransformer();



 List<CriteriaImpl.OrderEntry> orderEntries = null;

 try {

 orderEntries = (List) ReflectionUtils.getFieldValue(impl,

 "orderEntries");

 ReflectionUtils

 .setFieldValue(impl, "orderEntries", new ArrayList());

 } catch (Exception e) {

 logger.error("不可能抛出的异常:{}", e.getMessage());

 }



 // 执行Count查询

 Long totalCountObject = Long.parseLong(c

 .setProjection(Projections.rowCount()).uniqueResult()

 .toString());

 long totalCount = (totalCountObject != null) ? totalCountObject : 0;



 // 将之前的Projection,ResultTransformer和OrderBy条件重新设回去

 c.setProjection(projection);



 if (projection == null) {

 c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);

 }

 if (transformer != null) {

 c.setResultTransformer(transformer);

 }

 try {

 ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);

 } catch (Exception e) {

 logger.error("不可能抛出的异常:{}", e.getMessage());

 }



 return totalCount;

 }



 // -- 属性过滤条件(PropertyFilter)查询函数 --//



 /**

  * 按属性查找对象列表,支持多种匹配方式.

  * 

  * @param matchType

  *            匹配方式,目前支持的取值见PropertyFilter的MatcheType enum.

  */

 public List<T> findBy(final String propertyName, final Object value,

 final MatchType matchType) {

 Criterion criterion = buildCriterion(propertyName, value, matchType);

 return find(criterion);

 }



 /**

  * 按属性过滤条件列表查找对象列表.

  */

 public List<T> find(List<PropertyFilter> filters) {

 Criterion[] criterions = buildCriterionByPropertyFilter(filters);

 return find(criterions);

 }



 /**

  * 按属性过滤条件列表分页查找对象.

  */

 public Page<T> findPage(final Page<T> page,

 final List<PropertyFilter> filters) {

 Criterion[] criterions = buildCriterionByPropertyFilter(filters);

 return findPage(page, criterions);

 }



 /**

  * 按属性条件参数创建Criterion,辅助函数.

  */

 protected Criterion buildCriterion(final String propertyName,

 final Object propertyValue, final MatchType matchType) {

 Assert.hasText(propertyName, "propertyName不能为空");

 Criterion criterion = null;

 // 根据MatchType构造criterion

 switch (matchType) {

 case EQ:

 criterion = Restrictions.eq(propertyName, propertyValue);

 break;

 case LIKE:

 criterion = Restrictions.like(propertyName, (String) propertyValue,

 MatchMode.ANYWHERE);

 break;



 case LE:

 criterion = Restrictions.le(propertyName, propertyValue);

 break;

 case LT:

 criterion = Restrictions.lt(propertyName, propertyValue);

 break;

 case GE:

 criterion = Restrictions.ge(propertyName, propertyValue);

 break;

 case GT:

 criterion = Restrictions.gt(propertyName, propertyValue);

 }

 return criterion;

 }



 /**

  * 按属性条件列表创建Criterion数组,辅助函数.

  */

 protected Criterion[] buildCriterionByPropertyFilter(

 final List<PropertyFilter> filters) {

 List<Criterion> criterionList = new ArrayList<Criterion>();

 for (PropertyFilter filter : filters) {

 if (!filter.hasMultiProperties()) { // 只有一个属性需要比较的情况.

 Criterion criterion = buildCriterion(filter.getPropertyName(),

 filter.getMatchValue(), filter.getMatchType());

 criterionList.add(criterion);

 } else {// 包含多个属性需要比较的情况,进行or处理.

 Disjunction disjunction = Restrictions.disjunction();

 for (String param : filter.getPropertyNames()) {

 Criterion criterion = buildCriterion(param,

 filter.getMatchValue(), filter.getMatchType());

 disjunction.add(criterion);

 }

 criterionList.add(disjunction);

 }

 }

 return criterionList.toArray(new Criterion[criterionList.size()]);

 }

}