`
shz2008bj
  • 浏览: 489433 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

应用Hibernate3的DetachedCriteria实现分页查询

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

分页支持类：

Java代码 复制代码
  1. package com.iteye.common.util;  
  2.   
  3. import java.util.List;  
  4.   
  5. public class PaginationSupport {  
  6.   
  7.     public final static int PAGESIZE = 30;  
  8.   
  9.     private int pageSize = PAGESIZE;  
  10.   
  11.     private List items;  
  12.   
  13.     private int totalCount;  
  14.   
  15.     private int[] indexes = new int[0];  
  16.   
  17.     private int startIndex = 0;  
  18.   
  19.     public PaginationSupport(List items, int totalCount) {  
  20.         setPageSize(PAGESIZE);  
  21.                 setTotalCount(totalCount);  
  22.         setItems(items);          
  23.         setStartIndex(0);  
  24.     }  
  25.   
  26.     public PaginationSupport(List items, int totalCount, int startIndex) {  
  27.                 setPageSize(PAGESIZE);  
  28.         setTotalCount(totalCount);  
  29.         setItems(items);          
  30.         setStartIndex(startIndex);  
  31.     }  
  32.   
  33.     public PaginationSupport(List items, int totalCount, int pageSize, int startIndex) {  
  34.                 setPageSize(pageSize);  
  35.         setTotalCount(totalCount);  
  36.         setItems(items);  
  37.         setStartIndex(startIndex);  
  38.     }  
  39.   
  40.     public List getItems() {  
  41.         return items;  
  42.     }  
  43.   
  44.     public void setItems(List items) {  
  45.         this.items = items;  
  46.     }  
  47.   
  48.     public int getPageSize() {  
  49.         return pageSize;  
  50.     }  
  51.   
  52.     public void setPageSize(int pageSize) {  
  53.         this.pageSize = pageSize;  
  54.     }  
  55.   
  56.     public int getTotalCount() {  
  57.         return totalCount;  
  58.     }  
  59.   
  60.     public void setTotalCount(int totalCount) {  
  61.         if (totalCount > 0) {  
  62.             this.totalCount = totalCount;  
  63.             int count = totalCount / pageSize;  
  64.             if (totalCount % pageSize > 0)  
  65.                 count++;  
  66.             indexes = new int[count];  
  67.             for (int i = 0; i < count; i++) {  
  68.                 indexes[i] = pageSize * i;  
  69.             }  
  70.         } else {  
  71.             this.totalCount = 0;  
  72.         }  
  73.     }  
  74.   
  75.     public int[] getIndexes() {  
  76.         return indexes;  
  77.     }  
  78.   
  79.     public void setIndexes(int[] indexes) {  
  80.         this.indexes = indexes;  
  81.     }  
  82.   
  83.     public int getStartIndex() {  
  84.         return startIndex;  
  85.     }  
  86.   
  87.     public void setStartIndex(int startIndex) {  
  88.         if (totalCount <= 0)  
  89.             this.startIndex = 0;  
  90.         else if (startIndex >= totalCount)  
  91.             this.startIndex = indexes[indexes.length - 1];  
  92.         else if (startIndex < 0)  
  93.             this.startIndex = 0;  
  94.         else {  
  95.             this.startIndex = indexes[startIndex / pageSize];  
  96.         }  
  97.     }  
  98.   
  99.     public int getNextIndex() {  
  100.         int nextIndex = getStartIndex() + pageSize;  
  101.         if (nextIndex >= totalCount)  
  102.             return getStartIndex();  
  103.         else  
  104.             return nextIndex;  
  105.     }  
  106.   
  107.     public int getPreviousIndex() {  
  108.         int previousIndex = getStartIndex() - pageSize;  
  109.         if (previousIndex < 0)  
  110.             return 0;  
  111.         else  
  112.             return previousIndex;  
  113.     }  
  114.   
  115. }  


抽象业务类
Java代码 复制代码
  1. /** 
  2.  * Created on 2005-7-12 
  3.  */  
  4. package com.iteye.common.business;  
  5.   
  6. import java.io.Serializable;  
  7. import java.util.List;  
  8.   
  9. import org.hibernate.Criteria;  
  10. import org.hibernate.HibernateException;  
  11. import org.hibernate.Session;  
  12. import org.hibernate.criterion.DetachedCriteria;  
  13. import org.hibernate.criterion.Projections;  
  14. import org.springframework.orm.hibernate3.HibernateCallback;  
  15. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
  16.   
  17. import com.iteye.common.util.PaginationSupport;  
  18.   
  19. public abstract class AbstractManager extends HibernateDaoSupport {  
  20.   
  21.     private boolean cacheQueries = false;  
  22.   
  23.     private String queryCacheRegion;  
  24.   
  25.     public void setCacheQueries(boolean cacheQueries) {  
  26.         this.cacheQueries = cacheQueries;  
  27.     }  
  28.   
  29.     public void setQueryCacheRegion(String queryCacheRegion) {  
  30.         this.queryCacheRegion = queryCacheRegion;  
  31.     }  
  32.   
  33.     public void save(final Object entity) {  
  34.         getHibernateTemplate().save(entity);  
  35.     }  
  36.   
  37.     public void persist(final Object entity) {  
  38.         getHibernateTemplate().save(entity);  
  39.     }  
  40.   
  41.     public void update(final Object entity) {  
  42.         getHibernateTemplate().update(entity);  
  43.     }  
  44.   
  45.     public void delete(final Object entity) {  
  46.         getHibernateTemplate().delete(entity);  
  47.     }  
  48.   
  49.     public Object load(final Class entity, final Serializable id) {  
  50.         return getHibernateTemplate().load(entity, id);  
  51.     }  
  52.   
  53.     public Object get(final Class entity, final Serializable id) {  
  54.         return getHibernateTemplate().get(entity, id);  
  55.     }  
  56.   
  57.     public List findAll(final Class entity) {  
  58.         return getHibernateTemplate().find("from " + entity.getName());  
  59.     }  
  60.   
  61.     public List findByNamedQuery(final String namedQuery) {  
  62.         return getHibernateTemplate().findByNamedQuery(namedQuery);  
  63.     }  
  64.   
  65.     public List findByNamedQuery(final String query, final Object parameter) {  
  66.         return getHibernateTemplate().findByNamedQuery(query, parameter);  
  67.     }  
  68.   
  69.     public List findByNamedQuery(final String query, final Object[] parameters) {  
  70.         return getHibernateTemplate().findByNamedQuery(query, parameters);  
  71.     }  
  72.   
  73.     public List find(final String query) {  
  74.         return getHibernateTemplate().find(query);  
  75.     }  
  76.   
  77.     public List find(final String query, final Object parameter) {  
  78.         return getHibernateTemplate().find(query, parameter);  
  79.     }  
  80.   
  81.     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria) {  
  82.         return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, 0);  
  83.     }  
  84.   
  85.     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int startIndex) {  
  86.         return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, startIndex);  
  87.     }  
  88.   
  89.     public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int pageSize,  
  90.             final int startIndex) {  
  91.         return (PaginationSupport) getHibernateTemplate().execute(new HibernateCallback() {  
  92.             public Object doInHibernate(Session session) throws HibernateException {  
  93.                 Criteria criteria = detachedCriteria.getExecutableCriteria(session);  
  94.                 int totalCount = ((Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();  
  95.                 criteria.setProjection(null);  
  96.                 List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();  
  97.                 PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);  
  98.                 return ps;  
  99.             }  
  100.         }, true);  
  101.     }  
  102.   
  103.     public List findAllByCriteria(final DetachedCriteria detachedCriteria) {  
  104.         return (List) getHibernateTemplate().execute(new HibernateCallback() {  
  105.             public Object doInHibernate(Session session) throws HibernateException {  
  106.                 Criteria criteria = detachedCriteria.getExecutableCriteria(session);  
  107.                 return criteria.list();  
  108.             }  
  109.         }, true);  
  110.     }  
  111.   
  112.     public int getCountByCriteria(final DetachedCriteria detachedCriteria) {  
  113.         Integer count = (Integer) getHibernateTemplate().execute(new HibernateCallback() {  
  114.             public Object doInHibernate(Session session) throws HibernateException {  
  115.                 Criteria criteria = detachedCriteria.getExecutableCriteria(session);  
  116.                 return criteria.setProjection(Projections.rowCount()).uniqueResult();  
  117.             }  
  118.         }, true);  
  119.         return count.intValue();  
  120.     }  
  121. }  



用户在web层构造查询条件detachedCriteria，和可选的startIndex，调用业务bean的相应findByCriteria方法，返回一个PaginationSupport的实例ps。

ps.getItems()得到已分页好的结果集
ps.getIndexes()得到分页索引的数组
ps.getTotalCount()得到总结果数
ps.getStartIndex()当前分页索引
ps.getNextIndex()下一页索引
ps.getPreviousIndex()上一页索引 
分享到：
| Struts2引用Servlet API中的对象，reques ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate 使用DetachedCriteria操作

    - 在服务层进行分页查询时，可以先创建DetachedCriteria，然后在视图层根据请求参数调整限制条件，避免重复计算。 **4. DetachedCriteria 的基本用法** 创建DetachedCriteria通常从`DetachedCriteria.forClass()`...

    Hibernate+sqlserver2000分页

    要将两者结合起来，我们可以创建一个自定义的SQL查询，并在Hibernate的`DetachedCriteria`中使用。这通常涉及到在HQL中嵌入SQL片段，或者使用`createSQLQuery`方法直接执行SQL查询。同时，别忘了映射查询结果到对应...

    springMVC+hibernate的条件查询加分页的demo

    总的来说，"springMVC+hibernate的条件查询加分页的demo"涵盖了Web应用中常见的查询和分页需求，通过SpringMVC接收和处理用户请求，利用Hibernate的Criteria查询动态构造SQL，并通过设置分页参数实现数据的分批次...

    struts2+spring+hibernate分页查询

    综上所述，Struts2、Spring和Hibernate的整合使得开发者能够便捷地实现分页查询，从而优化Web应用的性能和用户体验。在实际项目中，需要根据具体需求和业务场景，选择合适的分页策略和实现方式，同时注意性能优化和...

    hibernate里面的 两种查询

    在Java的持久化框架Hibernate中，查询是连接应用程序与数据库的关键环节。Hibernate提供了两种主要的查询方式：离线查询（Criteria API）和HQL（Hibernate Query Language）语句查询。这两种查询方法各有特点，适用...

    Hibernate3中文文档

    8. ** Criteria API的DetachedCriteria**：DetachedCriteria允许在不打开Session的情况下构建查询，之后在需要时再与Session结合执行，适合于分页查询和延迟加载。 9. **缓存机制**：Hibernate提供了第一级缓存...

    Hibernate 在查询操作中要使用分页+命名参数+排序技术

    在IT行业中，数据库查询是日常开发中的重要环节，特别是在大型应用中，为了提高用户体验和系统性能，分页、命名参数和排序技术的应用至关重要。本文将深入探讨如何在使用Hibernate框架时，有效地结合这些技术进行...

    Hibernate的MySql查询.rar

    本文将深入探讨在使用Hibernate进行MySQL查询时的一些关键知识点，以帮助开发者更好地理解和应用这些技术。 首先，我们需要理解Hibernate的核心概念。Hibernate通过提供一个中间层，将Java对象与数据库表进行映射，...

    hibernate查询详解

    本文将详细介绍Hibernate的五种查询方式，包括HQL查询、Criteria方法、动态查询DetachedCriteria、例子查询、SQL查询以及命名查询，以满足不同场景下的需求。 1. HQL查询： Hibernate Query Language（HQL）是一种...

    Hibernate查询方式代码示例

    本教程将深入探讨Hibernate 3.x版本中的查询方式，包括基本查询、HQL（Hibernate Query Language）以及Criteria API，帮助开发者更高效地处理数据库交互。 1. **基本查询（Criteria API）** Hibernate Criteria ...

    sh分页，增删改查

    Criteria查询提供了动态构建查询的方式，可以通过DetachedCriteria实现分页；HQL是面向对象的查询语言，可以方便地进行分页；对于更复杂的SQL操作，可以直接使用SQL查询，并配合 ScrollableResults 接口实现分页。在...

    Hibernate 查询经典练习题

    在本文中，我们将探讨基于Hibernate的查询实践，包括HQL（Hibernate Query Language）和Criteria API的使用。我们将通过两个经典的练习题来深入理解这两个查询方式，并讨论它们在处理不同查询需求时的特点。 ### ...

    \Hibernate_query条件查询

    Hibernate提供了方便的分页查询功能，无论是HQL还是Criteria API都能实现。例如： ```java // HQL query.setFirstResult(0).setMaxResults(10); // 第一页，每页10条 // Criteria criteria.setFirstResult(0...

    Hibernate中查询的法方

    为了解决这个问题，可以在`DetachedCriteria`中设置相应的查询条件，以实现带条件的分页查询。 通过理解和熟练运用这些基本查询方法，你可以有效地利用Hibernate进行数据操作，从而提高开发效率。在实际项目中，还...

    传智播客_hibernate

    3. **集合分页**: 使用Query的setFirstResult()和setMaxResults()方法实现分页查询，避免一次性加载大量数据。 通过以上讲解，我们可以看到，传智播客的Hibernate教程覆盖了从基础到进阶的各个方面，为初学者提供了...

    Hibernate-基础联表模板

    通过DetachedCriteria、Criteria、Projection等接口，可以方便地实现联表查询，同时支持各种查询条件、排序和分页。 6. **多对一（One-to-Many）和一对多（Many-to-One）关联** 这是两种常见的关联关系。在...

    Hibernate

    6. **查询语言（HQL）**：Hibernate提供的面向对象的查询语言，类似于SQL，但更贴近Java对象，包括简单的查询、复杂查询、条件查询和分页查询。 7. **Criteria API**：另一种进行数据库查询的方式，提供动态构建...

    hibernate-release-5.2.3.Final

    Criteria API提供了一种更灵活的查询方式，通过DetachedCriteria实现离线查询，通过Criteria构建动态查询，结合Projection和Criterion进行结果集处理和条件限制。 8. Hibernate缓存： Hibernate支持二级缓存，...

    Hibernate_3 api

    - 使用Hibernate 3 API，可以方便地实现创建（Create）、读取（Read）、更新（Update）和删除（Delete）数据库记录。例如，`save()`方法用于保存新对象，`update()`用于更新现有对象，`delete()`用于删除对象，`get...

    hibernate in action 中文版书籍

    5. ** Criteria和DetachedCriteria**：详细阐述Criteria查询的使用，包括条件查询、排序、分页，以及DetachedCriteria的概念，用于创建可复用的查询模板。 6. **事务和缓存**：讨论Hibernate的事务管理，包括编程式...

Magicbox
Global site tag (gtag.js) - Google Analytics