Mybatis-Flex之增、删、改

最新推荐文章于 2024-01-02 10:46:47 发布
最新推荐文章于 2024-01-02 10:46:47 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： MybatisFlex 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45529338/article/details/132120730
版权

方法全解

(1) INSERT

BaseMapper 的接口提供了 insert 和 insertBatch 方法，用于新增数据；

  • insert(entity)：插入实体类数据，不忽略 null 值。
  • insertSelective(entity)：插入实体类数据，但是忽略 null 的数据，只对有值的内容进行插入。这样的好处是数据库已经配置了一些默认值，这些默认值才会生效。
  • insert(entity, ignoreNulls)：插入实体类数据。
  • insertWithPk(entity)：插入带有主键的实体类，不忽略 null 值。
  • insertSelectiveWithPk(entity)：插入带有主键的实体类，忽略 null 值。
  • insertWithPk(entity, ignoreNulls)：带有主键的插入，此时实体类不会经过主键生成器生成主键。
  • insertBatch(entities)：批量插入实体类数据，只会根据第一条数据来构建插入的字段内容。
  • insertBatch(entities, size)：批量插入实体类数据，按 size 切分。
  • insertOrUpdate(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都不会忽略 null 值。
  • insertOrUpdateSelective(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都会忽略 null 值。
  • insertOrUpdate(entity, ignoreNulls)：插入或者更新，若主键有值，则更新，若没有主键值，则插入。
① insert
/**
     * insert(entity)：插入实体类数据，不忽略 null 值。
     * insert(entity, ignoreNulls)：插入实体类数据。
     */
    @Test
    public void testInsert() {
        /**
         * 默认不忽略null值
         * INSERT INTO `tb_account`(`user_name`, `age`, `birthday`) VALUES (?, ?, ?)
         */
        int row = accountMapper.insert(new Account().setUserName(null).setBirthday(new Date()).setAge(25));
        Assertions.assertEquals(row, 1);

        /**
         * ignoreNulls true:忽略null , false:不忽略null
         * INSERT INTO `tb_account`(`user_name`) VALUES (?)
         */
        int row2 = accountMapper.insert(new Account().setUserName("ly3").setBirthday(null).setAge(null), true);
        Assertions.assertEquals(row2, 1);
    }
② insertSelective
/**
     * insertSelective(entity)：插入实体类数据，但是忽略 null 的数据，只对有值的内容进行插入。这样的好处是数据库已经配置了一些默认值，这些默认值才会生效。
     */
    @Test
    public void testInsertSelective() {
        /**
         * INSERT INTO `tb_account`(`user_name`) VALUES (?)
         */
        int row = accountMapper.insertSelective(new Account().setUserName("陈远航").setAge(null));
        Assertions.assertEquals(row, 1);
    }
③ insertWithPk
/**
     * insertWithPk(entity)：插入带有主键的实体类，不忽略 null 值。
     */
    @Test
    public void testInsertWithPk() {
        /**
         * INSERT INTO `tb_account`(`id`, `user_name`, `age`, `birthday`) VALUES (?, ?, ?, ?)
         */
        int row = accountMapper.insertWithPk(new Account().setUserName("廖楷瑞").setId(5L).setBirthday(null));
        Assertions.assertEquals(row, 1);
    }
④ insertBatch
/**
     * insertBatch(entities)：批量插入实体类数据，只会根据第一条数据来构建插入的字段内容。
     * insertBatch(entities, size)：批量插入实体类数据，按 size 切分。
     */
    @Test
    public void testInsertBatch() {
        List<Account> accounts = new ArrayList<>(10);
        for (int i = 0; i < 10; i++) {
            Account account = new Account().setUserName("ly" + i).setBirthday(new Date()).setAge(20 + i);
            accounts.add(account);
        }
        /**
         * 批量插入，可以指定每次插入的数据大小size
         * size=2 : INSERT INTO `tb_account`(`user_name`, `age`, `birthday`) VALUES (?, ?, ?), (?, ?, ?)
         * size=3 : INSERT INTO `tb_account`(`user_name`, `age`, `birthday`) VALUES (?, ?, ?), (?, ?, ?), (?, ?, ?)
         * ......
         */
        int rows = accountMapper.insertBatch(accounts, 2);
        System.out.println("rows = " + rows);
    }
⑤ insertOrUpdate
/**
     * insertOrUpdate(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都不会忽略 null 值。
     * insertOrUpdateSelective(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都会忽略 null 值。
     * insertOrUpdate(entity, ignoreNulls)：插入或者更新，若主键有值，则更新，若没有主键值，则插入。
     */
    @Test
    public void testInsertOrUpdate() {
        Account account = new Account().setUserName("ly-update2").setId(3L).setBirthday(new Date()).setAge(21);
        /**
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        int row = accountMapper.insertOrUpdate(account);
        Assertions.assertEquals(row, 0, 1);

        account = new Account().setUserName("ly-update2").setBirthday(null).setAge(21);
        /**
         * INSERT INTO `tb_account`(`user_name`, `age`) VALUES (?, ?)
         */
        int row2 = accountMapper.insertOrUpdateSelective(account);
        Assertions.assertEquals(row2, 0, 1);
    }
(2) DELETE

BaseMapper 的接口提供了 deleteById、deleteBatchByIds、deleteByMap、deleteByQuery 方法，用于删除数据；

  • deleteById(id)：根据主键删除数据。如果是多个主键的情况下，需要传入数组，例如：new Integer[]{100,101}。
  • deleteBatchByIds(ids)：根据多个主键批量删除数据。
  • deleteBatchByIds(ids, size)：根据多个主键批量删除数据。
  • deleteByMap(whereConditions)：根据 Map 构建的条件来删除数据。
  • deleteByCondition(whereConditions)：根据查询条件来删除数据。
  • deleteByQuery(queryWrapper)：根据查询条件来删除数据。
① deleteById
/**
     * deleteById(id)：根据主键删除数据。
     * ??? 如果是多个主键的情况下，需要传入数组，例如：new Integer[]{100,101}。 ??? 怀疑态度
     */
    @Test
    public void testDeleteById() {
        /**
         * DELETE FROM `tb_account` WHERE `id` = ?
         */
        int row = accountMapper.deleteById(9L);
        Assertions.assertTrue(row > 0);
    }
② deleteBatchByIds
/**
     * deleteBatchByIds(ids)：根据多个主键批量删除数据。
     * deleteBatchByIds(ids, size)：根据多个主键批量删除数据。
     */
    @Test
    public void testDeleteBatchByIds() {
        List<Integer> ids = List.of(5, 6, 7, 8);
        /**
         * DELETE FROM `tb_account` WHERE `id` = ? OR `id` = ? OR `id` = ? OR `id` = ?
         */
        int rows = accountMapper.deleteBatchByIds(ids);
        Assertions.assertTrue(rows > 0);

        /**
         * 分批删除
         * size=2 : DELETE FROM `tb_account` WHERE `id` = ? OR `id` = ?
         */
        int rows2 = accountMapper.deleteBatchByIds(ids, 2);
        Assertions.assertTrue(rows2 > 0);
    }
③ deleteByMap
/**
     * deleteByMap(whereConditions)：根据 Map 构建的条件来删除数据。
     */
    @Test
    public void testDeleteByMap() {
        /**
         * DELETE FROM `tb_account` WHERE `tb_account`.`age` = ?
         */
        int rows = accountMapper.deleteByMap(Map.of("age", 25));
        Assertions.assertTrue(rows > 0);
    }
④ deleteByCondition
 /**
     * deleteByCondition(whereConditions)：根据查询条件来删除数据。
     */
    @Test
    public void testDeleteByCondition() {
        QueryCondition condition = QueryCondition.createEmpty().and("age = 27");
        /**
         * DELETE FROM `tb_account` WHERE age = 27
         */
        int rows = accountMapper.deleteByCondition(condition);
        Assertions.assertTrue(rows > 0);

        /**
         * DELETE FROM `tb_account` WHERE `id` > ?
         */
        int rows2 = accountMapper.deleteByCondition(ACCOUNT.ID.gt(35));
        Assertions.assertTrue(rows2 > 0);
    }
⑤ deleteByQuery
/**
     * deleteByQuery(queryWrapper)：根据查询条件来删除数据。
     */
    @Test
    public void testDeleteByQuery() {
        /**
         * DELETE FROM `tb_account` WHERE `age` >= ?
         */
        QueryWrapper wrapper = QueryWrapper.create().where(ACCOUNT.AGE.ge(32));
        int rows = accountMapper.deleteByQuery(wrapper);
        Assertions.assertTrue(rows > 0);
    }
(3) UPDATE

BaseMapper 的接口提供了 update、updateByMap、updateByQuery 方法，用于更新数据；

  • update(entity)：根据主键来更新数据，若实体类属性数据为 null，该属性不会新到数据库。
  • update(entity, ignoreNulls)：根据主键来更新数据到数据库。
  • updateByMap(entity, whereConditions)：根据 Map 构建的条件来更新数据。
  • updateByMap(entity, ignoreNulls, whereConditions)：根据 Map 构建的条件来更新数据。
  • updateByCondition(entity, whereConditions)：根据查询条件来更新数据。
  • updateByCondition(entity, ignoreNulls, whereConditions)：根据查询条件来更新数据。
  • updateByQuery(entity, queryWrapper)：根据查询条件来更新数据。
  • updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。
① update
 @Test
    public void testUpdate() {
        Account account = new Account().setId(5L)
                .setAge(39)
                .setUserName("测试修改")
                .setBirthday(new Date(2023, Calendar.SEPTEMBER, 6, 12, 12, 12));
        /**
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        int rows = accountMapper.update(account);
        Assertions.assertTrue(rows > 0);
    }
	
 @Test
    public void testUpdateIgnoreNulls() {
        Account account = new Account().setId(6L)
                .setAge(null)
                .setUserName(null)
                .setBirthday(new Date(2023, Calendar.SEPTEMBER, 6, 12, 12, 12));
        /**
         * 不忽略null值
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        int rows = accountMapper.update(account, false);
        System.out.println("rows = " + rows);
    }
② updateByMap
@Test
    public void testUpdateByMap() {
        Account account = new Account()
                .setId(7L) // 不生效
                .setUserName("updateByMap")
                .setAge(24)
                .setBirthday(null);
        // 注意：这样更新实体类的id是不生效的
        Map<String, Object> whereCondition = Map.of("id", 13);

        /**
         * 忽略null
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? WHERE `id` = ?
         */
        accountMapper.updateByMap(account, whereCondition);

        /**
         * 不忽略null
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        accountMapper.updateByMap(account, false, whereCondition);
    }
③ updateByCondition
/**
     * updateByCondition(entity, whereConditions)：根据查询条件来更新数据。
     * updateByCondition(entity, ignoreNulls, whereConditions)：根据查询条件来更新数据。
     */
    @Test
    public void testUpdateByCondition() {
        Account account = new Account()
                .setId(8L)
                .setUserName("updateByCondition")
                .setBirthday(DateUtil.toDate(LocalDateTime.now()));
        QueryCondition condition = QueryCondition.create(new QueryColumn("id"),
                SqlConsts.EQUALS, 8);
        /**
         * 忽略null
         * UPDATE `tb_account` SET `user_name` = ? , `birthday` = ? WHERE `id` = ?
         */
        accountMapper.updateByCondition(account, condition);

        /**
         * 不忽略null
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        accountMapper.updateByCondition(account, false, condition);
    }
④ updateByQuery
/**
     * updateByQuery(entity, queryWrapper)：根据查询条件来更新数据。
     * updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。
     */
    @Test
    public void testUpdateByQuery() {
        Account account = new Account().setUserName("updateByQuery");

        /**
         * UPDATE `tb_account` SET `user_name` = ? WHERE `id` = ?
         */
        accountMapper.updateByQuery(account,
                QueryWrapper.create().where(ACCOUNT.ID.eq(9L)));
    }
⑤ UpdateEntity
@Test
    public void testUpdateEntity1() {
        Account account = UpdateEntity.of(Account.class, 10L);
        /**
         * 官方说明：通过 UpdateEntity 创建的对象，只会更新调用了 setter 方法的字段，若不调用 setter 方法，不管这个对象里的属性的值是什么，都不会更新到数据库。
         */
        account.setAge(66)
                .setUserName("UpdateEntity")
                .setBirthday(null);
        accountMapper.update(account);
    }

    @Test
    public void testUpdateEntity2() {
        Account account = new Account()
                .setId(10L)
                .setUserName("UpdateEntity2");
        UpdateWrapper wrapper = UpdateWrapper.of(account);
        // wrapper.set(ACCOUNT.AGE, ACCOUNT.AGE.add(1));

        wrapper.setRaw("age", "age + 1");
        accountMapper.update(account);
    }

    @Test
    public void testUpdateEntity3() {
        Account account = new Account()
                .setId(10L)
                .setUserName("UpdateEntity2");
        UpdateWrapper wrapper = UpdateWrapper.of(account);

        // wrapper.set(ACCOUNT.AGE, ACCOUNT.AGE.add(1));

        wrapper.setRaw(ACCOUNT.AGE, "select * from t_account where id = 3");
        // accountMapper.updateByCondition(account, wrapper);
    }
⑥ UpdateChain
@Test
    public void testUpdateChain() {
        /**
         * UPDATE `tb_account` SET `birthday` = ? , `age` = age + 1 WHERE `age` = ?
         */
        UpdateChain.of(Account.class)
                .set(Account::getBirthday, new Date())
                .setRaw(Account::getAge, "age + 1")
                .where(ACCOUNT.AGE.eq(11)).update();
    }
我也有梦想呀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis-Flex 一个优雅的 Mybatis 增强框架
04-16
Mybatis-Flex 一个优雅的 Mybatis 增强框架
Mybatis Condition 条件查询，修改
翊墨的博客
08-07 711
注意：updateByConditionSelective只会修改被赋值的字段，而updateByCondition会修改全部字段，未赋值的字段会被修改为null
this.updateByConditionSelective(bottle, condition);
qq_34638435的博客
04-26 4424
mybatis 自定义的更新数据的方法 this.updateByConditionSelective(bottle, condition); 只更新对应记录的指定字段；实体类赋值的具体属性值。
通用Mapper常用方法
_Gerald的博客
08-11 3565
一、基础接口 1、Insert（2个） 接口：InsertMapper<T> 方法：int insert(T record); 说明：保存一个实体，null的属性也会保存，不会使用数据库默认值 接口：InsertSelectiveMapper<T> 方法：int insertSelective(T record); 说明：保存一个实体，null的属性不会保存，会使用数据库默认值 2、Delete（2个） 接口：DeleteMapper<T> 方法：int de
更好用的的MybatisPlus：MybatisFlex（上）
Bummon的学习随笔
09-27 1435
中确实提供了一些比中更好用的功能，扩展性与灵活性都比较高，总体来说是一款不错的ORM框架。
SpringBoot+MyBatis flex实现简单增删改查
m0_67930426的博客
09-17 510
项目创建完成。
mybatis-flex-1.6.2.zip
09-01
mybatis-flex-1.6.2.zip源码： 更轻量 MyBatis-Flex 除了 MyBatis 本身，再无任何第三方依赖，因此会带来更高的自主性、把控性和稳定性。在任何一个系统中，依赖越多，稳定性越差。 更灵活 MyBatis-Flex 提供了...
Mybatis-Plus的增删改查快速入门
09-07
在本文中，我们将深入探讨Mybatis-Plus的增删改查快速入门，特别适合对Mybatis-Plus感兴趣的初学者。Mybatis-Plus是一个强大的Mybatis扩展，它简化了Java开发中的数据库操作，提供了便捷的CRUD（创建、读取、更新、...
mybatis-plus 增删改查模板
06-02
plus 增删改查模板mybatis_plus 增删改查模板mybatis_plus 增删改查模板mybatis_plus 增删改查模板mybatis_plus 增删改查模板mybatis_plus 增删改查模板mybatis_plus 增删改查模板mybatis_plus 增删改查模板mybatis_...
mybatis-plus增删改查
最新发布
01-24
MyBatis-Plus增删改查基础知识点总结 MyBatis-Plus是一款基于MyBatis框架的增强工具，提供了许多实用的特性和功能，帮助开发者快速实现数据库的增删改查操作。下面是MyBatis-Plus增删改查基础知识点总结： 一、...
通用Mapper各种方法及说明
weixin_45941064的博客
04-25 4481
基础接口 Select 接口： SelectMapper 方法： List select(T record); 解释： 根据实体中的属性值进行查询，查询条件使用等号 接口： SelectByPrimaryKeyMapper 方法： T selectByPrimaryKey(Object key); 解释： 根据主键字段进行查询，方法参数必须包含完整的主键属性，查询条件使用等号 接口： SelectAllMapper 方法： List selectAll(); 解释： 查询全部结果，se
MyBatis Mapper3接口大全
wtopps的专栏
04-18 1万+
Mapper3接口有两种形式，一种是提供了一个方法的接口。还有一种是不提供方法，但是继承了多个单方法的接口，一般是某类方法的集合。 例如SelectMapper是一个单方法的接口，BaseSelectMapper是一个继承了4个基础查询方法的接口。 基础接口 Select 接口：SelectMapper 方法：List select(T record); 说明
MyBatis的updateByExample()，updateByExampleSelective()，updateByPrimaryKey()，updateByPrimaryKeySelectiv
小高同学要努力吖
11-12 2387
1、updateByExample()按主键更新 更新所有的字段，包括字段为null的也更新 2、updateByExampleSelective()按主键更新值不为null的字段 会对字段进行判断再更新，实体类的属性为null时，mybatis会使用动态sql过滤掉 3、updateByPrimaryKey()按条件更新 对你注入的字段全部更新 4、updateByPrimaryKeySelective()按条件更新值不为null的字段 会对字段进行判断再更新，实体类的属性为null时，mybatis会使
第三十五天：Mybatis进阶（动态SQL+分页插件+多表关系+延迟加载）
qq_38250571的博客
12-07 297
/* 请使用user.sql初始化Mybatis数据库 需求1： 查询所有Student 根据ID查询 需求2： 添加一个Student 需求3： 修改一个Student 需求4： 删除一个Student 需求5： 查询Student，数据库字段名和实体类属性名不一致 // 需求6：根据现有student对象属性的值查找学生 // 学生对象如果只设置了id属性的值，就通过id查询， // 如果id和name属性都有值，那就根据id和name两个条件查询 // 如果id和name、age属性都有值，那就根据i
MyBatis-Plus02 条件构造器QueryWrapper、UpdateWrapper、Condition、LambdaQuery用法详解
weixin_52536274的博客
05-23 1万+
MyBatis-Plus中的条件构造器QueryWrapper、UpdateWrapper、Condition、LambdaQuery用法详解
mybatis-flex笔记
weixin_43247803的博客
01-02 1267
MyBatis-Flex 的增删改功能 - MyBatis-Flex 官方网站http://项目地址。
mybatis-flex探索
qq_14926283的博客
08-10 981
最近无意之中发现了一个非常棒的持久层框架mybatis-flex，迫不及待研究了一下发现简直就是我的梦中情框，之前写ibatis，后来写mybatis，接着写mybatis-plus，接着研究mybatis-flex。
Mybatis Mapper3通用接口查询
热门推荐
wtopps的专栏
03-31 1万+
Mybatis的第三方通用类库通用Mapper 提供了简易的直接进行查询的方式，只需要继承指定的父类，调用其相应的方法，即可完成增删改查的基础操作，但只限于单表，下面来看一下是如何进行配置的。常用的父类及其方法 SelectOneMapper (selectOne) SelectMapper (select) SelectAllMapper (selectAll) SelectCountMapper
MyBatis-Flex 一个优雅的 MyBatis 增强框架
一碗清深的博客
08-07 955
MyBatis-Flex 是一个优雅的 MyBatis 增强框架，它非常轻量、同时拥有极高的性能与灵活性。我们可以轻松的使用 Mybaits-Flex 链接任何数据库，其内置的 QueryWrapper 帮助我们极大的减少了 SQL 编写的工作的同时，减少出错的可能性。
mybatis-plus实现增删改查
03-16
Mybatis-Plus是一个基于Mybatis的增强工具，可以简化Mybatis的开发，提高开发效率。以下是使用Mybatis-Plus实现增删改查的示例： 1. 增加数据 使用Mybatis-Plus的BaseMapper接口的insert方法可以实现数据的增加操作。例如： User user = new User(); user.setName("张三"); user.setAge(20); userMapper.insert(user); 2. 删除数据 使用Mybatis-Plus的BaseMapper接口的deleteById方法可以实现根据ID删除数据的操作。例如： userMapper.deleteById(1); 3. 修改数据 使用Mybatis-Plus的BaseMapper接口的updateById方法可以实现根据ID修改数据的操作。例如： User user = new User(); user.setId(1); user.setName("李四"); user.setAge(25); userMapper.updateById(user); 4. 查询数据 使用Mybatis-Plus的BaseMapper接口的selectById方法可以实现根据ID查询数据的操作。例如： User user = userMapper.selectById(1); 使用Mybatis-Plus的BaseMapper接口的selectList方法可以实现查询所有数据的操作。例如： List<User> userList = userMapper.selectList(null); 使用Mybatis-Plus的QueryWrapper类可以实现复杂的查询条件。例如： QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.eq("name", "张三"); List<User> userList = userMapper.selectList(wrapper);

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值