一个泛型Hibernate DAO实现

自己四处参考，写写抄抄折腾出来的一个泛型Hibernate DAO，用了Spring的HibernateDaoSupport。提供基本的CRUD操作，支持分页查询，可使用HQL、Criteria和DetachedCriteria。
废话不说了，上代码

package sgf4web.dao;

import java.io.Serializable;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.hibernate.*;
import org.hibernate.criterion.*;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import sgf4web.dao.support.PaginationSupport;
import sgf4web.util.GenericsUtils;

/** *//**
 * 泛型Hibernate DAO类
 * 
 * @author DigitalSonic
 */
@SuppressWarnings("unchecked")
public class HibernateGenericDao<T, ID extends Serializable> extends HibernateDaoSupport ...{
    private Class<T> pojoClass;
    
    /** *//**
     * 初始化DAO，获取POJO类型
     */
    public HibernateGenericDao() ...{
//        this.pojoClass = (Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        this.pojoClass = GenericsUtils.getSuperClassGenricType(getClass());
    }
    
    /** *//**
     * 获得该DAO对应的POJO类型
     */
    public Class<T> getPojoClass() ...{
        return this.pojoClass;
    }
    
    /** *//**
     * 获得该DAO对应的POJO类型名
     */
    public String getPojoClassName() ...{
        return getPojoClass().getName();
    }

    //加载对象
    
    /** *//**
     * 加载所有的对象
     */
    public List<T> loadAll() ...{
        return (List<T>)getHibernateTemplate().loadAll(getPojoClass());
    }
    
    /** *//**
     * 根据hql查询
     *
     * @param values 可变参数
     */
    public List find(String hql, Object... values) ...{
        return getHibernateTemplate().find(hql, values);
    }

    /** *//**
     * 根据条件加载对象
     * 
     * @param criteria Criteria实例
     */
    public List<T> findByCriteria(final Criteria criteria) ...{
        List list = criteria.list(); 
        return transformResults(list);
    }
    
    /** *//**
     * 根据条件加载对象
     * @param detachedCriteria DetachedCriteria实例
     */
    public List<T> findByCriteria(final DetachedCriteria detachedCriteria) ...{
        return (List<T>) getHibernateTemplate().execute(new HibernateCallback() ...{
               public Object doInHibernate(Session session) throws HibernateException ...{
                   Criteria criteria = detachedCriteria.getExecutableCriteria(session);
                   List list = criteria.list(); 
                   return transformResults(list); 
               }
           }, true);
    }
    
    /** *//**
     * 根据给定的实例查找对象
     */
    public List<T> findByExample(T instance) ...{
        List<T> results = (List<T>)getHibernateTemplate().findByExample(instance);
        return results;
    }    
    
    /** *//**
     * 根据ID查找对象
     */
    public T findById(ID id) ...{
        return (T) getHibernateTemplate().get(getPojoClassName(), id);
    }
    
    /** *//**
     * 根据某个具体属性进行查找
     */
    public List<T> findByProperty(String propertyName, Object value) ...{
       String queryString = "from " + getPojoClassName() + " as model where model." 
                               + propertyName + "= ?";
       return (List<T>)getHibernateTemplate().find(queryString, value);
    }
    
    //新建、修改、删除
    
    /** *//**
     * 新建对象实例化
     */
    public ID save(T transientInstance) ...{
        return (ID)getHibernateTemplate().save(transientInstance);
    }
    
    /** *//**
     * 更新已存在的对象
     */
    public void update(T transientInstance) ...{
        getHibernateTemplate().update(transientInstance);
    }
    
    /** *//**
     * 删除指定ID的对象
     */
    public void delete(ID id) ...{
           T instance = findById(id);
           if (instance != null)
               getHibernateTemplate().delete(instance);
    }
    
    /** *//**
     * 删除指定对象
     */
    public void delete(T persistentInstance) ...{
        getHibernateTemplate().delete(persistentInstance);
    }    
    
    //分页
    /** *//**
     * 根据Criteria加载分页，指定页大小和起始位置
     */
    public PaginationSupport findPageByCriteria(final Criteria criteria, final int pageSize, final int startIndex) ...{   
        int totalCount = getCountByCriteria(criteria);   
        criteria.setProjection(null);
        List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();
        items = transformResults(items);
        PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);
        return ps;
    }
    
    /** *//**
     * 根据Criteria加载分页，默认页大小，从第0条开始
     */
    public PaginationSupport findPageByCriteria(final Criteria criteria) ...{   
        return findPageByCriteria(criteria, PaginationSupport.PAGESIZE, 0);   
    }   
 
    /** *//**
     * 根据Criteria加载分页，默认页大小，从第startIndex条开始
     */
    public PaginationSupport findPageByCriteria(final Criteria criteria, final int startIndex) ...{   
        return findPageByCriteria(criteria, PaginationSupport.PAGESIZE, startIndex);   
    }
    
    /** *//**
     * 根据Criteria统计总数
     */
    public int getCountByCriteria(final Criteria criteria) ...{   
        Integer count = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult();    
        return count.intValue();   
    }
    
    /** *//**
     * 根据DetachedCriteria加载分页，指定页大小和起始位置
     */
    public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int pageSize, final int startIndex) ...{   
        return (PaginationSupport) getHibernateTemplate().execute(new HibernateCallback() ...{   
            public Object doInHibernate(Session session) throws HibernateException ...{   
                Criteria criteria = detachedCriteria.getExecutableCriteria(session);
                int totalCount = ((Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();   
                criteria.setProjection(null);
                List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();
                items = transformResults(items);
                PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);   
                return ps;   
            }
        }, true);   
    }
    
    /** *//**
     * 根据DetachedCriteria加载分页，默认页大小，从第0条开始
     */
    public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria) ...{   
        return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, 0);   
    }   
  
    /** *//**
     * 根据DetachedCriteria加载分页，默认页大小，从第startIndex条开始
     */
    public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int startIndex) ...{   
        return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, startIndex);   
    } 
    
    /** *//**
     * 根据DetachedCriteria统计总数
     */
    public int getCountByCriteria(final DetachedCriteria detachedCriteria) ...{   
        Integer count = (Integer) getHibernateTemplate().execute(new HibernateCallback() ...{   
            public Object doInHibernate(Session session) throws HibernateException ...{   
                Criteria criteria = detachedCriteria.getExecutableCriteria(session);   
                return criteria.setProjection(Projections.rowCount()).uniqueResult();   
            }   
        }, true);   
        return count.intValue();   
    } 
    
    /** *//**
     * 根据hql加载分页，指定页大小和起始位置
     */
    public PaginationSupport findPageByQuery(final String hql, final int pageSize, final int startIndex, Object...values) ...{
        int totalCount = getCountByQuery(hql, values);
        
        if (totalCount < 1)
            return new PaginationSupport(new ArrayList(0), 0);

        Query query = createQuery(hql, values);
        List items = query.setFirstResult(startIndex).setMaxResults(pageSize).list();
        PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);
        return ps;
    }
    
    /** *//**
     * 根据hql加载分页，默认页大小，从第0条开始
     */
    public PaginationSupport findPageByQuery(final String hql, Object...values) ...{   
        return findPageByQuery(hql, PaginationSupport.PAGESIZE, 0, values);   
    }   
 
    /** *//**
     * 根据hql加载分页，默认页大小，从第startIndex条开始
     */
    public PaginationSupport findPageByQuery(final String hql, final int startIndex, Object...values) ...{   
        return findPageByQuery(hql, PaginationSupport.PAGESIZE, startIndex, values);  
    }
    
    /** *//**
     * 根据hql统计总数
     */
    public int getCountByQuery(final String hql, Object...values) ...{   
        String countQueryString = " select count (*) " + removeSelect(removeOrders(hql));
        List countlist = getHibernateTemplate().find(countQueryString, values);
        return (Integer) countlist.get(0);
    }
    
    //创建Criteria和Query
    
    /** *//**
     * 创建Criteria对象
     *
     * @param criterions 可变的Restrictions条件列表
     */
    public Criteria createCriteria(Criterion...criterions) ...{
        Criteria criteria = getSession().createCriteria(getPojoClass());
        for (Criterion c : criterions)
            criteria.add(c);
        return criteria;
    }

    /** *//**
     * 创建Criteria对象，带排序字段与升降序字段
     */
    public Criteria createCriteria(String orderBy, boolean isAsc, Criterion...criterions) ...{
        Criteria criteria = createCriteria(criterions);
        if (isAsc)
            criteria.addOrder(Order.asc(orderBy));
        else
            criteria.addOrder(Order.desc(orderBy));
        return criteria;
    }
    
    /** *//**
     * 方法取自SpringSide.
     * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
     * 留意可以连续设置,如下：
     * <pre>
     * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
     * </pre>
     * 调用方式如下：
     * <pre>
     *        dao.createQuery(hql)
     *        dao.createQuery(hql,arg0);
     *        dao.createQuery(hql,arg0,arg1);
     *        dao.createQuery(hql,new Object[arg0,arg1,arg2])
     * </pre>
     *
     * @param values 可变参数.
     */
    public Query createQuery(String hql, Object... values) ...{
        Query query = getSession().createQuery(hql);
        for (int i = 0; i < values.length; i++) ...{
            query.setParameter(i, values[i]);
        }
        return query;
    }
    
    /** *//**
     * 方法取自SpringSide.
     * 去除hql的select子句，未考虑union的情况
     */
    private static String removeSelect(String hql) ...{
        int beginPos = hql.toLowerCase().indexOf("from");
        return hql.substring(beginPos);
    }

    /** *//**
     * 方法取自SpringSide.
     * 去除hql的orderby子句
     */
    private static String removeOrders(String 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();
    }
    
    /** *//**
     * 将联合查询的结果内容从Map或者Object[]转换为实体类型，如果没有转换必要则直接返回
     */
    private List transformResults(List items) ...{
        if (items.size() > 0) ...{
            if (items.get(0) instanceof Map) ...{
                ArrayList list = new ArrayList(items.size());
                for (int i = 0; i < items.size(); i++) ...{
                    Map map = (Map)items.get(i);
                    list.add(map.get(CriteriaSpecification.ROOT_ALIAS));
                }
                return list;
            } else if (items.get(0) instanceof Object[]) ...{
                ArrayList list = new ArrayList(items.size());
                int pos = 0;
                for (int i = 0; i < ((Object[])items.get(0)).length; i++) ...{
                    if (((Object[])items.get(0))[i].getClass() == getPojoClass()) ...{
                        pos = i;
                        break;
                    }
                }
                for (int i = 0; i < items.size(); i++) ...{
                    list.add(((Object[])items.get(i))[pos]);
                }
                return list;
            } else
                return items;
        } else
            return items;
    }
}

package sgf4web.util;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/** *//**
 * 泛型参数辅助类
 * 
 * @author DigitalSonic
 */
@SuppressWarnings("unchecked")
public class GenericsUtils ...{
    /** *//**
     * 通过反射，获得定义Class时声明的父类的第一个范型参数的类型。
     */
    public static Class getSuperClassGenricType(Class clazz) ...{
        return getSuperClassGenricType(clazz, 0);
    }
    
    /** *//**
     * 通过反射，获得定义Class时声明的父类的范型参数的类型。
     * 如没有找到符合要求的范型参数，则递归向上直到Object。
     *
     * @param clazz 要进行查询的类
     * @param index 如有多个范型声明该索引从0开始
     * @return 在index位置的范型参数的类型，如果无法判断则返回<code>Object.class</code>
     */
    public static Class getSuperClassGenricType(Class clazz, int index) ...{
        boolean flag = true;
        Type genType = clazz.getGenericSuperclass();
        Type[] params = null;
        
        if (!(genType instanceof ParameterizedType))
            flag = false;
        else ...{
            params = ((ParameterizedType) genType).getActualTypeArguments();
            if (index >= params.length || index < 0)
                flag = false;
            if (!(params[index] instanceof Class))
                flag = false;
        }
        if (!flag) ...{
            clazz = clazz.getSuperclass();
            if (clazz == Object.class)
                return Object.class;
            else
                return getSuperClassGenricType(clazz, index);
        }
        
        return (Class) params[index];
    }
}

package sgf4web.dao.support;

import java.util.List;

/** *//**
 * 分页类，参考自JavaEye及SpringSide
 */
@SuppressWarnings("unchecked")
public class PaginationSupport ...{
    public final static int PAGESIZE = 10;

    private int pageSize = PAGESIZE;

    private List items;

    private int totalCount;

    private int[] indexes = new int[0];

    private int startIndex = 0;

    public PaginationSupport(List items, int totalCount) ...{
        setPageSize(PAGESIZE);
        setTotalCount(totalCount);
        setItems(items);
        setStartIndex(0);
    }

    public PaginationSupport(List items, int totalCount, int startIndex) ...{
        setPageSize(PAGESIZE);
        setTotalCount(totalCount);
        setItems(items);
        setStartIndex(startIndex);
    }

    public PaginationSupport(List items, int totalCount, int pageSize, int startIndex) ...{
        setPageSize(pageSize);
        setTotalCount(totalCount);
        setItems(items);
        setStartIndex(startIndex);
    }

    /** *//**
     * 将页码转换为列表的startIndex，页大小为默认大小
     */
    public static int convertFromPageToStartIndex(int pageNo) ...{
        return (pageNo - 1) * PAGESIZE;
    }
    
    /** *//**
     * 将页码转换为列表的startIndex
     */
    public static int convertFromPageToStartIndex(int pageNo, int pageSize) ...{
        return (pageNo - 1) * pageSize;
    }

    public List getItems() ...{
        return items;
    }

    public void setItems(List items) ...{
        this.items = items;
    }

    public int getPageSize() ...{
        return pageSize;
    }

    public void setPageSize(int pageSize) ...{
        this.pageSize = pageSize;
    }

    public int getTotalCount() ...{
        return totalCount;
    }

    /** *//**
     * 设置数据总数，并计算各页起始位置
     */
    public void setTotalCount(int totalCount) ...{
        if (totalCount > 0) ...{
            this.totalCount = totalCount;
            int count = totalCount / pageSize;
            if (totalCount % pageSize > 0)
                count++;
            indexes = new int[count];
            for (int i = 0; i < count; i++) ...{
                indexes[i] = pageSize * i;
            }
        } else ...{
            this.totalCount = 0;
        }
    }

    public int[] getIndexes() ...{
        return indexes;
    }

    public void setIndexes(int[] indexes) ...{
        this.indexes = indexes;
    }

    public int getStartIndex() ...{
        return startIndex;
    }

    /** *//**
     * 设置当前起始位置
     */
    public void setStartIndex(int startIndex) ...{
        if (totalCount <= 0)
            this.startIndex = 0;
        else if (startIndex >= totalCount)
            this.startIndex = indexes[indexes.length - 1];
        else if (startIndex < 0)
            this.startIndex = 0;
        else ...{
            this.startIndex = indexes[startIndex / pageSize];
        }
    }

    /** *//**
     * 获得下页起始位置
     */
    public int getNextIndex() ...{
        int nextIndex = getStartIndex() + pageSize;
        if (nextIndex >= totalCount)
            return getStartIndex();
        else
            return nextIndex;
    }

    /** *//**
     * 获得上页起始位置
     */
    public int getPreviousIndex() ...{
        int previousIndex = getStartIndex() - pageSize;
        if (previousIndex < 0)
            return 0;
        else
            return previousIndex;
    }

    /** *//**
     * 取总页数.
     */
    public long getTotalPageCount() ...{
        if (totalCount % pageSize == 0)
            return totalCount / pageSize;
        else
            return totalCount / pageSize + 1;
    }

    /** *//**
     * 取该页当前页码,页码从1开始.
     */
    public long getCurrentPageNo() ...{
        return startIndex / pageSize + 1;
    }

    /** *//**
     * 该页是否有下一页.
     */
    public boolean hasNextPage() ...{
        return this.getCurrentPageNo() < this.getTotalPageCount() - 1;
    }

    /** *//**
     * 该页是否有上一页.
     */
    public boolean hasPreviousPage() ...{
        return this.getCurrentPageNo() > 1;
    }
}