使用Page对象进行分页

1
2
3
4
5
6
 @ApiOperation("出差列表")
    @GetMapping("/search")
    @Authorization(menuId = 10L)
    Page<BusinessDTO> search(@RequestParam(required = false) String name, PageParam pageParam) {
        return businessService.page(name, pageParam);
    }

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
/**
 * 分页包装对象
 */
@Data
public class Page<T> implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 页码
     */
    private Integer pageNo;

    /**
     * 是否有上一页
     */
    private Boolean hasPreviousPage;

    /**
     * 是否有下一页
     */
    private Boolean hasNextPage;

    /**
     * 本页的条目一览
     */
    private List<T> entitiesInPage;

    /**
     * 一共有几页
     */
    private Integer pagesCount;

    /**
     * 总共多少条目
     */
    private Long total;

    private Page() {
    }

    /**
     * 空页
     */
    public static <T> Page<T> empty() {
        return new Page<>();
    }

    public static <T> Page<T> wrap(List<T> entities) {
        PageInfo<T> pageInfo = new PageInfo<>(entities);
        Page<T> page = new Page<>();
        page.pageNo = pageInfo.getPageNum();
        page.hasPreviousPage = pageInfo.isHasPreviousPage();
        page.hasNextPage = pageInfo.isHasNextPage();
        page.entitiesInPage = pageInfo.getList();
        page.pagesCount = pageInfo.getPages();
        page.total = pageInfo.getTotal();
        return page;
    }

    public static <T> Page<T> overWriteEntities(Page page, List<T> entities) {
        Page<T> newPage = new Page<>();
        newPage.pageNo = page.pageNo;
        newPage.hasPreviousPage = page.hasPreviousPage;
        newPage.hasNextPage = page.hasNextPage;
        newPage.entitiesInPage = entities;
        newPage.pagesCount = page.pagesCount;
        newPage.total = page.total;
        return newPage;
    }

}

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
@Data
public class PageParam {

    private static final int DEFAULT_PAGE_NO = 1;

    private static final int DEFAULT_PAGE_SIZE = 10;

    private String pageNo;

    private String pageSize;

    public void startPage() {
        int pageNoEx;
        if (NumberUtils.isCreatable(pageNo)) {
            pageNoEx = NumberUtils.toInt(pageNo);
            pageNoEx = pageNoEx > 0 ? pageNoEx : DEFAULT_PAGE_NO;
        } else {
            pageNoEx = DEFAULT_PAGE_NO;
        }
        int pageSizeEx;
        if (NumberUtils.isCreatable(pageSize)) {
            pageSizeEx = NumberUtils.toInt(pageSize);
            pageSizeEx = pageSizeEx > 0 ? pageSizeEx : DEFAULT_PAGE_SIZE;
        } else {
            pageSizeEx = DEFAULT_PAGE_SIZE;
        }
        PageHelper.startPage(pageNoEx, pageSizeEx);
    }

}

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
@Override
    public Page<BusinessDTO> page(String name, PageParam pageParam) {
        Condition condition = new Condition(Business.class);
        // 查询结果集
        if (StringUtils.isNoneBlank(name)) {
            condition.createCriteria().andLike("employeeName", "%" + name + "%");
        }
        condition.orderBy("insertedAt").desc();
        List<Business> businesss = businessMapper.selectBatchByCondition(condition);
        List<BusinessDTO> businessDTOs = Lists.newArrayList();
        // 将bussiness对象转成Dto对象
        if (businesss != null) {
            businessDTOs = businesss.stream().map(e -> {
                BusinessDTO businessDTO = new BusinessDTO();
                BeanUtils.copyProperties(e, businessDTO);
                if (e.getEmployeeId() != null) {
                    try {
                        businessDTO.setEmployeeNumber(
                                employeeService.getEX(e.getEmployeeId()).getEmployeeNumber());
                    }catch(Exception exception) {
                        log.info("employee= "+exception.getMessage());
                    }
                   
                }
                return businessDTO;
            }).filter(x->x.getEmployeeNumber()!=null).collect(Collectors.toList());
        }
        // 封装Page对象
        Page<BusinessDTO> pages = Page.wrap(new ArrayList<>());
        PageUtil.setPagesByHands(pageParam, businessDTOs, pages);
        return pages;
    }

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
@UtilityClass
public class PageUtil {
	
	public static <T> void setPagesByHands(PageParam pageParam, List<T> lists, Page<T> pages) {
        if (!lists.isEmpty()) {
            Double pageNo = 1.00;
            if (NumberUtils.isCreatable(pageParam.getPageNo())) {
                pageNo = Double.valueOf(pageParam.getPageNo());
            }
            Double pageSize = 10.00;
            if (NumberUtils.isCreatable(pageParam.getPageSize())) {
                pageSize = Double.valueOf(pageParam.getPageSize());
            }
            Integer total = lists.size();
            Double totalPages = total / Double.valueOf(pageSize);
            totalPages = Math.ceil(totalPages);
            Integer lastPageSize = total % pageSize.intValue();
            pages.setTotal(Long.valueOf(total));
            pages.setPageNo((int) (double) pageNo);
            List<T> outList = new ArrayList<>();
            // 只有一页
            if (new Double(1).equals(totalPages)) {
                pages.setEntitiesInPage(lists);
                pages.setHasNextPage(false);
                pages.setHasPreviousPage(false);
                pages.setPagesCount(total);
            }
            // 超过一页&&传入页码==1
            if (new Double(1).equals(pageNo)) {
                if (lists.size() <= pageSize) {
                    pages.setEntitiesInPage(lists);
                    pages.setHasNextPage(false);
                    pages.setHasPreviousPage(false);
                    pages.setPagesCount(total);
                } else {
                    for (int i = 0; i < pageSize; i++) {
                        outList.add(lists.get(i));
                    }
                    pages.setEntitiesInPage(outList);
                    pages.setHasNextPage(true);
                    pages.setHasPreviousPage(false);
                    pages.setPagesCount(outList.size());
                }
            } else {
                // 超过一页
                int no = 1;
                for (int i = 1; i < total + 1; i++) {
                    if (no == pageNo) {
                        for (int j = i - 1; j < i + pageSize-1; j++) {
                            if(j==lists.size()) {
                                break;
                            }
                            outList.add(lists.get(j));   
                        }
                        break;
                    }
                    if (i % pageSize == 0) {
                        no++;
                    }
                }
                pages.setEntitiesInPage(outList);
                if (pageNo.equals(totalPages)) {
                    pages.setHasNextPage(false);
                } else {
                    pages.setHasNextPage(true);
                }
                pages.setHasPreviousPage(true);
                pages.setPagesCount(outList.size());
            }
        }
    }

}