原生jdbc导入百万数据

最新推荐文章于 2024-05-10 22:26:18 发布
最新推荐文章于 2024-05-10 22:26:18 发布
阅读量921 收藏 3
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_index/article/details/78673611
版权

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"

 

 

 

y_index
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jdbc连接程序实现不同数据库数据的迁移
09-27
采用jdbc连接数据库，将两种不同类型的数据（SqlServer、Oracle）进行转换，来完成数据库数据的迁移。 实现方式，查询SqlServer数据，批处理插入到Oracle中。
jdbc批量导入数据
郝大侠的博客
08-09 304
java链接mysql批量导入数据 package MysqlDemo; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.sql.Connection; import java.sql.DriverManager; impo...
EasyExcel处理Mysql百万数据的导入导出案例，秒级效率，拿来即用！
JavaBuild的博客
05-10 1545
以上就是SpringBoot项目下，通过阿里开源的EasyExcel技术进行百万级数据的导入与导出，不过针对百万数据量的导入，时间在分钟级别，这很明显不够优秀，但考虑到本文的篇幅已经很长了，我们在下一篇文章针对导入进行性能优化，敬请期待！
通过jdbc的方式把excel表格中的数据导入数据库
dongyuancaizi的博客
10-21 1458
/* *在导入数据之前，如果你是window 7用户，请将mysql的配置做如下修改，负责很可能导入数据失败， */ //第一步，找到mysql安装路径下的my.ini文件 //第二步，打开my.ini文件，在最后一行做如下配置，等号后边的路径由你自己定，但是请注意，最好是一个不含中文的路径，且是空文件夹 //3.创建数据库的表结构，如下图，也可参阅如下表创建语句创建 //表
JDBC数据库查询
热门推荐
易水寒
01-09 2万+
package org.lxh.execdemon; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.Statement; //查询数据库中的内容 public class ResultSetDemon01 { public stat
sybase 数据库 jdbc 驱动下载
11-04
1. **导入JDBC驱动**：在Java项目中，需要将`jconn4-7.5.jar`添加到类路径中。 2. **加载驱动**：使用`Class.forName()`方法加载JDBC驱动。 3. **创建连接**：通过`DriverManager.getConnection()`方法建立与Sybase...
DataGear数据可视化分析平台
10-20
DataGear是一款数据可视化分析平台，使用Java语言开发，采用浏览器/服务器架构，支持SQL、CSV、Excel、HTTP接口、JSON等多种数据源，主要功能包括数据管理、SQL工作台、数据导入/导出、数据集管理、图表管理、看板...
sharding-jdbc开源分表框架整合mybatis-demo
11-19
4. **SQL调整**: 使用Sharding-JDBC时，部分原生的SQL可能需要进行调整，以适应分片环境。例如，全局表的查询、跨分片的JOIN操作等需要特殊处理。 5. **事务管理**: Sharding-JDBC支持分布式事务，但与MyBatis的...
基于原生servlet和jdbc的学生信息管理系统，前端使用layui.zip
08-22
【标题】"基于原生servlet和jdbc的学生信息管理系统，前端使用layui.zip"涉及的核心技术是Web开发中的Servlet、JDBC以及前端框架LayUI。Servlet是Java Web应用中的服务器端组件，负责处理HTTP请求并生成响应。JDBC...
Java_使用原生Kibana在ClickHouse中可视化数据.zip
最新发布
05-22
这可能涉及到自定义Java代码或者使用现有的数据流工具，如Logstash或Beats，将ClickHouse的数据导入Elasticsearch。 3. **配置Kibana**：在Kibana中设置新的数据源，指向Elasticsearch实例。确保Elasticsearch能够...
jdbc-批量插入数据
04-02
NULL 博文链接：https://sunfish.iteye.com/blog/1455357
JDBC实现纵向导出数据库数据
04-03
NULL 博文链接：https://nirohappy.iteye.com/blog/1482206
MYSQL原生JDBC + maven + idea 一百万数据8秒
weixin_44135909的博客
11-26 199
一百万数据8秒c查询 package test; import java.sql.*; /** *@functon 多线程学习 *@author 林炳文 *@time 2015.3.9 */ class Thread1 extends Thread{ String name; public Thread1( String name) { thi...
原生JDBC连接数据库查询和插入数据
weixin_45399731的博客
03-14 1321
原生JDBC基本不会在工作中写，已经被各种框架所代替，但是不意味着面试/笔试中不会出现，而且这也考量了一个程序员的基础是否扎实 建表 Mysql create table t_test( id BIGINT auto_increment COMMENT '主键', name VARCHAR(20) NOT NULL COMMENT '姓名', age INT NOT NULL COM...
通过jdbc对数据库表导入大量数据
HQXQ2874760112的博客
12-07 1732
在要对数据库表导入大量数据时，使用PrepareStatement加批处理是比较好的，我使用的时候每秒能导入几万数据。 导入jdbc文件，获得连接conn 先conn.setAutoCommit(false) 关闭自动提交 PrepareStatement ps =conn.prepareStatement("insert into <tableName> (id,name)values(?,?)"); 这是插入，执行其他操作也行。 然后再把数据放进去 ps.setInt(1,"101
jdbc批量插入实现大批量数据快速插入
weixin_34347651的博客
02-27 1155
2019独角兽企业重金招聘Python工程师标准>>> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值