【Spring Data Access】JdbcTemplate 批量插入

最新推荐文章于 2024-08-07 17:16:40 发布
最新推荐文章于 2024-08-07 17:16:40 发布
阅读量8.1k 收藏 6
点赞数 2
分类专栏： spring框架 Spring技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjlovefj/article/details/82878800
版权

JdbcTemplate批量插入

JdbcTemplate支持批量命令的操作，我们先简单了解一下JdbcTemplate的API接口支持情况:

在这里插入图片描述
从上面的截图中我们可以了解当前有5个方法，注意这些方法都是JdbcTemplate实现JdbcOperations接口而来的方法

int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss) throws DataAccessException;

int[] batchUpdate(String sql, List<Object[]> batchArgs) throws DataAccessException;

int[] batchUpdate(String sql, List<Object[]> batchArgs, int[] argTypes) throws DataAccessException;

<T> int[][] batchUpdate(String sql, Collection<T> batchArgs, int batchSize,
    ParameterizedPreparedStatementSetter<T> pss) throws DataAccessException;
    
int[] batchUpdate(String... sql) throws DataAccessException;

下面对其中的方法进行简单的解释:

1. int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss) throws DataAccessException

使用这个方法的时候需要我们去提供BatchPreparedStatementSetter接口的实现，下面是这个接口的定义:

public interface BatchPreparedStatementSetter {

	/**
	 * Set parameter values on the given PreparedStatement.
	 * @param ps the PreparedStatement to invoke setter methods on
	 * @param i index of the statement we're issuing in the batch, starting from 0
	 * @throws SQLException if a SQLException is encountered
	 * (i.e. there is no need to catch SQLException)
	 */
	void setValues(PreparedStatement ps, int i) throws SQLException;

	/**
	 * Return the size of the batch.
	 * @return the number of statements in the batch
	 */
	int getBatchSize();

}

因此实现这个方法的时候，我们得明确的提供批操作中的语句数量，通过getBatchSize方法给出，另外我们要给出批操作中每个独立语句的内容，这种情况下我们需要实现的就是setValues这个方法。

示例:

  1. Config.java文件
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

/**
 * @author jiangjian
 */
@Configuration
@ComponentScan
@PropertySource("classpath:jdbc.properties")
public class Config {
    @Autowired
    private Environment env;

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
        dataSource.setUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));
        dataSource.setPassword(env.getProperty("spring.datasource.password"));
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        return new JdbcTemplate(dataSource());
    }
}
  1. jdbc.prperites文件
spring.datasource.url=jdbc:mysql://localhost/test?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&autoReconnect=true&failOverReadOnly=false&autoReconnectForPools=true&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  1. 测试主类 JdbcTemplateBatchOperationSample.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;

import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author jiangjian
 */
public class JdbcTemplateBatchOperationSample {
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
        JdbcTemplate jdbcTemplate = ac.getBean(JdbcTemplate.class);
        
        //准备环境
        jdbcTemplate.execute("drop table if exists user  ");
        jdbcTemplate.execute("create table user(id int auto_increment primary key, name varchar(40))");

        //这里面我们需要批量插入多个用户，所以我们这里先定义了待插入用户的列表，
        // 这个列表可以方便实现BatchPreparedStatementSetter接口，比如:获取
        // 批操作的大小 <==> uses.size()即可
        List<String> users = Arrays.asList("Alice", "Bob");
        jdbcTemplate.batchUpdate("insert into user(name) values(?)", new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps, int i) throws SQLException {
                ps.setString(1, users.get(i));
            }

            @Override
            public int getBatchSize() {
                return users.size();
            }
        });

        Long count = jdbcTemplate.queryForObject("select count(*) from user", Long.class);
        System.out.println("count is :" + count);
        
        //清空环境
        jdbcTemplate.execute("drop table user");
    }
}

2. int[] batchUpdate(String sql, List<Object[]> batchArgs) throws DataAccessException;

这个方法操作同上面介绍的区别在于它是直接通过传入操作自身来判断上述对应的batchSize, 而每个独立语句的参数则是通过内部的Object[]提供，下面写出如果使用当前方法的写法(其他部分代码都类似):

       //另外一种方式去批量插入
       List<Object[]> users = new ArrayList<>();
       users.add(new Object[]{"Jim"});
       users.add(new Object[]{"Tom"});
       jdbcTemplate.batchUpdate("insert into user(name) value(?)", users);
       Long count = jdbcTemplate.queryForObject("select count(*) from user", Long.class);
       System.out.println("count is :" + count);

preparedStatement的参数是通过List中的Object[]给出，底层根据Object[]中元素对应的java 类型，来调用合适的preparedStatement.setXXX方法，但是这样操作可能会存在问题，比如如果给出的值是null这时候会导致问题的方式，Spring默认会通过调用ParameterMetaData.getParameterType方法来获取对应placeholder的类型，这种操作对于某些jdbc driver或者数据库产品（比如: n Oracle 12c (SPR-16139))会造成很大的性能开销，如果出现这种情况，可以尝试使用int[] batchUpdate(String sql, List<Object[]> batchArgs, int[] argTypes) throws DataAccessException;方法，来显示指定具体的place holder的类型， 另外可以通过配置spring.jdbc.getParameterType.ignore为true来禁用上面的ParameterMetaData.getParameterType的操作。

3. int[][] batchUpdate(String sql, Collection batchArgs, int batchSize,

ParameterizedPreparedStatementSetter<T> pss) throws DataAccessException;

这个方法看起来好可怕，这么多参数，这个方法主要的用途是将一个batch操作分为多个子batch操作，主要的应用场景就是大数据量的批操作，比如我们有2w个用户用插入，用一个batch提交会造成很大的性能瓶颈，此时我们可以试着每100个用户作为一个batch提交。

上面的方法各个参数也很容易理解:
sql: 待执行的sql语句;
batchArgs: 这里面就是待处理的数据集，比如：2w个用户；
batchSize:用来指定batch的总共大小，它会根据batchArgs的大小来计算每个batch应该处理的数据集（比如: batchArgs / batchSize);
pss: 这个接口主要用来提供构造ParameterStatement的实现；

下面通过一个例子来感受一下:

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.Arrays;
import java.util.List;

/**
 * @author jiangjian
 */
public class BatchOperationWithMultiBatchesSample {
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
        JdbcTemplate jdbcTemplate = ac.getBean(JdbcTemplate.class);

        jdbcTemplate.execute("drop table if exists user  ");
        jdbcTemplate.execute("create table user(id int auto_increment primary key, name varchar(40))");

        List<User> users = Arrays.asList(new User("alice"),
                new User("bob"),
                new User("cindy"),
                new User("dave"));
        int[][] batchResult = jdbcTemplate.batchUpdate("insert into user(name) values(?)", users, 2, (ps, argument) -> {
            ps.setString(1, argument.getName());
        });

        //batchResult这个数组的最上层的长度表示batch的数量，而第二级的数组长度表示每次batch包含的update语句数量,
        // 而每个具体数组的值包含着当前update语句修改记录的数量（由jdbc driver提供)
        //上面的例子中，users分两个批次，每个批次应该为2， 而且每个批次里面的statement数量为2，具体每个statement的
        //update 数量为1（因为当前是insert语句),所以batchResult应该是int[2][2]维度的数组，而且值都为1，
        System.out.println("第一维度长度为:" + batchResult.length);
        System.out.println("第二维度长度为:" + batchResult[0].length);
        //下面是输出所有的值
        for(int i = 0; i < batchResult.length; i++) {
            for(int j = 0; j < batchResult[0].length; j++) {
                System.out.println(batchResult[i][j]);
            }
        }

        List<User> findUsers = jdbcTemplate.query("select * from user",
                (rs, rowNum) -> new User(rs.getLong(1), rs.getString(2)));
        findUsers.forEach(System.out::println);

        jdbcTemplate.execute("drop table user");
    }
}

User类定义如下:

package com.together.learning.spring.dataaccess.jdbc.step7_batch_operation_with_multi_batches;

public class User {
    private Long id;
    private String name;

    public User() {
    }

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public User(String name) {
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

其他的Config.java和jdbc.properties同上面的示例；

4. int[] batchUpdate(String… sql) throws DataAccessException;

这个方法比较简单，将提供的sql列表作为一个batch进行执行，每个sql的update count可以通过返回int[]进行了解。

小姜dot
关注
专栏目录
【项目实战】使用JdbcTemplate.batchUpdate执行批量更新操作（批处理）
本本本添哥
07-30 398
JdbcTemplate，提供了大量的方法来帮助开发者执行JDBC操作。其中，batchUpdate方法是JdbcTemplate中非常重要的一个方法。batchUpdate方法是Spring框架中非常实用的功能之一。batchUpdate方法是JdbcTemplate中用于执行批量更新操作的。batchUpdate方法可以显著提高处理大量数据时的效率。batchUpdate方法可以一次性执行多条SQL语句，以简化数据库操作。
Spring源码分析——JdbcTemplate执行批量insert操作
weixin_34280237的博客
10-16 1183
最近用到一个方法： @Override public int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss) throws DataAccessException { if (logger.isDebugEnabled()) { logger.debug...
JdbcTemplate批量插入
freekaiQaQ的博客
12-14 6359
jdbcTemplate批量插入数据，优化springJpa插入慢的情况
JdbcTemplate 批量插入，HikariCP数据库连接池
CJ_L1995的博客
03-03 2130
例如，你可以从1000开始测试，逐步调整，观察性能变化，找到一个最适合你的应用场景的批量大小。过大的批量大小可能导致内存溢出或者长时间的事务锁定，而过小的批量大小则可能导致频繁的数据库交互，影响性能。假设你正在使用HikariCP作为数据库连接池，为了支持大量的并发插入操作，你需要合理配置数据库连接池的参数，比如。在调整这些参数时，建议进行适当的测试，以确保配置的修改能够带来预期的效果，并且不会对应用用性能产生不利影响。进行数据库操作时，批量插入是一种常见的需求，尤其是在需要高效地插入大量数据时。
使用spring的JdbcTemplate操作批量插入数据
热门推荐
zhangbeizhen18的博客
01-04 1万+
场景:从数据库中一张表批量查出数,每条记录封装到一个实例对象中,再将批量查出的数据插入到另一张数据库表 1.实现类与测试main方法 public class BatchOperationDao { private static String querySql = "SELECT CITY_NAME,LAND_AREA,POPULATION,GROSS,AREA_NUMBER,POSTA...
JdbcTemplate 批量插入
持续学习，持续更新
11-16 1万+
因为使用template插入速度过慢，上网查了资料，找到了一种插入速度很快的方法 String sql = "INSERT INTO `party_dealer_info_grp` ( `ID`, `PARTY_CODE6`, `PARTY_NAME`, `DEALER_ID`, `DEALER_NAME`, `TELE`, `FAX`, `EMAIL`, `MSN`, `ADDRESS`, `POSTAL_CODE` ) VALUES (?,?,?,?,?,?,?,?,?,?,?)";
Spring--JdbcTemplate.pdf
01-02
3. 创建对应的Service类和DAO（Data Access Object）类。Service类用于封装业务逻辑，而DAO类负责与数据库进行交互。 4. 在DAO类中注入JdbcTemplate对象，这通常是通过Spring的依赖注入特性完成的。 5. 创建与数据库...
Just Spring Data Access
07-02
- **JdbcBatching**：在处理大量数据时，批量插入或更新操作能够显著提高性能。Spring的JdbcTemplate支持批量操作，通过`batchUpdate`方法可以实现这一功能。 - **使用SqlParameterSourceUtils**：这个工具类提供了...
_Spring_使用 JdbcTemplate和JdbcDaoSupport.rar
07-02
`JdbcTemplate`是Spring对JDBC API的一个轻量级包装，它通过提供一系列模板方法来处理常见的JDBC操作，如查询、更新、插入和删除数据。这样可以避免手动处理连接、事务和异常，降低了代码的复杂性。`JdbcTemplate`...
jdbc-批量插入数据
04-02
NULL 博文链接：https://sunfish.iteye.com/blog/1455357
spring的jdbctemplate的crud的基类dao
09-04
在本文中，我们讨论了如何利用`JdbcTemplate`来实现一个基类DAO（Data Access Object），用于支持基本的CRUD（Create, Read, Update, Delete）操作。 首先，`BaseDaoInf` 是一个接口，它定义了两个方法：`find` 和 ...
spring-data-access-weekend
04-11
在"spring-data-access-weekend"项目中，可能包含了从创建数据库连接到实现复杂查询的整个过程，涵盖了Spring JDBC、Spring Data JPA、Spring Data MongoDB、Repository接口设计、事务管理以及Spring Boot的应用。...
使用JdbcTemplate的BatchPreparedStatementSetter批量插入数据
zhangbeizhen18的博客
04-10 3106
记录：397 场景：使用JdbcTemplate从一个数据库批量查出数据存放在List中，把查出的结果数据批量写入到另一个数据库。
Java笔记-JdbcTemplate批量执行insert及update
bai_Mou的博客
08-30 3126
主要就是batchUpdate函数 用法如下： insert： String cmdTmp = "INSERT INTO %s(CREATE_DATE, UPDATE_TIME, XXX_ID, XXXID, XXX_TYPE) VALUES(?, ?, ?, ?, ?)"; String cmd = String.format(cmdTmp, tableName); List<Object[]> batchArgs=new ArrayList<Object[]>()
jdbcTemplate批量插入处理数据
c601757850的博客
09-10 703
jdbcTemplate批量插入处理数据 public void batchCarFlowInsert(List<FlowCarReportDayBo> list) { String sql =" INSERT INTO flow_report_day (id, park_number, park_name, start_time, nature_sum_count, " + " temp_car_count, vip_car_count,
JdbcTemplate实现批处理（插入、更新）
键盘游离-Alan的专栏
12-10 5810
针对大数据量的插入推荐使用批量插入以便提高性能，经过实战说明JdbcTemplate批量插入效率高于循环单条插入。   JdbcTemplate继承JdbcAccessor类与JdbcOperations接口；其中JdbcAccessor类设置数据源，JdbcOperations定义方法JdbcTemplate来实现。
JDBC和JdbcTemplate批量插入
最新发布
Erwinl的博客
08-07 290
rewriteBatchedStatements=true这个参数会使用驱动重写sql,改成单条sql的插入多条数据的方式。1.jdbc驱动版本5.1.13以上。JdbcTemplate的方式。批量快速插入需要的开启。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值