-
2021-03-08 14:35:45
用批处理方法:
public boolean updateLocation(String[] obj1,String[] obj) throws SQLException {
Connection conn = getConnection();
try{
// 保存当前自动提交模式
boolean autoCommit = conn.getAutoCommit();
// 关闭自动提交
conn.setAutoCommit(false);
Statement stmt = conn.createStatement();
// 使用Statement同时收集多条sql语句
String[] sql = new String[10];
for(int i=0;i<10;i++){
stmt.addBatch(sql[i]);
}
// 同时提交所有的sql语句
stmt.executeBatch();
// 提交修改
conn.commit();
conn.setAutoCommit(autoCommit);
} catch( Exception e){
e.printStackTrace();
conn.rollback();
}
return false;
}
更多相关内容 -
mysql,jdbc详解,与ibatis对比。批量查询,分页处理。
2017-12-29 17:06:04mysq增删改查,jdbc 驱动加载 各个类和接口详解,与ibatis对比。批量查询,分页处理。 -
Spring JDBC批量操作
2021-02-28 15:17:19以下示例将演示如何使用spring jdbc进行批量更新。我们将在单次批次操作中更新student表中的记录。student表的结果如下 -CREATE TABLE student(id INT NOT NULL AUTO_INCREMENT,name VARCHAR(20) NOT NULL,age INT ...以下示例将演示如何使用spring jdbc进行批量更新。我们将在单次批次操作中更新student表中的记录。
student表的结果如下 -
CREATE TABLE student(
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(20) NOT NULL,
age INT NOT NULL,
PRIMARY KEY (id)
);
SQL
语法:
String SQL = "update Student set age = ? where id = ?";
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,
new BatchPreparedStatementSetter() {
public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setInt(1, students.get(i).getAge());
ps.setInt(2, students.get(i).getId());
}
public int getBatchSize() {
return students.size();
}
});
Java
在上面语法中 -
SQL - 更新语句以更新学生的年龄。
BatchPreparedStatementSetter - 批量执行者,在PerparedStatement对象中设置每个项目的值,由学生对象和索引i列出。 getBatchSize()返回批处理的数量。
jdbcTemplateObject - NamedParameterJdbcTemplate对象来更新数据库中的学生对象。
updateCounts - int数组包含每个更新查询更新的行计数(数量)。
创建项目
要了解上面提到的Spring JDBC相关的概念,这里创建一个项目用来演示如何执行批量更新。打开Eclipse IDE,并按照以下步骤创建一个名称为:BatchOperation 的Spring应用程序项目。
步骤说明
参考第一个Spring JDBC项目来创建一个Maven项目 - http://www.yiibai.com/springjdbc/first_application.html
更新bean配置并运行应用程序。
完整的项目结构如下所示 -
文件 : pom.xml 的内容 -
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.0.0
com.yiibai
BatchOperation
0.0.1-SNAPSHOT
jar
BatchOperation
http://maven.apache.org
junit
junit
3.8.1
test
mysql
mysql-connector-java
5.1.40
org.springframework
spring-jdbc
4.1.0.RELEASE
org.springframework
spring-context
4.1.4.RELEASE
以下是数据访问对象接口文件:StudentDAO.java的代码内容:
package com.yiibai;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize database resources ie.
* connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down all the records from the
* Student table.
*/
public List listStudents();
public void create(String name, Integer age);
public void batchUpdate(final List students);
}
Java
以下是文件:Student.java的代码内容:
package com.yiibai;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
Java
以下是文件:StudentMapper.java的代码内容:
package com.yiibai;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
Java
以下是文件:StudentJDBCTemplate.java的代码内容:
package com.yiibai;
import java.sql.PreparedStatement;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import java.sql.SQLException;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List listStudents() {
String SQL = "select * from Student";
List students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
public void batchUpdate(final List students) {
String SQL = "update Student set age = ? where id = ?";
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL, new BatchPreparedStatementSetter() {
public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setInt(1, students.get(i).getAge());
ps.setInt(2, students.get(i).getId());
}
public int getBatchSize() {
return students.size();
}
});
System.out.println("Records updated!");
}
public void create(String name, Integer age) {
// TODO Auto-generated method stub
String insertQuery = "insert into student (name, age) values (?, ?)";
jdbcTemplateObject.update( insertQuery, name, age);
System.out.println("Created Record Name = " + name + " Age = " + age);
return;
}
}
Java
以下是程序执行入口文件:MainApp.java的代码内容:
package com.yiibai;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.yiibai.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("application-beans.xml");
StudentJDBCTemplate studentJDBCTemplate = (StudentJDBCTemplate) context.getBean("studentJDBCTemplate");
System.out.println("------Records Creation--------");
studentJDBCTemplate.create("Maxsu", 21);
studentJDBCTemplate.create("Curry", 22);
studentJDBCTemplate.create("Weiwei", 25);
List initialStudents = studentJDBCTemplate.listStudents();
System.out.println("Initial Students");
for (Student student2 : initialStudents) {
System.out.print("ID : " + student2.getId());
System.out.println(", Age : " + student2.getAge());
}
Student student = new Student();
student.setId(1);
student.setAge(25);
Student student1 = new Student();
student1.setId(3);
student1.setAge(25);
List students = new ArrayList();
students.add(student);
students.add(student1);
studentJDBCTemplate.batchUpdate(students);
List updatedStudents = studentJDBCTemplate.listStudents();
System.out.println("Updated Students");
for (Student student3 : updatedStudents) {
System.out.print("ID : " + student3.getId());
System.out.println(", Age : " + student3.getAge());
}
}
}
Java
以下是Bean和数据库配置文件:application-beans.xml的代码内容:
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
XML
注意: application-beans.xml 文件的位置是:{workspace}/fistapp/src/main/java 目录,如果放置错了,程序可能会因为找不到此配置文件而出错。
完成创建源代码和bean和数据库连接信息的文件配置后,运行应用程序。这里先简单说明一下运行的步骤,在项目名称(BatchOperation)上点击右键,在弹出的菜单中选择:【Run As】-> 【Maven test】
在运行测试成功后,应该会输出类似以下内容(含有 BUILD SUCCESS 的信息) 。
接下来,点击类文件:MainApp.java 选择【Run As】->【Java Application】,如果应用程序一切正常,这将打印以下消息:
------Records Creation--------
Created Record Name = Maxsu Age = 21
Created Record Name = Curry Age = 22
Created Record Name = Weiwei Age = 25
Initial Students
ID : 1, Age : 21
ID : 2, Age : 22
ID : 3, Age : 25
Records updated!
Updated Students
ID : 1, Age : 25
ID : 2, Age : 22
ID : 3, Age : 25
Shell
数据库中的student表中的数据被修改为:
mysql> select * from student;
+----+--------+-----+
| id | name | age |
+----+--------+-----+
| 1 | Maxsu | 25 |
| 2 | Curry | 22 |
| 3 | Weiwei | 25 |
+----+--------+-----+
3 rows in set
mysql>
-
java实现jdbc批量插入数据
2020-09-02 09:42:06主要为大家详细介绍了java实现jdbc批量插入数据,三种JDBC批量插入编程方法进行比较,感兴趣的朋友可以参考一下 -
jdbc-批量插入数据
2019-04-02 02:02:07NULL 博文链接:https://sunfish.iteye.com/blog/1455357 -
Java之JDBC-批量操作
2018-04-10 20:08:511.增加插入1000条数据,查看各种方法所需要的时间:*普通方式:package com.test.jdbc; import java.sql.*; /** * @Author: cxx * @Date: 2018/4/10 18:22 */ public class JdbcTest { public static void ...1.增加
插入1000条数据,查看各种方法所需要的时间:
*普通方式:
package com.test.jdbc; import java.sql.*; /** * @Author: cxx * @Date: 2018/4/10 18:22 */ public class JdbcTest { public static void main(String[] args) { Connection conn = null; PreparedStatement cmd = null; ResultSet rs = null; try { long start = System.currentTimeMillis(); conn = JdbcUtil.getConnection(); conn.setAutoCommit(false); cmd = conn.prepareStatement("insert into news (title,context) values (?,?)"); for (int i = 0; i < 1000; i++) {//100万条数据 cmd.setString(1, "test"+i); cmd.setString(2, "values"); cmd.executeUpdate(); System.out.println(i); } conn.commit(); JdbcUtil.close(conn,cmd,rs); long end = System.currentTimeMillis(); System.out.println("花费的时间:"+(end - start));//158918毫秒 }catch (SQLException e) { e.printStackTrace(); } } }
批量增加1000条时,只用了18秒
package com.test.jdbc; import java.sql.*; /** * @Author: cxx * @Date: 2018/4/10 18:22 */ public class JdbcTest { public static void main(String[] args) { Connection conn = null; PreparedStatement cmd = null; ResultSet rs = null; try { long start = System.currentTimeMillis(); conn = JdbcUtil.getConnection(); conn.setAutoCommit(false); cmd = conn.prepareStatement("insert into news (title,context) values (?,?)"); for (int i = 0; i < 1000; i++) {//100万条数据 cmd.setString(1, "test"+i); cmd.setString(2, "values"); cmd.addBatch(); if (i%500==0){ System.out.println(i); cmd.executeBatch(); } } conn.commit(); JdbcUtil.close(conn,cmd,rs); long end = System.currentTimeMillis(); System.out.println("花费的时间:"+(end - start));//158918毫秒 }catch (SQLException e) { e.printStackTrace(); } } }
-
JDBC PreparedStatement 批量查询 in 的实现 方案
2019-03-18 10:34:21我们经常会有这种业务需求,根据一个条件集合去查询一张表的数据,比如: select*fromall_element twheret.task_idin(List<taskids>); 在java语言中,我们需要用到JDBC来和数据库打交道,那么在JDBC中...我们经常会有这种业务需求,根据一个条件集合去查询一张表的数据,比如:
select * from all_element t where t.task_id in (List <taskids>);
在java语言中,我们需要用到JDBC来和数据库打交道,那么在JDBC中该如何处理这种需求呢?我们可以有如下几种处理方式方案一:写一个函数把参数集合转换成一个or 条件 或 in 条件的字符串,最后拼成一个sql
select * from all_element t where t.task_id in (123 ,456, 789);
或者是:
select * from all_element t where t.task_id=123 or t.task_id= 456 t.task_id= 789;但是这样效率如何呢?我们知道Oracle对传过来的SQL是需要事先编译的,不过是Oracle有个缓存功能可以缓存编译好的SQL,但前提是传过来的SQL必须完全一致,很明显,如果按照以上方式的话,一旦taskid值变化,那么Oracle的缓存便无法利用。
方案二:使用预编译的PrepareStatement
为了解决Oracle缓存无法利用问题,Jdbc提供了预编译的PrepareStatement,对于变化的参数可以用占位符 <?> 来代替,因此我们可以用占位符来减少Oracle编译次数。
private static final String QUERY = "select * from all_element where taskId = ?";
ps = con .prepareStatement(QUERY);
for(String taskId : taskIds){
ps.setInt(1, taskId);
rs = ps .executeQuery();
}
这样做虽然可以很好的利用Oracle的缓存,但缺点也很明显,就是每一个Id都需要查询数据库一次,这样效率是极低的。方案三:动态地创建PrepareStatement
虽然变化的参数可以用占位符 <?> 来代替,然而遗憾的是Jdbc只提供了单一占位符功能即占位符不能是一个可迭代的集合。因此,对于我们传过来的集合参数,我们可以动态地创建一个PrepareStatement:
拼一个和集合大小相等数量占位符的SQL,再写一个循环来赋值每一个占位符,这样就可以解决taskId的值变化而导致Oracle重新编译SQL问题。
private static void createQuery(List<String> taskIds) {
String query = "select * from all_element t where t.task_id in (";
StringBuilder queryBuilder = new StringBuilder(query);
for ( int i = 0; i < taskIds.size(); i++) {
queryBuilder.append( " ?");
if (i != taskIds.size() - 1)
queryBuilder.append( ",");
}
queryBuilder.append( ")");
ps = con .prepareStatement(query);
for ( int i = 1; i <= taskIds.size(); i++) {
ps.setInt(i, taskIds.get(i - 1));
}
rs = ps .executeQuery();
}
但是这么做还是存在一个问题,如果集合的值变化不会导致Oracle重新编译,但是如果集合的大小发生变化,相对应的SQL也就发生了变化,同样也会导致Oracle重新编译,那么该如何解决这个问题呢?方案四:批量查询(减少查询次数并利用到Oracle缓存)
批量查询兼顾了第二、第三种方案,其思想是预先定义好几个每次要查询参数的个数,然后把参数集合按这些定义好的值划分成小组。比如我们的前台传过来一个数量为75的taskId的集合,我预定义的批量查询参数的个数分别为:
SINGLE_BATCH = 1;//注意:为了把参数集合完整划分,这个值为1的批量数是必须的
SMALL_BATCH = 4;
MEDIUM_BATCH = 11;
LARGE_BATCH = 51;那么我们第一次会查询51条数据,还剩下24个没有查询,那么第二次批量查询11条数据,还剩下13条未查询,第三次再批量查询11条数据,最后还剩2条未查询,那么我们再分两批次,每批次仅查询一条,这样,最终一个75条的数据分5批次即可查询完成,减少了查询次数,而且还利用到了数据库缓存。附获取批量的算法:
public static final int SINGLE_BATCH = 1; //注意:为了把参数集合完整划分,这个值为1的批量数是必须的
public static final int SMALL_BATCH = 4;
public static final int MEDIUM_BATCH = 11;
public static final int LARGE_BATCH = 51;
static int totalNumberOfValuesLeftToBatch=75;
public static List<Integer> getBatchSize( int totalNumberOfValuesLeftToBatch){
List<Integer> batches= new ArrayList<Integer>();
while ( totalNumberOfValuesLeftToBatch > 0 ) {
int batchSize = SINGLE_BATCH;
if ( totalNumberOfValuesLeftToBatch >= LARGE_BATCH ) {
batchSize = LARGE_BATCH;
} else if ( totalNumberOfValuesLeftToBatch >= MEDIUM_BATCH ) {
batchSize = MEDIUM_BATCH;
} else if ( totalNumberOfValuesLeftToBatch >= SMALL_BATCH ) {
batchSize = SMALL_BATCH;
}
batches.add(batchSize);
totalNumberOfValuesLeftToBatch -= batchSize;
System. out.println(batchSize);
}
return batches;
}
---------------------
作者:Heaven-Wang
来源:CSDN
原文:https://blog.csdn.net/suifeng3051/article/details/24033237
版权声明:本文为博主原创文章,转载请附上博文链接! -
JAVA—JDBC数据库查询小程序
2013-12-29 19:15:04JAVA封装JDBC查询数据库小程序,内含增、删、改、查数据库基本功能,提供模糊查询等附加功能。 此小程序各类封装完整,可作为初学者面向对象封装思维的一次练习模板。 -
JdbcTemplate 实现批量查询
2021-08-23 16:18:02使用spring的JdbcTemplate可以进行数据库crud。...这种批量查询可以使用 NamedParameterJdbcTemplate 来进行查询。 List<String> idList = new ArrayList<>(); String sql = select * fr -
mysql JDBC批量操作
2017-01-05 11:53:54private static void insertData() throws SQLException { DruidDataSource dataSource = new DruidDataSource(); dataSource.setUrl("jdbc:mysql://ip:3306/cms?rewriteBatchedStatements=true"); -
Java jdbc批量多线程读取CVS文件入库
2020-08-25 16:38:07主要为大家详细介绍了Java jdbc批量多线程读取CVS文件入库,具有一定的参考价值,感兴趣的小伙伴们可以参考一下 -
JDBC批量操作批量增加批量修改
2021-02-22 13:37:56批量增加 利用JdbcTemplate的batchUpdate方法 有两个参数,第一个是Sql语句,第二个是list集合 代码: 1.先在service中创建方法(已经有了增删改查方法,现在加上) public void batchAdd(List<Object[]>... -
JDBC批量插入
2021-02-27 18:31:041.Statement:提供addBatch(String sql) 和 excuteBatch()方法批量更新数据Connection conn=DriverManager.getConnection(url, "root", "admin");Statement stmt=conn.createStatement();stmt.addBatch("insert into ... -
JDBC连接MySQL数据库批量插入数据过程详解
2020-08-25 09:56:42主要介绍了JDBC连接MySQL数据库批量插入数据过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 -
jdbc 大批量更新 oracle数据库中的数据
2021-05-01 08:21:10jdbc 大批量更新 oracle数据库中的数据我用的是PreparedStatement来发送提交,并且数据量非常庞大。一次需要执行8900多条更新语句,也就是Update语句。我试过分开,一部分一部分来执行提交,但还是一样的速度慢,... -
jdbc中mysql多条SQL批量操作(CRUD)
2021-12-28 16:15:35jdbc:mysql://192.168.1.21:3306/database?useUnicode=true&characterEncoding=UTF8&rewriteBatchedStatements=true&serverTimezone=Asia/Shanghai&allowMultiQueries=true jdbc-url中必须加上... -
jdbc批量更新数据
2021-02-07 09:24:43} spring jdbc批量入库 //采用insert into replace 检测手机号码是否存在,存在更新,不存在新增 String sql = "insert into push_token(token,mobile) values(?,?) on DUPLICATE KEY UPDATE token = ?"; List args... -
jdbc可以支持批量查询么
2012-08-31 03:06:22我将一列sql语句打包成数组传到数据库连接类,想通过执行sql数组返回表中一列的List,可以实现么 -
JDBC批量插入 更新 删除等操作
2012-03-23 00:40:54一、JDBC的批量插入 一、JDBC的批量更新 一、JDBC的批量删除 一、JDBC的批量修改 -
八、JDBC批量处理sql语句
2018-05-29 16:58:28业务场景:当需要向数据库发送一批SQL语句执行时,应避免向数据库一条条的发送执行,而应采用JDBC的批处理机制,以提升执行效率。实现批处理的第一种方式采用如下方法:Statement.addBatch(sql)执行批处理SQL语句... -
软件测试中使用JDBC插入大量数据的性能测试
2021-03-23 16:27:18jdbc数据软件测试中使用JDBC插入大量数据的性能测试使用jdbc向数据库插入100000条记录,分别使用statement,PreparedStatement,及PreparedStatement+批处理3种方式进行测试:1、使用statement插入100000条记录... -
jdbc 批量执行sql
2021-06-02 09:42:38最近有个需求是需要在java 后端执行导入,数据量比较大, 需要对数据进行很多操作,...直接使用了jdbctemplate内部封装的batchUpdate方法,他的底层也是用了 jdbc 的批量执行,但是执行效率要比 正常使用jdbc 批量执行要. -
JdbcTemplate查询与批量更新
2018-09-11 20:01:08JdbcTemplate是将spring与jdbc进行了整合,可以简化数据库操作,相比Hibernate、Mybatis感觉配置少很多,用起来有点像springboot的JPA,但是会比它臃肿一些。 2.应用 2.1 配置 采用数据库连接池 <bean ... -
JDBC批量处理操作Batch方法
2021-06-03 15:50:28使用之前,需要在连接数据库的...package jdbc.batch; import org.junit.jupiter.api.Test; import java.io.FileInputStream; import java.sql.Connection; import java.sql.DriverManager; import java.sql.Prepared -
JDBC批量执行SQL
2021-03-06 20:34:14批量执行SQL,效率比较高,但执行SQL太多,谨防内存溢出。代码案例一:package com.what21.jdbc.demo05;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.sql.... -
Mybatis与JDBC批量插入MySQL数据库性能测试
2017-04-13 14:47:19Mybatis与JDBC批量插入MySQL数据库性能测试,资源包含文档、代码和数据库。 -
jdbc批量插入的4种方式【百万条数据插入只需几秒】
2021-12-21 19:01:19解决批量插入【BatchUpdateException】异常,以及4秒插入100W条数据 -
JDBC的批量批量插入
2021-01-27 15:59:50JDBC的批量插入使用MySQL的Batch批量处理,JDBC驱动版本需要5.1.13或以上测试使用的JDBC驱动版本:mysql-connector-java-5.1.18-bin(一开始我忽略掉这个jar包的条件要求了,使用的是mysql-connector-java-5.1.6-bin.... -
jdbc批量插入大字段
2013-07-08 09:34:50针对oracle中blob字段的操作,能批量快速的插入大字段,效率非常高