JDBC實現往MySQL插入百萬級數據

本文轉載自查看原文 2016-07-27 23:49 22043 MySQL插入百萬級數據/ MySQL/ JDBC/ sql

想往某個表中插入幾百萬條數據做下測試，

原先的想法，直接寫個循環10W次隨便插入點數據試試吧，好吧，我真的很天真....

DROP PROCEDURE IF EXISTS proc_initData;--如果存在此存儲過程則刪掉
DELIMITER $
CREATE PROCEDURE proc_initData()
BEGIN
    DECLARE i INT DEFAULT 1;
    WHILE i<=100000 DO
        INSERT INTO text VALUES(i,CONCAT('姓名',i),'XXXXXXXXX');
        SET i = i+1;
    END WHILE;
END $
CALL proc_initData();

執行CALL proc_initData()后，本來想想，再慢10W條數據頂多30分鍾能搞定吧，結果我打了2把LOL后，回頭一看，還在執行，此時心里是徹底懵逼的....待我打完第三把結束后，終於執行完了，這種方法若是讓我等上幾百萬條數據，是不是早上去上班，下午下班回來還沒結束呢？10W條數據，有圖有真相

JDBC往數據庫中普通插入方式

后面查了一下，使用JDBC批量操作往數據庫插入100W+的數據貌似也挺快的，

先來說說JDBC往數據庫中普通插入方式，簡單的代碼大致如下，循環了1000條，中間加點隨機的數值，畢竟自己要拿數據測試，數據全都一樣也不好區分

 1 　　 private String url = "jdbc:mysql://localhost:3306/test01";
 2     private String user = "root";
 3     private String password = "123456";
 4     @Test
 5     public void Test(){
 6         Connection conn = null;
 7         PreparedStatement pstm =null;
 8         ResultSet rt = null;
 9         try {
10             Class.forName("com.mysql.jdbc.Driver");
11             conn = DriverManager.getConnection(url, user, password);        
12             String sql = "INSERT INTO userinfo(uid,uname,uphone,uaddress) VALUES(?,CONCAT('姓名',?),?,?)";
13             pstm = conn.prepareStatement(sql);
14             Long startTime = System.currentTimeMillis();
15             Random rand = new Random();
16             int a,b,c,d;
17             for (int i = 1; i <= 1000; i++) {
18                     pstm.setInt(1, i);
19                     pstm.setInt(2, i);
20                     a = rand.nextInt(10);
21                     b = rand.nextInt(10);
22                     c = rand.nextInt(10);
23                     d = rand.nextInt(10);
24                     pstm.setString(3, "188"+a+"88"+b+c+"66"+d);
25                     pstm.setString(4, "xxxxxxxxxx_"+"188"+a+"88"+b+c+"66"+d);27                     pstm.executeUpdate();
28             }
29             Long endTime = System.currentTimeMillis();
30             System.out.println("OK,用時：" + (endTime - startTime)); 
31         } catch (Exception e) {
32             e.printStackTrace();
33             throw new RuntimeException(e);
34         }finally{
35             if(pstm!=null){
36                 try {
37                     pstm.close();
38                 } catch (SQLException e) {
39                     e.printStackTrace();
40                     throw new RuntimeException(e);
41                 }
42             }
43             if(conn!=null){
44                 try {
45                     conn.close();
46                 } catch (SQLException e) {
47                     e.printStackTrace();
48                     throw new RuntimeException(e);
49                 }
50             }
51         }
52     }

輸出結果：OK,用時：738199，單位毫秒，也就是說這種方式與直接數據庫中循環是差不多的。

在討論批量處理之前，先說說遇到的坑，首先，JDBC連接的url中要加rewriteBatchedStatements參數設為true是批量操作的前提，其次就是檢查mysql驅動包時候是5.1.13以上版本（低於該版本不支持），因網上隨便下載了5.1.7版本的，然后執行批量操作（100W條插入），結果因為驅動器版本太低緣故並不支持，導致停止掉java程序后，mysql還在不斷的往數據庫中插入數據，最后不得不停止掉數據庫服務才停下來...

那么低版本的驅動包是否對100W+數據插入就無力了呢？實際還有另外一種方式，效率相比來說還是可以接受的。

使用事務提交方式

先將命令的提交方式設為false，即手動提交conn.setAutoCommit(false);最后在所有命令執行完之后再提交事務conn.commit();

 1     private String url = "jdbc:mysql://localhost:3306/test01";
 2     private String user = "root";
 3     private String password = "123456";
 4     @Test
 5     public void Test(){
 6         Connection conn = null;
 7         PreparedStatement pstm =null;
 8         ResultSet rt = null;
 9         try {
10             Class.forName("com.mysql.jdbc.Driver");
11             conn = DriverManager.getConnection(url, user, password);        
12             String sql = "INSERT INTO userinfo(uid,uname,uphone,uaddress) VALUES(?,CONCAT('姓名',?),?,?)";
13             pstm = conn.prepareStatement(sql);
14             conn.setAutoCommit(false);
15             Long startTime = System.currentTimeMillis();
16             Random rand = new Random();
17             int a,b,c,d;
18             for (int i = 1; i <= 100000; i++) {
19                     pstm.setInt(1, i);
20                     pstm.setInt(2, i);
21                     a = rand.nextInt(10);
22                     b = rand.nextInt(10);
23                     c = rand.nextInt(10);
24                     d = rand.nextInt(10);
25                     pstm.setString(3, "188"+a+"88"+b+c+"66"+d);
26                     pstm.setString(4, "xxxxxxxxxx_"+"188"+a+"88"+b+c+"66"+d);
27                     pstm.executeUpdate();
28             }
29             conn.commit();
30             Long endTime = System.currentTimeMillis();
31             System.out.println("OK,用時：" + (endTime - startTime)); 
32         } catch (Exception e) {
33             e.printStackTrace();
34             throw new RuntimeException(e);
35         }finally{
36             if(pstm!=null){
37                 try {
38                     pstm.close();
39                 } catch (SQLException e) {
40                     e.printStackTrace();
41                     throw new RuntimeException(e);
42                 }
43             }
44             if(conn!=null){
45                 try {
46                     conn.close();
47                 } catch (SQLException e) {
48                     e.printStackTrace();
49                     throw new RuntimeException(e);
50                 }
51             }
52         }
53     }

以上代碼插入10W條數據，輸出結果：OK,用時：18086，也就十八秒左右的時間，理論上100W也就是3分鍾這樣，勉強還可以接受。

批量處理

接下來就是批量處理了，注意，一定要5.1.13以上版本的驅動包。

 1 private String url = "jdbc:mysql://localhost:3306/test01?rewriteBatchedStatements=true";
 2     private String user = "root";
 3     private String password = "123456";
 4     @Test
 5     public void Test(){
 6         Connection conn = null;
 7         PreparedStatement pstm =null;
 8         ResultSet rt = null;
 9         try {
10             Class.forName("com.mysql.jdbc.Driver");
11             conn = DriverManager.getConnection(url, user, password);        
12             String sql = "INSERT INTO userinfo(uid,uname,uphone,uaddress) VALUES(?,CONCAT('姓名',?),?,?)";
13             pstm = conn.prepareStatement(sql);
14             Long startTime = System.currentTimeMillis();
15             Random rand = new Random();
16             int a,b,c,d;
17             for (int i = 1; i <= 100000; i++) {
18                     pstm.setInt(1, i);
19                     pstm.setInt(2, i);
20                     a = rand.nextInt(10);
21                     b = rand.nextInt(10);
22                     c = rand.nextInt(10);
23                     d = rand.nextInt(10);
24                     pstm.setString(3, "188"+a+"88"+b+c+"66"+d);
25                     pstm.setString(4, "xxxxxxxxxx_"+"188"+a+"88"+b+c+"66"+d);
26                     pstm.addBatch();
27             }
28             pstm.executeBatch();
29             Long endTime = System.currentTimeMillis();
30             System.out.println("OK,用時：" + (endTime - startTime)); 
31         } catch (Exception e) {
32             e.printStackTrace();
33             throw new RuntimeException(e);
34         }finally{
35             if(pstm!=null){
36                 try {
37                     pstm.close();
38                 } catch (SQLException e) {
39                     e.printStackTrace();
40                     throw new RuntimeException(e);
41                 }
42             }
43             if(conn!=null){
44                 try {
45                     conn.close();
46                 } catch (SQLException e) {
47                     e.printStackTrace();
48                     throw new RuntimeException(e);
49                 }
50             }
51         }
52     }

10W輸出結果：OK,用時：3386，才3秒鍾.

批量操作+事務

然后我就想，要是批量操作+事務提交呢？會不會有神器的效果？

 1 private String url = "jdbc:mysql://localhost:3306/test01?rewriteBatchedStatements=true";
 2     private String user = "root";
 3     private String password = "123456";
 4     @Test
 5     public void Test(){
 6         Connection conn = null;
 7         PreparedStatement pstm =null;
 8         ResultSet rt = null;
 9         try {
10             Class.forName("com.mysql.jdbc.Driver");
11             conn = DriverManager.getConnection(url, user, password);        
12             String sql = "INSERT INTO userinfo(uid,uname,uphone,uaddress) VALUES(?,CONCAT('姓名',?),?,?)";
13             pstm = conn.prepareStatement(sql);
14             conn.setAutoCommit(false);
15             Long startTime = System.currentTimeMillis();
16             Random rand = new Random();
17             int a,b,c,d;
18             for (int i = 1; i <= 100000; i++) {
19                     pstm.setInt(1, i);
20                     pstm.setInt(2, i);
21                     a = rand.nextInt(10);
22                     b = rand.nextInt(10);
23                     c = rand.nextInt(10);
24                     d = rand.nextInt(10);
25                     pstm.setString(3, "188"+a+"88"+b+c+"66"+d);
26                     pstm.setString(4, "xxxxxxxxxx_"+"188"+a+"88"+b+c+"66"+d);
27                     pstm.addBatch();
28             }
29             pstm.executeBatch();
30             conn.commit();
31             Long endTime = System.currentTimeMillis();
32             System.out.println("OK,用時：" + (endTime - startTime)); 
33         } catch (Exception e) {
34             e.printStackTrace();
35             throw new RuntimeException(e);
36         }finally{
37             if(pstm!=null){
38                 try {
39                     pstm.close();
40                 } catch (SQLException e) {
41                     e.printStackTrace();
42                     throw new RuntimeException(e);
43                 }
44             }
45             if(conn!=null){
46                 try {
47                     conn.close();
48                 } catch (SQLException e) {
49                     e.printStackTrace();
50                     throw new RuntimeException(e);
51                 }
52             }
53         }
54     }

以下是100W數據輸出對比：（5.1.17版本MySql驅動包下測試，交替兩種方式下的數據測試結果對比）

批量操作(10W)	批量操作+事務提交(10W)	批量操作(100W)	批量錯作+事務提交(100W)
OK,用時：3901	OK,用時：3343	OK,用時：44242	OK,用時：39798
OK,用時：4142	OK,用時：2949	OK,用時：44248	OK,用時：39959
OK,用時：3664	OK,用時：2689	OK,用時：44389	OK,用時：39367

可見有一定的效率提升，但是並不是太明顯，當然因為數據差不算太大，也有可能存在偶然因數，畢竟每項只測3次。

預編譯+批量操作

網上還有人說使用預編譯+批量操作的方式能夠提高效率更明顯，但是本人親測，效率不高反降，可能跟測試的數據有關吧。

預編譯的寫法，只需在JDBC的連接url中將寫入useServerPrepStmts=true即可，

如：

private String url = "jdbc:mysql://localhost:3306/test01?useServerPrepStmts=true&rewriteBatchedStatements=true"

好了，先到這里...

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Java mysql 實現JDBC百萬級數據插入關於mysql百萬級數據的插入和刪除 php實現mysql百萬級數據插入，耗時10s左右 PHP+MySQL百萬級數據插入的優化百萬級數據mysql分區 MYSQL百萬級數據，如何優化 MYSQL百萬級數據優化方法 mysql 百萬級數據條件分頁查詢 Mysql百萬級數據遷移，怎么遷移？實戰過沒？ MySQL百萬級數據分頁查詢及優化