精华内容
下载资源
问答
  • java jdbc批量操作大量oracle数据如何提高性能?
    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;

    }

    更多相关内容
  • mysq增删改查,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配置并运行应用程序。

    完整的项目结构如下所示 -

    1270763832644b2c1485085d56a6108c.png

    文件 : 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批量插入数据,三种JDBC批量插入编程方法进行比较,感兴趣的朋友可以参考一下
  • jdbc-批量插入数据

    2019-04-02 02:02:07
    NULL 博文链接:https://sunfish.iteye.com/blog/1455357
  • Java之JDBC-批量操作

    千次阅读 2018-04-10 20:08:51
    1.增加插入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();
            }
    
        }
    }

    
                                            
    展开全文
  • 我们经常会有这种业务需求,根据一个条件集合去查询一张表的数据,比如: select*fromall_element twheret.task_idin(List&lt;taskids&gt;); 在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查询数据库小程序,内含增、删、改、查数据库基本功能,提供模糊查询等附加功能。 此小程序各类封装完整,可作为初学者面向对象封装思维的一次练习模板。
  • 使用spring的JdbcTemplate可以进行数据库crud。...这种批量查询可以使用 NamedParameterJdbcTemplate 来进行查询。 List<String> idList = new ArrayList<>(); String sql = select * fr
  • mysql JDBC批量操作

    2017-01-05 11:53:54
    private static void insertData() throws SQLException { DruidDataSource dataSource = new DruidDataSource(); dataSource.setUrl("jdbc:mysql://ip:3306/cms?rewriteBatchedStatements=true");
  • 主要为大家详细介绍了Java jdbc批量多线程读取CVS文件入库,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 批量增加 利用JdbcTemplate的batchUpdate方法 有两个参数,第一个是Sql语句,第二个是list集合 代码: 1.先在service中创建方法(已经有了增删改查方法,现在加上) public void batchAdd(List<Object[]>...
  • JDBC批量插入

    2021-02-27 18:31:04
    1.Statement:提供addBatch(String sql) 和 excuteBatch()方法批量更新数据Connection conn=DriverManager.getConnection(url, "root", "admin");Statement stmt=conn.createStatement();stmt.addBatch("insert into ...
  • 主要介绍了JDBC连接MySQL数据库批量插入数据过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • jdbc 大批量更新 oracle数据库中的数据我用的是PreparedStatement来发送提交,并且数据量非常庞大。一次需要执行8900多条更新语句,也就是Update语句。我试过分开,一部分一部分来执行提交,但还是一样的速度慢,...
  • jdbc: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...
  • 我将一列sql语句打包成数组传到数据库连接类,想通过执行sql数组返回表中一列的List,可以实现么
  • 一、JDBC批量插入 一、JDBC批量更新 一、JDBC批量删除 一、JDBC批量修改
  • 八、JDBC批量处理sql语句

    千次阅读 2018-05-29 16:58:28
    业务场景:当需要向数据库发送一批SQL语句执行时,应避免向数据库一条条的发送执行,而应采用JDBC的批处理机制,以提升执行效率。实现批处理的第一种方式采用如下方法:Statement.addBatch(sql)执行批处理SQL语句...
  • jdbc数据软件测试中使用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:08
    JdbcTemplate是将spring与jdbc进行了整合,可以简化数据库操作,相比Hibernate、Mybatis感觉配置少很多,用起来有点像springboot的JPA,但是会比它臃肿一些。 2.应用 2.1 配置 采用数据库连接池 &lt;bean ...
  • 使用之前,需要在连接数据库的...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数据库性能测试,资源包含文档、代码和数据库。
  • 解决批量插入【BatchUpdateException】异常,以及4秒插入100W条数据
  • JDBC批量批量插入

    2021-01-27 15:59:50
    JDBC批量插入使用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字段的操作,能批量快速的插入大字段,效率非常高

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,666
精华内容 25,066
关键字:

jdbc批量查询