一、大背景
前段时间接到资料库CPU监视系统，追踪后辨认出是有爸爸妈妈在循环式操作形式资料库，每一统计数据都要查阅+预览，看著血糖有点儿高~
伪标识符:
java拷贝标识符Map<String, GetTaskListResponse> taskList = ;// USB查阅一个条目taskList.forEach((taskId, task) -> { Task originalTask = taskMapper .selectOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, taskId)); … // 存有推论+排序taskMapper.updateById(originalTask); });预测cpu攀升操作过程：假如循环式操作形式10亿次 【查阅+预览】，会有大批允诺资料库的操作形式。其二，允诺总天数会很久，在初始化笔记里头看见一场允诺小于60s(那个慢允诺是计时器收到的，因此一已经开始没倚重)，促发一场延时重传，会再度发动允诺，最后会引致资料库频密允诺，cpu增高。
与资料库的可视化
应用领域相连到资料库后，与资料库间的可视化基本上天数开支有：连接、互联网、io，假如操作形式的统计信息量非常大，还会有资料库的排序开支。下面事例中的统计状态参数统计数据太少，而相连是有韦格尔的，因此开支主要是互联网和io，增加可视化的单次，是最简单的强化形式。
考量共管：改成份批号预览，比如说操作形式10亿个统计数据，一场查1000个统计数据出，排序好，一场递交1000个预览sql，循环式100次方可。假如统计数据是没倚赖亲密关系的，标识符里头能用多处理器，促发器查阅、排序及预览。总之，促发器推送允诺太多博蒙阿，小心资料库会这么一来，那个要检视。
sql 大批量操作形式方法
常见的资料库，比如说mysql，能使用的大批量技术有2种，ORM框架用的机制也是基于这2个：
多个sql一场递交；多个sql合成单个sql。(1)多个sql一场递交
用”;”分割的多个sql：将多次递交变成一场递交。比如说下面的sql,统计状态参数为user：
sql拷贝标识符CREATE TABLE `user` ( `id` int(11) NOT NULL, `name` varchar(255) DEFAULT “”, `age` int(11) DEFAULT 0, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;大批量sql:
sql拷贝标识符— 插入 INSERT INTO user(name, id) VALUES(hello,1); INSERT INTO user(name, id) VALUES(world,2); — 预览 update user set name=hello1 where id=1; update user set name=world1 where id=2;(2)合成sql
多个sql合成一个递交：
sql拷贝标识符— 插入: 这里用自增id做主键 INSERT INTO user(name, age) VALUES (hello,10), (world,20); — 预览: 利用 case-when-then 合成 update user set name= case when id=1 then hello1 when id=2 then world1 end where id in (1,2); — 这里也能用or，但是可能会索引失效。二、常见ORM的大批量操作形式
1.JPA
大批量预览、大批量插入都是saveAll，demo：
java拷贝标识符List<User> userList = userRepository.saveAll(userList);源码：
java拷贝标识符// org.springframework.data.jpa.repository.support.SimpleJpaRepository@Transactionalpublic <S extends T> List<S> saveAll(Iterable<S> entities) { Assert.notNull(entities, “Entities must not be null!”); List<S> result = new ArrayList(); Iterator var3 = entities.iterator(); while(var3.hasNext()) { S entity = var3.next(); result.add(this.save(entity)); } returnresult; }这里能看见那个saveAll是”假”的，实现形式是循环式初始化save()，大批统计数据递交的话，会有性能问题。
2.mybatis-plus 大批量预览
（1）手动大批量flush
java拷贝标识符List<Task> taskList = try(SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH)) { TaskMapper taskMapper = sqlSession.getMapper(TaskMapper.class); for(Task task : taskList) { taskMapper.updateById(task); } sqlSession.flushStatements();// 递交一批sqlsqlSession.commit(); }处理形式是多个sql一场递交。
（2）updateBatchById
来自
mybatis-plus-extension-3.2.0.jar，下是初始化demo: java拷贝标识符public interface UserService extends IService<User> { void updateBatchUserById(List<User> list); } @Service public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { @Override public void updateBatchUserById(List<User> list) { this.updateBatchById(list); } }ServiceImpl 里的 this.updateBatchById源码如下：
java拷贝标识符@Transactional( rollbackFor = {Exception.class} ) publicboolean updateBatchById(Collection<T> entityList, int batchSize) { … String sqlStatement =this.sqlStatement(SqlMethod.UPDATE_BY_ID); // UPDATE_BY_ID(“updateById”, “根据ID 选择修改统计数据”, “<script>\nUPDATE %s %s WHERE %s=#{%s} %s\n</script>”), SqlSession batchSqlSession = this.sqlSessionBatch(); try{ int i =0; // 分批 for(Iterator var7 = entityList.iterator(); var7.hasNext(); ++i) { T anEntityList = var7.next(); ParamMap<T> param = new ParamMap(); param.put(“et”, anEntityList); // 这里有坑 anEntityList不能为null batchSqlSession.update(sqlStatement, param); if (i >= 1&& i % batchSize ==0) { batchSqlSession.flushStatements(); //递交sql} } batchSqlSession.flushStatements();//递交最后一批sql return true; } catch (Throwable var17) { // 异常转换 } finally { // 关闭会话 } }思路其实和下面(1)的大批量flush是一样的。也能自定义sql:
xml拷贝标识符<update id=“batchUpdate” parameterType=“java.util.List”> <foreach collection=“list” item=“item” separator=“;”> update user set name = #{item.name} where id = #{item.id} </foreach> </update>（3）更进一步：合成一个sql
递交的一批sql还能合并吗？使用case-when-then
xml拷贝标识符<update id=“updateBatch” parameterType=“java.util.List” > update user <trim prefix=“set” suffixOverrides=“,”> <trim prefix=“name=case” suffix=“end,”> <foreach collection=“list” item=“i” index=“index”> <if test=“i.name != null and i.name != “> when id=#{i.id} then #{i.name} </if> </foreach> </trim> </trim> where <foreach collection=“list” separator=“or” item=“i” index=“index” > id = #{i.id} </foreach> </update>假如直接递交10亿个预览的sql,也是能的。有可能出的问题：
(1)jvm 字符串太大，OOM。(2)资料库限制条数或者递交sql的统计数据大小。参考：Mybatis中进行大批量预览（updateBatch）
3.mybatis-plus 大批量插入
（1）对象操作形式saveBatch
demo:
sql拷贝标识符List<User> userList = new ArrayList<>(); userList.add(new User(1L, “Tom”)); userList.add(new User(2L, “Jerry”)); userList.add(new User(3L, “Mike”)); intresult = userMapper.saveBatch(userList);源码：
java拷贝标识符@Transactional( rollbackFor = {Exception.class} ) publicboolean saveBatch(Collection<T> entityList, int batchSize) { String sqlStatement =this.sqlStatement(SqlMethod.INSERT_ONE);//INSERT_ONE(“insert”, “插入一条统计数据（选择字段插入）”, “<script>\nINSERT INTO %s %s VALUES %s\n</script>”), SqlSession batchSqlSession =this.sqlSessionBatch(); Throwable var5 = null; try { int i = 0; // 分批 for(Iterator var7 = entityList.iterator(); var7.hasNext(); ++i) { T anEntityList = var7.next(); batchSqlSession.insert(sqlStatement, anEntityList);if (i >= 1 && i % batchSize == 0) { batchSqlSession.flushStatements();// 递交sql} } batchSqlSession.flushStatements();// //递交最后一批sql return true; } catch (Throwable var16) { // 异常处理 } finally { // 关闭会话 } }这里比较遗憾，mybatis-plus的插入不会合成一个sql，只是一场递交多个插入的sql。
#####（2）合成一个sql 脚本如下：
xml拷贝标识符<insert id=“batchInsert”parameterType=“java.util.List” useGeneratedKeys=“true” keyProperty=“id” flushCache=“true”> insert into user (name) values <foreach item=“item” index=“index” collection=“list” separator=“,”> (#{item.name}) </foreach> </insert>参考： 资料库大批量插入这么讲究的么？ MyBatis大批量插入的五种形式，哪种最强
4.jdbcTemplate
（1）手动拼接
这种形式比较原始，需要把每一预览的insert/update sql语句写好，拼成一个大的sql递交。
（2）大批量操作形式
demo如下：
java拷贝标识符List<User> userList = String sql = “update user set age=? where id=?”; jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { User user = userList.get(i); ps.setInt(1, user.gee()); ps.setLong(2, user.getId()); } @Override public int getBatchSize() { return userList.size(); } });源码：
ini拷贝标识符public int[] batchUpdate(String sql, BatchPreparedStatementSetter pss) throws DataAccessException { int[] result =(int[])this.execute(sql, (ps) -> {// execute执行sql try { … if(JdbcUtils.supportsBatchUpdates(ps.getConnection())) { int ixx =0; while(true) { if(ixx < batchSize) { pss.setValues(ps, ixx);if (ipss == null|| !ipss.isBatchExhausted(ixx)) { ps.addBatch();// 添加 ++ixx; continue; } } //获取预编译参数 int[] var11 = ps.executeBatch();returnvar11; } }else { List<Integer> rowsAffected = new ArrayList(); for(int i = 0; i < batchSize; ++i) { pss.setValues(ps, i);if (ipss != null && ipss.isBatchExhausted(i)) { break; } rowsAffected.add(ps.executeUpdate());//添加 } int[] rowsAffectedArray =new int[rowsAffected.size()]; for(int ix = 0; ix < rowsAffectedArray.length; ++ix) { rowsAffectedArray[ix] = (Integer)rowsAffected.get(ix); }//returnvar13; } }finally { // 清理 } }); Assert.state(result != null, “No result array”); return result; }看源码，原理一样的~最后都是拼接一批sql，JdbcTemplate只是提供了辅助拼接的工具。
