SpringBoot+MyBatis批量插入数据的三种方式

于 2024-06-12 18:23:20 发布
阅读量1.3k 收藏 29
点赞数 29
分类专栏： # mybatis 文章标签： spring boot mybatis 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16992475/article/details/139633631
版权

文章目录

原文链接：SpringBoot+MyBatis批量插入数据的三种方式

1. 背景介绍

在开发过程中，我们经常会遇到往数据库表中插入大量数据的场景，比如excel批量导入数据。那么该如何快速地插入数据呢？

我们可以考虑使用批量插入来实现，实测100000条数据添加，后附具体实现代码。

2. 方案介绍

2.1 第一种方案，用 for语句循环插入（不推荐）

用一个 for 循环，把数据一条一条地插入。

insert into t_user values (?, ?, ?, ?, ?)

/**
* 第一种方案，用 for语句循环插入 10万 条数据
*/
@GetMapping("/test1")
public String test1(int count) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    for (int i = 0; i < count; i++) {
        User user = new User();
        user.setName("方案1测试" + i);
        user.setGender("男");
        user.setUsername("方案1测试");
        user.setPassword("方案1测试");
        user.setRemark("方案1测试");
        userService.saveInfo(user);
    }
    stopWatch.stop();
    System.out.println("第一种方案，用 for语句循环插入耗时：" + stopWatch.getTotalTimeMillis());
    return "操作完成";
}

优势：JDBC 中的 PreparedStatement 有预编译功能，预编译之后会缓存起来。

之后SQL执行会比较快，且 JDBC可以开启批处理，这个批处理执行非常给力。

劣势：这种方式插入大量数据时，效率非常底下，不推荐。很多时候我们的 SQL 服务器和应用服务器可能并不是同一台，所以必须要考虑网络 IO。

如果网络 IO 比较费时间的话，那么可能会拖慢 SQL 执行的速度。

2.2 第二种方案，利用mybatis的foreach来实现循环插入（不推荐）

insert into t_user values (?, ?, ?, ?, ?) , (?, ?, ?, ?, ?) , (?, ?, ?, ?, ?)

/**
* 第二种方案，利用mybatis的foreach来实现循环插入 10万 条数据
*/
@GetMapping("/test2")
public String test2(int count) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    List<User> list = new ArrayList<>();
    for (int i = 0; i < count; i++) {
        User user = new User();
        user.setName("方案2测试" + i);
        user.setGender("男");
        user.setUsername("方案2测试");
        user.setPassword("方案2测试");
        user.setRemark("方案2测试");
        list.add(user);
    }
    userService.saveList(list);
    stopWatch.stop();
    System.out.println("第二种方案，利用mybatis的foreach来实现循环插入耗时：" + stopWatch.getTotalTimeMillis());
    return "操作完成";
}

<insert id="saveList" parameterType="list">
    insert into t_user values
    <foreach collection="list" item="item" separator=",">
        (#{item.name}, #{item.gender}, #{item.username}, #{item.password}, #{item.remark})
    </foreach>
</insert>

优势：不用频繁访问数据库，一条sql搞定，效率比较高。

劣势：一当数据量太大时，会出现拼接的sql语句超长而执行失败，所以当数据量太大时，也不推荐。

二是 SQL 太长了，甚至可能需要分片后批量处理。

三是无法充分发挥 PreparedStatement 预编译的优势，SQL 要重新解析且无法复用

com.mysql.cj.jdbc.exceptions.PacketTooBigException: Packet for query is too large (4,879,714 > 4,194,304).
    You can change this value on the server by setting the 'max_allowed_packet' variable.

2.3 第三种方案，使用sqlSessionFactory实现批量插入（推荐）

@Resource
private SqlSessionFactory sqlSessionFactory;

// 关闭session的自动提交
SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH, false);
try {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    list.stream().forEach(user -> userMapper.saveInfo(user));
    // 提交数据
    sqlSession.commit();
} catch (Exception e) {
    sqlSession.rollback();
} finally {
    sqlSession.close();
}

优势：这种方式可以说是集第一种和第二种方式的优点于一身，既可以提高运行效率，又可以保证大数据量时执行成功，大数据量时推荐使用这种方式。

3. 创建Springboot项目

3.1 选择Spring Initializr(springboot项目)

在这里插入图片描述

3.2 配置属性，完成点击next

在这里插入图片描述

3.3 项目启动类

在这里插入图片描述

3.4 Pom文件添加依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/>
    </parent>

    <groupId>com.liyh</groupId>
    <artifactId>springboot_mybatis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_mybatis</name>
    <description>springboot_mybatis</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--jdbc 数据库连接-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--引入阿里数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.5 配置application.yml文件

# 配置端口
server:
  port: 8091

spring:
  # 配置数据源
  datasource:
    url: jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

# mybatis相关配置
mybatis:
  mapper-locations: classpath*:mapper/*.xml   #指定mapper映射文件路径
  type-aliases-package: com.liyh.mybatis.entity  # 别名
  configuration:
    map-underscore-to-camel-case: true

#打印sql，保存到文件
logging:
  level:
    com.liyh.mybatis.mapper: debug

3.6 导入数据库

CREATE TABLE `t_user`  (
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `gender` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `remark` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '批量导入用户表' ROW_FORMAT = COMPACT;

3.7 项目结构

在这里插入图片描述

4. 方案测试

4.1 测试第一种方案，用 for语句循环插入 10万 条数据

1. 通过postman调用接口

在这里插入图片描述

2. 查看耗时情况（20万条数据需要10几分钟！！！）

在这里插入图片描述
在这里插入图片描述

3. 数据库数据

在这里插入图片描述

4.2 测试第二种方案，用 for语句循环插入 10万 条数据

1. 通过postman调用接口

在这里插入图片描述

2. 查看耗时情况（测试2000，10000，50000，100000条数据）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
当数据量达到5万条时，报错了！！！（单批次少量数据效率还可以）
在这里插入图片描述

### Cause: com.mysql.cj.jdbc.exceptions.PacketTooBigException: Packet for query is too large (5,238,915 > 4,194,304). You can change this value on the server by setting the 'max_allowed_packet' variable.
; Packet for query is too large (5,238,915 > 4,194,304). You can change this value on the server by setting the 'max_allowed_packet' variable.; nested exception is com.mysql.cj.jdbc.exceptions.PacketTooBigException: Packet for query is too large (5,238,915 > 4,194,304). You can change this value on the server by setting the 'max_allowed_packet' variable.] with root cause

com.mysql.cj.jdbc.exceptions.PacketTooBigException: Packet for query is too large (5,238,915 > 4,194,304). You can change this value on the server by setting the 'max_allowed_packet' variable.
	at com.mysql.cj.jdbc.exceptions.SQLExceptionsMapping.translateException(SQLExceptionsMapping.java:107) ~[mysql-connector-j-8.0.31.jar:8.0.31]
	at com.mysql.cj.jdbc.ClientPreparedStatement.executeInternal(ClientPreparedStatement.java:916) ~[mysql-connector-j-8.0.31.jar:8.0.31]
	at com.mysql.cj.jdbc.ClientPreparedStatement.execute(ClientPreparedStatement.java:354) ~[mysql-connector-j-8.0.31.jar:8.0.31]
	at com.zaxxer.hikari.pool.ProxyPreparedStatement.execute(ProxyPreparedStatement.java:44) ~[HikariCP-4.0.3.jar:na]
	at com.zaxxer.hikari.pool.HikariProxyPreparedStatement.execute(HikariProxyPreparedStatement.java) ~[HikariCP-4.0.3.jar:na]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_201]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_201]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_201]
	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_201]
	at org.apache.ibatis.logging.jdbc.PreparedStatementLogger.invoke(PreparedStatementLogger.java:59) ~[mybatis-3.5.9.jar:3.5.9]
	at com.sun.proxy.$Proxy72.execute(Unknown Source) ~[na:na]
	at org.apache.ibatis.executor.statement.PreparedStatementHandler.update(PreparedStatementHandler.java:47) ~[mybatis-3.5.9.jar:3.5.9]
	at org.apache.ibatis.executor.statement.RoutingStatementHandler.update(RoutingStatementHandler.java:74) ~[mybatis-3.5.9.jar:3.5.9]
	at org.apache.ibatis.executor.SimpleExecutor.doUpdate(SimpleExecutor.java:50) ~[mybatis-3.5.9.jar:3.5.9]
	at org.apache.ibatis.executor.BaseExecutor.update(BaseExecutor.java:117) ~[mybatis-3.5.9.jar:3.5.9]
	at org.apache.ibatis.executor.CachingExecutor.update(CachingExecutor.java:76) ~[mybatis-3.5.9.jar:3.5.9]

4.3 测试第三种方案，使用sqlSessionFactory实现批量插入 20万 条数据

1. 通过postman调用接口

在这里插入图片描述

2. 查看耗时情况（20万条数据大概17秒）

在这里插入图片描述
在这里插入图片描述

3. 数据库数据

在这里插入图片描述

6. 部分代码

6.1 UserController

package com.liyh.mybatis.controller;

import com.liyh.mybatis.entity.User;
import com.liyh.mybatis.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StopWatch;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * 测试接口
 *
 * @Author: liyh
 */
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    UserService userService;

    /**
     * 第一种方案，用 for语句循环插入 10万 条数据
     */
    @GetMapping("/test1")
    public String test1(int count) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        for (int i = 0; i < count; i++) {
            User user = new User();
            user.setName("方案1测试" + i);
            user.setGender("男");
            user.setUsername("方案1测试");
            user.setPassword("方案1测试");
            user.setRemark("方案1测试");
            userService.saveInfo(user);
        }
        stopWatch.stop();
        System.out.println("第一种方案，用 for语句循环插入耗时：" + stopWatch.getTotalTimeMillis());
        return "操作完成";
    }

    /**
     * 第二种方案，利用mybatis的foreach来实现循环插入 10万 条数据
     */
    @GetMapping("/test2")
    public String test2(int count) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        List<User> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            User user = new User();
            user.setName("方案2测试" + i);
            user.setGender("男");
            user.setUsername("方案2测试");
            user.setPassword("方案2测试");
            user.setRemark("方案2测试");
            list.add(user);
        }
        userService.saveList(list);
        stopWatch.stop();
        System.out.println("第二种方案，利用mybatis的foreach来实现循环插入耗时：" + stopWatch.getTotalTimeMillis());
        return "操作完成";
    }

    /**
     * 第三种方案，使用sqlSessionFactory实现批量插入 10万 条数据
     */
    @GetMapping("/test3")
    public String test3(int count) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        List<User> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            User user = new User();
            user.setName("方案3测试" + i);
            user.setGender("男");
            user.setUsername("方案3测试");
            user.setPassword("方案3测试");
            user.setRemark("方案3测试");
            list.add(user);
        }
        userService.saveBeach(list);
        stopWatch.stop();
        System.out.println("第三种方案，使用sqlSessionFactory实现批量插入：" + stopWatch.getTotalTimeMillis());
        return "操作完成";
    }

}

6.2 UserServiceImpl

package com.liyh.mybatis.service.impl;

import com.liyh.mybatis.entity.User;
import com.liyh.mybatis.mapper.UserMapper;
import com.liyh.mybatis.service.UserService;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

/**
 * 用户业务实现类
 *
 * @Author: liyh
 */
@Service
@Transactional
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    @Resource
    private SqlSessionFactory sqlSessionFactory;

    @Override
    public void saveInfo(User user) {
        userMapper.saveInfo(user);
    }

    @Override
    public void saveList(List<User> list) {
        userMapper.saveList(list);
    }

    @Override
    public void saveBeach(List<User> list) {
        // ExecutorType.SIMPLE: 这个执行器类型不做特殊的事情。它为每个语句的执行创建一个新的预处理语句。
        // ExecutorType.REUSE: 这个执行器类型会复用预处理语句。
        // ExecutorType.BATCH: 这个执行器会批量执行所有更新语句,如果 SELECT 在它们中间执行还会标定它们是 必须的,来保证一个简单并易于理解的行为。

        // 关闭session的自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH, false);
        try {
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            list.stream().forEach(user -> userMapper.saveInfo(user));
            // 提交数据
            sqlSession.commit();
        } catch (Exception e) {
            sqlSession.rollback();
        } finally {
            sqlSession.close();
        }
    }
}

6.3 UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.liyh.mybatis.mapper.UserMapper">

    <insert id="saveInfo">
        insert into t_user
        values (#{name}, #{gender}, #{username}, #{password}, #{remark})
    </insert>

    <insert id="saveList" parameterType="list">
        insert into t_user values
        <foreach collection="list" item="item" separator=",">
            (#{item.name}, #{item.gender}, #{item.username}, #{item.password}, #{item.remark})
        </foreach>
    </insert>


</mapper>
ps酷教程
关注
  • 29
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Mybatis实现多表联合查询和批量插入
06-14
文档中主要说明：（1）多表联合查询步骤，快捷便利；（2）数据批量插入，以及相关的案例，节省运行资源。
spring中使用mybatis实现批量插入的示例代码
08-19
主要介绍了spring中使用mybatis实现批量插入的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring Boot 配置MyBatis-Plus（实现查询、新增、更新、删除）
旭东怪的博客
08-15 3087
1MyBatis-Plus MyBatis-Plus (opens new window)（简称 MP）是一个MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 特性： （1）无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑。 （2）损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作。 （3...
springboot集成mybatis-plus实现自定义批量插入更新方法
weixin_44261754的博客
11-04 2806
springboot集成mybatis-plus实现自定义批量插入更新方法
MyBatis批量插入的五种方式
qq_45525848的博客
04-13 2372
MyBatis批量插入的五种方式
SpringBoot高效批量插入百万数据
seeyouagain_的博客
02-05 3013
前言：我相信很多小伙伴和我一样在初学的时候，面对几万几十万数据插入，不知道如何下手，面对百万级别数据时更是不知所措，我们大部分初学者，很多人都喜欢for循环插入数据，或者是开启多个线程，然后分批使用for循环插入，当我们需要将大量数据存储到数据库中时，传统的逐条插入方式显然效率低下，并且容易导致性能瓶颈。总结：经过上面的示例演示我们心里已经有谱了，知道什么时候该使用哪一种数据插入方式，针对对不同线程数的测试，发现不是线程数越多越好，具体多少合适，通常的算法：CPU核心数量*2 +2 个线程。
springboot+mybatis批量插入数据+小问题
qq_24970965的博客
09-23 552
之前一直动手用过mybatis，这次刚好项目需要，做了个小项目，但是我没发现myBatista的批量插入数据的接口，可能是没找到，也或许真的没有。然后网上找了个方式如下： 在xml文件中这样写 <insert id="addDataBach"parameterType="arraylist"> INSERT INTO eimm_basic_enterprise_power ([id], [userCode], [userName], [yearAndMonth], [zcbh],
spring boot + sql server大数据量批量新增
FanZaiYo的博客
09-20 571
先发出来 注释慢慢完善。
spring boot2.0 + mybatis 批量插入
The_dream_is_a_verb的专栏
10-11 342
sql.xml 文件 <insert id="testxxx22" parameterType="java.util.List"> INSERT INTO sy_test ( open_id, sy_code, card_img, card_name, card_title...
springboot整合Mybatis增删改查实现
fjf_666的博客
04-23 1063
springboot整合Mybatis增删改查简单实现
springboot+mybatis配置clickhouse实现插入查询功能
08-18
Spring Boot + MyBatis 配置 ...通过实例代码，读者可以了解如何添加 Maven 依赖、配置数据源、参数配置、MyBatis 配置、ClickHouse 配置和实现插入查询功能。这些知识点对读者的学习或工作具有一定的参考借鉴价值。
springboot+mybatis+poi 实现excel导入导出
09-04
在IT行业中，SpringBoot、MyBatis和Apache POI是三种非常重要的技术，它们分别用于构建微服务应用、数据库操作和处理Excel数据。本篇文章将详细介绍如何利用SpringBoot和MyBatis结合Apache POI实现Excel的导入导出...
java抽奖系统后台 springboot+mybatis redis队列处理高并发.rar
06-18
同时，通过对数据库的操作进行优化，如合理设计索引、使用批量插入等，也能提高系统在高并发环境下的性能。 5. **分布式设计** 在大型抽奖系统中，可能会采用分布式设计，如负载均衡、数据库分库分表等策略。...
SpringBoot +Mybatis +POI导入、导出Excel文件
07-26
- 将读取的数据转换为Java对象，然后通过Mybatis的Mapper接口批量插入到数据库中。 4. **Excel文件导出** - 在需要导出Excel的接口中，根据业务需求查询数据库中的数据，并转换为List集合。 - 创建一个新的...
基于SpringBoot+Mybatis+layui(学生成绩管理系统，包含数据库脚本文件).zip
06-01
这是一个基于SpringBoot、Mybatis和layui技术栈的学生成绩管理系统源码，旨在提供一个毕业设计的参考项目。下面将详细介绍这个系统的核心知识点和技术要点。 1. **SpringBoot**: SpringBoot是Spring框架的一个扩展...
Mybatis批量插入的四种方式
热门推荐
一零贰肆的博客
06-13 3万+
测试结果还是显而易见的，循环插入>批量插入>BatchType插入>JDBC批量插入
SpringBoot ＋MyBatis批量插入数据
Wen先森的博客
09-18 1183
在最近的开发过程中，遇到了往数据库中表中插入大量的数据。有一个全国银行各分行的信息，共计148032条数据文件有8.45MB，因为考虑到数据量比较大，就想着导入到MySQL看一看需要多长时间。
SpringBoot项目中对数据库的基本操作+批量插入数据的优化
最新发布
a289246的博客
05-09 1406
SpringBoot项目中对数据库的基本操作+批量插入数据的优化，主要包括增删改查基本操作以及批量插入的优化，如何成功插入百万条数据
springboot+mybatis批量插入
08-18
在Spring Boot中使用MyBatis进行批量插入操作非常简单。下面是一个示例代码： 首先，确保你的Spring Boot项目中已经集成了MyBatis和相应的数据库驱动。接下来，你需要创建一个Mapper接口来定义批量插入的方法。假设你的实体类为User，可以创建一个名为UserMapper的接口，如下所示： ```java @Mapper public interface UserMapper { void batchInsert(List<User> userList); } ``` 然后，在你的Mapper XML文件中，编写对应的SQL语句。在这个例子中，我们使用MySQL数据库，可以使用INSERT INTO ... VALUES ...语句进行批量插入。如下所示： ```xml <insert id="batchInsert" parameterType="java.util.List"> INSERT INTO user (name, age) VALUES <foreach collection="list" item="item" separator=","> (#{item.name}, #{item.age}) </foreach> </insert> ``` 最后，在你的Service或Controller类中注入UserMapper，并调用batchInsert方法即可实现批量插入。例如： ```java @Service public class UserService { private final UserMapper userMapper; public UserService(UserMapper userMapper) { this.userMapper = userMapper; } public void batchInsert(List<User> userList) { userMapper.batchInsert(userList); } } ``` 这样，你就可以通过调用UserService的batchInsert方法来批量插入数据了。 希望以上信息能对你有所帮助！如果你有任何其他问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值