devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：IT小白 | 2024-05-03 09:53:30

赞

踩

hibernate的离线分页
         我们现在学习的是基于 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>
声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号