论坛首页 → Java企业应用论坛 →

自己对分页的理解

浏览 4319 次
锁定老帖子 主题：自己对分页的理解
精华帖 (0) :: 良好帖 (0) :: 新手帖 (0) :: 隐藏帖 (0)
作者 正文
  • wuhua
  • 等级: 三钻会员
  • 性别:
  • 文章: 634
  • 积分: 1688
  • 来自: 广州
   发表时间：2007-01-17  
        最近要启动一个比较大的项目了。回忆以前做的那些web项目，快乐，痛苦，成功，失败都是经历过了。
        好久没动那些web了，都块忘记这么设计了，今天在java重新找出一些关于hibernate分页的帖子，受益良多。
        robbin大哥的说的最详细的 www.iteye.com/topic/14657
         www.iteye.com/topic/17857
        哈哈，有时间多复习是不错的。
         
        分页的主要思想是：
1：构造一个Page对象，把相关的属性设置好，比如记录数，每页包含条数，是否有下一页，是否有上一页，当前页，总页数等，然后通过Page工厂生成一个Page对象（构造的前题是：你必须知道记录总数，一般从数据中获取），最后通过对于数据库的分页语句得到结果，比如hibernate分页的写法是：
java 代码
 
  1. String querySentence = "FROM user in class com.adt.po.User";    
  2.        Query query = getSession().createQuery(querySentence);    
  3.       query.setFirstResult(page.getBeginIndex())    
  4.             .setMaxResults(page.getEveryPage());    
  5.         return query.list();    
这样做的充分利用数据各自的特性，提供性能。
2：直接从数据load出所有数据，然后再对结果集进行处理。
    对所有数据的操作都是用一条语句就ok了，方便处理，缺点是，数据量大的时候性能会有影响。而且每次都去load这么多数据，不合理。看看代码，很简单
java 代码
 
  1. /** 
  2.  * @author wuhua 
  3.  *  
  4.  * 分页代码，实现策略是，用List类来保存所有对象，并以page为分页标记 
  5.  */  
  6.   
  7. import java.util.List;  
  8.   
  9. public class PageModel {  
  10.     private int page = 1; // 当前页  
  11.   
  12.     public int totalPages = 0; // 总页数  
  13.   
  14.     private int pageRecorders;// 每页5条数据  
  15.   
  16.     private int totalRows = 0; // 总数据数  
  17.   
  18.     private int pageStartRow = 0;// 每页的起始数  
  19.   
  20.     private int pageEndRow = 0; // 每页显示数据的终止数  
  21.   
  22.     private boolean hasNextPage = false; // 是否有下一页  
  23.   
  24.     private boolean hasPreviousPage = false; // 是否有前一页  
  25.   
  26.     private List list;  
  27.   
  28.     // private Iterator it;  
  29.   
  30.     public PageModel(List list, int pageRecorders) {  
  31.         init(list, pageRecorders);// 通过对象集，记录总数划分  
  32.     }  
  33.   
  34.     /** 
  35.      *  
  36.      */  
  37.     public PageModel() {  
  38.     }  
  39.   
  40.     /** 
  41.      * @param list 
  42.      * @param pageRecorders 
  43.      */  
  44.     public void init(List list, int pageRecorders) {  
  45.         this.pageRecorders = pageRecorders;  
  46.         this.list = list;  
  47.         totalRows = list.size();  
  48.         // it = list.iterator();  
  49.         hasPreviousPage = false;  
  50.         if ((totalRows % pageRecorders) == 0) {  
  51.             totalPages = totalRows / pageRecorders;  
  52.         } else {  
  53.             totalPages = totalRows / pageRecorders + 1;  
  54.         }  
  55.   
  56.         if (page >= totalPages) {  
  57.             hasNextPage = false;  
  58.         } else {  
  59.             hasNextPage = true;  
  60.         }  
  61.   
  62.         if (totalRows < pageRecorders) {  
  63.             this.pageStartRow = 0;  
  64.             this.pageEndRow = totalRows;  
  65.         } else {  
  66.             this.pageStartRow = 0;  
  67.             this.pageEndRow = pageRecorders;  
  68.         }  
  69.     }  
  70.   
  71.     /** 
  72.      * @return 返回 page。 
  73.      */  
  74.     public int getPage() {  
  75.         return page;  
  76.     }  
  77.   
  78.     /** 
  79.      * @param page 
  80.      *            要设置的 page。 
  81.      */  
  82.     public void setPage(int page) {  
  83.         this.page = page;  
  84.     }  
  85.   
  86.     /** 
  87.      * @return Returns the pageRecorders. 
  88.      */  
  89.     public int getPageRecorders() {  
  90.         return pageRecorders;  
  91.     }  
  92.   
  93.     /** 
  94.      * @param pageRecorders 
  95.      *            The pageRecorders to set. 
  96.      */  
  97.     public void setPageRecorders(int pageRecorders) {  
  98.         this.pageRecorders = pageRecorders;  
  99.     }  
  100.   
  101.     /** 
  102.      * @return Returns the pageEndRow. 
  103.      */  
  104.     public int getPageEndRow() {  
  105.         return pageEndRow;  
  106.     }  
  107.   
  108.     /** 
  109.      * @return Returns the pageStartRow. 
  110.      */  
  111.     public int getPageStartRow() {  
  112.         return pageStartRow;  
  113.     }  
  114.   
  115.     /** 
  116.      * @return Returns the totalPages. 
  117.      */  
  118.     public String getTotalPages() {  
  119.         return this.toString(totalPages);  
  120.     }  
  121.   
  122.     /** 
  123.      * @return Returns the totalRows. 
  124.      */  
  125.     public String getTotalRows() {  
  126.         return this.toString(totalRows);  
  127.     }  
  128.   
  129.     /** 
  130.      * @return Returns the hasNextPage. 
  131.      */  
  132.     public boolean isHasNextPage() {  
  133.         return hasNextPage;  
  134.     }  
  135.   
  136.     /** 
  137.      * @param hasNextPage 
  138.      *            The hasNextPage to set. 
  139.      */  
  140.     public void setHasNextPage(boolean hasNextPage) {  
  141.         this.hasNextPage = hasNextPage;  
  142.     }  
  143.   
  144.     /** 
  145.      * @return Returns the hasPreviousPage. 
  146.      */  
  147.     public boolean isHasPreviousPage() {  
  148.         return hasPreviousPage;  
  149.     }  
  150.   
  151.     // 判断要不要分页  
  152.     public boolean isNext() {  
  153.         return list.size() > 8;  
  154.     }  
  155.   
  156.     /** 
  157.      * @param hasPreviousPage 
  158.      *            The hasPreviousPage to set. 
  159.      */  
  160.     public void setHasPreviousPage(boolean hasPreviousPage) {  
  161.         this.hasPreviousPage = hasPreviousPage;  
  162.     }  
  163.   
  164.     public String toString(int temp) {  
  165.         String str = Integer.toString(temp);  
  166.         return str;  
  167.     }  
  168.   
  169.     public void description() {  
  170.   
  171.         String description = "共有数据数:" + this.getTotalRows() +  
  172.   
  173.         "共有页数: " + this.getTotalPages() +  
  174.   
  175.         "当前页数为:" + this.getPage() +  
  176.   
  177.         " 是否有前一页: " + this.isHasPreviousPage() +  
  178.   
  179.         " 是否有下一页:" + this.isHasNextPage() +  
  180.   
  181.         " 开始行数:" + this.getPageStartRow() +  
  182.   
  183.         " 终止行数:" + this.getPageEndRow();  
  184.   
  185.         System.out.println(description);  
  186.     }  
  187.   
  188.     public List getNextPage() {  
  189.         page = page + 1;  
  190.   
  191.         disposePage();  
  192.   
  193.         System.out.println("用户凋用的是第" + page + "页");  
  194.         this.description();  
  195.         return getObjects(page);  
  196.     }  
  197.   
  198.     /** 
  199.      * 处理分页 
  200.      */  
  201.     private void disposePage() {  
  202.   
  203.         if (page == 0) {  
  204.             page = 1;  
  205.         }  
  206.   
  207.         if ((page - 1) > 0) {  
  208.             hasPreviousPage = true;  
  209.         } else {  
  210.             hasPreviousPage = false;  
  211.         }  
  212.   
  213.         if (page >= totalPages) {  
  214.             hasNextPage = false;  
  215.         } else {  
  216.             hasNextPage = true;  
  217.         }  
  218.     }  
  219.   
  220.     public List getPreviousPage() {  
  221.   
  222.         page = page - 1;  
  223.   
  224.         if ((page - 1) > 0) {  
  225.             hasPreviousPage = true;  
  226.         } else {  
  227.             hasPreviousPage = false;  
  228.         }  
  229.         if (page >= totalPages) {  
  230.             hasNextPage = false;  
  231.         } else {  
  232.             hasNextPage = true;  
  233.         }  
  234.         this.description();  
  235.         return getObjects(page);  
  236.     }  
  237.   
  238.     /** 
  239.      * 获取第几页的内容 
  240.      *  
  241.      * @param page 
  242.      * @return 
  243.      */  
  244.     public List getObjects(int page) {  
  245.         if (page == 0)  
  246.             this.setPage(1);  
  247.         else  
  248.             this.setPage(page);  
  249.         this.disposePage();  
  250.         if (page * pageRecorders < totalRows) {// 判断是否为最后一页  
  251.             pageEndRow = page * pageRecorders;  
  252.             pageStartRow = pageEndRow - pageRecorders;  
  253.         } else {  
  254.             pageEndRow = totalRows;  
  255.             pageStartRow = pageRecorders * (totalPages - 1);  
  256.         }  
  257.   
  258.         List objects = null;  
  259.         if (!list.isEmpty()) {  
  260.             objects = list.subList(pageStartRow, pageEndRow);  
  261.         }  
  262.         this.description();  
  263.         return objects;  
  264.     }  
  265.   
  266.     public List getFistPage() {  
  267.         if (this.isNext()) {  
  268.             return list.subList(0, pageRecorders);  
  269.         } else {  
  270.             return list;  
  271.         }  
  272.     }  
  273.   
  274.     /** 
  275.      * @return 返回 list。 
  276.      */  
  277.     public List getList() {  
  278.         return list;  
  279.     }  
  280.   
  281.     /** 
  282.      * @param list 
  283.      *            要设置的 list。 
  284.      */  
  285.     public void setList(List list) {  
  286.         this.list = list;  
  287.     }  
  288.   
  289.     /** 
  290.      * @param totalRows 
  291.      *            要设置的 totalRows。 
  292.      */  
  293.     public void setTotalRows(int totalRows) {  
  294.         this.totalRows = totalRows;  
  295.     }  
  296. }  

3：采用缓存的机制，用户在第一次查询的时候把查询结果存入缓存中，这样用户下载下一页的时候，就不用再去从数据库中查询，也可以通过第一中方法，先查询，然后在存入缓存，可以这样理解，智能的记录用户的操作，如果用户有重复操作就可以把上次的操作结果展示给用户



     
返回顶楼
         
  • karna
  • 等级: 二星会员
  • 文章: 79
  • 积分: 222
   发表时间：2007-01-18  

第一种吧，真的，第一种是最好的
返回顶楼
          回帖地址
0 请登录后投票
论坛首页 → Java企业应用版

跳转论坛:
Global site tag (gtag.js) - Google Analytics