對於需要批量插入資料庫操作JDBC有多重方式，本利從三個角度對Statement和PreparedStatement兩種執行方式進行分析，總結較優的方案。

當前實現由如下條件：

　　執行資料庫：Mysql

執行資料數量：10萬條

執行前提：執行差入資料庫錢均需要提供空表，防止資料量大造成的影響

執行方式：Statement和PreparedStatement兩種方式

執行步驟開始：

1、建立表

1 CREATE TABLE T_PRODUCT (
2   ID bigint(12) NOT NULL AUTO_INCREMENT COMMENT '主鍵',
3   NAME varchar(60) NOT NULL COMMENT '產品名稱',
 
4   WEIGHT varchar(60) NOT NULL COMMENT '產品重量',
5   MARK varchar(60) NOT NULL COMMENT '產品說明',
6   PRIMARY KEY (ID)
7 ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='產品表';

2、編寫操作資料庫工具類

  1 package com.luwei.test.jdbc;
  2 
  3 import java.sql.Connection;
  4 import java.sql.DriverManager;
 
  5 import java.sql.SQLException;
  6 import java.sql.Statement;
  7 import java.util.ResourceBundle;
  8 
  9 /**
 10  * <Description> TODO<br>
 11  * 
 12  * @author lu.wei<br>
 13  * @email [email protected] <br>
 14  * @date 2017年1月9日 <br>
 15  * @since V1.0<br>
 
 16  * @see com.luwei.test.jdbc <br>
 17  */
 18 public class JdbcTemplate {
 19     private static String DRIVER_CLASS_NAME = null;
 20     private static String URL = null;
 21     private static String USERNAME = null;
 22     private static String PASSWORD = null;
 23 
 24     static {
 25         ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
 26         DRIVER_CLASS_NAME = bundle.getString("jdbc.driverClassName");
 27         URL = bundle.getString("jdbc.url");
 28         USERNAME = bundle.getString("jdbc.username");
 29         PASSWORD = bundle.getString("jdbc.password");
 30     }
 31 
 32     /**
 33      * 
 34      * <Description> 獲取資料庫連線<br>
 35      * 
 36      * @author lu.wei<br>
 37      * @email [email protected] <br>
 38      * @date 2017年1月9日 下午10:19:41 <br>
 39      * @return
 40      * @throws Exception
 41      * <br>
 42      */
 43     public static Connection getConnection() throws Exception {
 44         Class.forName(DRIVER_CLASS_NAME);
 45         Connection connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
 46         return connection;
 47     }
 48 
 49     /**
 50      * 
 51      * <Description> 提交事務<br>
 52      * 
 53      * @author lu.wei<br>
 54      * @email [email protected] <br>
 55      * @date 2017年1月9日 下午10:20:48 <br>
 56      * @param connection
 57      * <br>
 58      */
 59     public static void commit(Connection connection) {
 60         try {
 61             connection.commit();
 62         }
 63         catch (SQLException e) {
 64             e.printStackTrace();
 65         }
 66     }
 67 
 68     /**
 69      * 
 70      * <Description> 開啟事務<br>
 71      * 
 72      * @author lu.wei<br>
 73      * @email [email protected] <br>
 74      * @date 2017年1月9日 下午10:23:56 <br>
 75      * @param connection
 76      * <br>
 77      */
 78     public static void beginTx(Connection connection) {
 79         try {
 80             connection.setAutoCommit(false);
 81         }
 82         catch (SQLException e) {
 83             e.printStackTrace();
 84         }
 85     }
 86 
 87     /**
 88      * 
 89      * <Description> 回滾<br>
 90      * 
 91      * @author lu.wei<br>
 92      * @email [email protected] <br>
 93      * @date 2017年1月9日 下午10:24:33 <br>
 94      * @param connection
 95      * <br>
 96      */
 97     public static void rollback(Connection connection) {
 98         try {
 99             connection.rollback();
100         }
101         catch (SQLException e) {
102             e.printStackTrace();
103         }
104     }
105 
106     /**
107      * 
108      * <Description> TODO<br>
109      * 
110      * @author lu.wei<br>
111      * @email [email protected] <br>
112      * @date 2017年1月9日 下午10:28:49 <br>
113      * @param statement
114      * @param connection
115      * <br>
116      */
117     public static void releaseDb(Statement statement, Connection connection) {
118         try {
119             statement.close();
120             connection.close();
121         }
122         catch (SQLException e) {
123             e.printStackTrace();
124         }
125     }
126 }

3、執行資料庫插入操作

3.1、使用Statement直接插入，三次執行耗時：41979 42608 42490

 1 @Test
 2 public void testStatement() {
 3     Connection connection = null;
 4     Statement statement = null;
 5     try {
 6         connection = JdbcTemplate.getConnection();
 7         JdbcTemplate.beginTx(connection);
 8 
 9         statement = connection.createStatement();
10         long begin = System.currentTimeMillis();
11         for (int i = 0; i < 100000; i++) {
12             String sql = "insert into t_product values(null,'name_" + i + "','120kg','mark_" + i + "')";
13             statement.execute(sql);
14         }
15         long end = System.currentTimeMillis();
16         System.out.println(end - begin);
17         JdbcTemplate.commit(connection);
18     }
19     catch (Exception e) {
20         e.printStackTrace();
21         JdbcTemplate.rollback(connection);
22     }
23     finally {
24         JdbcTemplate.releaseDb(statement, connection);
25     }
26 }

3.2、使用PreparedStatement直接插入，三次執行耗時：22808 24675 22281

 1 @Test
 2 public void testPreparedStatement() {
 3     Connection connection = null;
 4     PreparedStatement statement = null;
 5     try {
 6         connection = JdbcTemplate.getConnection();
 7         JdbcTemplate.beginTx(connection);
 8         String sql = "insert into t_product values(null,?,?,?)";
 9 
10         statement = connection.prepareStatement(sql);
11         long begin = System.currentTimeMillis();
12         for (int i = 0; i < 100000; i++) {
13             statement.setString(1, "name_" + i);
14             statement.setString(2, "120kg");
15             statement.setString(3, "mark_" + i);
16             statement.executeUpdate();
17         }
18         long end = System.currentTimeMillis();
19         System.out.println(end - begin);
20         JdbcTemplate.commit(connection);
21     }
22     catch (Exception e) {
23         e.printStackTrace();
24         JdbcTemplate.rollback(connection);
25     }
26     finally {
27         JdbcTemplate.releaseDb(statement, connection);
28     }
29 }

3.3、使用BatchStatement直接插入，三次執行耗時：15342 15235 15485

 1 @Test
 2 public void testBatchStatement() {
 3     Connection connection = null;
 4     Statement statement = null;
 5     try {
 6         connection = JdbcTemplate.getConnection();
 7         JdbcTemplate.beginTx(connection);
 8 
 9         statement = connection.createStatement();
10         long begin = System.currentTimeMillis();
11         for (int i = 0; i < 100000; i++) {
12             String sql = "insert into t_product values(null,'name_" + i + "','120kg','mark_" + i + "')";
13             statement.addBatch(sql);
14 
15             if ((i + 1) % 100 == 0) {
16                 statement.executeBatch();
17                 statement.clearBatch();
18             }
19         }
20         statement.executeBatch();
21         statement.clearBatch();
22         long end = System.currentTimeMillis();
23         System.out.println(end - begin);
24         JdbcTemplate.commit(connection);
25     }
26     catch (Exception e) {
27         e.printStackTrace();
28         JdbcTemplate.rollback(connection);
29     }
30     finally {
31         JdbcTemplate.releaseDb(statement, connection);
32     }
33 }

3.4、使用BatchPreparedStatement直接插入，三次執行耗時：21913 22045 23291

 1 @Test
 2 public void testBatchPreparedStatement() {
 3     Connection connection = null;
 4     PreparedStatement statement = null;
 5     try {
 6         connection = JdbcTemplate.getConnection();
 7         JdbcTemplate.beginTx(connection);
 8         String sql = "insert into t_product values(null,?,?,?)";
 9 
10         statement = connection.prepareStatement(sql);
11         long begin = System.currentTimeMillis();
12         for (int i = 0; i < 100000; i++) {
13             statement.setString(1, "name_" + i);
14             statement.setString(2, "120kg");
15             statement.setString(3, "mark_" + i);
16             statement.addBatch();
17             if ((i + 1) % 100 == 0) {
18                 statement.executeBatch();
19                 statement.clearBatch();
20             }
21         }
22         statement.executeBatch();
23         statement.clearBatch();
24         long end = System.currentTimeMillis();
25         System.out.println(end - begin);
26         JdbcTemplate.commit(connection);
27     }
28     catch (Exception e) {
29         e.printStackTrace();
30         JdbcTemplate.rollback(connection);
31     }
32     finally {
33         JdbcTemplate.releaseDb(statement, connection);
34     }
35 }

3.5、使用採用多Value值Statement直接插入，三次執行耗時：2931 3007 3203 2964

 1 @Test
 2 public void testMutilValueStatement() {
 3     Connection connection = null;
 4     Statement statement = null;
 5     try {
 6         connection = JdbcTemplate.getConnection();
 7         JdbcTemplate.beginTx(connection);
 8 
 9         statement = connection.createStatement();
10 
11         StringBuffer sql = new StringBuffer("insert into t_product values");
12         long begin = System.currentTimeMillis();
13         for (int i = 0; i < 100000; i++) {
14             if (i != 0) {
15                 sql.append(",");
16             }
17             sql.append("(null,'name_" + i + "','120kg','mark_" + i + "')");
18         }
19         statement.execute(sql.toString());
20         long end = System.currentTimeMillis();
21         System.out.println(end - begin);
22         JdbcTemplate.commit(connection);
23     }
24     catch (Exception e) {
25         e.printStackTrace();
26         JdbcTemplate.rollback(connection);
27     }
28     finally {
29         JdbcTemplate.releaseDb(statement, connection);
30     }
31 }

3.6、使用採用多Value值PreparedStatement直接插入，三次執行耗時：3356 3218 3233

 1 @Test
 2 public void testMutilValuePreparedStatement() {
 3     Connection connection = null;
 4     PreparedStatement statement = null;
 5     try {
 6         connection = JdbcTemplate.getConnection();
 7         JdbcTemplate.beginTx(connection);
 8 
 9         StringBuffer sql = new StringBuffer("insert into t_product values");
10         long begin = System.currentTimeMillis();
11         for (
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
JDBC各種插入資料的速度對比
     
 
                

對於需要批量插入資料庫操作JDBC有多重方式，本利從三個角度對Statement和PreparedStatement兩種執行方式進行分析，總結較優的方案。

當前實現由如下條件：

　　執行資料庫：Mysql

執行資料數量：10萬條

執行前提：執行差入資料庫錢均需要提 

  
 

    

    
    
Java之JDBC批量插入資料
     
  
 
  
  
 普通插入方式 
 10萬條資料，耗時13秒。。。 
 private String url = "jdbc:mysql://localhost:3306/test01";
  private String user = "root";
  private String password  

  
 

    

    
    
EF批量插入資料耗時對比
     
  
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EF批量插入
{
    class Progra 

  
 

    

    
    
LinkedList和ArrayList在尾部插入資料效率對比
     
 
                做這個實驗之前，我的猜想的是：因為每次都是在尾部插入資料，而LinkedLiist裡面有一個last指標一直指向最後一個元素，而ArrayList則根據索引來找到最後一個元素，那麼，這兩個方式中，效率應該是差不多的；

但是實驗結果卻不是這樣的；

先看程式碼：

packa 

  
 

    

    
    
用原始的jdbc批量插入資料
     
 
								
								            
						
                
原始的jdbc批量插入資料的方法
@Service("importDao")
@Transactional                                    //使用jdbc進行批 

  
 

    

    
    
JDBC插入資料後返回新資料id
     
  
 
  
  
 使用jdbc向表中插入資料時，有時候需要返回新插入資料的id。比如現在要向兩個表中分別插入一條資料，第一條資料插入後生成的id要作為第二條資料的一個欄位值。  具體程式碼： 
     PreparedStatement pstmt = null;
    ResultSet rs =  

  
 

    

    
    
JDBC對插入,刪除,修改資料庫中的資料
     
     public static void add()
    {
        String sql = "insert into users values(?,?,?,?,?,?)";
        try
        {
            preparedStatement = conn 

  
 

    

    
    
使用JDBC向SqlServer資料庫中插入資料
     
 
							
							
							在實際的開發的當中 
我們會發現在資料庫中插入資料是比查詢資料難的 
因為查詢只需要一個固定的值就可以進行查詢 
但是插入的話需要對照資料庫的建表

因為有些鍵值不允許為空

示例程式碼：



package sqlserver.controller;

im 

  
 

    

    
    
使用JDBC在MySQL資料庫中快速批量插入資料
     
 
                
使用JDBC連線MySQL資料庫進行資料插入的時候，特別是大批量資料連續插入（10W+），如何提高效率呢？
在JDBC程式設計介面中Statement 有兩個方法特別值得注意：

void addBatch() throws SQLException
Adds a set  

  
 

    

    
    
JDBC插入資料，更新資料，使用NamedParameterJdbcTemplate物件直接操作javaBean
     
 
                

原來如此簡單：



DButil:

public NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {

if (nam == null) {
            synchronized(DBU 

  
 

    

    
    
java利用jdbc連線資料庫之插入資料
     
 
							
							
							java通過JDBC連線資料庫

具體功能： 
使用PreparedStatement介面中的executeUpdate()方法向資料庫中插入一條資料 
前提： 
具有一個數據庫和一個列表（列表和資料庫長啥樣後面會說） 
1：建立java project



 

  
 

    

    
    
如何利用jdbc快速插入百萬條資料
     
 
                當須要向資料庫插入百萬條資料時，利用hibernate，mybatis等持久層框架時耗時較久，此時使用jdbc插入效率會更高。此種場景特別適用於讀取檔案匯入到資料庫。可以利用批處理來加快jdbc的插入效率。String sql = "insert into person(id 

  
 

    

    
    
JDBC使用佔位符插入資料報錯MySQLSyntaxErrorException: You have an error.....syntax to use near '?,?)'
     
 
                
JDBC使用佔位符插入資料報錯：com.mysql.jdbc.exceptions.MySQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that correspo 

  
 

    

    
    
各種加密演算法的速度對比
     
 
                
cpu: Intel Core i7-4712MQ CPU 2.3GHz 
memory:8GB
os:win7 64
命令：
cryptotest bAlgorithm
MiB/Second
Microseconds to
Setup Key and IV
AES/GCM 

  
 

    

    
    
海量資料插入資料庫效率對比測試 ---ADO.NET下SqlBulkCopy()對比LINQ 下InsertAllOnSubmit()
     
 
                
摘要：使用.NET相關技術向資料庫中插入海量資料是常用操作。本文對比ADO.NET和LINQ兩種技術，分別使用SqlBulkCopy()和InsertAllOnSubmit()方法進行操作。得出結論：相同插入工作量（1w條資料）插入效率相差200倍之巨！

測試場景：
準備 

  
 

    

    
    
jdbc批量插入幾百萬資料怎麼實現？
     
 
                網上搜到這樣的一篇部落格,我覺得講的不錯,分享給大家:今天在做一個將excel資料匯入資料庫的程式時，由於資料量大，準備採用jdbc的批量插入。於是用了preparedStatement.addBatch();當加入1w條資料時，再執行插入操作，preparedStateme 

  
 

    

    
    
JDBC操作Vertica資料庫，用PreparedStatements物件實現批量插入資料
     
 
                

import java.sql.*;
import java.util.Properties;
public class BatchInsertExample {
    public static void main(String[] args) {
 
        

  
 

    

    
    
select *  和 select 所有字段寫出來 ，速度對比！
     
 bsp   第一次   blog   師說   sel   lec   意見   -1   tab   從很早時候，聽老師說 select * from table  比 select a,b,c,d from table 要慢很多。3年來從未測試。  今天沒事測一測， 不測不知道，一測嚇一跳。
當然 以下純 

  
 

    

    
    
解決拿蛋問題的時候，通過幾個shell腳本運算速度對比，體會了算法和編程優化的重要性
     
 拿蛋問題   shell腳本運算速度對比   算法和編程優化   前幾天，一位同學在群裏提出一個拿蛋的問題，原題如下：有一筐雞蛋，1個1個拿，正好拿完2個2個拿，正好拿完3個3個拿，正好拿完4個4個拿，剩下2個5個5個拿，剩下4個6個6個拿，正好拿完7個7個拿，剩下5個8個8個拿，剩下2個9個9個拿，正好拿完 

  
 

    

    
    
35 JDBC批量插入數據二
     
 獲取   else   ++   star   bsp   pri   conn   nal   cat   
package MYSQK;
import java.sql.*;

/**
 * PreparedStatement 對象可以對sql語句進行預編譯，預編譯的信息會存在存儲該對象中，當相同的sql