PageHelper 分页查询「原理篇」_pagehelper分页原理

pagehelper简介

PageHelper方法分页原理

PageHelper方法使用了静态的ThreadLocal参数，分页参数和线程是绑定的。内部流程是ThreadLocal中设置了分页参数（pageNum，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<PayProject> list = payProjectMapper.queryPayProjectByPage(dto);
1
2

这样，查出来的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<Model> modelList = xxService.queryListByCondition(model);
    List<RespDTO> respList = new ArrayList<>();
    // 将查到的数据复制到返参respList中
    if (CollectionUtils.isNotEmpty(modelList)) {
        modelList.stream().forEach(model -> {
            RespDTO respDto = new RespDTO();
            BeanUtils.copyProperties(model, respDto);
            respList.add(respDto);
        });
    }
    
    PageInfo<RespDTO> result = new PageInfo<>(respList);
    return ResultUtils.toSuccess(result);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

设计理念

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

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

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

1. 页的信息描述部分
2. 页的数据部分

信息描述部分包括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<T>

PageInfo 源码

package com.github.pagehelper;

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

/**
 * 现在再来看PageInfo就好理解了
 * PageInfo继承了PageSerializable，而PageSerializable的成员变量可以为Page实例，而Page实际上就是个ArrayList
 * 所以PageInfo继承了PageSerializable的成员变量，所以PageInfo的成员变量可以为Page实例
 */
@Data // 赋予 getter setter 
public class PageInfo<T> extends PageSerializable<T> {
    
    /**
     * 通过字段可以看出，PageInfo是一个 页信息 类，用来描述一页的各种信息
     */
    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;
    }

    /** 
     * 有参构造器，参数类型为 List<T>
     * 默认将 导航页码数 navigatePages 设置为8
     */
    public PageInfo(List<T> list) {
        this(list, 8);
    }

    /**
     * 有参构造器 
     */
    public PageInfo(List<T> list, int navigatePages) {
        super(list);  // 调用父类 PageSerializable<T> 的构造器
        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 <T> PageInfo<T> of(List<T> list) {
        return new PageInfo(list);
    }

    public static <T> PageInfo<T> of(List<T> 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

PageSerializable<T>

PageSerializable<T> 源码

package com.github.pagehelper;

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

/** 
 * 实现了Serializable，意为可序列化的Page
 */
public class PageSerializable<T> implements Serializable {
    
    private static final long serialVersionUID = 1L;
    protected long total;
    protected List<T> list;
    
    public PageSerializable() {}

    /**
     * 有参构造器 传入List<T>
     * 这里道出了PageSerializable和Page的关系：Page实例可作为PageSerializable的成员变量
     * 
     */
    public PageSerializable(List<T> list) {
        this.list = list;
        if (list instanceof Page) {  // 而Page继承了ArrayList
            this.total = ((Page)list).getTotal();
        } else {
            this.total = (long)list.size();
        }
    }

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

    /** 后面为属性的getter setter方法 **/
    public long getTotal() {return this.total;}
    public void setTotal(long total) {this.total = total;}
    public List<T> getList() {return this.list;}
    public void setList(List<T> list) {this.list = list;}
    public String toString() {
        return "PageSerializable{total=" + this.total + ", list=" + this.list + '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

Page<T>

Page<T> 源码

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

package com.github.pagehelper;

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

/**
 * 可以看出Page继承了ArrayList
 */
public class Page<E> extends ArrayList<E> 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];
    }

    /** 后面主要是一些getter setter 方法以及少量其他方法 **/
    
    public List<E> getResult() {
        return this;
    }

    public int getPages() {return this.pages;}
    public Page<E> setPages(int pages) {this.pages = pages;return this;}
    public int getEndRow() {return this.endRow;}
    public Page<E> setEndRow(int endRow) {this.endRow = endRow;return this;}
    public int getPageNum() {return this.pageNum;}
    public Page<E> setPageNum(int pageNum) {
        this.pageNum = this.reasonable != null && this.reasonable && pageNum <= 0 ? 1 : pageNum;
        return this;
    }
    public int getPageSize() {return this.pageSize;}
    public Page<E> setPageSize(int pageSize) {this.pageSize = pageSize;return this;}
    public int getStartRow() {return this.startRow;}
    public Page<E> 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<E> 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<E> setPageSizeZero(Boolean pageSizeZero) {
        if (pageSizeZero != null) {this.pageSizeZero = pageSizeZero;}
        return this;
    }

    public String getOrderBy() {return this.orderBy;}
    public <E> Page<E> 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<E> setCount(boolean count) {
        this.count = count;
        return this;
    }
    public Page<E> pageNum(int pageNum) {
        this.pageNum = this.reasonable != null && this.reasonable && pageNum <= 0 ? 1 : pageNum;
        return this;
    }
    public Page<E> pageSize(int pageSize) {
        this.pageSize = pageSize;
        this.calculateStartAndEndRow();
        return this;
    }
    public Page<E> count(Boolean count) {this.count = count;return this;}
    public Page<E> reasonable(Boolean reasonable) {this.setReasonable(reasonable);return this;}
    public Page<E> pageSizeZero(Boolean pageSizeZero) {this.setPageSizeZero(pageSizeZero);return this;}
    public Page<E> countColumn(String columnName) {this.countColumn = columnName;return this;}
    public PageInfo<E> toPageInfo() {PageInfo<E> pageInfo = new PageInfo(this);return pageInfo;}
    public PageSerializable<E> toPageSerializable() {
        PageSerializable<E> serializable = new PageSerializable(this);
        return serializable;
    }
    public <E> Page<E> doSelectPage(ISelect select) {select.doSelect();return this;}
    public <E> PageInfo<E> doSelectPageInfo(ISelect select) {select.doSelect();return this.toPageInfo();}
    public <E> PageSerializable<E> 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();}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179