批量查询-分批2

场景1：针对一次查询结果太多，数据库查询会超时这种情况
处理1：需要分批次查询，把查询结果汇总在一起
场景2：针对1次查询结果不多，一次查询多个结果，但是多个结果可能会超时
处理2：把多次查询分成多次查询

处理1
工具类：

 import lombok.Data;

    @Data
    class PageParameter{
        private int start;
        private int limit = 20;
    }

    /**
     * 适合查询结果太多分页查询
     * @param function
     * @param query
     * @param batchSize
     * @param remark
     * @param <T>
     * @param <R>
     * @return
     */
    public static  <T extends PageParameter,R > List<R> doBatchWithRetry(Function<T, List<R>> function, T query, Integer batchSize, String remark) {

        List<R> result = new ArrayList<>();
        int start = 0;
        query.setLimit(batchSize);
        try {
            while (true){
                query.setStart(start);
                List<R> result1 = function.apply(query);
                if(CollectionUtils.isEmpty(result1)){
                    break;
                }
                result.addAll(result1);
                start += batchSize;
            }
        }catch (Exception e){
            log.info("{} 批量查询异常",remark,e);
            throw new BaseException("分批查询出现异常");
        }
        return result;
    }

使用例子：

    public List<QtHotelRoom> listALl(String hotelCode){
        MyQry qry = new MyQry();
        qry.setHotelCode(hotelCode);
        qry.setLimit(10);
        return DoBatchWithRetry.doBatchWithRetry(this::getlist,qry,11,"111");
    }
    @Data
    class MyQry extends PageParameter {
        private String hotelCode;
        
    }
    
    public List<QtHotelRoom> getlist(MyQry qry){
        QtHotelRoomCriteria example = new QtHotelRoomCriteria();
        example.createCriteria().andHotelCodeEqualTo(qry.getHotelCode());
        example.setStart(qry.getStart());
        example.setLimit(qry.getLimit());
        return qtHotelRoomMapper.selectByExample(example);
    }

场景2：针对1次查询结果不多，一次查询多个结果，但是多个结果可能会超时
处理2：把多次查询分成多次查询

处理2：
工具类：

/**
     * 使用场景：需要按照索引查询 记录，一次查询 容易超时，把一次查询 分为多次查询，每一次查询一部分，把结果组合起来，要求每一次查询的结果之间没有交集
     * <p>
     * <p>
     * 批量查询，一次查询 次数为 batchSize，直到把所需要的数据查询完
     *
     * @param function
     * @param query
     * @param batchSize
     * @param remark
     * @author: wuss@wjs.com
     * @date: 2021/5/24 20:08 PM
     * @return: java.util.List<R>
     */
    public static <T extends Serializable, R extends Serializable> List<R> doBatchWithRetry(Function<List<T>, List<R>> function, List<T> query, Integer batchSize, String remark) {

        if (batchSize == null) {
        //默认批次大小20
            batchSize = defaultBatchSize;
        }
        int size = query.size();

        List<R> list = new ArrayList<>(size);
        List<R> result = null;
        Exception exception = null;

        for (int batch = 0; batch < size; batch += batchSize) {
        // 默认重试3次
            for (int i = 0; i < defaultTime; i++) {
                try {

                    result = function.apply(query.subList(batch, Math.min(batch + batchSize, size)));
                    exception = null;

                    if (CollectionUtils.isNotEmpty(result)) {
                        list.addAll(result);
                    }
                    break;
                } catch (Exception e) {
                    log.info("执行批量处理 第:{}次调用:{}异常，入参:[{},{}),异常信息", i + 1, remark, batch, Math.min(batch + batchSize, size), e);
                    exception = e;
                }

            }
            if (exception != null) {
                throw new BaseException("执行批量处理异常", exception);
            }
        }
        return list;
    }

调用方式：

    static int j = 0;
    static List<Integer> doQuery(List<Integer> list) {
        System.out.println(list);
        //模拟包含20的时候，调用前2次抛异常，超过2次正常，验证重试3次
        if(list.indexOf(20)>=0){
            j++;
            if (j <= 2) {
                System.out.println(list.get(0)/0);
            }
        }
        return list;
    }

     */
    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 55; i++) {
            list.add(i);
        }

        System.out.println(list.size());

        List<Integer> list1 = doBatchWithRetry(this::doQuery, list, 8, "111");
        System.out.println(list1);
        System.out.println(list1.size());

}

执行结果与分析：

55 //原数组大小55
[0, 1, 2, 3, 4, 5, 6, 7] //不含20调用8个正常
[8, 9, 10, 11, 12, 13, 14, 15]//不含20调用8个正常
[16, 17, 18, 19, 20, 21, 22, 23]// 此处含有20，需要抛异常，并重试2次
16:56:38.937 [main] INFO  com.wjs.tmc.utils.DoBatchWithRetry - 执行批量处理 第:1次调用:111异常，入参:[16,24),异常信息
java.lang.ArithmeticException: / by zero
	at com.wjs.tmc.utils.DoBatchWithRetry.doQuery(DoBatchWithRetry.java:231) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry(DoBatchWithRetry.java:58) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.main(DoBatchWithRetry.java:203) [classes/:na]
[16, 17, 18, 19, 20, 21, 22, 23]//第一次重试，异常
16:56:38.940 [main] INFO  com.wjs.tmc.utils.DoBatchWithRetry - 执行批量处理 第:2次调用:111异常，入参:[16,24),异常信息
java.lang.ArithmeticException: / by zero
	at com.wjs.tmc.utils.DoBatchWithRetry.doQuery(DoBatchWithRetry.java:231) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry(DoBatchWithRetry.java:58) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.main(DoBatchWithRetry.java:203) [classes/:na]
[16, 17, 18, 19, 20, 21, 22, 23]//第二次重试，这时候调用3次，成功
[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]
[0, 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 //总数也是55个

优化改进：
问题：
1.如果分页大小过大，重试3次仍然超时则没法处理，这时候不好定义最优的分页大小
2.如果90%的数据量都较小，极少部分数据量很大，为了考虑情况1的时候，只能减少分片大小，对绝大多数数据量较少的查询不友好，
3.能否优化？

• 传递一个相对较大的分页，如果查询失败自动减少分页大小

优化：

代码：

 /**
     * 如果该批次调用异常，则修改分批次大小
     * 分批查询，如果有一批次发生异常，则修改该批次大小为1/2继续查询，如果该批次大小小于1，则报错
     * @param function
     * @param query
     * @param batchSize
     * @param remark
     * @return: java.util.List<R>
     */
    public static <T extends Serializable, R extends Serializable> List<R> doBatchWithRetry1(Function<List<T>, List<R>> function, List<T> query, Integer batchSize, String remark) {

        if (batchSize == null) {
            batchSize = defaultBatchSize;
        }
        int size = query.size();

        List<R> list = new ArrayList<>(size);
        List<R> result = null;

        for (int batch = 0; batch < size; batch += batchSize) {

            List<T> sub = query.subList(batch, Math.min(batch + batchSize, size));
            try {
                //尝试查询
                result = queryWithRetry(sub,function);
                if(CollectionUtils.isEmpty(result)){
                    continue;
                }
                list.addAll(result);
            }catch (Exception e){
                List<R> rs = null;
                int len1 = batchSize/2;
                if(len1 == 0){
                    log.info("发生异常,入参:{}",query,e);
                    throw new BaseException("执行批量处理异常",e);
                }

                rs = tryWhenException(function, sub, len1);
                if(CollectionUtils.isNotEmpty(rs)){
                    list.addAll(rs);
                }
            }

        }
        return list;
    }

    private static <T extends Serializable, R extends Serializable>  List<R> tryWhenException(Function<List<T>, List<R>> function, List<T> sub, int size) {
        Exception exception = null;
        System.out.println("遇到异常，尝试减少分片大小"+ sub);
        List<R> rs = null;
        while (size >= 1){
           try {
               rs = doBatchWithRetry1(function, sub, size, "分批查询大小:" + size);
               exception = null;
               break;
           }catch (Exception e1){
               exception = e1;
               size = size/2;
           }
        }
        if(exception != null){
            throw new BaseException("执行批量处理异常",exception);
        }
        return rs;
    }


    //重试3次
    public static <T,R> List<R> queryWithRetry(List<T> list,Function<List<T>, List<R>> function){
        Exception exception = null;
        List<R> result = null;
        for (int i = 0; i < defaultTime; i++) {
            try {
                result =  function.apply(list);
                exception = null;
                break;
            } catch (Exception e) {
                exception = e;
                System.out.println(String.format("第{%s}次执行批量处理异常", i+1));
            }
        }
        if(exception != null){
            throw new BaseException("执行批量处理异常", exception);
        }
        return result;
    }

用法：

        List<Integer> list2 = doBatchWithRetry1(this::doQuery1, list, 10, "111");
        System.out.println(list2);
        System.out.println("------");
        System.out.println(list2.size());
        ```
执行结果：
55
查询个数超过8发生超时异常	入参:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第{1}次执行批量处理异常
查询个数超过5发生超时异常	入参:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第{2}次执行批量处理异常
查询个数超过7发生超时异常	入参:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
查询个数超过4发生超时异常	入参:[0, 1, 2, 3, 4]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[0, 1, 2, 3, 4]
第{2}次执行批量处理异常
查询个数超过3发生超时异常	入参:[0, 1, 2, 3, 4]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[0, 1, 2, 3, 4]
[0, 1]	4
[2, 3]	7
[4]	5
查询个数超过3发生超时异常	入参:[5, 6, 7, 8, 9]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[5, 6, 7, 8, 9]
第{2}次执行批量处理异常
查询个数超过3发生超时异常	入参:[5, 6, 7, 8, 9]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[5, 6, 7, 8, 9]
[5, 6]	9
[7, 8]	4
[9]	6
查询个数超过8发生超时异常	入参:[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
第{1}次执行批量处理异常
查询个数超过4发生超时异常	入参:[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
第{2}次执行批量处理异常
查询个数超过4发生超时异常	入参:[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
查询个数超过0发生超时异常	入参:[10, 11, 12, 13, 14]
第{1}次执行批量处理异常
查询个数超过4发生超时异常	入参:[10, 11, 12, 13, 14]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[10, 11, 12, 13, 14]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[10, 11, 12, 13, 14]
查询个数超过1发生超时异常	入参:[10, 11]
第{1}次执行批量处理异常
[10, 11]	7
[12, 13]	9
查询个数超过0发生超时异常	入参:[14]
第{1}次执行批量处理异常
[14]	3
查询个数超过1发生超时异常	入参:[15, 16, 17, 18, 19]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[15, 16, 17, 18, 19]
第{2}次执行批量处理异常
[15, 16, 17, 18, 19]	8
查询个数超过8发生超时异常	入参:[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
第{1}次执行批量处理异常
查询个数超过5发生超时异常	入参:[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
第{2}次执行批量处理异常
查询个数超过1发生超时异常	入参:[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
[20, 21, 22, 23, 24]	5
查询个数超过4发生超时异常	入参:[25, 26, 27, 28, 29]
第{1}次执行批量处理异常
查询个数超过3发生超时异常	入参:[25, 26, 27, 28, 29]
第{2}次执行批量处理异常
查询个数超过3发生超时异常	入参:[25, 26, 27, 28, 29]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[25, 26, 27, 28, 29]
查询个数超过1发生超时异常	入参:[25, 26]
第{1}次执行批量处理异常
查询个数超过1发生超时异常	入参:[25, 26]
第{2}次执行批量处理异常
[25, 26]	2
查询个数超过0发生超时异常	入参:[27, 28]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[27, 28]
第{2}次执行批量处理异常
[27, 28]	9
[29]	8
查询个数超过3发生超时异常	入参:[30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
第{1}次执行批量处理异常
查询个数超过1发生超时异常	入参:[30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
第{2}次执行批量处理异常
查询个数超过6发生超时异常	入参:[30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
[30, 31, 32, 33, 34]	6
查询个数超过0发生超时异常	入参:[35, 36, 37, 38, 39]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[35, 36, 37, 38, 39]
第{2}次执行批量处理异常
查询个数超过3发生超时异常	入参:[35, 36, 37, 38, 39]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[35, 36, 37, 38, 39]
查询个数超过0发生超时异常	入参:[35, 36]
第{1}次执行批量处理异常
[35, 36]	4
查询个数超过0发生超时异常	入参:[37, 38]
第{1}次执行批量处理异常
[37, 38]	7
查询个数超过0发生超时异常	入参:[39]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[39]
第{2}次执行批量处理异常
[39]	8
查询个数超过8发生超时异常	入参:[40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
第{1}次执行批量处理异常
查询个数超过4发生超时异常	入参:[40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
第{2}次执行批量处理异常
查询个数超过7发生超时异常	入参:[40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
[40, 41, 42, 43, 44]	8
查询个数超过3发生超时异常	入参:[45, 46, 47, 48, 49]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[45, 46, 47, 48, 49]
第{2}次执行批量处理异常
[45, 46, 47, 48, 49]	9
[50, 51, 52, 53, 54]	7
[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]
------
55

异常模仿：
55
查询个数超过0发生超时异常	入参:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第{2}次执行批量处理异常
查询个数超过1发生超时异常	入参:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
查询个数超过1发生超时异常	入参:[0, 1, 2, 3, 4]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[0, 1, 2, 3, 4]
第{2}次执行批量处理异常
查询个数超过1发生超时异常	入参:[0, 1, 2, 3, 4]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[0, 1, 2, 3, 4]
查询个数超过0发生超时异常	入参:[0, 1]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[0, 1]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[0, 1]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[0, 1]
[0]	1
查询个数超过0发生超时异常	入参:[1]
第{1}次执行批量处理异常
[1]	1
查询个数超过0发生超时异常	入参:[2, 3]
第{1}次执行批量处理异常
查询个数超过1发生超时异常	入参:[2, 3]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[2, 3]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[2, 3]
[2]	1
[3]	1
[4]	1
查询个数超过0发生超时异常	入参:[5, 6, 7, 8, 9]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[5, 6, 7, 8, 9]
第{2}次执行批量处理异常
查询个数超过1发生超时异常	入参:[5, 6, 7, 8, 9]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[5, 6, 7, 8, 9]
查询个数超过0发生超时异常	入参:[5, 6]
第{1}次执行批量处理异常
查询个数超过1发生超时异常	入参:[5, 6]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[5, 6]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[5, 6]
查询个数超过0发生超时异常	入参:[5]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[5]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[5]
第{3}次执行批量处理异常
19:20:01.425 [main] INFO  com.wjs.tmc.utils.DoBatchWithRetry - 发生异常,入参:[5, 6]
com.wjs.common.exception.BaseException: [执行批量处理异常]com.wjs.common.exception.BaseException:  [查询个数超过0发生超时异常	入参:[5]]
	at com.wjs.tmc.utils.DoBatchWithRetry.queryWithRetry(DoBatchWithRetry.java:162) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:103) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:132) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:132) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:132) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.main(DoBatchWithRetry.java:225) [classes/:na]
查询个数超过0发生超时异常	入参:[5]
第{1}次执行批量处理异常
[5]	1
[6]	1
查询个数超过0发生超时异常	入参:[7]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[7]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[7]
第{3}次执行批量处理异常
19:20:01.430 [main] INFO  com.wjs.tmc.utils.DoBatchWithRetry - 发生异常,入参:[5, 6, 7, 8, 9]
com.wjs.common.exception.BaseException: [执行批量处理异常]com.wjs.common.exception.BaseException:  [查询个数超过0发生超时异常	入参:[7]]
	at com.wjs.tmc.utils.DoBatchWithRetry.queryWithRetry(DoBatchWithRetry.java:162) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:103) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:132) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:132) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.main(DoBatchWithRetry.java:225) [classes/:na]
查询个数超过1发生超时异常	入参:[0, 1]
第{1}次执行批量处理异常
查询个数超过1发生超时异常	入参:[0, 1]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[0, 1]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[0, 1]
[0]	1
查询个数超过0发生超时异常	入参:[1]
第{1}次执行批量处理异常
[1]	1
查询个数超过1发生超时异常	入参:[2, 3]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[2, 3]
第{2}次执行批量处理异常
查询个数超过1发生超时异常	入参:[2, 3]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[2, 3]
[2]	1
[3]	1
查询个数超过1发生超时异常	入参:[4, 5]
第{1}次执行批量处理异常
查询个数超过1发生超时异常	入参:[4, 5]
第{2}次执行批量处理异常
查询个数超过1发生超时异常	入参:[4, 5]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[4, 5]
查询个数超过0发生超时异常	入参:[4]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[4]
第{2}次执行批量处理异常
[4]	1
查询个数超过0发生超时异常	入参:[5]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[5]
第{2}次执行批量处理异常
[5]	1
查询个数超过0发生超时异常	入参:[6, 7]
第{1}次执行批量处理异常
查询个数超过1发生超时异常	入参:[6, 7]
第{2}次执行批量处理异常
查询个数超过1发生超时异常	入参:[6, 7]
第{3}次执行批量处理异常
遇到异常，尝试减少分片大小[6, 7]
查询个数超过0发生超时异常	入参:[6]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[6]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[6]
第{3}次执行批量处理异常
19:20:01.432 [main] INFO  com.wjs.tmc.utils.DoBatchWithRetry - 发生异常,入参:[6, 7]
com.wjs.common.exception.BaseException: [执行批量处理异常]com.wjs.common.exception.BaseException:  [查询个数超过0发生超时异常	入参:[6]]
	at com.wjs.tmc.utils.DoBatchWithRetry.queryWithRetry(DoBatchWithRetry.java:162) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:103) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:132) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:132) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.main(DoBatchWithRetry.java:225) [classes/:na]
查询个数超过0发生超时异常	入参:[0]
第{1}次执行批量处理异常
查询个数超过0发生超时异常	入参:[0]
第{2}次执行批量处理异常
查询个数超过0发生超时异常	入参:[0]
第{3}次执行批量处理异常
19:20:01.433 [main] INFO  com.wjs.tmc.utils.DoBatchWithRetry - 发生异常,入参:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
com.wjs.common.exception.BaseException: [执行批量处理异常]com.wjs.common.exception.BaseException:  [查询个数超过0发生超时异常	入参:[0]]
	at com.wjs.tmc.utils.DoBatchWithRetry.queryWithRetry(DoBatchWithRetry.java:162) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:103) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:132) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116) [classes/:na]
	at com.wjs.tmc.utils.DoBatchWithRetry.main(DoBatchWithRetry.java:225) [classes/:na]
Exception in thread "main" com.wjs.common.exception.BaseException: [执行批量处理异常]com.wjs.common.exception.BaseException: [执行批量处理异常]com.wjs.common.exception.BaseException: [执行批量处理异常]com.wjs.common.exception.BaseException:  [查询个数超过0发生超时异常	入参:[0]]
	at com.wjs.tmc.utils.DoBatchWithRetry.tryWhenException(DoBatchWithRetry.java:141)
	at com.wjs.tmc.utils.DoBatchWithRetry.doBatchWithRetry1(DoBatchWithRetry.java:116)
	at com.wjs.tmc.utils.DoBatchWithRetry.main(DoBatchWithRetry.java:225)