PageHelper 分页查询「原理篇」_随笔

PageHelper 分页查询「原理篇」 pagehelper简介

PageHelper方法分页原理

PageHelper方法使用了静态的ThreadLocal参数，分页参数和线程是绑定的。内部流程是ThreadLocal中设置了分页参数（pageIndex，pageSize），之后在查询执行的时候，获取当前线程中的分页参数，执行查询的时候通过拦截器在sql语句中添加分页参数，之后实现分页查询，查询结束后在 finally 语句中清除ThreadLocal中的查询参数。

通俗地讲，就是

PageHelper.startPage(int pageNum, int pageSize)相当于开启分页，通过拦截 MySQL 的方式，把查询语句拦截下来加 limit.

所以，该语句应该放在查询语句之前。

因此，整个过程应该是，前端会传过来pageNum和pageSize这两个参数，当点击前端的下一页按钮的时候，这个pageNum会加1，然后重新传到后端，调用后端的接口。后端拿到pageNum和pageSize之后，利用PageHelper.startPage设置分页，这样，在后面的sql语句中不用加 limit了。

注意：只要保证在PageHelper方法调用后紧跟 MyBatis 查询方法，这就是安全的。因为PageHelper在finally代码段中自动清除了ThreadLocal存储的对象。

比如

PageHelper.startPage(dto.getPageNum(), dto.getPageSize());
List list = payProjectMapper.queryPayProjectByPage(dto);

这样，查出来的list则不是所有满足查询条件的数据，而是一页的数据，这也是分页查询的其中一种方式：利用limit去查，每次只返回一页数据。

还有另外一种方式：直接全部查出来所有满足查询条件的数据放到list中，然后再进行分页返回给前端。该方式的弊端是，如果数据量过多，全部查出来放到内存中，很有可能导致内存溢出。

使用分页插件的好处

提升开发效率
便于维护

使用分页插件后，只需在查询语句前添加分页语句，而不用在sql语句中写limit，尽管可以使用Mybatis实现动态sql，但是SQL中还是要写limit。一个sql语句越简单，被复用的可能性就越大，没有limit的sql语句，在不加分页语句的时候还可以直接调用实现全查询。

越复杂的sql语句越象征着被重用的几率越低，因为语句复杂，且查寻条件耦合到了一个sql语句中。

Mybatis动态sql的特性使得硬邦邦的原本查询数据的sql语句得到了部分参数的灵活多变，如果不使用Mybatis，对于比较复杂的查询 *** 作就需要更多的sql来完成，而且，Mybatis提供了判空、传参等机制，这样我们就不用在业务代码中进行判空。

实例

如下

public Result queryPageList(QueryDTO dto) {
    
    // 设置分页信息，将pageNum 和 pageSize与当前线程绑定
    PageHelper.startPage(dto.getPageNum(), dto.getPageSize());
    
    // 设置查询条件
    Model model = new Model();
    model.setId(dto.getId());
    model.setStartDate(dto.getStartDate());
    model.setEndDate(dto.getEndDate());
    // 查询数据库（查出来的是一页的数据）
    List modelList = xxService.queryListByCondition(model);
    List respList = new ArrayList<>();
    // 将查到的数据复制到返参respList中
    if (CollectionUtils.isNotEmpty(modelList)) {
        modelList.stream().forEach(model -> {
            RespDTO respDto = new RespDTO();
            BeanUtils.copyProperties(model, respDto);
            respList.add(respDto);
        });
    }
    
    PageInfo result = new PageInfo<>(respList);
    return ResultUtils.toSuccess(result);
}

设计理念

按照自己的理解来分析一下PageHelper这个插件的设计理念。

Java是面向对象的语言，所以，关键的是，把实际需求建成模型然后用编程语言表示出来，更进一步地说，就是如何抽象成一个个Java类。

在这里，作者将一个页面分为两部分

页的信息描述部分
页的数据部分

信息描述部分包括PageSerializable、PageInfo

数据部分是用Page

PageInfo定义了一个页面的基本信息，包括页大小、页码等；PageSerializable提供了一个List，让PageInfo去继承PageSerializable，这样整个页面的框架部分就搭好了，总结就是：PageInfo描述页的基本信息，PageSerializable提供一个List放数据，至于放的数据类型是啥，那就是这个了。

这里的就是ArrayList，也就是xxRequestDTO类型

Page继承了ArrayList，所以Page本质上就是一个ArrayList，可以用来存放一个个数据实体
PageSerializable 的成员变量很简单，总共个就两个成员变量，一个是Long total；一个是List list，可以指向一个Page实例
PageInfo继承了PageSerializable，提供了更加丰富的成员变量来描述页的信息：比如当前页、每页条数、当前页的数量等

PageInfo

PageInfo 源码

package com.github.pagehelper;

import java.util.Collection;
import java.util.List;
import lombok.Data;


@Data // 赋予 getter setter 
public class PageInfo extends PageSerializable {
    
    
    private int pageNum;  // 当前页
    private int pageSize;  // 每页条数
    private int size;  // 当前页的数量
    private int startRow;  // 当前页面第一个元素在数据库中的行号
    private int endRow;  // 当前页面最后一个元素在数据库中的行号
    private int pages; // 总页数
    private int prePage;  // 当前页
    private int nextPage;  // 下一页
    private boolean isFirstPage;  // 是否是首页
    private boolean isLastPage;  // 是否是最后一页
    private boolean hasPreviousPage;  // 是否有前一页
    private boolean hasNextPage;  // 是否有后一页
    private int navigatePages;  // 导航页码数
    private int[] navigatepageNums;  // 所有导航页号
    private int navigateFirstPage;  // 导航条上的第一页
    private int navigateLastPage;  // 导航条上的最后一页

    
    public PageInfo() {
        this.isFirstPage = false;
        this.isLastPage = false;
        this.hasPreviousPage = false;
        this.hasNextPage = false;
    }

    
    public PageInfo(List list) {
        this(list, 8);
    }

    
    public PageInfo(List list, int navigatePages) {
        super(list);  // 调用父类 PageSerializable 的构造器
        this.isFirstPage = false;
        this.isLastPage = false;
        this.hasPreviousPage = false;
        this.hasNextPage = false;
        if (list instanceof Page) {
            Page page = (Page)list;
            this.pageNum = page.getPageNum();
            this.pageSize = page.getPageSize();
            this.pages = page.getPages();
            this.size = page.size();
            if (this.size == 0) {
                this.startRow = 0;
                this.endRow = 0;
            } else {
                this.startRow = page.getStartRow() + 1;
                this.endRow = this.startRow - 1 + this.size;
            }
        } else if (list instanceof Collection) {
            this.pageNum = 1;
            this.pageSize = list.size();
            this.pages = this.pageSize > 0 ? 1 : 0;
            this.size = list.size();
            this.startRow = 0;
            this.endRow = list.size() > 0 ? list.size() - 1 : 0;
        }

        if (list instanceof Collection) {
            this.navigatePages = navigatePages;
            this.calcNavigatepageNums();
            this.calcPage();
            this.judgePageBoudary();
        }

    }

    public static  PageInfo of(List list) {
        return new PageInfo(list);
    }

    public static  PageInfo of(List list, int navigatePages) {
        return new PageInfo(list, navigatePages);
    }

    private void calcNavigatepageNums() {
        int i;
        if (this.pages <= this.navigatePages) {
            this.navigatepageNums = new int[this.pages];

            for(i = 0; i < this.pages; ++i) {
                this.navigatepageNums[i] = i + 1;
            }
        } else {
            this.navigatepageNums = new int[this.navigatePages];
            i = this.pageNum - this.navigatePages / 2;
            int endNum = this.pageNum + this.navigatePages / 2;
            int i;
            if (i < 1) {
                i = 1;

                for(i = 0; i < this.navigatePages; ++i) {
                    this.navigatepageNums[i] = i++;
                }
            } else if (endNum > this.pages) {
                endNum = this.pages;

                for(i = this.navigatePages - 1; i >= 0; --i) {
                    this.navigatepageNums[i] = endNum--;
                }
            } else {
                for(i = 0; i < this.navigatePages; ++i) {
                    this.navigatepageNums[i] = i++;
                }
            }
        }

    }

    private void calcPage() {
        if (this.navigatepageNums != null && this.navigatepageNums.length > 0) {
            this.navigateFirstPage = this.navigatepageNums[0];
            this.navigateLastPage = this.navigatepageNums[this.navigatepageNums.length - 1];
            if (this.pageNum > 1) {
                this.prePage = this.pageNum - 1;
            }

            if (this.pageNum < this.pages) {
                this.nextPage = this.pageNum + 1;
            }
        }

    }

    private void judgePageBoudary() {
        this.isFirstPage = this.pageNum == 1;
        this.isLastPage = this.pageNum == this.pages || this.pages == 0;
        this.hasPreviousPage = this.pageNum > 1;
        this.hasNextPage = this.pageNum < this.pages;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder("PageInfo{");
        sb.append("pageNum=").append(this.pageNum);
        sb.append(", pageSize=").append(this.pageSize);
        sb.append(", size=").append(this.size);
        sb.append(", startRow=").append(this.startRow);
        sb.append(", endRow=").append(this.endRow);
        sb.append(", total=").append(this.total);
        sb.append(", pages=").append(this.pages);
        sb.append(", list=").append(this.list);
        sb.append(", prePage=").append(this.prePage);
        sb.append(", nextPage=").append(this.nextPage);
        sb.append(", isFirstPage=").append(this.isFirstPage);
        sb.append(", isLastPage=").append(this.isLastPage);
        sb.append(", hasPreviousPage=").append(this.hasPreviousPage);
        sb.append(", hasNextPage=").append(this.hasNextPage);
        sb.append(", navigatePages=").append(this.navigatePages);
        sb.append(", navigateFirstPage=").append(this.navigateFirstPage);
        sb.append(", navigateLastPage=").append(this.navigateLastPage);
        sb.append(", navigatepageNums=");
        if (this.navigatepageNums == null) {
            sb.append("null");
        } else {
            sb.append('[');

            for(int i = 0; i < this.navigatepageNums.length; ++i) {
                sb.append(i == 0 ? "" : ", ").append(this.navigatepageNums[i]);
            }

            sb.append(']');
        }

        sb.append('}');
        return sb.toString();
    }
}

PageSerializable

PageSerializable 源码

package com.github.pagehelper;

import java.io.Serializable;
import java.util.List;


public class PageSerializable implements Serializable {
    
    private static final long serialVersionUID = 1L;
    protected long total;
    protected List list;
    
    public PageSerializable() {}

    
    public PageSerializable(List list) {
        this.list = list;
        if (list instanceof Page) {  // 而Page继承了ArrayList
            this.total = ((Page)list).getTotal();
        } else {
            this.total = (long)list.size();
        }
    }

    public static  PageSerializable of(List list) {
        return new PageSerializable(list);
    }

    
    public long getTotal() {return this.total;}
    public void setTotal(long total) {this.total = total;}
    public List getList() {return this.list;}
    public void setList(List list) {this.list = list;}
    public String toString() {
        return "PageSerializable{total=" + this.total + ", list=" + this.list + '}';
    }
}

Page

Page 源码

Page 类没什么特殊的地方
本质上是一个ArrayList，只不过要比ArrayList属性和功能更丰富一些

package com.github.pagehelper;

import java.io.Closeable;
import java.util.ArrayList;
import java.util.List;


public class Page extends ArrayList implements Closeable {
    private static final long serialVersionUID = 1L;
    private int pageNum;  // 当前页
    private int pageSize;  // 每页条数
    private int startRow;  // 当前页面第一个元素在数据库中的行号
    private int endRow;  // 当前页面最后一个元素在数据库中的行号
    private long total; 
    private int pages;
    private boolean count;
    private Boolean reasonable;
    private Boolean pageSizeZero;  // 每页条数是否为0
    private String countColumn;
    private String orderBy;
    private boolean orderByOnly;

    public Page() {
        this.count = true;
    }

    public Page(int pageNum, int pageSize) {
        this(pageNum, pageSize, true, (Boolean)null);
    }

    public Page(int pageNum, int pageSize, boolean count) {
        this(pageNum, pageSize, count, (Boolean)null);
    }

    private Page(int pageNum, int pageSize, boolean count, Boolean reasonable) {
        super(0);  // 调用父类ArrayList构造器初始化化大小为0
        this.count = true;
        if (pageNum == 1 && pageSize == 2147483647) {
            this.pageSizeZero = true;
            pageSize = 0;
        }
        this.pageNum = pageNum;
        this.pageSize = pageSize;
        this.count = count;
        this.calculateStartAndEndRow();
        this.setReasonable(reasonable);
    }

    // 有参构造器
    public Page(int[] rowBounds, boolean count) {
        super(0);
        this.count = true;
        if (rowBounds[0] == 0 && rowBounds[1] == 2147483647) {
            this.pageSizeZero = true;
            this.pageSize = 0;
        } else {
            this.pageSize = rowBounds[1];
            this.pageNum = rowBounds[1] != 0 ? (int)Math.ceil(((double)rowBounds[0] + (double)rowBounds[1]) / (double)rowBounds[1]) : 0;
        }

        this.startRow = rowBounds[0];
        this.count = count;
        this.endRow = this.startRow + rowBounds[1];
    }

    
    
    public List getResult() {
        return this;
    }

    public int getPages() {return this.pages;}
    public Page setPages(int pages) {this.pages = pages;return this;}
    public int getEndRow() {return this.endRow;}
    public Page setEndRow(int endRow) {this.endRow = endRow;return this;}
    public int getPageNum() {return this.pageNum;}
    public Page setPageNum(int pageNum) {
        this.pageNum = this.reasonable != null && this.reasonable && pageNum <= 0 ? 1 : pageNum;
        return this;
    }
    public int getPageSize() {return this.pageSize;}
    public Page setPageSize(int pageSize) {this.pageSize = pageSize;return this;}
    public int getStartRow() {return this.startRow;}
    public Page setStartRow(int startRow) {this.startRow = startRow;return this;}
    public long getTotal() {return this.total;}
    
    public void setTotal(long total) {
        this.total = total;
        if (total == -1L) {
            this.pages = 1;
        } else {
            if (this.pageSize > 0) {
                this.pages = (int)(total / (long)this.pageSize + (long)(total % (long)this.pageSize == 0L ? 0 : 1));
            } else {
                this.pages = 0;
            }

            if (this.reasonable != null && this.reasonable && this.pageNum > this.pages) {
                if (this.pages != 0) {
                    this.pageNum = this.pages;
                }

                this.calculateStartAndEndRow();
            }

        }
    }

    public Boolean getReasonable() {return this.reasonable;}
    public Page setReasonable(Boolean reasonable) {
        if (reasonable == null) {
            return this;
        } else {
            this.reasonable = reasonable;
            if (this.reasonable && this.pageNum <= 0) {
                this.pageNum = 1;
                this.calculateStartAndEndRow();
            }

            return this;
        }
    }

    public Boolean getPageSizeZero() {return this.pageSizeZero;}

    public Page setPageSizeZero(Boolean pageSizeZero) {
        if (pageSizeZero != null) {this.pageSizeZero = pageSizeZero;}
        return this;
    }

    public String getOrderBy() {return this.orderBy;}
    public  Page setOrderBy(String orderBy) {this.orderBy = orderBy;return this;}
    public boolean isOrderByOnly() {return this.orderByOnly;}
    public void setOrderByOnly(boolean orderByOnly) {this.orderByonly = orderByOnly;}
    private void calculateStartAndEndRow() {
        this.startRow = this.pageNum > 0 ? (this.pageNum - 1) * this.pageSize : 0;
        this.endRow = this.startRow + this.pageSize * (this.pageNum > 0 ? 1 : 0);
    }
    public boolean isCount() {return this.count;}
    public Page setCount(boolean count) {
        this.count = count;
        return this;
    }
    public Page pageNum(int pageNum) {
        this.pageNum = this.reasonable != null && this.reasonable && pageNum <= 0 ? 1 : pageNum;
        return this;
    }
    public Page pageSize(int pageSize) {
        this.pageSize = pageSize;
        this.calculateStartAndEndRow();
        return this;
    }
    public Page count(Boolean count) {this.count = count;return this;}
    public Page reasonable(Boolean reasonable) {this.setReasonable(reasonable);return this;}
    public Page pageSizeZero(Boolean pageSizeZero) {this.setPageSizeZero(pageSizeZero);return this;}
    public Page countColumn(String columnName) {this.countColumn = columnName;return this;}
    public PageInfo toPageInfo() {PageInfo pageInfo = new PageInfo(this);return pageInfo;}
    public PageSerializable toPageSerializable() {
        PageSerializable serializable = new PageSerializable(this);
        return serializable;
    }
    public  Page doSelectPage(ISelect select) {select.doSelect();return this;}
    public  PageInfo doSelectPageInfo(ISelect select) {select.doSelect();return this.toPageInfo();}
    public  PageSerializable doSelectPageSerializable(ISelect select) {select.doSelect();return this.toPageSerializable();}
    public long doCount(ISelect select) {
        this.pageSizeZero = true;
        this.pageSize = 0;
        select.doSelect();
        return this.total;
    }
    public String getCountColumn() {return this.countColumn;}
    public void setCountColumn(String countColumn) {this.countColumn = countColumn;}
    public String toString() {
        return "Page{count=" + this.count + ", pageNum=" + this.pageNum + ", pageSize=" + this.pageSize + ", startRow=" + this.startRow + ", endRow=" + this.endRow + ", total=" + this.total + ", pages=" + this.pages + ", reasonable=" + this.reasonable + ", pageSizeZero=" + this.pageSizeZero + '}' + super.toString();
    }
    public void close() {PageHelper.clearPage();}
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://www.outofmemory.cn/zaji/5676731.html

PageHelper 分页查询「原理篇」

发表评论

评论列表（0条）