mybatisPlus的CRUD总结及条件构造

Posted 2021-05-25 捡黄金的少年

准备工作

（1）、创建测试的数据库表

（2)、配置mybatisPlus环境

1、Dao层（Mapper层）的增删改查方法总结

一、Mapper层insert插入
下面是官网的截图

我的例子：

   @Test
    public void insertTest() {
        User user = new User();
        user.setName("测试增加一个");
        userMapper.insert(user);
    }

打印的日志入下

==>  Preparing: INSERT INTO tb_user ( name, create_time ) VALUES ( ?, ? ) 
==> Parameters: 测试增加一个(String), null
<==    Updates: 1

二、Mapper层delete删除
官网的解释如下：

我的列子如下
（1）、delete方法
传入删除条件为 name=“测试增加一个”的方法

 @Test
    public void deleteTest() {
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("name","测试增加一个");
        int delete = userMapper.delete(userQueryWrapper);
        System.out.println(delete);
    }

使用Lambda表达式构造条件，调用delete方法删除，和上面一个一样

    @Test
    public void deleteTest() {
//        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
//        userQueryWrapper.eq("name","测试增加一个");
//        int delete = userMapper.delete(userQueryWrapper);
//        System.out.println(delete);
        LambdaQueryWrapper<User> objectLambdaQueryWrapper = Wrappers.<User>lambdaQuery();
        objectLambdaQueryWrapper.eq(User::getName,"测试增加一个");
        int delete = userMapper.delete(objectLambdaQueryWrapper);
        System.out.println("删除了"+delete);
    }

（2）、deleteBatchIds 批量删除ID

   @Test
    public void deleteTest2() {
        int i = userMapper.deleteBatchIds(Arrays.asList(11, 1094592041087729666L));
        System.out.println("删除了"+i);
    }

（3）、deleteById 根据 ID 删除

  @Test
    public void deleteTest3() {
        int i = userMapper.deleteById(11);
        System.out.println(i);
    }

（4）、deleteByMap 根据 columnMap 条件，删除记录
删除前

删除后

这个就和第一个delete方法差不多的，满足map中的条件就能删除

    @Test
    public void deleteTest4() {
        Map<String,Object> someMap=new HashMap<>();
        someMap.put("name","测试增加一个");
        someMap.put("age",22);
        int i = userMapper.deleteByMap(someMap);
        System.out.println("删除了"+i);
    }

三、Mapper层update修改
官网的解释如下

（1）、updateById
修改前数据库表如下

修改后数据库表如下

除了通过userMapper.updateById的方法进行修改，还能通过实体类进行user.updateById();直接调用哦，同样user也能调用insert方法，以及 user.insertOrUpdate()；当实体类中ID存在就修改，不存在就新增

  @Test
    public void updateTest() {
        User user = new User();
        user.setName("建设局三");
        user.setId(1094592041087729690L);
        user.setAge(22);
//        boolean updateById = user.updateById();
        int id = userMapper.updateById(user);
        System.out.println(id);
    }

（2）、update 方法
update方法，传入参数，第一个是修改的参数，第二个是查询需要修改的条件

     public void updateTest22() {
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<User>();
        userQueryWrapper.eq("name","建设").eq("age",22);
        User user = new User();
        user.setAge(999);

        int update = userMapper.update(user, userQueryWrapper);
        System.out.println(update);
    }

采用 Lambda防误写功能，方式和上面一样的，修改方法

@Test
    public void updateTest2() {

        LambdaUpdateWrapper<User> lambdaUpdateWrapper = Wrappers.<User>lambdaUpdate();
        lambdaUpdateWrapper.eq(User::getName, "建设").eq(User::getAge, 22).set(User::getAge,32);

        int update = userMapper.update(null, lambdaUpdateWrapper);
        System.out.println(update);
    }

四、Mapper层select查询
官网的解释如下

（1）selectById
通过ID查询

 @Test
    public void selectTest() {
        User user = userMapper.selectById(1094592041087729691L);
        System.out.println(user);

    }

（2）selectOne
返回一个实体类，限制只能查询一个，如果满足查询条件的有多个，则会报错

   @Test
    public void selectTest2() {
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<User>();
        userQueryWrapper.eq("name","建设");
        User user = userMapper.selectOne(userQueryWrapper);
        System.out.println(user);

    }

（3）selectBatchIds
通过ID的集合查询，返回一个实体类的数组

   public void selectTest3() {
        List<User> userList = userMapper.selectBatchIds(Arrays.asList(1094592041087729693L,1094592041087729692L));
        userList.forEach(System.out::println);
    }

（4）、selectList 根据 entity 条件，查询全部记录
1、采用QueryWrapper编辑查询条件

   @Test
    public void selectTest4() {
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("name","建设").le("age",999);
        List<User> userList = userMapper.selectList(userQueryWrapper);
        userList.forEach(System.out::println);
    }

2、采用LambdaQueryWrapper编辑查询条件（具有防误写功能）

    public void selectTest4() {
      // lamaDa表达式防误写功能
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getName, "建设").le(User::getAge, 999);
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

（5）、selectByMap 通过Map添加查询条件

    @Test
    public void selectTest5() {
        Map<String, Object> map = new HashMap<>();
        map.put("name","建设");
        map.put("age",999);
        List<User> userList = userMapper.selectByMap(map);
        userList.forEach(System.out::println);
    }

（6）、 selectMaps 根据 Wrapper 条件，查询全部记录

    @Test
    public void selectTest6() {
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getEmail, "3333");
        List<Map<String, Object>> list = userMapper.selectMaps(queryWrapper);
        list.forEach(System.out::println);
    }

（7）、selectObjs 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值

   @Test
    public void selectTest7() {
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getName, "建设");
        List<Object> objects = userMapper.selectObjs(queryWrapper);
        objects.forEach(System.out::println);
    }

打印的代码如下，

==>  Preparing: SELECT id,name,age,email,manager_id,create_time,update_time,version,deleted FROM tb_user WHERE (name = ?) 
==> Parameters: 建设(String)
<==    Columns: id, name, age, email, manager_id, create_time, update_time, version, deleted
<==        Row: 1094592041087729690, 建设, 32, null, null, null, null, 1, 0
<==        Row: 1094592041087729692, 建设, 999, null, null, null, null, 1, 0
<==        Row: 1094592041087729693, 建设, 999, 3333, null, null, null, 1, 0
<==      Total: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@34a2d6e0]
1094592041087729690
1094592041087729692
1094592041087729693

（8）、selectPage 根据 entity 条件，查询全部记录（并翻页）
查询返回的是一个IPage的对象，里面包含总记录数getTotal，和查询内容getRecords，以及当前页等其他信息

@Test
    public void selectTest8() {
        IPage<User> userIPage = new Page<>(1, 2);
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("name", "建设");
        IPage<User> userIPage1 = userMapper.selectPage(userIPage, userQueryWrapper);
        System.out.println("总数为"+userIPage1.getTotal());
        System.out.println("查询内容"+userIPage1.getRecords());

    }

查询结果

总数为3
查询内容[User(id=1094592041087729690, name=建设, age=32, email=null, managerId=null, createTime=null, updateTime=null, version=1, deleted=0), User(id=1094592041087729692, name=建设, age=999, email=null, managerId=null, createTime=null, updateTime=null, version=1, deleted=0)]

（9）、selectMapsPage 根据 Wrapper 条件，查询全部记录（并翻页）

     @Test
    public void selectTest9() {
//        IPage<User> userIPage2 = new Page<>(1, 2);
        IPage<Map<String,Object>> userIPage2=new Page<>(1,2);
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("name", "建设");
        IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(userIPage2, userQueryWrapper);
        System.out.println("纪录record："+mapIPage.getRecords());
        System.out.println("记录数Total："+mapIPage.getTotal());
        System.out.println("总共页数Pages：" +mapIPage.getPages());
    }

查询的结果为

纪录record：[{deleted=0, name=建设, id=1094592041087729690, version=1, age=32}, {deleted=0, name=建设, id=1094592041087729692, version=1, age=999}]
记录数Total：3
总共页数Pages：2

（10）selectCount 根据 Wrapper 条件，查询总记录数

   @Test
    public void selectTest10() {
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("name", "建设");
        Integer integer = userMapper.selectCount(userQueryWrapper);
        System.out.println("查询的总记录数" + integer);
    }

2、Service CRUD 接口总结

一、Service 层的Save增加
官网的介绍如下

（1）、save 插入一条记录（选择字段，策略插入）

   @Test
    public  void saveTest(){
        User user = new User();
        user.setAge(888);
        user.setName("浩浩");
        boolean save = userService.save(user);
        System.out.println(save);
    }

（2）、saveBatch 插入（批量）
通过数组的方式插入多个

   @Test
    public void saveTest2() {
        User user = new User();
        user.setAge(888);
        user.setName("浩浩");
        User user2 = new User();
        user2.setAge(8888);
        user2.setName("浩浩皓");
        List<User> userList=Arrays.asList(user,user2);
        boolean b = userService.saveBatch(userList);
        System.out.println(b);
    }

3、saveBatch 插入（批量）
虽然都是通过数组的方式插入，但是这个数量官方说法是，插入批次数量，也是每次系统执行SQL的数量打印测试代码入下

   @Test
    public void saveTest2() {
        User user = new User();
        user.setAge(888);
        user.setName("浩浩");
        User user2 = new User();
        user2.setAge(8888);
        user2.setName("浩浩皓");
        User user3 = new User();
        user3.setAge(8888);
        user3.setName("浩浩皓222");
//        List<User> userList=Arrays.asList(user,user2,user3);
        List<User> userList=new ArrayList<>();
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        boolean b = userService.saveBatch(userList,3);
        System.out.println(b);
    }

当设置为1的时候，每次执行的条数为1的时候

 boolean b = userService.saveBatch(userList,1);
 System.out.println(b);

因为数组长度为3，所以执行3次SQL

JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@14fded9d] will be managed by Spring
==>  Preparing: INSERT INTO tb_user ( name, age, create_time ) VALUES ( ?, ?, ? ) 
==> Parameters: 浩浩(String), 888(Integer), null
以上是关于mybatisPlus的CRUD总结及条件构造的主要内容，如果未能解决你的问题，请参考以下文章
 
 掌握MyBatisPlus中的分页及条件查询构建 | 黑马程序员
 第121天学习打卡（MyBatisPlus  CRUD扩展之查询操作  分页查询 删除操作 逻辑删除 条件构造器 自动生成器 ）
 MybatisPlus-03
 用MyBatis Plus来整CRUD
 用MyBatis Plus来整CRUD
 用MyBatis Plus来整CRUD