java实现的翻页查询小构件

使用场景：
需要对一个大的表格进行全表扫描。

设计思路：
翻页查询，每页查询数据控制在一定数量内，不会对数据库造成压力。
将翻页部分抽象成公共代码。
具体业务逻辑单独定义。

使用代码：
一、定义查询函数、转化函数、处理函数
二、定义数据持有的容器
三、调用组件翻页查询（PageQueryUtil.pageQuery），支持定义翻页的个数、处理总个数、起始id、翻页睡眠时间

具体sql：

    <select id="queryPage" resultType="com.ItemDO">
        select * from item_table where deleted=0
        <if test="beginId!=null">
            <choose>
                <when test="isFirst==true">
                    and item_id >=#{beginId}
                </when>
                <otherwise>
                    and tem_id >#{beginId}
                </otherwise>
            </choose>
        </if>
        order by item_id limit #{pageSize}
    </select>

使用代码举例：

public PaperStatisticsDto querAllProductStatistics(){
        try {
            logger.info("查询 begin");
            BizDto resultDto = new BizDto ();
            //查询函数
            Function<PageQueryUtil.QueryParam, PageQueryUtil.QueryResult> queryFunction = this::doPaperQueryPage;
            //参数转化函数
            Function<PageQueryUtil.QueryResult, PageQueryUtil.DealParam> transformFunction = this::doPaperTransform;
            //逻辑处理函数
            Function<PageQueryUtil.DealParam, PageQueryUtil.DealResult> dealFunction = this::dealPaperList;
            //数据持有容器
            Map<Integer, Record> dataContainMap = new HashMap<>();
            //翻页查询
            logger.info("3.1查询 page begin");
            //翻页查询
            PageQueryUtil.pageQuery(queryFunction, transformFunction, dealFunction, null, null, QUERY_SIZE, null, dataContainMap, logger, "日志前缀", TIME_SLEEP);
            resultDto.setTitle(new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
            ArrayList<BizDto.Record> recordList = new ArrayList<>(dataContainMap .values());
            //排序
            Collections.sort(recordList);
            resultDto.setRecordList(recordList);
            int idx = 1;
            for (Record record : recordList) {
                record.setIdx(idx++);
            }
            save2Mongo(resultDto, getFileDate());
            return resultDto;
        }catch (Exception e){
            logger.error("querAllProductStatisticsErr", e);
        }
        return null;
    }

   
    /**
     * 查询函数举例
     * @param queryParam
     * @return
     */
    public PageQueryUtil.QueryResult doPaperQueryPage(PageQueryUtil.QueryParam queryParam){
        List<PaperDO> doList = repository.queryPage(queryParam.getFirstPageId()==null? null : (String)queryParam.getFirstPageId(), queryParam.getPageSize(), queryParam.getIsFirst());
        PageQueryUtil.QueryResult queryResult = new PageQueryUtil.QueryResult();
        queryResult.setData(doList);
        queryResult.setHasNext(!CollectionUtils.isEmpty(doList)&&doList.size()==queryParam.getPageSize());
        queryResult.setSize(CollectionUtils.isEmpty(doList)? 0 : doList.size());
        queryResult.setFirstPageId(CollectionUtils.isEmpty(doList) ? null : doList.get(doList.size()-1).getId().toString());
        return queryResult;
    }
    /**
     * 转化函数
     * @param queryResult
     * @return
     */
    private PageQueryUtil.DealParam doPaperTransform(PageQueryUtil.QueryResult queryResult) {
        PageQueryUtil.DealParam dealParam = new PageQueryUtil.DealParam();
        dealParam.setData(queryResult.getData());
        return dealParam;
    }

    /**
     * 处理函数
     * @param dealParam
     * @return
     */
    public PageQueryUtil.DealResult dealPaperList(PageQueryUtil.DealParam dealParam){
        List<BizDO> paperDOList = (List<BizDO>)dealParam.getData();
        Map<Integer,Record> schoolMap = (Map<Integer, Record>)dealParam.getResultContainer();
        for (BizDO bizDO : paperDOList) {
            //业务逻辑实现
        }
        PageQueryUtil.DealResult dealResult = new PageQueryUtil.DealResult();
        dealResult.setDealedSize(paperDOList.size());
        return dealResult;
    }

翻页构件代码：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.slf4j.Logger;

import java.util.concurrent.TimeUnit;
import java.util.function.Function;

public class PageQueryUtil {
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class QueryParam{
        //查询起始的id，第一次可以为空，从第二次开始都要取最后一条的id
        private Object firstPageId;
        //每次查询的个数
        private Integer pageSize;
        //是否是第一次查询，第一次查询会包含firstPageId（大于等于），从第二次开始不会包含（大于）
        private Boolean isFirst;
    }

    @Data
    public static class QueryResult{
        //是否还有数据，如果data长度等于pageSize就还有
        private boolean hasNext;
        //查询到的数据
        private Object data;
        //查询到的数据个数
        private Integer size;
        //查询到数据列表最后一条的id
        private Object firstPageId;
    }

    @Data
    public  static  class DealParam <C>{
        //保存处理结果的容器
        private  C resultContainer;
        //查询道德数据
        private Object data;
    }

    @Data
    public static class DealResult{
        //处理数据的个数(小于等于QueryResult的size，是满足条件的个数)
        private Integer dealedSize;
    }


    /**
     * 翻页查询处理模板
     * @param queryFuntion  查询函数，参数是Object[], 第一个参数是String, 页的开始id(空代表从第一个开始翻页)， 第二个是int，代表每页的个数。 返回值是一个list
     * @param transformFunction 转换函数
     * @param dealFuntion   处理函数，参数是list; 处理结果是Object[](第一个是string,最后一条的主键，第二个是int表示符合条件的条数)
     * @param beginId   从那里开始处理，排序的依据
     * @param pageSize 每页个数
     * @param total 要扫描的总数，如果为空，代表所有数据都要扫描
     * @param okSize 要处理的总数，如果为空，则使用其他条件退出循环 (实际处理的数据大于等于这个数，因为查询一页后，一页中的数据部分满足条件，这个部分的数量没有控制)
     * @param logger 日志
     * @param <T>
     * @param <R>
     */
    public static <T extends QueryParam, R extends QueryResult, M extends DealParam, N extends DealResult, C> void pageQuery(Function<T, R> queryFuntion, Function<R, M> transformFunction, Function<M, N> dealFuntion, Object beginId, Integer pageSize,
                                          Integer total, Integer okSize, C resultContainer, Logger logger, String logPrefix, Long sleepTime) {
        logger.info(logPrefix+"Start！！！");
        Object firstPageId = beginId;
        pageSize = pageSize==null? 1000 : pageSize;
        pageSize = (total!=null&&total<pageSize) ? total : pageSize;
        pageSize = (okSize!=null&&okSize<pageSize) ? okSize : pageSize;
        //计数
        int count=0;
        //已处理
        int dealedSize=0;
        boolean isFirst =true;
        long start = System.currentTimeMillis();
        int retryTimes=0;
        while (true){
            try {
                if(retryTimes>=3){
                    logger.info(logPrefix+"pageQueryRetryTimeGe3");
                    break;
                }
                logger.info(logPrefix + " beginToQuery,beginId:{},pageSize:{}", firstPageId, pageSize);
                //查询数据
                T queryParam = (T) new QueryParam(firstPageId, pageSize, isFirst);
                R queryResult = queryFuntion.apply(queryParam);
                if (queryResult == null || !queryResult.isHasNext()) {
                    logger.info(logPrefix+"resultIsNullOrEmpty");
                    break;
                }
                //将查询结果转化为处理函数的参数
                M dealParam = transformFunction.apply(queryResult);
                dealParam.setResultContainer(resultContainer);
                int currSize = queryResult.getSize();
                count += currSize;
                //处理数据
                N dealResult = (N) dealFuntion.apply(dealParam);
                firstPageId = queryResult.getFirstPageId();
                dealedSize += dealResult.getDealedSize();
                if (total != null && total <= count) {
                    break;
                }
                if (okSize != null && okSize <= dealedSize) {
                    break;
                }
                isFirst = false;
                try {
                    TimeUnit.MILLISECONDS.sleep(sleepTime);
                } catch (InterruptedException e) {
                    logger.error(logPrefix+"interrupt!", e);
                }
                retryTimes=0;
            }catch (Exception e){
                logger.error(logPrefix+"pageQueryExp!", e);
                try {
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e1) {
                    logger.error(logPrefix+"interrupt!", e1);
                }
                retryTimes++;
            }
        }
        logger.info(logPrefix+"End,spend:{}", System.currentTimeMillis()-start);
    }
}