DIY mybatisPlus的分页插件

起因

在我们通过list返回的列表页，出现了一个需要数据合计的需求，例如一个订单1块钱，那么所有订单加起来多少钱，那么list一般都通过分页返回，而统计所有订单又不能只统计分页的那几条数据，因此需要在查询一下数据库，如果通过left join去查询并在list中加个字段好像又不太合适

mybatisPlus自带了分页插件，但是在page中又不能set我们需要返回的合计数据，不过通过上次修改了poi的源码后，我们只要能看到源码就能轻易扒出来源码进行修改

修改

定义接口

继承原先的IPage接口，在此基础上进行扩展

import com.baomidou.mybatisplus.core.metadata.IPage;

public interface MyPage<T> extends IPage<T> {
    /**
     * 获取自定义内容
     *
     * @return 自定义内容
     */
    Object getContent();

    /**
     * 设置自定义内容
     * @param content 自定义内容
     * @return
     */
    MyPage<T> setContent(Object content);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

重写MyPage的方法

通过重写MyPage接口的方式实现diy分页

public class MyPageImpl<T> implements MyPage<T> {

    private static final long serialVersionUID = 8545996863226528798L;
    /**
     * 查询数据列表
     */
    protected List<T> records;
    /**
     * 总数
     */
    protected long total;
    /**
     * 每页显示条数，默认 10
     */
    protected long size;
    /**
     * 当前页
     */
    protected long current;
    /**
     * 排序字段信息
     */
    protected List<OrderItem> orders;
    /**
     * 自动优化 COUNT SQL
     */
    protected boolean optimizeCountSql;
    /**
     * 是否进行 count 查询
     */
    protected boolean searchCount;
    /**
     * countId
     */
    protected String countId;
    /**
     * maxLimit
     */
    protected Long maxLimit;
    /**
     * 自定义Object
     */
    protected Object content;

    public MyPageImpl() {
        this.records = Collections.emptyList();
        this.total = 0L;
        this.size = 10L;
        this.current = 1L;
        this.orders = new ArrayList();
        this.optimizeCountSql = true;
        this.searchCount = true;
        this.content = null;
    }

    /**
     * 分页构造函数
     *
     * @param current 当前页
     * @param size    每页显示条数
     */
    public MyPageImpl(long current, long size) {
        this(current, size, 0L);
    }

    public MyPageImpl(long current, long size, long total) {
        this(current, size, total, true);
    }

    public MyPageImpl(long current, long size, boolean searchCount) {
        this(current, size, 0L, searchCount);
    }

    public MyPageImpl(long current, long size, long total, boolean searchCount) {
        this.records = Collections.emptyList();
        this.total = 0L;
        this.size = 10L;
        this.current = 1L;
        this.orders = new ArrayList();
        this.optimizeCountSql = true;
        this.searchCount = true;
        if (current > 1L) {
            this.current = current;
        }

        this.size = size;
        this.total = total;
        this.searchCount = searchCount;
    }

    public MyPageImpl(long current, long size, long total, boolean searchCount, Object content) {
        this.records = Collections.emptyList();
        this.total = 0L;
        this.size = 10L;
        this.current = 1L;
        this.orders = new ArrayList();
        this.optimizeCountSql = true;
        this.searchCount = true;
        if (current > 1L) {
            this.current = current;
        }

        this.size = size;
        this.total = total;
        this.searchCount = searchCount;
        this.content = content;
    }

    /**
     * 是否存在上一页
     *
     * @return true / false
     */
    public boolean hasPrevious() {
        return this.current > 1L;
    }

    /**
     * 是否存在下一页
     *
     * @return true / false
     */
    public boolean hasNext() {
        return this.current < this.getPages();
    }

    public List<T> getRecords() {
        return this.records;
    }

    public MyPageImpl<T> setRecords(List<T> records) {
        this.records = records;
        return this;
    }

    public long getTotal() {
        return this.total;
    }

    public MyPageImpl<T> setTotal(long total) {
        this.total = total;
        return this;
    }


    public Object getContent() {
        return this.content;
    }

    public MyPageImpl<T> setContent(Object content) {
        this.content = content;
        return this;
    }

    public long getSize() {
        return this.size;
    }

    public MyPageImpl<T> setSize(long size) {
        this.size = size;
        return this;
    }

    public long getCurrent() {
        return this.current;
    }

    public MyPageImpl<T> setCurrent(long current) {
        this.current = current;
        return this;
    }

    public String countId() {
        return this.countId;
    }

    public Long maxLimit() {
        return this.maxLimit;
    }

    /**
     * 查找 order 中正序排序的字段数组
     *
     * @param filter 过滤器
     * @return 返回正序排列的字段数组
     */
    private String[] mapOrderToArray(Predicate<OrderItem> filter) {
        List<String> columns = new ArrayList(this.orders.size());
        this.orders.forEach((i) -> {
            if (filter.test(i)) {
                columns.add(i.getColumn());
            }

        });
        return columns.toArray(new String[0]);
    }

    /**
     * 移除符合条件的条件
     *
     * @param filter 条件判断
     */
    private void removeOrder(Predicate<OrderItem> filter) {
        for (int i = this.orders.size() - 1; i >= 0; --i) {
            if (filter.test(this.orders.get(i))) {
                this.orders.remove(i);
            }
        }

    }

    /**
     * 添加新的排序条件，构造条件可以使用工厂：{@link OrderItem#(String, boolean)}
     *
     * @param items 条件
     * @return 返回分页参数本身
     */
    public MyPageImpl<T> addOrder(OrderItem... items) {
        this.orders.addAll(Arrays.asList(items));
        return this;
    }

    /**
     * 添加新的排序条件，构造条件可以使用工厂：{@link OrderItem#(String, boolean)}
     *
     * @param items 条件
     * @return 返回分页参数本身
     */
    public MyPageImpl<T> addOrder(List<OrderItem> items) {
        this.orders.addAll(items);
        return this;
    }

    public List<OrderItem> orders() {
        return this.orders;
    }

    public boolean optimizeCountSql() {
        return this.optimizeCountSql;
    }

    public boolean searchCount() {
        return this.total >= 0L && this.searchCount;
    }

    public MyPageImpl<T> setSearchCount(boolean searchCount) {
        this.searchCount = searchCount;
        return this;
    }

    public MyPageImpl<T> setOptimizeCountSql(boolean optimizeCountSql) {
        this.optimizeCountSql = optimizeCountSql;
        return this;
    }

    public long getPages() {
        return MyPage.super.getPages();
    }

    /* --------------- 以下为静态构造方式 --------------- */
    public static <T> MyPageImpl<T> of(long current, long size) {
        return of(current, size, 0L);
    }

    public static <T> MyPageImpl<T> of(long current, long size, long total) {
        return of(current, size, total, true);
    }

    public static <T> MyPageImpl<T> of(long current, long size, boolean searchCount) {
        return of(current, size, 0L, searchCount);
    }

    public static <T> MyPageImpl<T> of(long current, long size, long total, boolean searchCount) {
        return new MyPageImpl<>(current, size, total, searchCount);
    }

    /**
     * --begin------------- 未来抛弃移除的方法 -------------begin--
     * 该部分属性转移至 {@link PageDTO}
     */
    /**
     * @deprecated
     */
    @Deprecated
    public String getCountId() {
        return this.countId;
    }

    /**
     * @deprecated
     */
    @Deprecated
    public Long getMaxLimit() {
        return this.maxLimit;
    }

    /**
     * @deprecated
     */
    @Deprecated
    public List<OrderItem> getOrders() {
        return this.orders;
    }

    /**
     * @deprecated
     */
    @Deprecated
    public boolean isOptimizeCountSql() {
        return this.optimizeCountSql;
    }

    /**
     * @deprecated
     */
    @Deprecated
    public boolean isSearchCount() {
        return this.searchCount;
    }

    public void setOrders(final List<OrderItem> orders) {
        this.orders = orders;
    }

    public void setCountId(final String countId) {
        this.countId = countId;
    }

    public void setMaxLimit(final Long maxLimit) {
        this.maxLimit = maxLimit;
    }
    /** --end------------- 未来抛弃移除的方法 -------------end-- */
}

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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334

实践测试

	//获取分页信息
	MyPageImpl<InStoreDtl> page = new MyPageImpl<>(pageNo, pageSize);
	//返回我们自定义的分页对象
	MyPage<InStoreDtl> pageList = inStoreDtlMapper.listByMainCode(mainCode, page);
	//获取合计的数据
	Map<String, Object> countMap = inStoreDtlMapper.selectCountNum(mainCode);
	pageList.setContent(countMap);
	return pageList;
1
2
3
4
5
6
7
8