应用Hibernate3的DetachedCriteria实现分页查询

本文介绍如何使用Hibernate3的DetachedCriteria实现分页查询。通过在Web层构造DetachedCriteria并调用业务层Bean,可以进行动态条件查询。文章提供了一个分页支持类PaginationSupport和一个抽象业务类AbstractManager的实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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

分页支持类: 

java代码: 


package com.javaeye.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; 
        } 

        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; 
        } 

}



抽象业务类 
java代码: 


/** 
* Created on 2005-7-12 
*/
 
package com.javaeye.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.javaeye.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) { 
                return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE0)
        } 

        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()上一页索引
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值