java简单分页实现

作者: __f0e6 | 来源:发表于2021-01-01 14:43 被阅读0次

BaseQuery.java

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;

import java.io.Serializable;

/**
 * @author yangqiaoxin
 * @date 2021/01/02
 */
@JsonIgnoreProperties(value = {"handler","hibernateLazyInitializer","fieldHandler"})
@JsonInclude(JsonInclude.Include.NON_NULL)
public abstract class BaseQuery implements Serializable {
}

PageInfo.java

/**
 * 分页信息
 * @author yangqiaoxin
 * @date 2021/01/01
 */
public class PageInfo<T> extends BaseQuery {

    /**
     * 当前页
     */
    private long pageNum;

    /**
     * 每页的数量
     */
    private long pageSize;

    /**
     * 当前页的数量
     */
    private long size;

    /**
     * 总记录数
     */
    private long total;

    /**
     * 总页数
     */
    private long pages;

    /**
     * 结果集
     */
    private List<T> list;

    /**
     * 第一页的页码
     */
    private long firstPage;

    /**
     * 最后一页的页码
     */
    private long lastPage;

    /**
     * 上一页的页码
     */
    private long prevPage;

    /**
     * 下一页的页码
     */
    private long nextPage;

    /**
     * 是否为第一页
     */
    private boolean hasFirstPage = false;

    /**
     * 是否为最后一页
     */
    private boolean hasLastPage = false;

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

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

    /**
     * 导航页码数
     */
    private long navigatePages;

    /**
     * 所有导航页号
     */
    private long[] navigatePageNums;

    /**
     * 导航页号第一页的页码
     */
    private long navigateFirstPage;

    /**
     * 导航页号最后一页的页码
     */
    private long navigateLastPage;

    // 此处省略构造函数、Getter、Setter、toString等方法

}

PageQuery.java

/**
 * 分页查询对象
 * @author yangqiaoxin
 * @date 2021/01/01
 */
public class PageQuery extends BaseQuery {

    /**
     * 偏移量
     */
    private long offset;

    /**
     * 查询的记录数
     */
    private long size;

    // 此处省略构造函数、Getter、Setter、toString等方法

}

PageUtil.java

/**
 * 简单的分页工具类
 * @author yangqiaoxin
 * @date 2021/01/01
 */
public class PageUtil {

    /**
     * 默认当前页
     */
    private static final long DEFAULT_PAGE_NUMBER = 1L;

    /**
     * 默认每页的数量
     */
    private static final long DEFAULT_PAGE_SIZE = 50L;

    /**
     * 默认导航页号数量
     */
    private static final long DEFAULT_NAVIGATE_PAGES = 10L;

    /**
     * 获取分页信息<br/>
     * 当前页小于1时，当前页为1<br/>
     * 当前页大于总页数时，当前页为总页数
     *
     * @param pageNum 当前页
     * @param pageSize 每页的数量
     * @param count 总记录数
     * @param list 结果集
     * @param navigatePages 导航页码数
     * @return {@link PageInfo} 分页信息
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    public static <T> PageInfo<T> getPageInfo(long pageNum, long pageSize, long count, List<T> list, long navigatePages) {
        PageInfo<T> pageInfo = new PageInfo<>();

        // 结果集（如果为null则填充一个空的List集合）
        List<T> validList = getList(list);
        pageInfo.setList(validList);

        // 每页的数量（小于1则等于1）
        long validPageSize = getPageSize(pageSize);
        pageInfo.setPageSize(validPageSize);

        // 当前页的数量（结果集的大小）
        int size = validList.size();
        pageInfo.setSize(size);

        // 总记录数（执行count(*)语句返回的结果）
        long total = count;
        pageInfo.setTotal(total);

        // 总页数（总记录数 / 每页的数量，如果 总记录数 % 每页的数量 != 0，总页数+1 ）
        long pages = getPages(total, validPageSize);
        pageInfo.setPages(pages);

        // 当前页（小于1则等于1，大于总页数则等于总页数）
        long validPageNum = getPageNum(pageNum, pages);
        pageInfo.setPageNum(validPageNum);

        // 第一页的页码（第一页的常量）
        long firstPage = DEFAULT_PAGE_NUMBER;
        pageInfo.setFirstPage(firstPage);

        // 最后一页的页码（总页数）
        long lastPage = pages;
        pageInfo.setLastPage(lastPage);

        // 上一页的页码（当前页-1）
        long prevPage = validPageNum - DEFAULT_PAGE_NUMBER;
        pageInfo.setPrevPage(prevPage);

        // 下一页的页码（当前页+1）
        long nextPage = getNextPage(validPageNum, lastPage);
        pageInfo.setNextPage(nextPage);

        // 是否为第一页（当前页 == 第一页的页码）
        boolean hasFirstPage = validPageNum == firstPage;
        pageInfo.setHasFirstPage(hasFirstPage);

        // 是否为最后一页（当前页 == 最后一页的页码）
        boolean hasLastPage = validPageNum == lastPage;
        pageInfo.setHasLastPage(hasLastPage);

        // 是否有上一页（！是否为第一页）
        boolean hasPreviousPage = !hasFirstPage;
        pageInfo.setHasPreviousPage(hasPreviousPage);

        // 是否有下一页（！是否为最后一页）
        boolean hasNextPage = !hasLastPage;
        pageInfo.setHasNextPage(hasNextPage);

        // 导航页码数
        long validNavigatePages = navigatePages;
        pageInfo.setNavigatePages(validNavigatePages);

        // 所有导航页号
        long[] navigatePageNums = getNavigatePageNums(validNavigatePages, pages, validPageNum, lastPage);
        pageInfo.setNavigatePageNums(navigatePageNums);

        // 导航页号第一页的页码（所有导航页号中的第一个）
        long navigateFirstPage = navigatePageNums[0];
        pageInfo.setNavigateFirstPage(navigateFirstPage);

        // 导航页号最后一页的页码（所有导航页号中的最后一个）
        long navigateLastPage = navigatePageNums[navigatePageNums.length - 1];
        pageInfo.setNavigateLastPage(navigateLastPage);

        return pageInfo;
    }

    /**
     * 获取分页信息（使用默认的每页数量与导航页码数）<br/>
     * 当前页小于1时，当前页为1<br/>
     * 当前页大于总页数时，当前页为总页数
     *
     * @param pageNum 当前页
     * @param count 总记录数
     * @param list 结果集
     * @return {@link PageInfo} 分页信息
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    public static <T> PageInfo<T> getPageInfo(long pageNum, long count, List<T> list) {
        return getPageInfo(pageNum, DEFAULT_PAGE_SIZE, count, list, DEFAULT_NAVIGATE_PAGES);
    }

    /**
     * 获取空集合的分页信息（使用默认的每页数量与导航页码数）<br/>
     * 且总记录数为0，结果集为null
     *
     * @param pageNum 当前页
     * @return {@link PageInfo} 分页信息
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    public static <T> PageInfo<T> getPageInfoForEmptyList(long pageNum) {
        return getPageInfo(pageNum, DEFAULT_PAGE_SIZE, 0, null, DEFAULT_NAVIGATE_PAGES);
    }

    /**
     * 获取分页查询对象（使用默认的每页数量）<br/>
     * 当前页小于1时，当前页为1
     *
     * @param pageNum 当前页
     * @return {@link PageQuery}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    public static PageQuery getPageQueryByDefaultPageSize(long pageNum) {
        return getPageQuery(pageNum, DEFAULT_PAGE_SIZE);
    }

    /**
     * 获取分页查询对象（使用默认的每页数量）<br/>
     * 当前页小于1时，当前页为1<br/>
     * 当前页大于总页数时，当前页为总页数
     *
     * @param pageNum 当前页
     * @param count 总记录数
     * @return {@link PageQuery}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    public static PageQuery getPageQueryByDefaultPageSize(long pageNum, long count) {
        return getPageQuery(pageNum, DEFAULT_PAGE_SIZE, count);
    }

    /**
     * 获取分页查询对象<br/>
     * 当前页小于1时，当前页为1
     *
     * @param pageNum 当前页
     * @param pageSize 每页的数量
     * @return {@link PageQuery}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    public static PageQuery getPageQuery(long pageNum, long pageSize) {
        PageQuery query = new PageQuery();
        query.setOffset(getOffset(pageNum, pageSize));
        query.setSize(pageSize);
        return query;
    }

    /**
     * 获取分页查询对象<br/>
     * 当前页小于1时，当前页为1<br/>
     * 当前页大于总页数时，当前页为总页数
     *
     * @param pageNum 当前页
     * @param pageSize 每页的数量
     * @param count 总记录数
     * @return {@link PageQuery}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    public static PageQuery getPageQuery(long pageNum, long pageSize, long count) {
        PageQuery query = new PageQuery();
        query.setOffset(getOffset(pageNum, pageSize, count));
        query.setSize(pageSize);
        return query;
    }

    /**
     * 获取偏移量
     *
     * @param pageNum 当前页
     * @param pageSize 每页的数量
     * @return {@link long}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static long getOffset(long pageNum, long pageSize) {
        return (getPageNum(pageNum) - 1) * pageSize;
    }

    /**
     * 获取偏移量
     *
     * @param pageNum 当前页
     * @param pageSize 每页的数量
     * @param count 总记录数
     * @return {@link long}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static long getOffset(long pageNum, long pageSize, long count) {
        pageNum = getPageNum(pageNum);
        // 总页数
        long pages = getPages(count, pageSize);

        // 如果请求的页码大于总页数的话
        boolean isInvalid = pageNum > pages;
        if (isInvalid) {
            pageNum = pages;
        }
        return (pageNum - 1) * pageSize;
    }

    /**
     * 获取当前页
     *
     * @param pageNum 当前页
     * @return {@link long}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static long getPageNum(long pageNum) {
        boolean isInvalid = pageNum < DEFAULT_PAGE_NUMBER;
        if (isInvalid) {
            pageNum = DEFAULT_PAGE_NUMBER;
        }
        return pageNum;
    }

    /**
     * 获取结果集
     *
     * @param list 结果集
     * @return {@link java.util.List<T>}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static <T> List<T> getList(List<T> list) {
        // 结果集（如果为null则填充一个空的List集合）
        return Optional.ofNullable(list).orElse(new ArrayList<>(0));
    }

    /**
     * 获取每页的数量
     *
     * @param pageSize 每页的数量
     * @return {@link long}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static long getPageSize(long pageSize) {
        // 每页的数量（小于1则等于1）
        long validPageSize = pageSize;
        if (validPageSize < DEFAULT_PAGE_NUMBER) {
            validPageSize = DEFAULT_PAGE_NUMBER;
        }
        return validPageSize;
    }

    /**
     * 获取总页数
     *
     * @param total 总记录数
     * @param validPageSize 有效的每页数量
     * @return {@link long}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static long getPages(long total, long validPageSize) {
        // 总页数（总记录数 / 每页的数量，如果 总记录数 % 每页的数量 != 0，总页数+1 ）
        long pages = total / validPageSize;
        if (total % validPageSize != 0) {
            pages++;
        }
        if (pages < DEFAULT_PAGE_NUMBER) {
            pages = DEFAULT_PAGE_NUMBER;
        }
        return pages;
    }

    /**
     * 获取当前页
     *
     * @param pageNum 当前页
     * @param pages 总页数
     * @return {@link long}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static long getPageNum(long pageNum, long pages) {
        // 当前页（小于1则等于1，大于总页数则等于总页数）
        long validPageNum = pageNum;
        if (validPageNum < DEFAULT_PAGE_NUMBER) {
            validPageNum = DEFAULT_PAGE_NUMBER;
        } else if (validPageNum > pages) {
            validPageNum = pages;
        }
        return validPageNum;
    }

    /**
     * 获取下一页
     *
     * @param validPageNum 有效的当前页
     * @param lastPage 最后一页
     * @return {@link long}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static long getNextPage(long validPageNum, long lastPage) {
        // 下一页的页码（当前页+1）
        long nextPage = validPageNum + DEFAULT_PAGE_NUMBER;
        if (nextPage > lastPage) {
            nextPage = DEFAULT_PAGE_NUMBER - 1;
        }
        return nextPage;
    }

    /**
     * 获取导航页号
     *
     * @param validNavigatePages 有效的导航页码数
     * @param pages 总页数
     * @param validPageNum 有效的当前页
     * @param lastPage 最后一页
     * @return {@link long[]}
     * @author yangqiaoxin
     * @date 2021/01/01
     */
    private static long[] getNavigatePageNums(long validNavigatePages,
                                              long pages,
                                              long validPageNum,
                                              long lastPage) {
        // 所有导航页号
        long start;
        long mid = validNavigatePages >> 1; // 中间索引 = 导航页码数 / 2
        long end;
        if (pages <= validNavigatePages) { // 总页数 <= 导航页码数
            start = DEFAULT_PAGE_NUMBER; // 起始 = 1
            end = pages; // 结束 = 总页数
        } else if (validPageNum <= mid + 1) { // 当前页 <= 最左范围的中间页码（即：中间索引 + 1）
            start = DEFAULT_PAGE_NUMBER; // 起始 = 1
            end = validNavigatePages; // 结束 = 导航页码数
        } else if (validPageNum >= lastPage - mid + 1) { // 当前页 >= 最右范围的中间页码（即：最后一页的页码 - 中间索引 + 1）
            end = lastPage; // 结束 = 最后一页的页码
            start = end - validNavigatePages + 1; // 起始 = 结束 - 导航页码数 + 1
        } else { // 否则
            start = validPageNum - mid; // 起始 = 当前页 - 中间索引
            end = start + validNavigatePages - 1; // 结束 = 起始 + 导航页码数 - 1
        }
        int capacity = (int) (end - start + 1);
        long[] navigatePageNums;
        if (capacity > 0) {
            navigatePageNums = new long[capacity];
            int i = 0;
            for (long val = start; val <= end; val++) {
                navigatePageNums[i++] = val;
            }
        } else {
            navigatePageNums = new long[(int) DEFAULT_PAGE_NUMBER];
            navigatePageNums[0] = DEFAULT_PAGE_NUMBER;
        }
        return navigatePageNums;
    }

}

java简单分页实现

BaseQuery.java

PageInfo.java

PageQuery.java

PageUtil.java

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

程序员