背景

在实际开发中，分页查询接口通常会设置单次查询的最大数目，有时下游接口的最大数目限制不能满足我们的业务场景需求，只能通过多次调用进行数据的查询获取（PS：此类方法的适用场景是总数据量不大的离线任务，不建议在即时查询接口中使用该方法），这种实现逻辑大致相同，将待查询的数据进行切分，分批进行查询，然后组合成最后的查询结果，因此可以尝试抽象出工具类。

现状

假设现在有如下的场景，下游有一个服务可以将List<String>转化成List<Integer>返回，但是每次最大转化数量限制为2；

  public List<Integer> toIntegers(List<String> list) {        if (list == null || list.size() > 2) {            throw new IllegalArgumentException();        }        return list.stream().map(Integer::valueOf).collect(Collectors.toList());    }

当有一个数组大小为5的集合，就需要手动进行分页，分批次调用接口；

  @Test    public void testOriginal() {        List<String> stringList = Arrays.asList("1", "2", "3", "4", "5");        List<Integer> result = convertListOriginal(stringList);        log.info("result = {}", result);    }     public List<Integer> convertListOriginal(List<String> stringList) {        List<Integer> result = new ArrayList<>();        int pageSize = 2;        int fromIndex = 0;        while (fromIndex < stringList.size()) {            int toIndex = Math.min(fromIndex + pageSize, stringList.size());            List<String> subList = stringList.subList(fromIndex, toIndex);            List<Integer> subResult = toIntegers(subList);            if (CollectionUtils.isNotEmpty(subResult)) {                result.addAll(subResult);            }            fromIndex = toIndex;        }        return result;    }

在其他情况下，遇到这种场景，仍需要将相应的代码逻辑拷贝一份，进行修改，这样就会显得代码过于冗余，因此，尝试进行抽象；

抽象

把对subList进行处理的方法抽象出来，作为一个Function传入

public class PageQueryUtil {    private static final int default_page_size = 50;    public static <T, R> List<R> handleListByPage(@NotNull List<T> list,                                                  @NotNull Function<List<T>, List<R>> function) {        return handleListByPage(list, function, default_page_size);    }    @Nullable    public static <T, R> List<R> handleListByPage(@NotNull List<T> list,                                                  @NotNull Function<List<T>, List<R>> function,                                                  @Nullable Integer pageSize) {        if (CollectionUtils.isEmpty(list)) {            return null;        }        pageSize = pageSize == null ? default_page_size : pageSize;        List<R> result = new ArrayList<>();        int fromIndex = 0;        while (fromIndex < list.size()) {            int toIndex = Math.min(fromIndex + pageSize, list.size());            List<T> subList = list.subList(fromIndex, toIndex);            List<R> subResult = function.apply(subList);            if (CollectionUtils.isNotEmpty(subResult)) {                result.addAll(subResult);            }            fromIndex = toIndex;        }        return result;    }}}

同时改造原方法

 @Test    public void testOriginal() {        List<String> stringList = Arrays.asList("1", "2", "3", "4", "5");        Function<List<String>, List<Integer>> function = this::toIntegers;        List<Integer> newResult =                PageQueryUtil.handleListByPage(stringList, function, 2);        log.info("new result = {}", newResult);    }

经过这样简单的抽象，就可以在后续类似场景下直接传入待处理的列表，以及单次查询的限制大小，还有对列表数据的处理函数，得到最后的处理结果；

总结

抽象出一个分页查询聚合的PageQueryUtil，可以通过该工具类简化对下游查询接口多次调用结果的聚合；

适用场景：

离线任务中或是时延不敏感的接口；下游接口对单次查询数据量有限制，不能满足业务场景需求，且不愿意调整上限；