`

Hibernate范型-离线分页实现（上）

HibernateStruts算法框架Web 
阅读更多
         我们现在学习的是基于Hibernate的离线查询分页，我们在Web设计中可以选用Struts框架、JSTL等等来实现其功能。<o:p></o:p>

首先，我们要理解分页的算法，也要讲究效率，也就是说我们不能把所有的记录取出来，我们只取一个页面中需要显示的纪录，那么怎么去实现是我们关心的问题！不要着急，重在理解而是单纯技术实现。我采用Web框架两种方式来实现，attention!<o:p></o:p>

分页算法，也就是我们提供给客户方便的操作。一般有哪些东西呢？<o:p></o:p>

       上页、下页、首页、末页、导航到X页，页码导航。说到这里我们先放下，我们来说说取出页面的记录，也就是只取一段的记录。打开Hibernate API 看到Criteria 接口，public Criteria setMaxResults(int maxResults)，意思为：设置记录对象数目的上限，第二方法,public Criteria setFirstResult setFirstResult(int firstResult),意思：设置开始取得记录对象的下标，其中的第一对象下标为0。这样我们可以看出Hibernate提供很好的方法给我们实现分页。<o:p></o:p>

       我们产生了思路：我们只有设置firstResult得下标，我们这里把它叫做游标。我们只要控制游标就可以控制取得的记录就是我们想要得到的，下面要做的工作就是我们来控制index,下面我写了一个HPage的类来实现这个工作，也就是取得一些相关的值，其中我们关系的有：当前的页码、当前的游标等等，下面我们结合代码来说明下！~~~<o:p></o:p>

实现代码如下：

java 代码
  1. public class HPage {   
  2.     private int countPage;  //页面的数量   
  3.     private int startIndex=0; //纪录游标       
  4.     private int recordPerPage;  //每页中的记录数量   
  5.     private int pageIndex=1;  //初始的页码   
  6.     private boolean nextPage=true;   
  7.     private boolean previousPage=false;   
  8.     private boolean firstPage=true;   
  9.     private boolean lastPage=false;   
  10.     public int getCountPage()  //取得页面的数量   
  11.     {   
  12.         return countPage;   
  13.     }   
  14.     public int getStartIndex() //取得游标的位置   
  15.     {   
  16.         return startIndex;   
  17.     }   
  18.     public HPage(int countRecord,int recordPerPage)     
  19.     //coutRecord参数：纪录的总数量；recordPerPage参数：设置每页的记录数量   
  20.     {   
  21.         this.recordPerPage=recordPerPage;   
  22.         if(countRecord % recordPerPage == 0)   
  23.             countPage=countRecord / recordPerPage;   
  24.         else  
  25.             countPage=countRecord / recordPerPage +1;   
  26.     }   
  27.     public int getPageIndex() // 取得当前页码   
  28.     {   
  29.         return pageIndex;   
  30.     }   
  31.     public int nextPage() // 游标下一页滚动   
  32.     {   
  33.         pageIndex++;   
  34.         if(isOnlyOne())   
  35.         {   
  36.             nextPage=false;   
  37.             previousPage=false;   
  38.             firstPage=false;   
  39.             lastPage=false;   
  40.         }   
  41.         else  
  42.         {   
  43.             previousPage=true;   
  44.             firstPage=true;   
  45.         }   
  46.         if(pageIndex > countPage)   
  47.             return lastPage();   
  48.         else  
  49.         {   
  50.             return (startIndex=forwardPage(pageIndex));   
  51.         }   
  52.     }   
  53.     public int previousPage()  // 游标上一页滚动   
  54.     {   
  55.         pageIndex--;   
  56.         if(isOnlyOne())   
  57.         {   
  58.             nextPage=false;   
  59.             previousPage=false;   
  60.             firstPage=false;   
  61.             lastPage=false;   
  62.         }   
  63.         else  
  64.         {   
  65.             nextPage=true;   
  66.             lastPage=true;   
  67.         }   
  68.         if(pageIndex <= 1)   
  69.             return firstPage();   
  70.         else  
  71.         {   
  72.             return (startIndex=forwardPage(pageIndex));   
  73.         }   
  74.     }   
  75.     public int lastPage() // 游标向末页滚动   
  76.     {   
  77.         pageIndex=countPage;   
  78.         if(isOnlyOne())   
  79.         {   
  80.             nextPage=false;   
  81.             previousPage=false;   
  82.             firstPage=false;   
  83.             lastPage=false;   
  84.         }   
  85.         else  
  86.         {   
  87.             nextPage=false;   
  88.             previousPage=true;   
  89.             firstPage=true;   
  90.             lastPage=false;   
  91.         }   
  92.         return (startIndex=(countPage-1) * recordPerPage);   
  93.     }   
  94.     public int firstPage() // 游标向首页滚动   
  95.     {   
  96.         pageIndex=1;   
  97.         if(isOnlyOne())   
  98.         {   
  99.             nextPage=false;   
  100.             previousPage=false;   
  101.             firstPage=false;   
  102.             lastPage=false;   
  103.         }   
  104.         else  
  105.         {   
  106.             nextPage=true;   
  107.             previousPage=false;   
  108.             firstPage=false;   
  109.             lastPage=true;   
  110.         }   
  111.         return (startIndex=0);   
  112.     }   
  113.     public int forwardPage(int pageIndex) //导向制定页面   
  114.     {   
  115.            
  116.         if(pageIndex >= countPage)   
  117.         {   
  118.             pageIndex=countPage;   
  119.             return (startIndex=lastPage());   
  120.         }   
  121.         else if(pageIndex <= 1)   
  122.         {   
  123.             pageIndex=1;   
  124.             return startIndex=firstPage();   
  125.         }   
  126.         this.pageIndex=pageIndex;   
  127.         if(isOnlyOne())   
  128.         {   
  129.             nextPage=false;   
  130.             previousPage=false;   
  131.             firstPage=false;   
  132.             lastPage=false;   
  133.         }   
  134.         else  
  135.         {   
  136.             nextPage=true;   
  137.             previousPage=true;   
  138.             firstPage=true;   
  139.             lastPage=true;   
  140.         }   
  141.         return (startIndex=(this.pageIndex -1)* recordPerPage);        
  142.     }   
  143.     private boolean isOnlyOne() //是否只有一页   
  144.     {   
  145.         return countPage==1 ? true : false;   
  146.     }   
  147.     public boolean isNextPage() //是否有下页   
  148.     {   
  149.         return nextPage;   
  150.     }   
  151.     public boolean isPreviousPage() //是否有上页   
  152.     {   
  153.         return previousPage;   
  154.     }   
  155.     public boolean isFirstPage() //是否首页   
  156.     {   
  157.         return firstPage;   
  158.     }   
  159.     public boolean isLastPage() //是否末页   
  160.     {   
  161.         return lastPage;   
  162.     }      
  163. }   

 

不是很难吧！好的，现在我们做好的工作就是取得了我们要的数值，下面要做的是加到Hibernate查询里面去，下面的工作很简单。但是我们要注意几个问题，第一个问题，我们的设计的目的不是为了解决一个问题，而是抽象出一个方案提供给相似的问题的解决方案。这样的话，我们最大化重利用代码，那么我们采用范性的特点（注意JDK5.0的特征，以前的版本会报错误）。下面我分析一下代码：<o:p></o:p>

java 代码
  1. public class DisplayPageRecordList<t></t> { //泛型实现   
  2.     private int startIndex;   
  3.     private static final int DEFAULT_RECORD_PER_PAGE=5; //默认：每页中5条记录   
  4.     private List<t></t> list;      
  5.     private HPage page;   
  6.     private int recordPerPage=DEFAULT_RECORD_PER_PAGE;   
  7.     private final Session session=HibernateSessionFactory.getSession();   
  8.     private DetachedCriteria deCriteria;   
  9.     private Criteria criteria;     
  10.     private int countRecord;   
  11.     public DisplayPageRecordList(String className) throws ClassNotFoundException   
  12.     //className参数：类的全定名称   
  13.     {          
  14.         deCriteria=DetachedCriteria.forClass(Class.forName(className)); //创造离线的查询   
  15.         criteria=deCriteria.getExecutableCriteria(session);   
  16.         criteria.setCacheable(true);           
  17.         doInit();   
  18.         page=new HPage(countRecord,recordPerPage);             
  19.     }   
  20.     public DisplayPageRecordList(int recordPerPage,String className) throws ClassNotFoundException   
  21.     //recordPerPage参数：每页的纪录的条目数，className参数：同上个构造方法中   
  22.     {   
  23.            
  24.         deCriteria=DetachedCriteria.forClass(Class.forName(className));   
  25.         criteria=deCriteria.getExecutableCriteria(session);   
  26.         criteria.setCacheable(true);   
  27.         this.recordPerPage=recordPerPage;   
  28.         doInit();   
  29.         page=new HPage(countRecord,recordPerPage);             
  30.     }      
  31.     public DisplayPageRecordList(int recordPerPage,String className,Criterion criterion) throws ClassNotFoundException   
  32.     //recordPerPage参数：同上个构造方法中，className参数：同上个构造方法中，criterion参数：设置查询条件   
  33.     {   
  34.            
  35.         deCriteria=DetachedCriteria.forClass(Class.forName(className));   
  36.         criteria=deCriteria.getExecutableCriteria(session);   
  37.         criteria.add(criterion);   
  38.         criteria.setCacheable(true);           
  39.         doInit();   
  40.         page=new HPage(countRecord,recordPerPage);             
  41.     }      
  42.     public void setRecordPerPage(int recordPerPage)   
  43.     {   
  44.         this.recordPerPage=recordPerPage;   
  45.         page=new HPage(countRecord,recordPerPage);     
  46.     }   
  47.     private void doInit()   
  48.     {   
  49.         this.countRecord=criteria.list().size(); //计算数据库中所有的记录数        
  50.     }   
  51.     public void addCriterion(Criterion criterion)   
  52.     {   
  53.         criteria=criteria.add(criterion); //更改所有所有查询条件   
  54.         doInit();   
  55.     }   
  56.     public void setCacheable(boolean cache) //是否启用缓存   
  57.     {   
  58.         criteria.setCacheable(cache);   
  59.     }   
  60.     public List doNextPage() //查询出下页中的纪录集   
  61.     {   
  62.         startIndex=page.nextPage();   
  63.         criteria.setFirstResult(startIndex);   
  64.         criteria.setMaxResults(this.recordPerPage);   
  65.         list=criteria.list();   
  66.         return list;   
  67.     }   
  68.     public List doPreviousPage() //查询出上页中的纪录集   
  69.     {   
  70.         startIndex=page.previousPage();   
  71.         criteria.setFirstResult(startIndex);   
  72.         criteria.setMaxResults(this.recordPerPage);   
  73.         list=criteria.list();   
  74.         return list;   
  75.     }   
  76.     public List doFirstPage() //查询出首页中的纪录集   
  77.     {   
  78.         startIndex=page.firstPage();   
  79.         criteria.setFirstResult(startIndex);   
  80.         criteria.setMaxResults(this.recordPerPage);   
  81.         list=criteria.list();   
  82.         return list;   
  83.     }   
  84.     public List doLastPage() //查询出末页中的纪录集   
  85.     {   
  86.         startIndex=page.lastPage();   
  87.         criteria.setFirstResult(startIndex);   
  88.         criteria.setMaxResults(this.recordPerPage);   
  89.         list=criteria.list();   
  90.         return list;   
  91.     }   
  92.     public List doForward(int pageIndex)   
  93.     {   
  94.         startIndex=page.forwardPage(pageIndex);   
  95.         criteria.setFirstResult(startIndex);   
  96.         criteria.setMaxResults(this.recordPerPage);   
  97.         list=criteria.list();   
  98.         return list;   
  99.     }   
  100.     public HPage getPage() //取得页面对象   
  101.     {   
  102.         return this.page;   
  103.     }      
  104. }   

 

以上代码中，实现了泛型-离线查询的页面的代码。上篇完，下篇我们来使用Struts和JSTL在网页上测试<o:p></o:p>

 

<o:p></o:p>
分享到：
| J2EE之JSP视频发布
评论
发表评论

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

相关推荐

    《分布式系统原理与范型--(第二版)》复习资料

    ### 分布式系统原理与范型...以上是对《分布式系统原理与范型--(第二版)》中第一章和第二章内容的知识点总结。通过这些内容的学习，可以更好地理解分布式系统的组成、原理及其关键特性，为后续深入研究打下坚实的基础。

    七周七语言_理解多种编程范型-[PDF]

    《七周七语言：理解多种编程范型》共介绍了七种不同的编程语言。对于每种语言，分别介绍了各自的特性、应用，以及编程入门知识和关键编程范型，还带领读者使用能够代表该语言最重要特性的技术，解决某个不寻常的问题...

    分布式系统原理与范型-naming

    综上所述，分布式系统的命名系统是一个复杂而关键的领域，涉及到了实体标识、名字解析、命名空间实现等多个方面。理解并设计有效的命名系统对于构建可扩展、健壮的分布式应用至关重要。通过研究各种命名范型和技术，...

    Hibernate_范型_级联

    Hibernate中的范型主要体现在SessionFactory、Session、Query等接口及其实现类上，通过使用泛型，我们可以在编译时检查类型，避免运行时出现ClassCastException。例如，我们可以声明Session&lt;实体类&gt;，这样在操作实体...

    DecalSDL-Delphi的范型类库-通用数据结构与算法类库(一).pdf

    Decal 的设计理念是提高代码复用性，提供高度抽象的数据结构和算法，使得开发人员能够更专注于业务逻辑，而非基础数据处理的实现细节。通过使用 Decal，开发者可以编写出更加模块化、高效且易于维护的 Delphi 应用...

    分布式系统原理与范型_考试_2009_答案

    华中科技大学 分布式系统原理与范型_考试_2009_答案

    用Java Socket实现一个简单的基于P2P范型的即时聊天系统。

    在本文中，我们将深入探讨如何使用Java的Socket编程来实现一个简单的基于P2P（Peer-to-Peer）范型的即时聊天系统。P2P网络架构允许每个节点既是客户端也是服务器，这种模式使得数据传输更加分散，提高了系统的可扩展...

    论文研究-消息传递范型与C/S范型双范型的主数据管理机制 .pdf

    通过这样的消息传递机制，主数据存储库与分系统之间可以实现数据的实时同步，保持数据的一致性。 消息队列机制的应用，不仅可以处理消息的异步传输，还能够支持大量数据的快速传输和高并发处理，提高了系统的可扩展...

    分布式系统-原理与范型(第2版)

    分布式系统-原理与范型(第2版) 分布式系统-原理与范型(第2版) 分布式系统-原理与范型(第2版) 分布式系统-原理与范型(第2版)

    C++多范型设计

    《C++多范型设计》是一本深入探讨C++编程语言中模板技术的专著，由知名软件工程师James O. Coplien撰写，并由鄢爱兰、周辉等翻译成中文版，ISBN号为9787508318240。这本书的核心主题是C++中的泛型编程，它是C++编程...

    论文研究-软件范型的演绎与智能体 .pdf

    文章中提到的第一个软件范型是面向过程（Procedural Programming Paradigm），这种范型强调算法的实现和顺序执行。在早期计算机科学中，算法求解和数值计算是研究的核心，因此软件的设计主要围绕着算法的实现来展开...

    jsf1.2+spring3.0+hibernate3.3例子-单表增删改查

    jsf1.2+spring3.0+hibernate3.3+ajax annotation集成，自定义转换器，自定义验证器，国际化，验证码等包含users表的登录增删改查操作，dao层设计抽象范型统一的父类，非常有参考价值。 欢迎交流q 38732796

    范型程序设计与 STL.pdf

    它们接受迭代器作为参数，可以在不同的容器上执行，不依赖容器的具体实现。 4. 函数对象（Function Objects）或谓之适配器（Adapters）：包括比较函数对象（如less、greater）和操作函数对象（如plus、minus），...

    分布式系统-原理与范型(第2版) 完整版

    第2～9章讨论的是分布式系统的的原理、概念和技术，包括通信、进程、命名、同步化、一致性和复制、容错性以及安全性等，而分布式应用的开发方法（即范型）在第10～13章中进行了讨论。但是，与前一版不同的是，我们...

    分布式系统原理与范型

    《分布式系统原理与范型》是分布式系统中的经典教材，全书分为两部分：原理和范型。第一部分详细讨论了分布式系统的原理、概念和技术，其中包括通信、进程、命名、同步、一致性和复制、容错以及安全。第二部分给出了...

    《分布式系统原理与范型》.pdf

    《分布式系统原理与范型》作为一本系统介绍分布式系统基本原理与实践应用的书籍，涵盖了分布式系统设计与实现的核心理念。分布式系统指的是由多个可以独立运行的计算单元构成的系统，这些计算单元通过通信网络相互...

    分布式系统原理与范型（第二版）

    在《分布式系统原理与范型》第二版中，读者可以期待深入探讨这些范型的实现细节，以及如何在实际项目中应用。书中可能涵盖了诸如CAP定理、Paxos协议、Raft共识算法、Chubby锁服务、Zookeeper协调服务等经典理论和...

    分布式系统原理与范型课件

    分布式系统原理与范型是计算机...通过深入学习这些分布式系统原理与范型的课件，可以理解分布式系统的设计思路，掌握实现分布式应用的关键技术和策略，这对于从事云计算、大数据、物联网等领域的开发人员来说至关重要。

    分布式系统原理与范型.pdf

    Tanenbaum教授是早期操作系统领域的知名学者，其著作深入浅出地介绍了分布式系统的基本原理和实现范型。 分布式系统的原理部分是该书的核心内容，涵盖了多个重要的概念和原理。首先，通信是分布式系统中最为基本的...

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