MyBatis-Plus批量保存

最新推荐文章于 2024-06-04 15:04:22 发布
最新推荐文章于 2024-06-04 15:04:22 发布
阅读量1.2w 收藏 22
点赞数 9
文章标签： java mysql mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48847558/article/details/119171236
版权

MyBatis-Plus批量保存的两种方法


springboot + mybatisPlus + mysql环境，批量保存的几种方法：

1.使用MybatisPlus自带的Iservice接口

BaseMapper中为提供批量插入接口，但是在com.baomidou.mybatisplus.extension.service.IService接口中提供了saveBatch批量插入方法。

1.1入门使用

  1. 新建一个接口，继承Iservice接口，泛型为被操作的实体类
package com.wsh.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.wsh.entity.Order;

public interface BatchInsertService extends IService<Order> {
}
  1. 创建一个方法，继承ServiceImpl，并且实现上述接口BatchInsertService
package com.wsh.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wsh.mapper.OrderMapper;
import com.wsh.entity.Order;
import org.springframework.stereotype.Service;

@Service
public class BatchInsertServiceImpl extends ServiceImpl<OrderMapper,Order> implements BatchInsertService{

}

其中，extends ServiceImpl<OrderMapper,Order>，Order是被操作的实体类，Ordermapper是继承BaseMapper的自定义接口，如下：

package com.wsh.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wsh.entity.Order;

// 使用mybatis-plus增强接口
public interface OrderMapper extends BaseMapper<Order> {

}
  1. 批量保存测试
package com.wsh;

import com.wsh.service.BatchInsertService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import com.wsh.entity.Order;
import javax.annotation.Resource;

import java.util.ArrayList;
import java.util.Date;

@SpringBootTest
public class TestBatchInsertService {

    @Resource
    private BatchInsertService batchInsertService;

    @Test
    public void testBatchSave(){

        long start = System.currentTimeMillis();

        ArrayList<Order> orders = new ArrayList<>();

        for (int i = 0; i < 100000; i++) { //十万条数据

            Order order = new Order();
            order.setName("wsh"+i);
            order.setOrderDate(new Date());
            orders.add(order);
        }

        boolean b = batchInsertService.saveBatch(orders, 50);
        long end = System.currentTimeMillis();
        System.out.println("保存时间为：" + (end - start)); //73474
        System.out.println(b);
    }
}

测试结果为（部分展示）：

==>  Preparing: INSERT INTO orders ( order_id, order_date, order_name ) VALUES ( ?, ?, ? ) 
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99951(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99952(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99953(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99954(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99955(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99956(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99957(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99958(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99959(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99960(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99961(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99962(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99963(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99964(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99965(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99966(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99967(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99968(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99969(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99970(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99971(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99972(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99973(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99974(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99975(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99976(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99977(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99978(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99979(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99980(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99981(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99982(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99983(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99984(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99985(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99986(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99987(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99988(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99989(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99990(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99991(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99992(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99993(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99994(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99995(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99996(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99997(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99998(String)
==> Parameters: 0(Integer), 2021-07-28 10:16:42.773(Timestamp), wsh99999(String)
保存时间为：73474
true

1.2 原理方法

Iservice接口中saveBatch方法:

  /**
     * 插入（批量）
     *
     * @param entityList 实体对象集合
     * @param batchSize  插入批次数量
     */
    boolean saveBatch(Collection<T> entityList, int batchSize);

ServiceImpl.java实现类中的saveBatch方法：

    /**
    * 批量插入
    *
    * @param entityList ignore
    * @param batchSize ignore
    * @return ignore
    */
   @Transactional(rollbackFor = Exception.class)
   @Override
   public boolean saveBatch(Collection<T> entityList, int batchSize) {
       String sqlStatement = sqlStatement(SqlMethod.INSERT_ONE);
       try (SqlSession batchSqlSession = sqlSessionBatch()) {
           int i = 0;
           for (T anEntityList : entityList) {
               batchSqlSession.insert(sqlStatement, anEntityList);
               if (i >= 1 && i % batchSize == 0) {
                   batchSqlSession.flushStatements();
               }
               i++;
           }
           batchSqlSession.flushStatements();
       }
       return true;
   }

sqlSessionBatch：

    /**
     * 批量操作 SqlSession
     */
    protected SqlSession sqlSessionBatch() {
        return SqlHelper.sqlSessionBatch(currentModelClass());
    }



    /**
     * 批量操作 SqlSession
     *
     * @param clazz 实体类
     * @return SqlSession
     */
    public static SqlSession sqlSessionBatch(Class<?> clazz) {
        // TODO 暂时让能用先,但日志会显示Closing non transactional SqlSession,因为这个并没有绑定.
        return GlobalConfigUtils.currentSessionFactory(clazz).openSession(ExecutorType.BATCH);
    }

注意：openSession(ExecutorType.BATCH),到这里就熟悉了。
插入十万条数据，时间为：73474

2.使用MybatisPlus自定义新增

2.1配置工作

注： 仅适用于MySQL

  1. 创建自定义数据方法注入类
package com.wsh.util;

import com.baomidou.mybatisplus.core.injector.AbstractMethod;
import com.baomidou.mybatisplus.core.injector.DefaultSqlInjector;
import com.baomidou.mybatisplus.extension.injector.methods.additional.InsertBatchSomeColumn;

import java.util.List;


public class EasySqlInjector extends DefaultSqlInjector {

 @Override
 public List<AbstractMethod> getMethodList(Class<?> mapperClass) {
     // 防止父类方法不可用
     List<AbstractMethod> methodList = super.getMethodList(mapperClass);
     methodList.add(new InsertBatchSomeColumn());
     return methodList;
 }
}
  1. 在MybatisPlus配置文件MybatisPlusConfig加入自定义
package com.wsh.config;

import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize;
import com.wsh.util.EasySqlInjector;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;


@EnableTransactionManagement
@Configuration
@MapperScan("com.wsh.mapper")
public class MybatisPlusConfig {

    @Bean
    public EasySqlInjector easySqlInjector(){
        return new EasySqlInjector();
    }
}
  1. 扩展通用Mapper，支持数据批量插入，即：创建EasyBaseMapper接口继承BaseMapper
package com.wsh.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;

import java.util.Collection;

/**
 * @author suahng
 * @date 2021-07-21 20:47
 * @dec
 */
public interface EasyBaseMapper<T> extends BaseMapper<T> {


    /**
     * 批量插入，仅使用批量插入
     * @param entityList 实体列表
     * @return 影响行数
     */
    Integer insertBatchSomeColumn(Collection<T> entityList);
}
  1. 定义业务mapper接口，继承刚刚扩展的EasyBaseMapper
package com.wsh.mapper;
import com.wsh.entity.Order;
import org.springframework.stereotype.Repository;

@Repository
public interface EasyMapper extends EasyBaseMapper<Order> {
}
  1. 定义Service接口
package com.wsh.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.wsh.entity.Order;

import java.util.Collection;


public interface EasyService extends IService<Order> {

    /**
     * 批量插入，仅适用于 mysql
     * @param orderList
     * @return
     */
    public Integer BatchSave(Collection<Order> orderList);
}
  1. 定义service接口的实现类
package com.wsh.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wsh.mapper.EasyBaseMapper;
import com.wsh.mapper.EasyMapper;
import com.wsh.entity.Order;
import org.springframework.stereotype.Service;

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


@Service
public class EasyServiceImpl extends ServiceImpl<EasyMapper, Order> implements EasyService{



    @Override
    public Integer BatchSave(Collection<Order> orderList) {
        return baseMapper.insertBatchSomeColumn(orderList);
    }
}

2.2 批量插入测试

package com.wsh;

import com.wsh.entity.Order;
import com.wsh.service.EasyServiceImpl;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;

@SpringBootTest
public class TestEasyService {

    @Resource
    EasyServiceImpl easyService;

    @Test
    public void testBatchSave(){

        long start = System.currentTimeMillis();

        ArrayList<Order> orders = new ArrayList<>();

        for (int i = 0; i < 100000; i++) {

            Order order = new Order();
            order.setName("hcy"+i);
            order.setOrderDate(new Date());
            orders.add(order);
        }

        Integer b = easyService.BatchSave(orders);
        long end = System.currentTimeMillis();
        System.out.println("保存时间为：" + (end - start));//6348 6093 4320
        System.out.println(b);
    }
}

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

0(Integer), 2021-07-28 11:28:02.54(Timestamp), hcy16065(String), 0(Integer), 2021-07-28 11:28:02.54(Timestamp), hcy16066(String), 0(Integer), 2021-07-28 11:28:02.54(Timestamp), hcy16067(String), 0(Integer), 2021-07-28 11:28:02.54(Timestamp), hcy16068(String), 0(Integer), 2021-07-28 11:28:02.54(Timestamp), hcy16069(String), 0(Integer), 2021-07-28 11:28:02.54(Timestamp), hcy16070(String), 0(Inte<...>.556(Timestamp), hcy99998(String), 0(Integer), 2021-07-28 11:28:02.556(Timestamp), hcy99999(String)
<==    Updates: 100000
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1d50a7ca]
保存时间为：4223
100000

插入十万条数据，时间为：4223，比上一个方法减少了大约一半的时间。

大江东去wsh
关注
  • 9
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Mybatis-plus.zip
05-04
Mybatis-plus在Mybatis的基础上进行了扩展，提供了包括但不限于条件构造器、批量操作、填充实体、主键自动生成、CRUD操作等实用功能。下面将详细阐述Mybatis-plus的主要特性及其使用方法。 1. **条件构造器**：...
SpringBoot整合EasyExcel+MyBatis-Plus实现Excel批量导入和导出
05-03
在`UserService`中，我们可以使用MyBatis-Plus的批量插入方法将数据保存到数据库： ```java @Service public class UserService { @Autowired private UserMapper userMapper; public void saveUser(User user)...
mybatis-plus批量保存异常及效率优化
qq_14926283的博客
01-15 1101
最近基于自己公司内部服务维护，发现其中调度中心近期出现不少错误日志，但是该任务却是正常执行，生成的报表数据也是正常的，所以很多天没有发现问题这就匪夷所思了，经仔细排查发现，是触发了feign超时hystrix熔断器机制也就是说子服务出现了执行时间过长的情况是什么让它花费这么多时间去执行呢，只有一个for循环，组装list这个组装过程在java看来是非常快，根本不可能出现问题我发现了mybatisplus3.3.2自带的批量保存的sql接口跟踪代码的实现。
mybatis-plus的saveBatch
做你想做的人，没有时间的限制，只要愿意，什么时候都可以start。
12-08 1万+
IService.saveBatch public interface IService<T> { default boolean saveBatch(Collection<T> entityList) { // return this.saveBatch(entityList, 1000); } ... } 走到了ServiceImpl.saveBatch,最终走到了SqlHelper里面 public class
【MyBatis-plus】saveBatch 性能调优和【MyBatis】的数据批量入库
最新发布
yinchoushi8780的博客
06-04 1187
使用了【MyBatis-plus】saveBatch 但是数据入库效率依旧很慢，那可能是是因为JDBC没有配置，saveBatch 批量写入并没有生效哦！！！详细配置如下：批量数据入库：rewriteBatchedStatements=true# 数据源master:# 数据源Driver使用【MyBatis】进行数据的批量入库：拼接sql语句，每1000条数据入库一次。@Override//1.先删除原有场次和工程的数据，再进行导入//2.将结果插入到数据库中//条数为1。
Mybatis-Plus实现多主键批量保存或更新
李长渊的博客
08-10 6587
Mybatis-Plus实现多主键批量保存或更新
MyBatis批量保存（Oracle）MyBatis批量插入、批量更新时，组装SQL过长会有问题，一定要根据批量插入数据量进行切割，再批次提交保存！！！
Be_insighted的博客
12-14 2079
Mybatis向Oracle中批量插入数据，MyBatis批量插入、更新时，组装SQL过长会有问题，一定要根据批量插入数据量进行切割，再批次提交保存！！！
【RuoYi-Vue-Plus】学习笔记 22 - Mybatis-Plus（四）批量插入功能（中篇）saveBatch 实现与分析（MyBatis-Plus 源码）
MichelleChung的星球
04-05 8449
Mybatis-Plus 批量插入 saveBatch 的实现以及流程分析。
Mybaties-Plus saveBatch()、自定义批量插入、多线程批量插入性能测试和对比
m0_37742400的博客
03-09 5270
本文降价了Mybaties-Plus批量插入相关方案及性能测试对比
MyBatis-Plus saveBatch保存太慢解决办法
暮雪寒寒的随手记
10-26 5573
mybatis-plus调用saveBatch方法保存慢的解决办法 主要有两个因素，具体可查看文章
xmljava系统源码-mybatis-generator-gui-plus:mybatis-generator-gul-plus
06-06
mybatis-generator-gui-plus mybatis-generator-gui-plus是基于 扩展的工具，区别在于功能上的扩展了批量操作的方法，其他几乎没有差别。 增加的方法说明： 批量更新 batchUpdate 批量可选更新 batchUpdateSelective...
mybatis plus 5种批量操作性能测试
03-31
MyBatis Plus 是 MyBatis 的一个扩展，它在 MyBatis 的基础上提供了更多的便捷功能，包括但不限于批量操作。在数据库交互中，批量操作能够显著提高效率，减少数据库连接的开销。本测试主要探讨了 MyBatis Plus 中的...
代码生成器，可以生成crud的mybatis-plus插件的功能
01-10
代码生成器，可以生成crud的插件，这里只是代码生成器的代码，还需要一些基础类，比如BaseController、ApiResult、PageParam、PageResult等，生成功出来时带有...批量保存，详情看本人博客：Java_代码生成_crud代码
mybatis-plus 的saveBatch性能分析
简单简单小白
03-18 1557
mybatis-plus 的service里面的saveBatch()真的是批量插入吗？性能如何？
mybatis-plus 关于savebatch,saveorupdatebatch遇到的坑及解决办法
热门推荐
qq_28025423的博客
04-13 7万+
一.背景 最近mybatis-plus框架的更新，让我们基础开发中如虎添翼。其中基本的增删改查，代码生成器想必大家用着那叫一个爽。本人在使用中，也遇到一些坑。比如savebatch,saveorupdatebatch，看着这不是批量新增，批量新增或更新嘛，看着api进行开发，感觉也太好用啦。开发完一测试，速度跟蜗牛一样，针对大数据量真是无法忍受。在控制台上发现，怎么名义上是批量插入，还是一条一条的进行插入，难怪速度龟速。 二.解决办法 查阅网上资料，大体有两种解决方案： ...
MyBatisPlus批量写入方法saveBatch速度很慢的解决方案
dongdong199033的博客
05-25 5488
项目组在使用MyBatisPlus的批量插入方法saveBatch时速度缓慢，插入1w条数据，需要近1分钟的时间。
mybatis-plus 批量插入
dj1955的博客
06-10 488
mybatis-plus 实现批量插入
MyBatis-Plus的saveBatch批量插入为何效率很低，耗时很长，怎么解决？
weixin_55181056的博客
04-14 1万+
MyBatis-Plus的saveBatch批量插入为何效率很低，耗时很长，怎么解决？
MyBatis批量插入数据优化，一个参数让效率飙升百倍
资料免费分享，点击名片
10-31 2026
项目中进行接口压测，发现批量插入的速度有点超出预期，感觉很奇怪，经过定位后发现mybatise-plus批量保存的处理十分缓慢，使用的是saveBatch方法，这点有点想不通。于是就进行了相关内容分析。根据mybatise-plus中saveBatch的方法进行源码查看:继续跟踪逻辑，从代码上看，确实是一条条执行了sqlSession.insert(sqlStatement, entity) 方法。
springboot+mybatis-plus批量删除前后端代码
09-04
### 回答1： 您好，关于SpringBoot和MyBatis-Plus的批量删除前后端代码，我可以为您提供一些信息。 首先，您需要在后端编写一个接口来处理批量删除的请求。可以使用MyBatis-Plus提供的批量删除方法来实现这一点。例如： ```java List<Integer> idList = Arrays.asList(1, 2, 3); int deleteCount = myService.removeByIds(idList); ``` 在前端，您需要创建一个表格或列表来显示需要删除的数据，并提供一个按钮来触发批量删除请求。可以使用JavaScript框架（如jQuery）来捕获用户点击事件并向后端发送请求。例如： ```javascript $('#deleteButton').click(function() { var idList = []; $('input[name="id"]:checked').each(function() { idList.push($(this).val()); }); $.ajax({ url: '/my-api/batch-delete', method: 'POST', data: { idList: idList }, success: function(response) { alert(response.message); }, error: function(jqXHR, textStatus, errorThrown) { alert('Error: ' + textStatus + ' - ' + errorThrown); } }); }); ``` 这里假设您的后端接口是`/my-api/batch-delete`，并且需要从前端接收一个名为`idList`的数组参数。 希望这些信息能对您有所帮助。如果您需要更具体的代码示例或其他方面的帮助，请随时提出。 ### 回答2： Spring Boot是一种用于创建基于Java的独立的、生产级别的应用程序的框架。MyBatis-Plus是一个建立在MyBatis之上的增强工具，提供了更多的功能和便利性。要批量删除前后端代码，可以按照以下步骤进行操作。 首先，确保你已经配置好了Spring Boot和MyBatis-Plus的环境，并且已经建立了数据库表和实体类。 一、前端代码删除 1. 打开前端代码所在的项目，找到要删除的文件或文件夹。 2. 右键点击选择“删除”或使用命令行删除相应文件。 3. 如果需要，可以在版本控制系统中提交并推送这些删除的更改。 二、后端代码删除 1. 打开后端代码所在的项目，找到要删除的文件或文件夹。 2. 右键点击选择“删除”或使用命令行删除相应文件。 3. 如果需要，可以在版本控制系统中提交并推送这些删除的更改。 三、数据库删除 1. 打开数据库管理工具，连接到你的数据库。 2. 找到与要删除的文件或文件夹对应的数据库表。 3. 使用SQL语句执行批量删除操作，例如：DELETE FROM 表名 WHERE 条件。 4. 如果需要，可以在数据库管理工具中提交和保存这些更改。 以上就是使用Spring Boot和MyBatis-Plus批量删除前后端代码的步骤。确保在删除代码之前备份相关文件和数据库，以防止数据丢失或无法恢复。同时，要小心地进行删除操作，确保不会删除错误的文件或数据。 ### 回答3： 如果要在Spring Boot中使用MyBatis-Plus进行批量删除操作，你需要完成以下几个步骤： 1. 首先，确保已经引入了Spring Boot和MyBatis-Plus的依赖包。可以在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>${mybatis-plus.version}</version> </dependency> ``` 2. 定义一个实体类，表示要进行删除操作的数据表。可以使用注解@Table和@Id来指定对应的表名和主键字段。例如： ```java @Table("user") public class User { @Id private Long id; private String name; private Integer age; // 省略getter和setter方法 } ``` 3. 创建一个Mapper接口，使用MyBatis-Plus的注解来定义要进行的删除操作。例如，可以使用@Delete注解和@Param注解来指定要删除的条件： ```java public interface UserMapper extends BaseMapper<User> { @Delete("delete from user where age > #{minAge} and age < #{maxAge}") int deleteByAgeRange(@Param("minAge") Integer minAge, @Param("maxAge") Integer maxAge); } ``` 4. 在服务层（Service）中调用Mapper接口的方法来进行删除操作。例如，可以直接调用deleteByAgeRange方法来删除满足条件的数据： ```java @Service public class UserService { @Autowired private UserMapper userMapper; public void deleteByAgeRange(Integer minAge, Integer maxAge) { int result = userMapper.deleteByAgeRange(minAge, maxAge); // 处理删除操作的结果 } } ``` 5. 最后，在控制器层（Controller）中处理请求，并调用相应的服务层方法来完成批量删除操作。例如，可以定义一个RESTful接口来接收前端发送的删除请求： ```java @RestController public class UserController { @Autowired private UserService userService; @DeleteMapping("/users") public void deleteUsers(@RequestParam("minAge") Integer minAge, @RequestParam("maxAge") Integer maxAge) { userService.deleteByAgeRange(minAge, maxAge); // 返回删除结果或其他响应 } } ``` 以上就是使用Spring Boot和MyBatis-Plus进行批量删除操作的基本步骤。通过定义实体类、Mapper接口和服务层方法，再结合控制器层对前端请求的处理，可以方便地实现批量删除功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值