JDBC批量插入

最新推荐文章于 2021-07-18 19:24:34 发布
最新推荐文章于 2021-07-18 19:24:34 发布
阅读量370 收藏 1
点赞数 1
分类专栏： javaweb 文章标签： jdbc 优化 




package testbatch; 

import java.io.IOException; 
import java.sql.*; 

/** 
* JDBC批量Insert优化（下） 
* 
* @author leizhimin 2009-7-29 10:03:10 
*/ 
public class TestBatch { 
        public static DbConnectionBroker myBroker = null; 

        static { 
                try { 
                        myBroker = new DbConnectionBroker("com.mysql.jdbc.Driver", 
                                        "jdbc:mysql://192.168.104.163:3306/testdb", 
                                        "vcom", "vcom", 2, 4, 
                                        "c:\\testdb.log", 0.01); 
                } catch (IOException e) { 
                        e.printStackTrace(); 
                } 
        } 

        /** 
         * 初始化测试环境 
         * 
         * @throws SQLException 异常时抛出 
         */ 
        public static void init() throws SQLException { 
                Connection conn = myBroker.getConnection(); 
                conn.setAutoCommit(false); 
                Statement stmt = conn.createStatement(); 
                stmt.addBatch("DROP TABLE IF EXISTS tuser"); 
                stmt.addBatch("CREATE TABLE tuser (\n" + 
                                "    id bigint(20) NOT NULL AUTO_INCREMENT,\n" + 
                                "    name varchar(12) DEFAULT NULL,\n" + 
                                "    remark varchar(24) DEFAULT NULL,\n" + 
                                "    createtime datetime DEFAULT NULL,\n" + 
                                "    updatetime datetime DEFAULT NULL,\n" + 
                                "    PRIMARY KEY (id)\n" + 
                                ") ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8"); 
                stmt.executeBatch(); 
                conn.commit(); 
                myBroker.freeConnection(conn); 
        } 

        /** 
         * 100000条静态SQL插入 
         * 
         * @throws Exception 异常时抛出 
         */ 
        public static void testInsert() throws Exception { 
                init();         //初始化环境 
                Long start = System.currentTimeMillis(); 
                for (int i = 0; i < 100000; i++) { 
                        String sql = "\n" + 
                                        "insert into testdb.tuser \n" + 
                                        "\t(name, \n" + 
                                        "\tremark, \n" + 
                                        "\tcreatetime, \n" + 
                                        "\tupdatetime\n" + 
                                        "\t)\n" + 
                                        "\tvalues\n" + 
                                        "\t('" + RandomToolkit.generateString(12) + "', \n" + 
                                        "\t'" + RandomToolkit.generateString(24) + "', \n" + 
                                        "\tnow(), \n" + 
                                        "\tnow()\n" + 
                                        ")"; 
                        Connection conn = myBroker.getConnection(); 
                        conn.setAutoCommit(false); 
                        Statement stmt = conn.createStatement(); 
                        stmt.execute(sql); 
                        conn.commit(); 
                        myBroker.freeConnection(conn); 
                } 
                Long end = System.currentTimeMillis(); 
                System.out.println("单条执行100000条Insert操作，共耗时：" + (end - start) / 1000f + "秒！"); 
        } 

        /** 
         * 批处理执行静态SQL测试 
         * 
         * @param m 批次 
         * @param n 每批数量 
         * @throws Exception 异常时抛出 
         */ 
        public static void testInsertBatch(int m, int n) throws Exception { 
                init();             //初始化环境 
                Long start = System.currentTimeMillis(); 
                for (int i = 0; i < m; i++) { 
                        //从池中获取连接 
                        Connection conn = myBroker.getConnection(); 
                        conn.setAutoCommit(false); 
                        Statement stmt = conn.createStatement(); 
                        for (int k = 0; k < n; k++) { 
                                String sql = "\n" + 
                                                "insert into testdb.tuser \n" + 
                                                "\t(name, \n" + 
                                                "\tremark, \n" + 
                                                "\tcreatetime, \n" + 
                                                "\tupdatetime\n" + 
                                                "\t)\n" + 
                                                "\tvalues\n" + 
                                                "\t('" + RandomToolkit.generateString(12) + "', \n" + 
                                                "\t'" + RandomToolkit.generateString(24) + "', \n" + 
                                                "\tnow(), \n" + 
                                                "\tnow()\n" + 
                                                ")"; 
                                //加入批处理 
                                stmt.addBatch(sql); 
                        } 
                        stmt.executeBatch();    //执行批处理 
                        conn.commit(); 
//                        stmt.clearBatch();        //清理批处理 
                        stmt.close(); 
                        myBroker.freeConnection(conn); //连接归池 
                } 
                Long end = System.currentTimeMillis(); 
                System.out.println("批量执行" + m + "*" + n + "=" + m * n + "条Insert操作，共耗时：" + (end - start) / 1000f + "秒！"); 
        } 

        /** 
         * 100000条预定义SQL插入 
         * 
         * @throws Exception 异常时抛出 
         */ 
        public static void testInsert2() throws Exception {     //单条执行100000条Insert操作，共耗时：40.422秒！ 
                init();         //初始化环境 
                Long start = System.currentTimeMillis(); 
                String sql = "" + 
                                "insert into testdb.tuser\n" + 
                                "    (name, remark, createtime, updatetime)\n" + 
                                "values\n" + 
                                "    (?, ?, ?, ?)"; 
                for (int i = 0; i < 100000; i++) { 
                        Connection conn = myBroker.getConnection(); 
                        conn.setAutoCommit(false); 
                        PreparedStatement pstmt = conn.prepareStatement(sql); 
                        pstmt.setString(1, RandomToolkit.generateString(12)); 
                        pstmt.setString(2, RandomToolkit.generateString(24)); 
                        pstmt.setDate(3, new Date(System.currentTimeMillis())); 
                        pstmt.setDate(4, new Date(System.currentTimeMillis())); 
                        pstmt.executeUpdate(); 
                        conn.commit(); 
                        pstmt.close(); 
                        myBroker.freeConnection(conn); 
                } 
                Long end = System.currentTimeMillis(); 
                System.out.println("单条执行100000条Insert操作，共耗时：" + (end - start) / 1000f + "秒！"); 
        } 

        /** 
         * 批处理执行预处理SQL测试 
         * 
         * @param m 批次 
         * @param n 每批数量 
         * @throws Exception 异常时抛出 
         */ 
        public static void testInsertBatch2(int m, int n) throws Exception { 
                init();             //初始化环境 
                Long start = System.currentTimeMillis(); 
                String sql = "" + 
                                "insert into testdb.tuser\n" + 
                                "    (name, remark, createtime, updatetime)\n" + 
                                "values\n" + 
                                "    (?, ?, ?, ?)"; 
                for (int i = 0; i < m; i++) { 
                        //从池中获取连接 
                        Connection conn = myBroker.getConnection(); 
                        conn.setAutoCommit(false); 
                        PreparedStatement pstmt = conn.prepareStatement(sql); 
                        for (int k = 0; k < n; k++) { 
                                pstmt.setString(1, RandomToolkit.generateString(12)); 
                                pstmt.setString(2, RandomToolkit.generateString(24)); 
                                pstmt.setDate(3, new Date(System.currentTimeMillis())); 
                                pstmt.setDate(4, new Date(System.currentTimeMillis())); 
                                //加入批处理 
                                pstmt.addBatch(); 
                        } 
                        pstmt.executeBatch();    //执行批处理 
                        conn.commit(); 
//                        pstmt.clearBatch();        //清理批处理 
                        pstmt.close(); 
                        myBroker.freeConnection(conn); //连接归池 
                } 
                Long end = System.currentTimeMillis(); 
                System.out.println("批量执行" + m + "*" + n + "=" + m * n + "条Insert操作，共耗时：" + (end - start) / 1000f + "秒！"); 
        } 

        public static void main(String[] args) throws Exception { 
                init(); 
                Long start = System.currentTimeMillis(); 
                System.out.println("--------C组测试----------"); 
                testInsert(); 
                testInsertBatch(100, 1000); 
                testInsertBatch(250, 400); 
                testInsertBatch(400, 250); 
                testInsertBatch(500, 200); 
                testInsertBatch(1000, 100); 
                testInsertBatch(2000, 50); 
                testInsertBatch(2500, 40); 
                testInsertBatch(5000, 20); 
                Long end1 = System.currentTimeMillis(); 
                System.out.println("C组测试过程结束，全部测试耗时：" + (end1 - start) / 1000f + "秒！"); 

                System.out.println("--------D组测试----------"); 
                testInsert2(); 
                testInsertBatch2(100, 1000); 
                testInsertBatch2(250, 400); 
                testInsertBatch2(400, 250); 
                testInsertBatch2(500, 200); 
                testInsertBatch2(1000, 100); 
                testInsertBatch2(2000, 50); 
                testInsertBatch2(2500, 40); 
                testInsertBatch2(5000, 20); 

                Long end2 = System.currentTimeMillis(); 
                System.out.println("D组测试过程结束，全部测试耗时：" + (end2 - end1) / 1000f + "秒！"); 
        } 
}


Java - JDBC批量插入原理
xxxzzzqqq_的博客
03-13 693
本实验将通过以下三步进行a. 记录jdbc在mysql中批量执行和单条执行的耗时b. 记录jdbc在oracle中批量执行和单条执行的耗时c. 记录oracle plsql批量执行和单条执行的耗时相关java和数据库版本如下：Java17，Mysql8，Oracle11Gmysql的批量执行就是改写sql。oracle的批量执行就是用的forall。选择一个合适批量值。
java 高效批量插入 sqlserver 数据库
热门推荐
longtingjing的专栏
10-02 1万+
@Test public void clockingIn_Img() throws Exception{ DbJdbc idb = DbMaster.getIDB("JXT"); List pays=idb.getBeanList("select top 100000 * from jxt_pay_info", Jxt_pay_info.class); //可以用idb进行测试了。。
JDBC批量插入数据优化,使用addBatch和executeBatch
weixin_33968104的博客
04-28 219
>>.在之前的玩转JDBC打造数据库操作万能工具类JDBCUtil，加入了高效的数据库连接池，利用了参数绑定有效防止SQL注入中其实忽略了一点，那就是SQL的批量插入的问题，如果来个for循环，执行上万次，肯定会很慢，那么，如何去优化呢？ https://www.awaimai.com/841.html 一.用 preparedStatement.addBatch()配合pr...
scala读取csv文件批量插入数据库
E的小小地方
08-10 5086
import java.io.FileWriter import scala.io.Source /** * 通过CSV文件，及其预处理的字段类型字符串，输出insert语句 */ class csv2InsertSQLServer { /** * @param CLASS_PATH 输入/输出路径 * @param inFilename 输入文件名 * @param tableN...
Scala JDBC操作数据库
whgyxy的博客
03-22 1023
Scala 操作数据库（查询、插入、更新） Scala操作数据库需要载入 java.sql.DriverManager ，我们分为查询和插入两个模块进行，每个模块也分为一条记录和多条记录来操作 首先，需要导入必须的信息，定义你要访问的JDBC地址和你的表名 import java.sql.DriverManager import org.joda.time.DateTime import sc...
jdbc批量插入实现大批量数据快速插入
weixin_34347651的博客
02-27 1193
2019独角兽企业重金招聘Python工程师标准>>> ...
使用JDBC在MySQL数据库中快速批量插入数据
Mr__fang的专栏
06-23 1282
原文地址：http://blog.csdn.net/whucyl/article/details/20838079 使用JDBC连接MySQL数据库进行数据插入的时候，特别是大批量数据连续插入（10W+），如何提高效率呢？ 在JDBC编程接口中Statement 有两个方法特别值得注意： void addBatch() throws SQLException
java实现jdbc批量插入数据
09-02
本篇文章将详细介绍如何使用Java实现JDBC批量插入数据，并比较三种常见的JDBC批量插入编程方法。 **方法一：使用PreparedStatement加批量的方法** PreparedStatement是Statement的子接口，允许预编译SQL语句，这...
Mybatis与JDBC批量插入MySQL数据库性能测试
04-13
本文将探讨Mybatis和JDBC在批量插入MySQL数据库时的性能差异，并提供相关的测试资源。 首先，JDBC（Java Database Connectivity）是Java平台中用于与数据库交互的一种规范，它允许程序员使用SQL语句直接操作数据库...
JDBC批量插入 更新 删除等操作
03-23
#### 一、JDBC批量插入 JDBC（Java Database Connectivity）是Java平台中用来标准地连接数据库的技术。通过JDBC，Java应用程序可以与多种类型的数据库进行交互，实现数据的读取、写入等功能。批量操作是指在一次...
jdbc批量插入大字段
07-08
因此，"jdbc批量插入大字段"这个话题旨在探讨如何高效地通过Java JDBC来实现Blob字段的批量插入，以提高性能。 首先，我们需要了解JDBC（Java Database Connectivity），它是Java编程语言与各种数据库之间通信的...
scala写jdbc连接数据库 实现数据库的批量操作
fljiaoyuxue的博客
07-18 332
结构 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-
使用batch insert解决MySQL的insert吞吐量问题
weixin_34138255的博客
06-11 598
最近使用了一个非常简单易用的方法解决了业务上的一个insert吞吐量的问题，在此总结一下。 首先我们明确一下，insert吞吐量其实并不是指的IPS（insert per second），而是指的RPS（effect rows per second）。 其次我们再说一下batch insert，其实顾名思义，就是批量插入。这种优化思想是很基本的，MySQL中最出名的应用就是group c...
Scala 通过JDBC操作数据库，增删改查
tang_xiaotang的博客
07-01 1736
1.改，update //连接信息 val onlineUrl = "jdbc:mysql://" val username = "root" val password = "1234" def getOnlineConnection(): sql.Connection = { DriverManager.getConnection(onlineUrl...
jdbc批量执行SQL insert 操作
weixin_34293902的博客
06-20 521
package com.file;      import java.io.BufferedReader;   import java.io.FileReader;   import java.util.ArrayList;      public class ResolvFile {       public static String readFileContent(Stri...
工业自动化中基于威纶通触摸屏的水箱液位PID控制仿真程序设计与实现
最新发布
04-26
内容概要：本文详细介绍了如何利用威纶通触摸屏及其配套软件EasyBuilder Pro构建一个水箱液位控制的PID仿真程序。主要内容涵盖触摸屏界面设计、PID算法实现、通信配置以及仿真模型搭建等方面。文中不仅提供了具体的代码示例，还分享了许多调试经验和优化技巧，如抗积分饱和处理、通信同步设置等。此外，作者还强调了实际应用中的注意事项，例如参数范围限制、突发情况模拟等。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是对PID控制器有一定了解并希望深入掌握其实际应用的人群。 使用场景及目标：适用于需要进行水箱液位控制系统设计、调试和优化的工作环境。主要目标是帮助读者理解和掌握PID控制的基本原理及其在实际工程项目中的具体实现方法。 其他说明：附带完整的工程文件可供下载，便于读者快速上手实践。文中提到的所有代码片段均经过实际验证，确保可靠性和实用性。
2024年中国城市低空经济发展指数报告
04-25
内容概要：《2024年中国城市低空经济发展指数报告》由36氪研究院发布，指出低空经济作为新质生产力的代表，已成为中国经济新的增长点。报告从发展环境、资金投入、创新能力、基础支撑和发展成效五个维度构建了综合指数评价体系，评估了全国重点城市的低空经济发展状况。北京和深圳在总指数中名列前茅，分别以91.26和84.53的得分领先，展现出强大的资金投入、创新能力和基础支撑。低空经济主要涉及无人机、eVTOL（电动垂直起降飞行器）和直升机等产品，广泛应用于农业、物流、交通、应急救援等领域。政策支持、市场需求和技术进步共同推动了低空经济的快速发展，预计到2026年市场规模将突破万亿元。 适用人群：对低空经济发展感兴趣的政策制定者、投资者、企业和研究人员。 使用场景及目标：①了解低空经济的定义、分类和发展驱动力；②掌握低空经济的主要应用场景和市场规模预测；③评估各城市在低空经济发展中的表现和潜力；④为政策制定、投资决策和企业发展提供参考依据。 其他说明：报告强调了政策监管、产业生态建设和区域融合错位的重要性，提出了加强法律法规建设、人才储备和基础设施建设等建议。低空经济正加速向网络化、智能化、规模化和集聚化方向发展，各地应找准自身比较优势，实现差异化发展。
多智能体协同编队控制：无人机编队背后的Python实现与关键技术解析
04-25
内容概要：本文详细介绍了多智能体协同编队控制的技术原理及其Python实现。首先通过生动形象的例子解释了编队控制的核心概念，如一致性算法、虚拟结构法、预测补偿等。接着深入探讨了编队形状的设计方法，包括如何利用虚拟结构法生成特定编队形状，并讨论了通信质量和参数调试的重要性。此外，还涉及了避障策略、动态权重分配以及故障检测等实际应用中的挑战和解决方案。最后，通过具体实例展示了如何将理论应用于实际项目中，如无人机编队表演、自动驾驶车队等。 适用人群：对多智能体系统、编队控制感兴趣的科研人员、工程师及高校师生。 使用场景及目标：适用于研究和开发多智能体协同编队控制系统的场景，旨在帮助读者理解并掌握相关技术和实现方法，提高系统的稳定性和可靠性。 其他说明：文中不仅提供了详细的代码示例，还分享了许多实践经验和技术细节，有助于读者更好地理解和应用这些技术。同时强调了参数调试、通信质量、预测补偿等方面的关键因素对于系统性能的影响。
四旋翼飞行器模型预测控制(MPC)的Matlab实现及其设定点收敛保证
04-25
内容概要：本文详细介绍了名为'MPC_ACC_2020-master'的四旋翼飞行器模型预测跟踪控制器(Matlab实现)。四旋翼飞行器由于其高度非线性和强耦合特性，在复杂环境中难以实现精准控制。模型预测控制（MPC）通过预测未来状态并在每一步进行在线优化，解决了这一难题。文中展示了关键代码片段，解释了系统参数定义、初始化、预测模型构建、成本函数构建、优化求解及控制输入的应用。此外，还探讨了MPC_ACC_2020-master如何通过精心设计的成本函数和优化算法确保四旋翼飞行器状态收敛到设定点。 适合人群：从事飞行器控制领域的研究人员和技术爱好者，尤其是对模型预测控制感兴趣的开发者。 使用场景及目标：适用于四旋翼飞行器的轨迹跟踪任务，旨在提高飞行器在复杂环境下的稳定性与准确性。具体应用场景包括但不限于无人机竞速、自动巡航、物流配送等。 其他说明：尽管该项目主要用于科研目的，但其简洁高效的代码结构也为实际工程应用提供了良好借鉴。同时，项目中存在一些待改进之处，如状态估计部分未考虑真实情况下的噪声干扰，后续版本计划移植到C++并集成进ROS系统。
jdbc批量插入
05-30
JDBC批量插入是一种快速插入大量数据的方法，具体实现如下： 1. 创建数据库连接并设置自动提交为false： ```java Connection conn = DriverManager.getConnection(url, username, password); conn.setAutoCommit(false); ``` 2. 创建PreparedStatement对象，并设置SQL语句： ```java PreparedStatement pstmt = conn.prepareStatement("insert into table_name (column1, column2, ...) values (?, ?, ...)"); ``` 3. 设置参数： ```java pstmt.setString(1, value1); pstmt.setInt(2, value2); ... ``` 4. 将PreparedStatement添加到批处理中： ```java pstmt.addBatch(); ``` 5. 执行批处理： ```java int[] results = pstmt.executeBatch(); ``` 6. 提交事务并关闭连接： ```java conn.commit(); conn.close(); ``` 其中，executeBatch()方法返回的是一个int数组，表示每条SQL语句执行后的结果。如果返回值为0，则表示执行失败；如果返回值为正整数，则表示受影响的行数。 注意事项： 1. 批量插入的数据量应该越大越好，但也不能过大，否则可能会导致内存溢出。建议每次插入的数据量在1000条左右。 2. 在插入大量数据时，为了提高效率，应该将批处理语句放在一个事务中执行，这样可以减少数据库的IO操作，提高数据插入速度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值