项目实战--批量插入数据接口优化过程详解

已于 2024-08-03 08:56:16 修改
阅读量525 收藏 3
点赞数 6
分类专栏： Java Javaweb mybatis 文章标签： mybatis java sql mysql
于 2024-07-31 14:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40623672/article/details/140818320
版权

批量插入数据接口优化

一、前言

最近在项目上遇到批量插入接口先响应缓慢然后抛出异常的问题，主要是将APP的业务数据和用户点击/操作的行为数据插入MySQL，且每次需要插入超过 10w+ 的数据量并且字段较多，导致使用循环插入的方式（即MyBatis的<foreach collection=“behaverList” item=“behaver” separator=“,”>…</foreach>）插入数据插入的效率不高甚至抛出异常。
项目是从 JDBC 升级到 MyBatis / MyBatis Plus ，那就依次记录实现及优化过程。
在这里插入图片描述

二、建表

数据库版本 mysql 5.7.19

DROP TABLE IF EXISTS `fee`;
CREATE TABLE `fee`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `owner` varchar(64) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL COMMENT '归属人',
  `fee1` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用1',
  `fee2` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用2',
  `fee3` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用3',
  `fee4` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用4',
  `fee5` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用5',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci COMMENT = '费用表' ROW_FORMAT = Dynamic;

三、JDBC插入

3.1 jdbc普通循环插入

/**
 * JDBC - 普通插入（循环遍历一条一条插入）
 */
public class JDBCDemo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/test";
        String user = "root";
        String password = "123456";
        String driver = "com.mysql.jdbc.Driver";
        // sql语句
        String sql = "INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`) VALUES (?,?,?,?,?,?);";
        Connection conn = null;
        PreparedStatement ps = null;
        // 开始时间
        long start = System.currentTimeMillis();
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            ps = conn.prepareStatement(sql);
            // 循环遍历插入数据
            for (int i = 1; i <= 100000; i++) {
                ps.setString(1, "o"+i);
                ps.setBigDecimal(2, new BigDecimal("11111.111"));
                ps.setBigDecimal(3, new BigDecimal("11111.111"));
                ps.setBigDecimal(4, new BigDecimal("11111.111"));
                ps.setBigDecimal(5, new BigDecimal("11111.111"));
                ps.setBigDecimal(6, new BigDecimal("11111.111"));
                ps.executeUpdate();
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（普通插入方式）：" + (end - start) + " ms");
    }
}

执行结果：
在这里插入图片描述

3.2 jdbc批处理插入

批量插入+ 手动事务提交减少磁盘的写入次数可以提高插入速度，在配置 MySQL 的 url 时需要加上 rewriteBatchedStatements=true 开启允许重写批量提交。分片大小为 1000（参考 MP 框架的默认分片大小）避免一次性提交的数据量过大

/**
 * JDBC - 批处理插入
 */
public class JDBCPlusDemo {
    public static void main(String[] args) {
        // url 设置允许重写批量提交 rewriteBatchedStatements=true
        String url = "jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true";
        String user = "root";
        String password = "123456";
        String driver = "com.mysql.jdbc.Driver";
        // sql语句（注意url设置为rewriteBatchedStatements=true时，不允许sql语句带有;号，否则会抛出BatchUpdateException异常）
        String sql = "INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`) VALUES (?,?,?,?,?,?)";
        Connection conn = null;
        PreparedStatement ps = null;
        // 开始时间
        long start = System.currentTimeMillis();
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            ps = conn.prepareStatement(sql);
            // 关闭自动提交
            conn.setAutoCommit(false);
            for (int i = 1; i <= 100000; i++) {
                ps.setString(1, "o"+i);
                ps.setBigDecimal(2, new BigDecimal("11111.111"));
                ps.setBigDecimal(3, new BigDecimal("11111.111"));
                ps.setBigDecimal(4, new BigDecimal("11111.111"));
                ps.setBigDecimal(5, new BigDecimal("11111.111"));
                ps.setBigDecimal(6, new BigDecimal("11111.111"));
                // 加入批处理（将当前sql加入缓存）
                ps.addBatch();
                // 以 1000 条数据作为分片
                if (i % 1000 == 0) {
                    // 执行缓存中的sql语句
                    ps.executeBatch();
                    // 清空缓存
                    ps.clearBatch();
                }
            }
            ps.executeBatch();
            ps.clearBatch();
            // 事务提交（实际开发中需要判断有插入失败的需要在 finally 中做好事务回滚操作）
            conn.commit();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（批处理插入）：" + (end - start) + " ms");
    }
}

执行结果：
在这里插入图片描述
可见使用批处理+手动提交的方式插入 10w 条数据的执行时间大概在 1s 左右，速度明显提高。

四、MyBatis批量插入

4.1 foreach动态拼接插入

使用<foreach>标签：此方式 MyBatis 和 MyBatis Plus 两个框架均可用
mapper.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="db.review.mapper.FeeMapper">
    <insert id="insertByForeach">
        INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`)
        VALUES
        <foreach collection="feeList" item="fee" separator=",">
            (#{fee.owner}, #{fee.fee1}, #{fee.fee2}, #{fee.fee3}, #{fee.fee4}, #{fee.fee5})
        </foreach>
   </insert>
</mapper>

service层调用：

@Service
public class FeeServiceImpl extends ServiceImpl<FeeMapper, Fee> implements FeeService {

    @Resource
    private FeeMapper feeMapper;

	@Override
    public int saveByForeach(List<Fee> feeList) {
        // 通过mapper的foreach动态拼接sql插入
        return feeMapper.insertByForeach(feeList);
    }
}

测试代码：

@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo2() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // foreach动态拼接插入
        feeService.saveByForeach(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（foreach动态拼接插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 1; i <= 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

ps：这里运行会报错，因为默认情况下 MySQL 可执行的最大 SQL 语句大小为 4194304 即 4MB，这里使用动态 SQL 拼接后的大小会远大于默认值，故报错。
在这里插入图片描述

解决方式，设置 MySQL 的默认 sql 大小为 10MB：

set global max_allowed_packet=10*1024*1024;

测试结果：
在这里插入图片描述
可见增大默认 SQL 大小后，插入的时间在 3s 左右，但这种方式的弊端明显，即无法确定 SQL 大小，也不能总更改默认的 SQL 大小，既不实用，也会引起项目异常。

4.2 批处理插入

在配置文件的数据库配置 url 中加上rewriteBatchedStatements=true

# 配置数据库
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
spring.datasource.username=root
spring.datasource.password=123456

service层加入批处理代码：

@Transactional
@Override
public int saveByBatch(List<Fee> feeList) {
    // 记录结果（影响行数）
    int res = 0;
    // 开启批处理模式
    SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
    FeeMapper feeMapper = sqlSession.getMapper(FeeMapper.class);
    for (int i = 1; i <= feeList.size(); i++) {
        // 利用mapper的单条插入方法插入
        res += feeMapper.insertByOne(feeList.get(i-1));
        // 进行分片类似 JDBC 的批处理，分片量增加为100000
        if (i % 100000 == 0) {
            sqlSession.commit();
            sqlSession.clearCache();
        }
    }
    sqlSession.commit();
    sqlSession.clearCache();
    return res;
}

测试类：

@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo3() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // 批处理插入
        feeService.saveByBatch(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（批处理插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：
在这里插入图片描述
可见插入效率在 1s 左右。

五、MyBatis Plus批处理插入

5.1 MyBatis Plus 自带批处理

使用MyBatis Plus 自带的saveBatch()批处理方法完成批量插入，配置文件同上，需要开启允许重写批量处理提交。

@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo4() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // MyBatis Plus 自带的批处理插入
        feeService.saveBatch(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（MP 自带的批处理插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：
在这里插入图片描述
可见使用 MP 自带的批处理方法执行时间在 2s 左右，虽然比自定义实现的批处理方法差一点点，但它可开箱即用，所以这是一种最好的选择。

5.2 MP 自带的 saveBatch() 方法源码分析

第一层源码：
在这里插入图片描述
可见带上一个默认参数 batchSize = 1000，即分片大小 1000，也是上文jdbc借鉴的分片大小。接着进入 executeBatch() 方法：
在这里插入图片描述
可见 Lambda 表达式功能跟上面的实现批处理插入方式类似，先逐条插入数据，当达到分片大小后，提交并刷新，从而达到批处理的效果。再深入到下一个 executeBatch() 方法会看到底层使用的也是批处理模式。
在这里插入图片描述
因此 MP 自带的批处理方法和上文中实现的批处理方法类似但更易用。

六、MyBatis-Plus + ThreadPoolTaskExecutor

使用 Spring Boot + MyBatis-Plus + ThreadPoolTaskExecutor 构建一个快速、稳定且能够处理百万级数据批量插入的接口。

6.1 项目创建及依赖配置（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 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>3.0.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.icoderoad</groupId>
    <artifactId>batch-insertion</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Batch Insertion</name>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <!-- Spring Boot Web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- MyBatis-Plus 依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>

        <!-- 数据库驱动 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- 线程池依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
    </dependencies>

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

6.2 配置文件（application.yml）

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_name?useUnicode=true&characterEncoding=UTF-8&useSSL=false
    username: username
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver

  task:
    executor:
      core-pool-size: 100
      max-pool-size: 300
      queue-capacity: 99999

6.3 实体类

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("data_table")
public class DataEntity {
    private Long id;
    private String name;
    private String description;
}

6.4 Mapper 接口

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.icoderoad.entity.DataEntity;

public interface DataMapper extends BaseMapper<DataEntity> {
}

6.5 DataService 接口类

import java.util.List;
import com.icoderoad.entity.DataEntity;

public interface DataService {

    void batchInsertData(List<DataEntity> dataList);
}

6.6 服务类

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.icoderoad.entity.DataEntity;
import com.icoderoad.mapper.DataMapper;
import com.icoderoad.service.DataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

@Service
public class DataServiceImpl extends ServiceImpl<DataMapper, DataEntity> implements DataService {

    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;

    @Transactional
    public void batchInsertData(List<DataEntity> dataList) {
        // 分批插入数据
        int batchSize = 1000;  // 每批插入的数量

        List<Future<?>> futures = new ArrayList<>();

        for (int i = 0; i < dataList.size(); i += batchSize) {
            List<DataEntity> subList = dataList.subList(i, Math.min(i + batchSize, dataList.size()));
            futures.add(taskExecutor.submit(new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                    baseMapper.insertBatchSomeColumn(subList);
                    return null;
                }
            }));
        }

        for (Future<?> future : futures) {
            try {
                future.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

6.7 Executor 配置类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class ExecutorConfig {

    @Value("${spring.task.executor.core-pool-size}")
    private int corePoolSize;

    @Value("${spring.task.executor.max-pool-size}")
    private int maxPoolSize;

    @Value("${spring.task.executor.queue-capacity}")
    private int queueCapacity;

    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        return executor;
    }
}

6.8 控制器类

import com.icoderoad.entity.DataEntity;
import com.icoderoad.service.DataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
public class DataController {

    @Autowired
    private DataService dataService;

    @PostMapping("/batchInsert")
    public String batchInsert(@RequestBody List<DataEntity> dataEntities) {
        dataService.batchInsertData(dataEntities);
        return "Batch insertion successful";
    }

    public static void main(String[] args) {
        List<DataEntity> dataList = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 1000000; i++) {
            DataEntity dataEntity = new DataEntity();
            dataEntity.setName("Name " + i);
            dataEntity.setDescription("Description " + random.nextInt());
            dataList.add(dataEntity);
        }
    }
}

七、总结

通过以上的优化和完善步骤，充分利用Spring Boot的强大功能、MyBatis-Plus的便捷高效操作以及ThreadPoolTaskExecutor 的高效并发处理能力，经验证可实现百万级数据的批量插入，在实际应用中，还可根据具体的业务需求和性能要求，对代码进行进一步的优化和调整。

springboot整合sharding-jdbc实现分库分表详解
congge
05-21 8116
springboot整合sharding-jdbc实现分库分表详解
【ChatGPT模型精调训练】AI 大模型精调 Fine-Tuning （微调）训练图文代码实战详解
AI天才研究院
03-09 2008
选择预训练模型：选择一个在类似任务上已经训练好的模型作为起点。数据准备：准备并预处理你的数据集，使其适合模型的输入格式。微调：在你的特定数据集上继续训练模型，调整模型的权重。评估：评估微调后模型的性能。应用：将微调后的模型部署到实际应用中。Fine-Tuning（精调）是指在预训练模型的基础上，对模型进行微调，使其适应特定任务。预训练模型通常在大量无标签数据上进行训练，以学习通用的语言表示。通过 Fine-Tuning，我们可以在较小的标签数据集上训练模型，以便模型能够更好地解决特定任务。
php如何批量添加接口,批量添加方法
weixin_39792049的博客
03-12 383
这次给大家带来批量添加方法，批量添加的注意事项有哪些，下面就是实战案例，一起来看一下。postman工具配置和数据准备：1)在地址栏输入测试IP地址和端口号已经对应的接口地址；2)在Headers一栏添加参数Content-Type=application/json;已本地测试为例：对应配置图如下：3)点击Body一栏,并选择raw,然后在对应的text区域输入要传递和添加的数据集合；本例已两条数...
MySQL批量插入数据的四种方案（性能测试对比）
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
05-16 2916
????????关注后回复“进群”，拉你进程序员交流群????????本文记录个人使用MySQL插入大数据总结较实用的方案，通过对常用插入大数据的4种方式进行测试，即for循环单条、拼接SQL、批量插入saveBatch()、循环 + 开启批处理模式，得出比较实用的方案心得。一、前言最近趁空闲之余，在对MySQL数据库进行插入数据测试，对于如何快速插入数据的操作无从下手，在仅1W数据量的情况下，竟花费接近47s，实在...
java项目开发之接口优化方案
kinbridge的专栏
04-01 1334
批量操作、异步、并行思想、空间换时间、池化思想，sql优化；更深就是采用新技术，代码重构等
微服务设计原则——高性能：批量
Dablelv 的博客专栏。
08-18 600
假设一个用户一次传 1w 个id进来，那么接口可能需要很长的时间才能处理完，这往往会导致超时，用户怎么调用结果都是超时异常，那怎么办？限制长度，比如限制长度为 100，即每次最多只能传 100 个id，这样就能避免长时间执行，如果用户传的 id 列表长度超过 100 就报异常。接口，那么使用方如果要一次性获取 20 个数据，它就需要循环遍历调用我们接口 20 次，不仅使用方性能很差，也无端增加了我们服务的压力，这时提供一个批量拉取的接口。对于批量接口，我们也要注意接口的吞吐能力，避免长时间执行。
电商订单批量导入API接口功能
热门推荐
kuaidi100API的博客
06-16 16万+
与主流的第三方物流快递信息服务商合作完成API对接，可以使整个平台订单管理以及物流货单管理高度自动化，因为在发货订单量较多（上万单时），电商卖家根本无法依靠在人力在合作的物流系统中一个个录入来完成。 因为表单需要提交的字段非常多，人工的方式带来的是更高的错误率和更久的工作时间，一旦录入错误，将严重影响包裹的投递，可能会导致理赔的产生，造成经济损失。因此，订单逐个录入的方式在降低卖家的工作效率的同时，也严重影响店铺的时效性和买家满意度，对物流提供商的好感度也随之降低。 所以接入第三方物流快递信息API和电商订
深入解析 MyBatis-Plus 批量操作：原理、实现与性能优化&MyBatis参数映射机制详解
最新发布
lucky_love816的博客
03-26 1378
本文探讨MyBatis-Plus在高并发场景下的批量数据库操作优化。重点分析批量更新和自定义批量插入的实现原理：批量更新通过动态拼接CASE WHEN语句实现单SQL多记录更新，减少网络请求；自定义批量插入突破MyBatis-Plus默认的逐条插入模式，通过SQL注入器和动态代理机制实现高效批量处理。文章提供了详细的XML配置示例、性能优化建议（如分批次提交、数据库参数配置）以及避坑指南，帮助开发者在处理大数据量时显著提升系统性能。
Java JDBC批量插入操作实战详解
资源摘要信息:"在本文件中，我们将介绍如何使用Java的JDBCBulkInsert进行批量插入操作。...在实际操作中，开发者需要根据具体的业务需求和数据库环境，调整构建过程和批量插入的参数，以达到最佳的性能表现。
Redis实战指南：Key-Value存储与数据类型详解
通过这两章的学习，读者可以对Redis的基本架构、数据模型和常见操作有深入理解，为进一步实践和优化Redis应用打下坚实基础。《红丸出品》作为一本实战教程，适合希望深入了解Redis并将其应用于实际项目中的开发者和...
tk.mybatis 通用批量更新接口设计（方法一：通过foreach批量更新）
sinat_40761705的博客
05-26 1453
通过foreach批量更新 1、pom <!-- tk.mybatis --> <dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper-spring-boot-starter</artifactId> <version>2.1.5</versi
接口怎么分批量同步数据_SaasS系统接口同步三方平台的优化方案
weixin_39673972的博客
12-08 596
本文主角是一个SaaS模式的“后台发货系统”，对接美团等O2O平台的订单。目的是将各销售渠道的订单统一管理，完成发货。既然统一发货，就少不了做统一的库存同步到销售渠道的机制。这样才能确保各平台数据互通，良性运营。本次案例就来自库存价格同步机制这块的优化。01. 产品模型整个业务模型大概是这样的：该图表自下往上，分别是：1)最下是“商户WMS”：作为真实的门店和门店商品库存、价格的来源。(因为是O2...
封装复杂度之批量接口
明明如月的技术博客
10-01 1805
一、背景 在平时项目开发过程中，难免需要作为接口提供方封装批量接口给上游调用；或者作为上游系统调用下游业务或者中间件的批量接口，执行某些操作。 常见的批量操作有很多，比如批量查询内容详情，批量发送提醒；批量插入数据、批量更新、批量发送MQ消息等。 不知道，大家想过没有。 为什么要提供批量接口？ 作为批量接口的提供方和批量接口的使用方我们通常需要注意哪些问题？ 二、 问题思考 2.1 为什么要提供批量接口？ 通常最主要的一个原因是为了性能优化。 通常 IO 操作是性能的主要瓶颈，批量接口可以减少
聊聊接口设计的36个小技巧
JavaShark的博客
07-20 1234
单一性是指接口做的事情比较单一、专一。比如一个登陆接口，它做的事情就只是校验账户名密码，然后返回登陆成功以及userId即可。但是如果你为了减少接口交互，把一些注册、一些配置查询等全放到登陆接口，就不太妥。其实这也是微服务一些思想，接口的功能单一、明确。比如订单服务、积分、商品信息相关的接口都是划分开的。将来拆分微服务的话，是不是就比较简便啦。我们写代码，不仅仅是为了实现当前的功能，也要有利于后面的维护。说到维护，代码不仅仅是写给自己看的，也是给别人看的。所以接口定义要清晰易懂，命名规范。...
Mybatis是什么？
weixin_69797860的博客
11-20 871
Mybatis是什么？
高并发接口实现、大数据批量插入、修改、删除优化
qq_52231508的博客
03-20 1230
Java高并发接口实现、大数据批量插入、修改、删除优化
性能优化：记一次批量新增&修改接口优化思路
Yal_insist的博客
06-15 861
经验、性能优化：记一次批量新增&修改接口优化思路
设计批量操作接口所需考虑的问题总结
Feng______的专栏
11-02 5476
背景对于增删改查这些操作，现代框架已经提供了比较好的实现。 在这基础上往往有一些扩展需求。 比如说批量的增删改查。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

容若只如初见

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值