2019-08-06问题纪要： 通过id来进行分页查询

今天遇到一个问题，就是定时去查询一张表数据然后进行逻辑处理更新同张表的字段，但是全量查肯定太大，

所以一开始想到limit50去查，用while循环，但是又想到如果这50条一直没处理更新，就会一直while循环这50条，进入死循环，

然后想着用分页去查，先查总数进行分页，但是又考虑到，如果第一页查到50条处理了，第二页从51-100就查不到数据，也不行。

可行方案：

第三种方案是先循环查询存放在redis中，等全部数据查出来后，在从redis里拿数据。但是有风险，因为redis网络原因可能会超时或者连接不上，导致数据没存到redis中或者没取出来。

第四种方案就是

先查询符合条件的最大id和最小id，

 select  max(id) as maxId, min(id) as minId
        from <include refid="table"/>
        where is_deleted = 0 and invoice_status = '1'
        and auth_status <> 4 and auth_status <> 5  and invoice_source = '2'
        <if test="invoiceType != null">
            and invoice_type = #{invoiceType}
        </if>

然后while循环，从最小值开始查询

 select <include refid="Base_Column_List"/>
        from <include refid="table"/>
        where is_deleted = 0 and invoice_status = '1'
        and auth_status <> 4 and auth_status <> 5  and invoice_source = '2'
        <if test="invoiceType != null">
            and invoice_type = #{invoiceType}
        </if>
        <if test="id != null">
            and id >= #{id}
        </if>
        order by id asc
        <if test="size != null">
            limit #{size}
        </if>

代码：

 //先查出符合条件的最大id和最小id，用id去分页
            Map<String, Long> map = invoiceDetailDao.selectUnauthorizedMaxMin(invoiceType);
            Long maxId = map.get("maxId");
            Long minId = map.get("minId");
            boolean flag = true;
            while (flag) {
                List<InvoiceDetailDO> list = invoiceDetailDao.selectUnauthorized(invoiceType, minId, size);
                if (CollectionUtils.isNotEmpty(list)) {
                    log.info("查出来数量：" + list.size());
                    //size可以指定一次查询出多少条，fixedGrouping可以拆list，拆成50条一个list,我这里需要拆成50一个list
                    List<List<InvoiceDetailDO>> listGroup = ListUtil.fixedGrouping(list, 50);
                    for (List<InvoiceDetailDO> detailDOS : listGroup) {
                        //逻辑处理
                    }
                    //计算出本次查询出来最大的id
                    minId = list.get(list.size()-1).getId();
                    //当查询出的id等于最大id时跳出循环
                    flag = maxId > minId;
                } else {
                    //没有数据就跳出循环
                    flag = false;
                }
            }

拆list代码

public class ListUtil {

    /**
     * 将一组数据固定分组，每组n个元素
     *
     * @param source 要分组的数据源
     * @param n      每组n个元素
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> fixedGrouping(List<T> source, int n) {

        if (null == source || source.size() == 0 || n <= 0) {
            return null;
        }
        List<List<T>> result = new ArrayList<List<T>>();
        int remainder = source.size() % n;
        int size = (source.size() / n);
        for (int i = 0; i < size; i++) {
            List<T> subset = null;
            subset = source.subList(i * n, (i + 1) * n);
            result.add(subset);
        }
        if (remainder > 0) {
            List<T> subset = null;
            subset = source.subList(size * n, size * n + remainder);
            result.add(subset);
        }
        return result;
    }


    public static void main(String[] args) {
        List a = Arrays.asList("1", "10", "12", "14", "18", "19", "23");
        List b = fixedGrouping(a,2);
        System.out.println(JSON.toJSONString(b));
    }

总结：当数据库数据量很大的时候，往往需要分页查询，但是在需要查询所有数据的时候，需要循环分页，但是跟页面分页又有所不同，因为我这里是查出来一部分就要处理好，下个循环去查更新好的数据就会没有，也就是总数会变，所以采用id来分页查询