mybatis-plus 多表批量

已于 2023-04-04 14:32:04 修改
阅读量322 收藏
点赞数
分类专栏： JAVA+
于 2022-03-17 14:33:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41619534/article/details/123549783
版权

MybatisPlus CRUD LambdaQueryWrapper 实体操作 数据库工具类
关键词由CSDN通过智能技术生成 
package com.launch.tencent.utils.UnonU.mybatisPlus.data3;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.launch.common.core.exception.BaseException;
import com.launch.tencent.utils.UnonU.mybatisPlus.data3.enums.CRUD;
import lombok.Builder;
import lombok.Data;

import java.util.List;
import java.util.Objects;

/**
 * 执行体
 *
 * @param <T>
 * @param <S>
 * @author No Use
 */
@Data
@Builder
public class CRUDAll<T, S extends IService<T>> {
    /**
     * 服务
     */
    private S s;
    /**
     * 单
     */
    private CRUDEntry<T> cruDEntry;
    /**
     * 多
     */
    private List<CRUDEntry<T>> lists;

    /**
     * 公共的不用提取
     */
    public void executeMany() {
        if(Objects.isNull(lists) || CollectionUtil.isEmpty(lists)){
            return;
        }
        try {
            lists.forEach(cruDEntry->{
                if (CRUD.R.equals(cruDEntry.getType())) {
                    remove();
                } else if (CRUD.C.equals(cruDEntry.getType()) || CRUD.U.equals(cruDEntry.getType())) {
                    saveOrUpdate();
                } else if (CRUD.R.equals(cruDEntry.getType())) {
                    selsect();
                }
            });
        }catch (Exception e){
            throw new BaseException("Mysql:"+e);
        }
    }
    /**
     * 单体执行 公共的不提取
     */
    public void execute() {
        if(Objects.isNull(cruDEntry)){
            return;
        }
        try {
            if (CRUD.R.equals(cruDEntry.getType())) {
                remove();
            } else if (CRUD.C.equals(cruDEntry.getType()) || CRUD.U.equals(cruDEntry.getType())) {
                saveOrUpdate();
            } else if (CRUD.R.equals(cruDEntry.getType())) {
                selsect();
            }
        } catch (Exception e) {
            throw new BaseException("Sql:" + e);
        }
    }

    /**
     * 保存修改
     */
    public void saveOrUpdate(){
        LambdaQueryWrapper<T> qw = cruDEntry.getQueryWrapper();
        List<T> ts = cruDEntry.getList();
        if (Objects.isNull(qw)) {
            cruDEntry.setExecuteStatus(s.saveOrUpdateBatch(ts));
        } else {
            cruDEntry.setExecuteStatus(s.saveOrUpdate(ts.get(0), qw));
        }
    }

    /**
     * 移除
     */
    public void remove(){
        List<T> list = s.list(cruDEntry.getQueryWrapper());
        cruDEntry.setList(list);
        cruDEntry.setExecuteStatus(true);
    }

    /**
     * 查询
     */
    public void selsect(){
        List<T> list = s.list(cruDEntry.getQueryWrapper());
        cruDEntry.setList(list);
        if (CollectionUtil.isNotEmpty(list)) {
            cruDEntry.setExecuteStatus(s.remove(cruDEntry.getQueryWrapper()));
        } else {
            cruDEntry.setExecuteStatus(true);
        }
    }


}

package com.launch.tencent.utils.UnonU.mybatisPlus;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.launch.tencent.utils.UnonU.mybatisPlus.data3.CRUDAll;
import com.launch.tencent.utils.UnonU.mybatisPlus.data3.MybatisPlusTools;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @author No Use
 * @请不要使用
 */
@Component
public class MybatisPlusInterface3 {
    /**
     * 执行-单执行体
     *
     * @param crudAlls 执行体
     * @param <T>
     * @param <S>
     */
    public <T, S extends IService<T>> void execute(List<CRUDAll<T, S>> crudAlls) {
        crudAlls.forEach(fe -> {
            fe.execute();
        });
    }

    /**
     * 执行-多执行体
     *
     * @param crudAlls 执行体
     * @param <T>
     * @param <S>
     */
    public <T, S extends IService<T>> void executeMany(List<CRUDAll<T, S>> crudAlls) {
        crudAlls.forEach(fe -> {
            fe.executeMany();
        });
    }

    /**
     * 单-多混合
     *
     * @param crudAlls
     * @param <T>
     * @param <S>
     */
    public <T, S extends IService<T>> void executeMix(List<CRUDAll<T, S>> crudAlls) {
        crudAlls.forEach(fe -> {
            fe.executeMany();
            fe.execute();
        });
    }

    /**
     * page（page,qw）分页条件查询
     *
     * @param mybatisPlusTools 工具类
     * @param servie           serviceInterface
     * @param t                实体类
     * @param pageNum          页码
     * @param pageSize         页数
     * @param <T>
     * @param <S>
     * @return
     */
    public <T, S extends IService<T>> Page<T> select(MybatisPlusTools<T> mybatisPlusTools,
                                                     S servie,
                                                     T t,
                                                     Integer pageNum,
                                                     Integer pageSize,
                                                     String timebetweenKey,
                                                     String timeDayValue) {
        QueryWrapper<T> tQueryWrapper = mybatisPlusTools.selectWhereJion(BeanUtil.beanToMap(t), timebetweenKey, timeDayValue);
        Page<T> page = servie.page(new Page<>(pageNum, pageSize), tQueryWrapper);
        return page;
    }

    /**
     * 多对一 根据外键删除 多
     *
     * @param s
     * @param key
     * @param value
     * @param <T>
     * @param <S>
     * @return
     */
    public <T, S extends IService<T>> Boolean removesEq(List<S> s, String key, Object value) {
        AtomicBoolean atomicBoolean = new AtomicBoolean(true);
        s.forEach(fe -> {
            if (atomicBoolean.get()) {
                QueryWrapper<T> queryWrapper = new QueryWrapper<>();
                if (value instanceof List) {
                    queryWrapper.in(key, value);
                } else {
                    queryWrapper.eq(key, value);
                }
                boolean remove = fe.count(queryWrapper) > 0 ? fe.remove(queryWrapper) : true;
                if (!remove) {
                    atomicBoolean.set(remove);
                }
            }
        });
        return atomicBoolean.get();
    }

}

package com.launch.tencent.utils.UnonU.mybatisPlus.data3;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.util.CollectionUtils;

import java.util.Date;
import java.util.Map;
import java.util.Objects;

/**
 * @请不要使用
 * @author No Use
 * @param <T>
 */
public class MybatisPlusTools<T> {


    public MybatisPlusTools() {}


    /**
     * 基本查询
     * @param stringObjectMap 查询对象
     * @param timebetweenKey 区间时间查询 开始,结束
     * @param timeDayValue 天查询
     * @return
     */
    public QueryWrapper<T> selectWhereJion(Map<String, Object> stringObjectMap,String timebetweenKey,String timeDayValue) {
        QueryWrapper<T> queryWrapper = new QueryWrapper<T>();
            if (!CollectionUtils.isEmpty(stringObjectMap)) {
                stringObjectMap.forEach((x, y) -> {
                    if (Objects.nonNull(timebetweenKey) && timebetweenKey.equals(x)) {
                        if (Objects.nonNull(y)) {
                            String s = y.toString();
                            String[] split = s.split(",");
                            if (split.length == 2) {
                                queryWrapper.apply("UNIX_TIMESTAMP(create_time) > UNIX_TIMESTAMP('" + split[0] + "')");
                                queryWrapper.apply("UNIX_TIMESTAMP(create_time) < UNIX_TIMESTAMP('" + split[1] + "')");
                            }
                        }
                    } else if (Objects.nonNull(timeDayValue) &&timeDayValue.equals(x)) {
                        if (y instanceof Date) {
                            DateTime yesDay = DateUtil.offsetDay((Date) y, -1);
                            DateTime monDay = DateUtil.offsetDay((Date) y, 1);
                            String strStart = DateFormatUtils.format(yesDay, "yyyy-MM-dd");
                            String strEnd = DateFormatUtils.format(monDay, "yyyy-MM-dd");
                            queryWrapper.apply("UNIX_TIMESTAMP(create_time) > UNIX_TIMESTAMP('" + strStart + "')");
                            queryWrapper.apply("UNIX_TIMESTAMP(create_time) < UNIX_TIMESTAMP('" + strEnd + "')");
                        }
                    } else if (null != y && !"".equals(y) && !"pageNum".equals(x) && !"pageSize".equals(x)) {
                        //驼峰转 下划线
                        String key = toUnderlineCase(x);
                        queryWrapper.like(key, y);
                    }
                });
            }
        return queryWrapper;
    }
    /**
     * 驼峰转 下划线
     * userName  ---->  user_name
     * user_name  ---->  user_name
     *
     * @param camelCaseStr 驼峰字符串
     * @return 带下滑线的String
     */
    public static String toUnderlineCase(String camelCaseStr) {
        if (camelCaseStr == null) {
            return null;
        }
        // 将驼峰字符串转换成数组
        char[] charArray = camelCaseStr.toCharArray();
        StringBuffer buffer = new StringBuffer();
        //处理字符串
        for (int i = 0, l = charArray.length; i < l; i++) {
            if (charArray[i] >= 65 && charArray[i] <= 90) {
                buffer.append("_").append(charArray[i] += 32);
            } else {
                buffer.append(charArray[i]);
            }
        }
        return buffer.toString();
    }

}

package com.launch.tencent.utils.UnonU.mybatisPlus.data3;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.launch.tencent.utils.UnonU.mybatisPlus.data3.enums.CRUD;
import lombok.Builder;
import lombok.Data;

import java.util.List;
@Data
@Builder
public class CRUDEntry<T> {
    /**
     * C.R.U.D
     */
    private CRUD type;
    /**
     * 执行状态
     */
    private Boolean executeStatus;
    /**
     * 不同type 存储结构不一样
     */
    private List<T> list;
    /**
     * 条件
     */
    private LambdaQueryWrapper<T> queryWrapper;

}

package com.launch.tencent.utils.UnonU.mybatisPlus.data3.enums;

/**
 * @请不要使用
 * @author NoUse
 */
public enum CRUD {
    C,R,U,D
}

JAVA官网
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis plus 5种批量操作性能测试
03-31
测试在单元测试中
SpringBoot整合EasyExcel+MyBatis-Plus实现Excel批量导入和导出
05-03
本文将详细介绍如何使用SpringBoot框架结合EasyExcel和MyBatis-Plus来实现Excel的批量导入和导出，从而提高数据处理效率。 首先，SpringBoot是一个轻量级的Java开发框架，它简化了Spring应用的初始搭建以及开发过程...
mybatisplus 复合主键表 批量保存实现
weixin_43972670的博客
12-07 985
mybatisplus 复合主键表 批量保存实现
【MyBatis】mybatis-plus 批量插入 性能优化
最新发布
九师兄
08-01 1514
稍微总结下我粗略的对比（虽然粗略，但实验结果符合原理层面的理解），如果你想更准确地实验，可以使用JMH，并且测试更多组数（如 5000，10000等）的情况。批量保存方式数据量（条）耗时（ms）单条循环插入1000121011100059927mybatis-plus saveBatch(添加rewtire参数)10002589手动拼接sql10002275100055663jdbc executeBatch(添加rewtire参数)1000324。
调优 mybatis saveBatch 25倍性能
yes
04-04 1680
稍微总结下我粗略的对比（虽然粗略，但实验结果符合原理层面的理解），如果你想更准确地实验，可以使用JMH，并且测试更多组数（如 5000，10000等）的情况。批量保存方式数据量（条）耗时（ms）单条循环插入1000121011100059927mybatis-plus saveBatch(添加rewtire参数)10002589手动拼接sql10002275100055663jdbc executeBatch(添加rewtire参数)1000324。
Mybatis批量存储数据
qq_33967820的博客
02-06 2664
mybatis批量保存数据
MyBatis-Plus批量保存
m0_48847558的博客
07-28 1万+
MyBatis-Plus批量保存的两种方法一级目录二级目录三级目录1.使用MybatisPlus自带的Iservice接口1.1入门使用1.2 原理方法2.使用MybatisPlus自定义新增2.1配置工作2.2 批量插入测试 一级目录 二级目录 三级目录 springboot + mybatisPlus + mysql环境，批量保存的几种方法： 1.使用MybatisPlus自带的Iservice接口 BaseMapper中为提供批量插入接口，但是在com.baomidou.mybatisplus.ext
mybatis-plus源码（mybatis-plus-3.5.1.zip）
03-03
4. **批量插入与更新**：MyBatis-Plus支持一次性插入或更新多条数据，提高了数据处理的效率。 5. **主键生成策略**：内置了多种主键生成策略，如ID_WORKER（分布式雪花算法）、SEQENCE（序列方式）等，可根据数据库...
Mybatis-plus自动生成代码
10-12
在描述中提到，“根据数据库表面，逗号分隔生成代码”，这可能是指在配置代码生成器时，我们可以指定多个表名，用逗号分隔，一次生成多个表的相关代码。这种方式尤其适合拥有大量表的项目，可以一次性完成批量生成，...
mybatis-plus代码生成器模版代码
08-17
Mybatis-Plus是一款基于Mybatis框架的扩展工具，它在Mybatis的基础上简化了开发工作，提供了包括自动 CRUD 操作、条件构造器、批量操作、关联查询等实用功能。本资源包含的是Mybatis-Plus的代码生成器模板代码，用于...
mybatis-plus 表名添加前缀的实现方法
09-07
MyBatis-Plus 是 MyBatis 的一个扩展，它提供了许多方便的数据操作功能，包括 CRUD 操作、条件构造器、批量插入等。在实际项目中，我们常常需要为表名添加前缀，以便于区分不同的环境或者模块。本文将详细介绍如何在...
Mybatis实现多表联合查询和批量插入
06-14
文档中主要说明：（1）多表联合查询步骤，快捷便利；（2）数据批量插入，以及相关的案例，节省运行资源。
Mybatis Plus批处理操作
逸轩
01-27 1417
在实际应用中，我们经常面对大批量数据的处理需求，例如数据的批量插入、更新、删除等操作。MyBatis Plus 提供了强大的批处理支持，可以帮助我们高效地处理大规模数据。
mybatis自定义动态sql批量保存（插入或更新）数据
Killua____的博客
09-20 1103
mybatis批量插入更新动态sql
深入理解 MyBatis-Plus 批量保存方法
大张伟
01-09 7410
在项目开发中，需要插入批量插入20多万条数据，通过日志观察，发现在调用MyBatis-Plus中的saveBatch()方法性能非常的差，本篇文章主要分享一下saveBatch()的原理以及使用的注意事项1: 想要批量执行操作 数据库链接参数加上rewriteBatchedStatements=true2: 根据doUpdate(ms,parameter). 完成SQL的拼装的原理可以得出，如果批量插入的数据，有些数据字段值为null，不会批量查询，而是单独拼装一个SQL执行。
MybatisPlus进行批量保存，提升保存速率，从你我做起
weixin_49190101的博客
10-09 4624
MybatisPlus进行批量保存 @Override public int insertRoleList(List<InsertRoleDto> insertRoleDtos) {//*1* try{ List<SysRole> sysRoleList=new ArrayList<>(); for (int i=0;i<insertRoleDtos.size();i++){
十五、MyBatis的多表操作
学习笔记
04-29 526
文章目录一对一查询1. 一对一查询的模型2. 一对一查询的语句3. 创建Order和User实体4. 创建OrderMapper接口5. 配置OrderMapper.xml6. 测试结果一对多查询1. 一对多查询的模型2. 一对多查询的语句3. 修改User实体4. 创建UserMapper接口5. 配置UserMapper.xml6. 测试结果多对多查询1. 多对多查询的模型2. 多对多查询的语句3. 创建Role实体，修改User实体4. 添加UserMapper接口方法5. 配置UserMapper.
Mybatis流式查询并将结果分批写入文件
persistence_PSH的博客
02-19 646
以mybatis-plus的方式。
MybatisPlus批量更新
热门推荐
雪落南城的博客
11-05 8万+
1、我们使用Mybatis批量更新时，通常是这样的： Mapper: void batchUpdateDemo(@Param("list") List<DemoDO> list); XML: <update id="batchUpdateDemo"> update `demo_table` set a = <foreach col...
mybatis-plus根据id批量删除
06-28
### 回答1： 根据id批量删除，可以使用MyBatis-Plus的LambdaQueryWrapper，例如： ```java List<Long> idList = Arrays.asList(1L, 2L, 3L); // 要删除的id列表 QueryWrapper<Entity> queryWrapper = new QueryWrapper<>(); queryWrapper.lambda().in(Entity::getId, idList); // 构建查询条件 int deletedCount = entityMapper.delete(queryWrapper); // 执行删除操作，deletedCount为删除的记录数 ``` 其中，Entity是实体类，entityMapper是对应的Mapper接口，可以根据实际情况替换为自己的实体类和Mapper接口。 ### 回答2： mybatis-plus是一个基于mybatis的轻量级增强工具，在实际开发过程中可以方便地进行增、删、改、查等数据库操作，极大地提高了开发效率。在mybatis-plus中，根据id批量删除数据非常方便。 1. 准备工作 首先需要在pom.xml文件中添加mybatis-plus的依赖，如下所示： ``` <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.3.1</version> </dependency> ``` 2. 定义Mapper接口 在定义Mapper接口时，继承mybatis-plus的BaseMapper接口，并在接口中添加批量删除的方法，示例如下： ``` @Mapper public interface UserMapper extends BaseMapper<User> { /** * 根据id批量删除数据 * * @param idList id列表 * @return 影响行数 */ int deleteBatchIds(@Param("idList") List<Long> idList); } ``` 在deleteBatchIds方法中，使用@Param注解指定参数名为idList，idList类型为List<Long>，表示需要删除的id列表。 3. 调用Mapper接口 在上一步中定义了批量删除的方法后，可以在Service中调用Mapper接口进行批量删除操作。示例代码如下： ``` @Service public class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; @Override public int deleteBatchByIds(List<Long> idList) { return userMapper.deleteBatchIds(idList); } } ``` 在deleteBatchByIds方法中，调用UserMapper的deleteBatchIds方法，并传入需要删除的id列表，即可实现根据id批量删除数据。 总之，mybatis-plus提供了丰富的接口和方法，可以方便地进行各种数据库操作，特别是根据id批量删除数据，只需要继承BaseMapper接口并添加对应的方法即可。 ### 回答3： MyBatis-Plus 是一个扩展 MyBatis 的工具，它提供了很多便捷的方法和功能来简化操作。在 MyBatis-Plus 中，批量删除是一项很常见的操作，可以使用 `deleteBatchIds` 方法来实现。下面是具体的实现步骤： 1. 首先，创建一个 List 集合来存储需要删除的 id 值，例如： ``` List<Long> idList = new ArrayList<>(); idList.add(1L); idList.add(2L); idList.add(3L); ``` 2. 接着，在调用 `deleteBatchIds` 方法时将该 List 集合作为参数传入，例如： ``` int count = userMapper.deleteBatchIds(idList); ``` 3. 最后，通过判断返回的影响行数来确定操作是否成功。如果返回的影响行数大于零，则表示删除成功，否则表示删除失败。 需要注意的是，在使用 `deleteBatchIds` 方法时，需要保证批量删除的 id 值在数据库中存在，否则会抛出异常。此外，该方法也支持使用 Map 来指定删除条件，具体可参考官方文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值