Springboot 手动分页查询，分批批量插入数据

小鱼儿 2023-09-28 13:34 7阅读 0赞

# 前言 #

# **业务场景是什么？**  #

就是数据库的一批数据，量不少，需要执行同步插入到别的地方。

简单点肯定是一次性查出来，然后循环一个个插入，完事。

考虑点：

① 数据量大，一次性查出来操作，很爆炸。

② 循环里面一次一次地去插入，如果非业务场景必要，基本是不会在循环里面使用sql操作的。

所以该篇作为抛砖引玉（还有很多需要考虑的点），给出一种解决上面场景的代码编写方案， 手动分页，查询后批量插入。

# 正文 #

实现的流程简图：  
  
![17b8cb0271654ba1b953a9dc95eb699b.png][]

看看最终实现的效果，通过代码日志记录了这个实现后的效果 :  
  
![b534a8820b444756a412ec40d4d78f07.png][]

开始实战：

代码大体就这样：

![306482ab04024e4a922582785870c815.png][]

代码：

//获取数据总计数
            UserQueryCondition userQueryCondition=new UserQueryCondition();
            Integer totalCount = userService.getAllUserCount(userQueryCondition);
            //每批同步的数据条数
            Integer batchSizeLimit = 500;
            //分批切割处理
            List<PageLimitDTO> pageLimitGroupList = getPageLimitGroupList(totalCount, batchSizeLimit);
            int count=1;
            //物理批次查询
            for (PageLimitDTO pageBatchLimit:pageLimitGroupList){
                List<User> pageBatchList = userService.getPageList(
                        userQueryCondition, pageBatchLimit.getCurrIndex(), pageBatchLimit.getPageSize()
                );
                if (!CollectionUtils.isEmpty(pageBatchList)){
                    //批量插入
                    Boolean syncAddResult = userSyncService.batchSyncAdd(pageBatchList);
                    //做其余业务
                    if (syncAddResult){
                        log.info("第{}次,user数据批量插入成功",count);
                    }
                }
                log.info("第{}批次,user数据同步批量插入业务结束执行",count);
                count=count+1;
            }

切割函数getPageLimitGroupList：

public List<PageLimitDTO> getPageLimitGroupList(Integer totalCount, Integer batchSizeLimit ) {
            log.info("这一次处理的总数据条数为 ={} 条, 每一批次处理条数为 ={} 条,现在开始做分批切割处理。",totalCount,batchSizeLimit);
            int pageNum = totalCount / batchSizeLimit;
            int surplus = totalCount % batchSizeLimit;
            if (surplus > 0) {
                pageNum = pageNum + 1;
            }
            List<PageLimitDTO> pageLimitGroupList =new LinkedList<>();
            for(int i = 0; i < pageNum; i++){
                Integer currIndex = i * batchSizeLimit;
                PageLimitDTO pageLimitDTO=new PageLimitDTO();
                pageLimitDTO.setPageSize(batchSizeLimit);
                pageLimitDTO.setCurrIndex(currIndex);
                pageLimitDTO.setDealDataCount(currIndex+batchSizeLimit);
                pageLimitGroupList.add(pageLimitDTO);
                log.info("分批切割,第={}次,每次={}条,最终会处理到={}条。",pageLimitGroupList.size(),batchSizeLimit,currIndex+batchSizeLimit);
    
            }
            log.info("这一次处理的总数据条数为 ={} 条, 每一批次处理条数为 ={} 条,总共切割分成了 ={} 次,一切准备就绪,可以开始批量插入。",totalCount,batchSizeLimit,pageLimitGroupList.size());
            return pageLimitGroupList;
        }

/**
     * @Author: JCccc
     * @Date: 2022-6-15 16:53
     * @Description:
     */
    @Data
    public class PageLimitDTO {
    
        private Integer pageSize;
        private Integer currIndex;
    
    }

物理分页查询的mybatis sql写法示例（核心手动切割分页查询红色部分）：

![14465b7a03574d748f9c99f5d3eab3f7.png][]

代码：

<select id="getPageList" resultMap="BaseResultMap">
            SELECT *
            FROM user
            <where>
                <if test="merchantId != null and merchantId != 0">
                    and MERCHANT_ID = #{merchantId}
                </if>
                <if test="nameList != null and !nameList.isEmpty()">
                    and NAME in
                    <foreach collection="nameList" separator="," open="(" close=")" item="name">
                        #{name}
                    </foreach>
                </if>
            </where>
            LIMIT #{currIndex} , #{pageSize}
    
        </select>

批量插入示例：

<insert id="batchSyncAdd" parameterType="java.util.List">
            insert into user(
            id,
            name,
            age
            )
            values
            <foreach collection="list" item="item" index="index" separator=",">
                (
                #{item.id,jdbcType=BIGINT},
                #{item.name,jdbcType=VARCHAR},
                #{item.age,jdbcType=INTEGER}
                )
            </foreach>
        </insert>

然后就是我们美如画的，手动批次切割查询插入：

![64c83d5db2134a06a9874ef9639c96a9.png][]

**当前方案作为抛砖引玉，还有比较多可优化的点，但是我不做扩展了，简单列举一下：**

1. 每次切割分页查询，其实可以优化。 例如取上一次的id作为下一次的起始条件。  
2. 同步异步的封装，可以更动态化。  
3. 是否完全需要分批？ 动态设置数据超过多少才开始分批切割，不超过，不需要走切割这些流程代码。

等等

好吧，该篇就到这吧（如果对你有帮助，给我点赞收藏一下。）。

[17b8cb0271654ba1b953a9dc95eb699b.png]: https://img-blog.csdnimg.cn/17b8cb0271654ba1b953a9dc95eb699b.png
[b534a8820b444756a412ec40d4d78f07.png]: https://img-blog.csdnimg.cn/b534a8820b444756a412ec40d4d78f07.png
[306482ab04024e4a922582785870c815.png]: https://img-blog.csdnimg.cn/306482ab04024e4a922582785870c815.png
[14465b7a03574d748f9c99f5d3eab3f7.png]: https://img-blog.csdnimg.cn/14465b7a03574d748f9c99f5d3eab3f7.png
[64c83d5db2134a06a9874ef9639c96a9.png]: https://img-blog.csdnimg.cn/64c83d5db2134a06a9874ef9639c96a9.png