一、前言
最近几天在开发公司业务时，遇到了须要往不数据库中多个表中插入大量数据的一个场景，于是有了这篇文章：
在应用Mybatis批量插入数据时的注意事项，以及应用函数式编程对分批次数据插入方法的简略封装。
对于蕴含我在内大部分Java后端开发的小伙伴们在平时的CURD开发工作中，肯定是免不了应用Mybatis这个工具来对数据库进行操作的。
在SpringBoot的工程中，引入Mybatis后，可应用mapper注入的形式来实现增删改查。
比方如果要新增一条数据，那么在mapper.xml文件中能够这么写：
<insert id="testInsert"> insert into massive_data_insert_test (value1,value2) values (#{value1},#{value2}) </insert>而后在service层调用mapper.insertOneItem(insertItem);即可。
如果要新增多条数据，如果是刚学Java的同学可能会这么写：
for(int i = 0; i < insertList.size(); i++){ mapper.insertOneItem(insertList.get(i));}就是简略的放在一个循环中，屡次调用mapper中的数据库新增办法。这种办法编写简略易于了解，在数据量比拟少的时候是不会有什么问题的。
然而一旦数据过多就会有问题了。
实际上每次的mapper办法调用都是一次连贯数据库、预处理（PreparedStatement）、execute（执行SQL）的过程。
由此发现，如果放在for循环中的话，上述过程则会屡次执行，而咱们又分明数据库的连接数是无限的（建设连贯的过程也是很消耗资源的），如果for循环的次数过多时，不仅性能会降落还会造成数据库的梗塞甚至程序解体。当然，咱们能够创立或配置数据库连接池（比方HikariCP、Durid等）来复用连贯，但这还是对资源的一种节约。
总而言之，如果能有一种办法来一次性把要实现的事件做完就不要分屡次去做。
大部分数据库的新增语句是反对一次插入多条数据的。
insert into table(value1, value2)values ('v1','v2'),('v3','v4'),('v1','v5')Mybatis也给出了一种批量操作数据的办法。应用动静SQL语句中的<foreach>标签，将帮忙咱们拼接出形似下面的SQL语句。
咱们在mapper.xml中编写上面的内容：
<insert id="testMassiveInsert"> insert into massive_data_insert_test (value1,value2) values <foreach collection="list" item="item" separator=","> (#{item.value1},#{item.value2}) </foreach> </insert>这样咱们就只须要调用一次mapper中的办法就能达到下面for循环代码的成果。
并且实际上执行的时候也是执行一次SQL，这个动静SQL语句的作用就是将传入的参数的内容拼接到插入语句的SQL中（预处理技术）。
这种办法很显著要比一开始的for循环的实现要好一点了。
二、批量插入数据量达到上万后报错
然而，当咱们用上述的拼接SQL的形式进行批量插入时，数据量过大也会呈现问题！
咱们能够先来试验一下批量插入一个四万条数据会怎么。
先来新建一张表作为插入数据的指标表：massive_data_insert_test。
CREATE TABLE "supply"."massive_data_insert_test" ( "value1" varchar(255) COLLATE "pg_catalog"."default", "value2" varchar(255) COLLATE "pg_catalog"."default");轻易在一个SpringBoot的工程中连贯数据库并创立mapper，编写插入语句（创立工程和扫描mapper等操作就不在此赘述了）：
上面是mapper接口和mapper.xml文件（中的sql语句）。
TestMapper.java
@Repositorypublic interface TestMapper.java { void testMassiveInsert(List<HashMap> list);}TestMapper.xml
<insert id="testMassiveInsert"> insert into massive_data_insert_test (value1,value2) values <foreach collection="list" item="item" separator=","> (#{item.value1},#{item.value2}) </foreach> </insert>测试语句：
@Service@Slf4jpublic class TestService { // 批量新增的最大数量 private static final int maxInsertItemNumPerTime = 500; private TestMapper mapper; @Autowired public TestService(TestMapper mapper) { this.mapper = mapper; } public Result testMassiveInsert() { long startTime = System.currentTimeMillis(); //获取开始工夫 List<HashMap> list = new LinkedList<>(); // 组装数据 取得一个长度为 500 * 80 = 40000的链表 for (int i = 0; i < maxInsertItemNumPerTime * 80; i++) { HashMap map = new HashMap(); map.put("value1", "value1" + i); map.put("value2", "value2" + i); list.add(map); } // 间接批量插入 try { mapper.testMassiveInsert(list); } catch (RuntimeException e) { log.info("间接批量插入" + list.size() + "失败", e.getMessage()); throw new RuntimeException(e); } long endTime = System.currentTimeMillis(); //获取完结工夫 return Result.ok().message("程序运行工夫：" + (endTime - startTime) + "ms"); }}当执行下面的间接批量插入时：
间接报出了I/O error，为什么会这样呢？
在前文中提到过这个动静SQL语句的作用就是将传入的参数的内容拼接到插入语句的SQL中，所以产生这个谬误的起因就是因为要拼接的内容过多，导致SQL语句过长从而导致了I/O的谬误。所以当数据量过大时就会使得拼接过长从而导致程序报错。
并且这个SQL的长度不光跟数据量无关，还跟插入语句的插入参数的数量无关。实际上，SQL的长度与二者的乘积呈正相干的线性变动，所以当插入参数过多时更要管制好批量插入数据量的大小。
那么怎么解决呢？最简略的就是分批次插入了，这有点像文章一开始提到的for循环中顺次插入的形式，只不过是这回for循环中的插入是批量插入了。
因为不是一次性的插入，所以须要加上事务的包裹，从而保障无论哪次插入出错都能回滚。
@Transactional public Result testMassiveInsert() { long startTime = System.currentTimeMillis(); //获取开始工夫 List<HashMap> list = new LinkedList<>(); // 组装数据 取得一个长度为 500 * 80 = 40000的链表 for (int i = 0; i < maxInsertItemNumPerTime * 80; i++) { HashMap map = new HashMap(); map.put("value1", "value1" + i); map.put("value2", "value2" + i); list.add(map); } // 分批次的批量插入 try { if (list.size() > maxInsertItemNumPerTime) { List<List<HashMap>> all = new ArrayList<>(); int i = 0; while (i < list.size()) { List subList = list.subList(i, i + maxInsertItemNumPerTime); i = i + maxInsertItemNumPerTime; all.add(subList); } all.parallelStream().forEach(o -> mapper.testMassiveInsert(o)); } } catch (RuntimeException e) { log.info("分批次批量插入" + list.size() + "失败", e.getMessage()); throw new RuntimeException(e); } long endTime = System.currentTimeMillis(); //获取完结工夫 return Result.ok().message("程序运行工夫：" + (endTime - startTime) + "ms"); }咱们通过设置一个maxInsertItemNumPerTime来管制每次批量插入数据的长度。
三、简略测试
上面我的简略测试（即插入总数量为4w条，但设置不同maxInsertItemNumPerTime大小时，计算比拟程序运行的耗时）。不过该测试没有进行很多次测试取均匀并又可能网络也有抖动，所以只能算是简略测试。
- 2000
- 1000
- 500
- 250
最初我抉择了500作为分批次插入时每个批次的大小。正如咱们上文所说的一样，即便有数据库连接池提供的连贯复用，然而如果跟数据库的交互多了还是会造成性能的降落，所以这里的maxInsertItemNumPerTime的也不是越小越好。
同时，随着maxInsertItemNumPerTime的变大，每一次for循环中的SQL的预处理过程（SQL拼接）耗时会变大，并且这种变大并不是一种线性的，而是往往出现指数型变大(查了一些材料证实了我的这个猜想)，否则的话就不会是2000的时候要远远大于500了。
大家在理论业务中也须要简略测测来选取一个比拟适合的值，总比没有测试的要好。
四、做点扩大
其实在Mybatis的官网文档中是提供了另外一种形式来反对批量插入的。
但因为公司的我的项目中都是用的扫描Mapper的形式来操作数据库，加上这种大数据插入场景的确比拟少，所以就没有特意引进上面Mybatis提供的形式。
A multiple row insert is a single insert statement that inserts multiple rows into a table. This can be a convenient way to insert a few rows into a table, but it has some limitations:
- Since it is a single SQL statement, you could generate quite a lot of prepared statement parameters. For example, suppose you wanted to insert 1000 records into a table, and each record had 5 fields. With a multiple row insert you would generate a SQL statement with 5000 parameters. There are limits to the number of parameters allowed in a JDBC prepared statement - and this kind of insert could easily exceed those limits. If you want to insert many records, you should probably use a JDBC batch insert instead (see below)
- The performance of a giant insert statement may be less than you expect. If you have many records to insert, it will almost always be more efficient to use a JDBC batch insert (see below). With a batch insert, the JDBC driver can do some optimization that is not possible with a single large statement
- Retrieving generated values with multiple row inserts can be a challenge. MyBatis currently has some limitations related to retrieving generated keys in multiple row inserts that require special considerations (see below)
Nevertheless, there are use cases for a multiple row insert - especially when you just want to insert a few records in a table and don’t need to retrieve generated keys. In those situations, a multiple row insert will be an easy solution.
翻译：
try (SqlSession session = sqlSessionFactory.openSession()) { GeneratedAlwaysAnnotatedMapper mapper = session.getMapper(GeneratedAlwaysAnnotatedMapper.class); List<GeneratedAlwaysRecord> records = getRecordsToInsert(); // not shown MultiRowInsertStatementProvider<GeneratedAlwaysRecord> multiRowInsert = insertMultiple(records) .into(generatedAlways) .map(id).toProperty("id") .map(firstName).toProperty("firstName") .map(lastName).toProperty("lastName") .build() .render(RenderingStrategies.MYBATIS3); int rows = mapper.insertMultiple(multiRowInsert); }下面就是文档中的示例代码。
五、进一步优化代码
因为我在公司理论开发中要做的是要往多张表中导入数据，如果依照下面的分批次的写法的话，那我的每一次插入都要有这么一段逻辑：
// 分批次的批量插入 try { if (list.size() > maxInsertItemNumPerTime) { List<List<HashMap>> all = new ArrayList<>(); int i = 0; while (i < list.size()) { List subList = list.subList(i, i + maxInsertItemNumPerTime); i = i + maxInsertItemNumPerTime; all.add(subList); } all.parallelStream().forEach(o -> mapper.testMassiveInsert(o)); } } catch (RuntimeException e) { log.info("分批次批量插入" + list.size() + "失败", e.getMessage()); throw new RuntimeException(e); }显然这有点反复代码的坏滋味了，看起来就很不好。所以接下来做个简略封装，将这段代码封装到一个办法中，谁插入时就由谁调用。
首先，这段代码须要传入的参数是什么？
maxInsertItemNumPerTime不须要传入，因为显然这是一个常量list插入的内容链表，须要传入，并且类型不会全都是HashMap，而是不同表对应不同的实体类。须要用到泛型T。mapper中的testMassiveInsert(HashMap map)办法，很显著不同表的插入mapper必定不是同一个办法，所以这个也须要传入，把一个办法当作参数传入，那么就须要用到Lambda表达式和函数式编程。如果你理解过函数式接口，你很天然就会想到像这种只有输出没有输入的函数应该由Consumer来传入（反之对应Supplier，有输出又有输入时则是Function）。
所以最初形象出的代码应该是这样的：
public <T> void batchSplitInsert(List<T> list, Consumer insertFunc) { List<List<T>> all = new ArrayList<>(); if (list.size() > maxInsertItemNumPerTime) { int i = 0; while (i < list.size()) { List subList = list.subList(i, i + maxInsertItemNumPerTime); i = i + maxInsertItemNumPerTime; all.add(subList); } all.parallelStream().forEach(insertFunc); } else { insertFunc.accept(list); }}这样子我在做不同表的插入时：
// 待插入数据链表List<TableDTO> needToInsert = ……；// 进行新增Consumer<List<TableDTO>> consumer = o -> mapper.insertTable(o);batchSplitInsert(needToInsert, consumer);当初整个世界都变优雅了！如果刚入职或者刚学Java的小伙伴还对函数式编程不理解，不如先从从简略的Lambda语句开始学起，这个真的是Java8中超好用的一个个性。
到此为止，本文就算是完结了，大家有啥疑难，请评论留言，咱们互相交换。
如果这篇文章对你有帮忙请多多点赞，感激！如果有大佬有更好的实现形式也请务必不吝赐教！