原文: https://blog.csdn.net/q6834850/article/details/73726707
下文展示代码为部分代码，源码-github地址

1. 先上Mysql数据库，随机生成的人员数据图。分别是ID、姓名、性别、年龄、Email、电话、住址。下图一共三千三百万数据：

JAVA向Mysql插入亿级别数据---测评 - 图1


在数据量在亿级别时。别点下面按钮，会导致Navicat持续加载这亿级别的数据，
导致电脑死机。~觉着自己电脑配置不错的可以去试试，可能会有惊喜

JAVA向Mysql插入亿级别数据---测评 - 图2

2、本次测评一共通过三种策略，五种情况，进行大批量数据插入测试

  1. 策略分别是：<br />    1、Mybatis 轻量级框架插入（无事务）<br />    2、采用JDBC直接处理（开启事务、无事务）<br />    3、采用JDBC批处理（开启事务、无事务）

先展示测试结果（耗费时间）

Mybatis轻量级插入 -》 JDBC直接处理 -》 JDBC 批处理。

JDBC 批处理，效率最高

下面开始第一种策略测试：

2.1 Mybatis 轻量级框架插入（无事务）

Mybatis是一个轻量级框架，它比hibernate轻便、效率高。但是处理大批量的数据插入操作时，需要过程中实现一个ORM的转换，本次测试存在实例，以及

未开启事务，导致mybatis效率很一般。这里实验内容是：

  1. 1、利用Spring框架生成mapper实例、创建人物实例对象<br />    2、循环更改该实例对象属性、并插入。
  1. //代码内无事务
  3. private long begin = 33112001;//起始id
  4. private long end = begin+100000;//每次循环插入的数据量
  5. private String url = "jdbc:mysql://localhost:3306/bigdata?useServerPrepStmts=false&rewriteBatchedStatements=true&useUnicode=true&amp;characterEncoding=UTF-8";
  6. private String user = "root";
  7. private String password = "0203";
  10. @org.junit.Test
  11. public void insertBigData2()
  12. {
  13.     //加载Spring，以及得到PersonMapper实例对象。这里创建的时间并不对最后结果产生很大的影响
  14.     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  15.     PersonMapper pMapper = (PersonMapper) context.getBean("personMapper");
  16.     //创建一个人实例
  17.     Person person = new Person();
  18.     //计开始时间
  19.     long bTime = System.currentTimeMillis();
  20.     //开始循环，循环次数500W次。
  21.     for(int i=0;i<5000000;i++)
  22.     {
  23.         //为person赋值
  24.         person.setId(i);
  25.         person.setName(RandomValue.getChineseName());
  26.         person.setSex(RandomValue.name_sex);
  27.         person.setAge(RandomValue.getNum(1, 100));
  28.         person.setEmail(RandomValue.getEmail(4,15));
  29.         person.setTel(RandomValue.getTel());
  30.         person.setAddress(RandomValue.getRoad());
  31.         //执行插入语句
  32.         pMapper.insert(person);
  33.         begin++;
  34.     }
  35.     //计结束时间
  36.     long eTime = System.currentTimeMillis();
  37.     System.out.println("插入500W条数据耗时："+(eTime-bTime));
  38.     }
  1. 本想测试插入五百万条数据，但是实际运行过程中太慢，中途不得不终止程

序。最后得到52W数据，大约耗时两首歌的时间（7~9分钟）。随后，利用mybatis向mysql插入 一万 数据。结果如下： 利用mybatis插入 一万 条数据耗时：28613，即_28.6秒_**

JAVA向Mysql插入亿级别数据---测评 - 图3

下面开始第二种策略测试：

2.2 采用JDBC直接处理（开启事务、关闭事务）


采用JDBC直接处理的策略，这里的实验内容分为开启事务、未开启事务是两种，过程均如下：

  1. 1、利用PreparedStatment预编译<br />    2、循环，插入对应数据，并存入

事务对于插入数据有多大的影响呢？看下面的实验结果:

  1. //该代码为开启事务
  2. private long begin = 33112001;//起始id
  3. private long end = begin+100000;//每次循环插入的数据量
  4. private String url = "jdbc:mysql://localhost:3306/bigdata?useServerPrepStmts=false&rewriteBatchedStatements=true&useUnicode=true&amp;characterEncoding=UTF-8";
  5. private String user = "root";
  6. private String password = "0203";
  9. @org.junit.Test
  10. public void insertBigData3() {
  11. //定义连接、statement对象
  12. Connection conn = null;
  13. PreparedStatement pstm = null;
  14. try {
  15. //加载jdbc驱动
  16. Class.forName("com.mysql.jdbc.Driver");
  17. //连接mysql
  18. conn = DriverManager.getConnection(url, user, password);
  19. //将自动提交关闭
  20. conn.setAutoCommit(false);
  21. //编写sql
  22. String sql = "INSERT INTO person VALUES (?,?,?,?,?,?,?)";
  23. //预编译sql
  24. pstm = conn.prepareStatement(sql);
  25. //开始总计时
  26. long bTime1 = System.currentTimeMillis();
  28. //循环10次，每次一万数据，一共10万
  29. for(int i=0;i<10;i++) {
  30. //开启分段计时，计1W数据耗时
  31. long bTime = System.currentTimeMillis();
  32. //开始循环
  33. while (begin < end) {
  34. //赋值
  35. pstm.setLong(1, begin);
  36. pstm.setString(2, RandomValue.getChineseName());
  37. pstm.setString(3, RandomValue.name_sex);
  38. pstm.setInt(4, RandomValue.getNum(1, 100));
  39. pstm.setString(5, RandomValue.getEmail(4, 15));
  40. pstm.setString(6, RandomValue.getTel());
  41. pstm.setString(7, RandomValue.getRoad());
  42. //执行sql
  43. pstm.execute();
  44. begin++;
  45. }
  46. //提交事务
  47. conn.commit();
  48. //边界值自增10W
  49. end += 10000;
  50. //关闭分段计时
  51. long eTime = System.currentTimeMillis();
  52. //输出
  53. System.out.println("成功插入1W条数据耗时："+(eTime-bTime));
  54. }
  55. //关闭总计时
  56. long eTime1 = System.currentTimeMillis();
  57. //输出
  58. System.out.println("插入10W数据共耗时："+(eTime1-bTime1));
  59. } catch (SQLException e) {
  60. e.printStackTrace();
  61. } catch (ClassNotFoundException e1) {
  62. e1.printStackTrace();
  63. }
  64.     }

1、我们首先利用上述代码测试无事务状态下，插入10W条数据需要耗时多少。如图：

JAVA向Mysql插入亿级别数据---测评 - 图4

成功插入1W条数据耗时：21603
成功插入1W条数据耗时：20537
成功插入1W条数据耗时：20470
成功插入1W条数据耗时：21160
成功插入1W条数据耗时：23270
成功插入1W条数据耗时：21230
成功插入1W条数据耗时：20372
成功插入1W条数据耗时：22608
成功插入1W条数据耗时：20361
成功插入1W条数据耗时：20494
插入10W数据共耗时：212106

实验结论如下：

在未开启事务的情况下，平均每 21.2 秒插入 一万 数据。 

  1. 接着我们测试开启事务后，插入十万条数据耗时，如图：

JAVA向Mysql插入亿级别数据---测评 - 图5

成功插入1W条数据耗时：4938
成功插入1W条数据耗时：3518
成功插入1W条数据耗时：3713
成功插入1W条数据耗时：3883
成功插入1W条数据耗时：3872
成功插入1W条数据耗时：3873
成功插入1W条数据耗时：3863
成功插入1W条数据耗时：3819
成功插入1W条数据耗时：3933
成功插入1W条数据耗时：3811
插入10W数据共耗时：39255

实验结论如下：

开启事务后，平均每 3.9 秒插入 一万 数据

下面开始第三种策略测试：

2.3 采用JDBC批处理（开启事务、无事务）

采用JDBC批处理时需要注意一下几点： 1、在URL连接时需要开启批处理、以及预编译
String url = “jdbc:mysql://localhost:3306/User?rewriteBatched
-Statements=true&useServerPrepStmts=false”;

2、PreparedStatement预处理sql语句必须放在循环体外

代码如下：

  1.     private long begin = 33112001;//起始id
  2.     private long end = begin+100000;//每次循环插入的数据量
  3.     private String url = "jdbc:mysql://localhost:3306/bigdata?useServerPrepStmts=false&rewriteBatchedStatements=true&useUnicode=true&amp;characterEncoding=UTF-8";
  4.     private String user = "root";
  5.     private String password = "0203";
  8.     @org.junit.Test
  9.     public void insertBigData() {
  10.         //定义连接、statement对象
  11.         Connection conn = null;
  12.         PreparedStatement pstm = null;
  13.         try {
  14.             //加载jdbc驱动
  15.             Class.forName("com.mysql.jdbc.Driver");
  16.             //连接mysql
  17.             conn = DriverManager.getConnection(url, user, password);
  18.             //将自动提交关闭
  19.             // conn.setAutoCommit(false);
  20.             //编写sql
  21.             String sql = "INSERT INTO person VALUES (?,?,?,?,?,?,?)";
  22.             //预编译sql
  23.             pstm = conn.prepareStatement(sql);
  24.             //开始总计时
  25.             long bTime1 = System.currentTimeMillis();
  27.             //循环10次，每次十万数据，一共1000万
  28.             for(int i=0;i<10;i++) {
  30.                 //开启分段计时，计1W数据耗时
  31.                 long bTime = System.currentTimeMillis();
  32.                 //开始循环
  33.                 while (begin < end) {
  34.                     //赋值
  35.                     pstm.setLong(1, begin);
  36.                     pstm.setString(2, RandomValue.getChineseName());
  37.                     pstm.setString(3, RandomValue.name_sex);
  38.                     pstm.setInt(4, RandomValue.getNum(1, 100));
  39.                     pstm.setString(5, RandomValue.getEmail(4, 15));
  40.                     pstm.setString(6, RandomValue.getTel());
  41.                     pstm.setString(7, RandomValue.getRoad());
  42.                     //添加到同一个批处理中
  43.                     pstm.addBatch();
  44.                     begin++;
  45.                 }
  46.                 //执行批处理
  47.                 pstm.executeBatch();
  48. //                //提交事务
  49. //                conn.commit();
  50.                 //边界值自增10W
  51.                 end += 100000;
  52.                 //关闭分段计时
  53.                 long eTime = System.currentTimeMillis();
  54.                 //输出
  55.                 System.out.println("成功插入10W条数据耗时："+(eTime-bTime));
  56.             }
  57.             //关闭总计时
  58.             long eTime1 = System.currentTimeMillis();
  59.             //输出
  60.             System.out.println("插入100W数据共耗时："+(eTime1-bTime1));
  61.         } catch (SQLException e) {
  62.             e.printStackTrace();
  63.         } catch (ClassNotFoundException e1) {
  64.             e1.printStackTrace();
  65.         }
  66.     }

首先开始测试
无事务，每次循环插入10W条数据，循环10次，一共100W条数据。结果如下图：

JAVA向Mysql插入亿级别数据---测评 - 图6

成功插入10W条数据耗时：3832
成功插入10W条数据耗时：1770
成功插入10W条数据耗时：2628
成功插入10W条数据耗时：2140
成功插入10W条数据耗时：2148
成功插入10W条数据耗时：1757
成功插入10W条数据耗时：1767
成功插入10W条数据耗时：1832
成功插入10W条数据耗时：1830
成功插入10W条数据耗时：2031
插入100W数据共耗时：21737

实验结果：

使用JDBC批处理，未开启事务下，平均每 2.1 秒插入 十万 条数据

接着测试
开启事务，每次循环插入10W条数据，循环10次，一共100W条数据。结果如下图：
JAVA向Mysql插入亿级别数据---测评 - 图7

成功插入10W条数据耗时：3482
成功插入10W条数据耗时：1776
成功插入10W条数据耗时：1979
成功插入10W条数据耗时：1730
成功插入10W条数据耗时：1643
成功插入10W条数据耗时：1665
成功插入10W条数据耗时：1622
成功插入10W条数据耗时：1624
成功插入10W条数据耗时：1779
成功插入10W条数据耗时：1698
插入100W数据共耗时：19003

实验结果：

使用JDBC批处理，开启事务，平均每 1.9 秒插入 十万 条数据

3 总结

能够看到，在开启事务下 JDBC直接处理 和 JDBC批处理 均耗时更短。 Mybatis 轻量级框架插入 , mybatis在我这次实验被黑的可惨了，哈哈。实际开启事务以后，差距不会这么大（差距10倍）。大家有兴趣的可以接着去测试
JDBC直接处理，在本次实验，开启事务和关闭事务，耗时差距5倍左右，并且这个倍数会随着数据量的增大而增大。因为在未开启事务时，更新10000条数据，就得访问数据库10000次。导致每次操作都需要操作一次数据库。
JDBC批处理，在本次实验，开启事务与关闭事务，耗时差距很微小（后面会增加测试，加大这个数值的差距）。但是能够看到开启事务以后，速度还是有提升。

结论，设计到大量单条数据的插入，使用JDBC批处理和事务混合速度最快
实测使用批处理+事务混合插入1亿条数据耗时：174756毫秒

提示：

下列只是部分代码，源码-github地址
转载请标明出处：——-by 陶浩伟

4、更多彩蛋

JDBC批处理事务，开启和关闭事务，测评插入20次，一次50W数据，一共一千万数据耗时：
{

1、开启事务(数据太长不全贴了)

插入1000W数据共耗时：197654

2、关闭事务(数据太长不全贴了)

}

还是没很大的差距~

插入1000W数据共耗时：200540

借用：

JAVA向Mysql插入亿级别数据---测评 - 图8

分别是：

  1.            不用批处理，不用事务；
  3.            只用批处理，不用事务；
  5.            只用事务，不用批处理；
  7.            既用事务，也用批处理；（很明显，这个最快，所以建议在处理大批量的数据时，同时使用批处理和事务）