利用hibernate的DetachedCriteria进行分页

Hibernate3提供了DetachedCriteria，使得我们可以在Web层构造detachedCriteria，然后调用业务层Bean，进行动态条件查询，根据这一功能，我设计了通用的抽象Bean基类和分页类支持，代码来自于Quake Wang的javaeye-core包的相应类，然后又做了很多修改。
  分页支持类：
  

package com.iteye.common.util; 
 
import java.util.List; 
 
public class PaginationSupport { 
 
    public final static int PAGESIZE = 30;  //定义一页显示多少行记录
 
    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); 
    } 
 
    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; 
    } 
  //设置总的记录数，总页数(count)  ,每一页的开始记录号
    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; 
    } 
 
} 

抽象业务类(我们的类要继承这个抽象类， 以便使用里面的类进行分类)

package com.iteye.common.business; 
 
import java.io.Serializable; 
import java.util.List; 
 
import org.hibernate.Criteria; 
import org.hibernate.HibernateException; 
import org.hibernate.Session; 
import org.hibernate.criterion.DetachedCriteria; 
import org.hibernate.criterion.Projections; 
import org.springframework.orm.hibernate3.HibernateCallback; 
import org.springframework.orm.hibernate3.support.HibernateDaoSupport; 
 
import com.iteye.common.util.PaginationSupport; 
 
public abstract class AbstractManager extends HibernateDaoSupport { 
 
    private boolean cacheQueries = false; 
 
    private String queryCacheRegion; 
 
    public void setCacheQueries(boolean cacheQueries) { 
        this.cacheQueries = cacheQueries; 
    } 
 
    public void setQueryCacheRegion(String queryCacheRegion) { 
        this.queryCacheRegion = queryCacheRegion; 
    } 
   //保存
    public void save(final Object entity) { 
        getHibernateTemplate().save(entity); 
    } 
 
    public void persist(final Object entity) { 
        getHibernateTemplate().save(entity); 
    } 
  //更新
    public void update(final Object entity) { 
        getHibernateTemplate().update(entity); 
    } 
  //删除
    public void delete(final Object entity) { 
        getHibernateTemplate().delete(entity); 
    } 
   //加载
    public Object load(final Class entity, final Serializable id) { 
        return getHibernateTemplate().load(entity, id); 
    } 
 
    public Object get(final Class entity, final Serializable id) { 
        return getHibernateTemplate().get(entity, id); 
    } 
   //查询全部
    public List findAll(final Class entity) { 
        return getHibernateTemplate().find("from " + entity.getName()); 
    } 
   //通过名字查询
    public List findByNamedQuery(final String namedQuery) { 
        return getHibernateTemplate().findByNamedQuery(namedQuery); 
    } 
  //通过参数动态查询
    public List findByNamedQuery(final String query, final Object parameter) { 
        return getHibernateTemplate().findByNamedQuery(query, parameter); 
    } 
 
    public List findByNamedQuery(final String query, final Object[] parameters) { 
        return getHibernateTemplate().findByNamedQuery(query, parameters); 
    } 
   
    public List find(final String query) { 
        return getHibernateTemplate().find(query); 
    } 
 
    public List find(final String query, final Object parameter) { 
        return getHibernateTemplate().find(query, parameter); 
    } 
  //以下是分页查询
    public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria) { 
             //通过detachedCriteri，一页显示记录数,   当前是第几页查询(0)
        return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, 0); 
    } 
 
    public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int startIndex) { 
           //用户指定当前为第几页
           return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, startIndex); 
    } 
 
    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(); 
                PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex); 
                return ps; 
            } 
        }, true); 
    } 
 
    public List findAllByCriteria(final DetachedCriteria detachedCriteria) { 
        return (List) getHibernateTemplate().execute(new HibernateCallback() { 
            public Object doInHibernate(Session session) throws HibernateException { 
                Criteria criteria = detachedCriteria.getExecutableCriteria(session); 
                return criteria.list(); 
            } 
        }, true); 
    } 
 
    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(); 
    } 
} 
用户在web层构造查询条件detachedCriteria，和可选的startIndex，调用业务bean的相应findByCriteria方法，返回一个PaginationSupport的实例ps。

ps.getItems()得到已分页好的结果集
ps.getIndexes()得到分页索引的数组
ps.getTotalCount()得到总结果数
ps.getStartIndex()当前分页索引
ps.getNextIndex()下一页索引
ps.getPreviousIndex()上一页索引