自己对分页的理解

        最近要启动一个比较大的项目了。回忆以前做的那些web项目，快乐，痛苦，成功，失败都是经历过了。
        好久没动那些web了，都块忘记这么设计了，今天在java重新找出一些关于hibernate分页的帖子，受益良多。
        robbin大哥的说的最详细的 www.iteye.com/topic/14657
         www.iteye.com/topic/17857
        哈哈，有时间多复习是不错的。
         
        分页的主要思想是：
1：构造一个Page对象，把相关的属性设置好，比如记录数，每页包含条数，是否有下一页，是否有上一页，当前页，总页数等，然后通过Page工厂生成一个Page对象（构造的前题是：你必须知道记录总数，一般从数据中获取），最后通过对于数据库的分页语句得到结果，比如hibernate分页的写法是：

java 代码

String querySentence = "FROM user in class com.adt.po.User";
       Query query = getSession().createQuery(querySentence);
      query.setFirstResult(page.getBeginIndex())
            .setMaxResults(page.getEveryPage());
        return query.list();

这样做的充分利用数据各自的特性，提供性能。
2：直接从数据load出所有数据，然后再对结果集进行处理。
    对所有数据的操作都是用一条语句就ok了，方便处理，缺点是，数据量大的时候性能会有影响。而且每次都去load这么多数据，不合理。看看代码，很简单

java 代码

/**
 * @author wuhua
 *
 * 分页代码，实现策略是，用List类来保存所有对象，并以page为分页标记
 */

import java.util.List;

public class PageModel {
    private int page = 1; // 当前页

    public int totalPages = 0; // 总页数

    private int pageRecorders;// 每页5条数据

    private int totalRows = 0; // 总数据数

    private int pageStartRow = 0;// 每页的起始数

    private int pageEndRow = 0; // 每页显示数据的终止数

    private boolean hasNextPage = false; // 是否有下一页

    private boolean hasPreviousPage = false; // 是否有前一页

    private List list;

    // private Iterator it;

    public PageModel(List list, int pageRecorders) {
        init(list, pageRecorders);// 通过对象集，记录总数划分
    }

    /**
     *
     */
    public PageModel() {
    }

    /**
     * @param list
     * @param pageRecorders
     */
    public void init(List list, int pageRecorders) {
        this.pageRecorders = pageRecorders;
        this.list = list;
        totalRows = list.size();
        // it = list.iterator();
        hasPreviousPage = false;
        if ((totalRows % pageRecorders) == 0) {
            totalPages = totalRows / pageRecorders;
        } else {
            totalPages = totalRows / pageRecorders + 1;
        }

        if (page >= totalPages) {
            hasNextPage = false;
        } else {
            hasNextPage = true;
        }

        if (totalRows < pageRecorders) {
            this.pageStartRow = 0;
            this.pageEndRow = totalRows;
        } else {
            this.pageStartRow = 0;
            this.pageEndRow = pageRecorders;
        }
    }

    /**
     * @return 返回 page。
     */
    public int getPage() {
        return page;
    }

    /**
     * @param page
     *            要设置的 page。
     */
    public void setPage(int page) {
        this.page = page;
    }

    /**
     * @return Returns the pageRecorders.
     */
    public int getPageRecorders() {
        return pageRecorders;
    }

    /**
     * @param pageRecorders
     *            The pageRecorders to set.
     */
    public void setPageRecorders(int pageRecorders) {
        this.pageRecorders = pageRecorders;
    }

    /**
     * @return Returns the pageEndRow.
     */
    public int getPageEndRow() {
        return pageEndRow;
    }

    /**
     * @return Returns the pageStartRow.
     */
    public int getPageStartRow() {
        return pageStartRow;
    }

    /**
     * @return Returns the totalPages.
     */
    public String getTotalPages() {
        return this.toString(totalPages);
    }

    /**
     * @return Returns the totalRows.
     */
    public String getTotalRows() {
        return this.toString(totalRows);
    }

    /**
     * @return Returns the hasNextPage.
     */
    public boolean isHasNextPage() {
        return hasNextPage;
    }

    /**
     * @param hasNextPage
     *            The hasNextPage to set.
     */
    public void setHasNextPage(boolean hasNextPage) {
        this.hasNextPage = hasNextPage;
    }

    /**
     * @return Returns the hasPreviousPage.
     */
    public boolean isHasPreviousPage() {
        return hasPreviousPage;
    }

    // 判断要不要分页
    public boolean isNext() {
        return list.size() > 8;
    }

    /**
     * @param hasPreviousPage
     *            The hasPreviousPage to set.
     */
    public void setHasPreviousPage(boolean hasPreviousPage) {
        this.hasPreviousPage = hasPreviousPage;
    }

    public String toString(int temp) {
        String str = Integer.toString(temp);
        return str;
    }

    public void description() {

        String description = "共有数据数:" + this.getTotalRows() +

        "共有页数: " + this.getTotalPages() +

        "当前页数为:" + this.getPage() +

        " 是否有前一页: " + this.isHasPreviousPage() +

        " 是否有下一页:" + this.isHasNextPage() +

        " 开始行数:" + this.getPageStartRow() +

        " 终止行数:" + this.getPageEndRow();

        System.out.println(description);
    }

    public List getNextPage() {
        page = page + 1;

        disposePage();

        System.out.println("用户凋用的是第" + page + "页");
        this.description();
        return getObjects(page);
    }

    /**
     * 处理分页
     */
    private void disposePage() {

        if (page == 0) {
            page = 1;
        }

        if ((page - 1) > 0) {
            hasPreviousPage = true;
        } else {
            hasPreviousPage = false;
        }

        if (page >= totalPages) {
            hasNextPage = false;
        } else {
            hasNextPage = true;
        }
    }

    public List getPreviousPage() {

        page = page - 1;

        if ((page - 1) > 0) {
            hasPreviousPage = true;
        } else {
            hasPreviousPage = false;
        }
        if (page >= totalPages) {
            hasNextPage = false;
        } else {
            hasNextPage = true;
        }
        this.description();
        return getObjects(page);
    }

    /**
     * 获取第几页的内容
     *
     * @param page
     * @return
     */
    public List getObjects(int page) {
        if (page == 0)
            this.setPage(1);
        else
            this.setPage(page);
        this.disposePage();
        if (page * pageRecorders < totalRows) {// 判断是否为最后一页
            pageEndRow = page * pageRecorders;
            pageStartRow = pageEndRow - pageRecorders;
        } else {
            pageEndRow = totalRows;
            pageStartRow = pageRecorders * (totalPages - 1);
        }

        List objects = null;
        if (!list.isEmpty()) {
            objects = list.subList(pageStartRow, pageEndRow);
        }
        this.description();
        return objects;
    }

    public List getFistPage() {
        if (this.isNext()) {
            return list.subList(0, pageRecorders);
        } else {
            return list;
        }
    }

    /**
     * @return 返回 list。
     */
    public List getList() {
        return list;
    }

    /**
     * @param list
     *            要设置的 list。
     */
    public void setList(List list) {
        this.list = list;
    }

    /**
     * @param totalRows
     *            要设置的 totalRows。
     */
    public void setTotalRows(int totalRows) {
        this.totalRows = totalRows;
    }
}

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



     

评论

1 楼 karna 2007-01-18  

<p>第一种吧，真的，第一种是最好的</p>