条件构造器和常用接口

文章写到这里，您应该会好奇，怎么没有提及到复杂的条件查询，如Like、Between、IsNull、>、<等条件查询。那么现在就是这些复杂条件查询亮相的时候了！这部分内容很重要！

1. Wrapper简介

• Wrapper ： 条件构造抽象类，最顶端父类
  • AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
    • QueryWrapper ： 查询条件封装
    • UpdateWrapper ： Update 条件封装
    • AbstractLambdaWrapper ： 使用 Lambda 语法
      • LambdaQueryWrapper ：用于 Lambda 语法使用的查询 Wrapper
      • LambdaUpdateWrapper ： Lambda 更新封装 Wrapper

在实际业务中QueryWrapper使用得比较多

2、QueryWrapper

2.1、例1：组装查询条件

  @Test
    public void test01() {
        //查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息
        /* SELECT id,name AS name,age,email,deleted FROM user WHERE
         deleted=0 AND (name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL) */
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name", "b").between("age", 20, 30).isNotNull("email");
        List<User> list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

2.2、例2：组装排序条件

    @Test
    public void test02() {

        //按年龄降序查询用户，如果年龄相同则按id升序排列
        /* SELECT id,name AS name,age,email,deleted FROM user WHERE deleted=0 ORDER BY age DESC,id ASC */
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("age").orderByAsc("id");
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

2.3、例3：组装删除条件

    @Test
    public void test03() {

        //删除email为空的用户
        //DELETE FROM user WHERE (email IS NULL)
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("email");
        //条件构造器也可以构建删除语句的条件
        int result = userMapper.delete(queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

2.4、例4：条件的优先级

  @Test
    public void test04() {

        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改
        /* UPDATE user SET age=?, email=? WHERE (name LIKE ? AND age > ? OR email IS NULL) */
        queryWrapper
                .like("name", "a")
                .gt("age", 20)
                .or()
                .isNull("email");
        User user = new User();
        user.setAge(18);
        user.setEmail("1811421199@ccit.stu.edu");
        int result = userMapper.update(user, queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

    @Test
    public void test04_2() {

        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息修改
        /* UPDATE user SET age=?, email=? WHERE (name LIKE ? AND (age > ? OR email IS NULL)) */
        //lambda表达式内的逻辑优先运算
        queryWrapper
                .like("name", "a")
                .and(i -> i.gt("age", 20).or().isNull("email"));
        User user = new User();
        user.setAge(18);
        user.setEmail("1811421199@ccit.stu.edu");
        int result = userMapper.update(user, queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

2.5、例5：组装select子句

 @Test
    public void test05() {

        //查询用户信息的name和age字段
        //SELECT name,age FROM user
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("name", "age");
        //selectMaps()返回Map集合列表，通常配合select()使用，避免User对象中没有被查询到的列值为null
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }

2.6、例6：实现子查询

  @Test
    public void test06() {

        //查询id小于等于3的用户信息
        /* SELECT id,name AS name,age,email,deleted FROM user WHERE (id IN(select id from user where id <= 3)) */
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.inSql("id", "select id from user where id <= 3");
        //selectObjs的使用场景：只返回一列
        List<Object> objects = userMapper.selectObjs(queryWrapper);
        objects.forEach(System.out::println);
    }

3、UpdateWrapper

   @Test
    public void test07() {

        //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息修改
        //组装set子句以及修改条件
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        //lambda表达式内的逻辑优先运算
        updateWrapper
                .set("age", 18)
                .set("email", "1811421199@ccit.stu.edu")
                .like("name", "a")
                .and(i -> i.gt("age", 20).or().isNull("email"));
        //这里必须要创建User对象，否则无法应用自动填充。如果没有自动填充，可以设置为null
        /* UPDATE user SET name=?, age=?,email=? WHERE (name LIKE ? AND (age > ? OR email IS NULL)) */
        User user = new User();
        user.setName("张三");
        int result = userMapper.update(user, updateWrapper);
        /* UPDATE user SET age=?,email=? WHERE (name LIKE ? AND (age > ? OR email IS NULL)) */
        int result1 = userMapper.update(null, updateWrapper);
        System.out.println(result1);
    }

4、condition

在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件，若没有选择则一定不能组装，以免影响SQL执行的结果。
思路一：

@Test
    public void test08() {

        //定义查询条件，有可能为null（用户未输入或未选择）
        String name = null;
        Integer ageBegin = 10;
        Integer ageEnd = 24;
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成
        if (StringUtils.isNotBlank(name)) {

            queryWrapper.like("name", "a");
        }
        if (ageBegin != null) {

            queryWrapper.ge("age", ageBegin);
        }
        if (ageEnd != null) {

            queryWrapper.le("age", ageEnd);
        }
        /* SELECT id,name AS name,age,email,deleted FROM user WHERE (age >=? AND age <= ?) */
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

思路二：
上面的实现方案没有问题，但是代码比较复杂，我们可以使用带condition参数的重载方法构建查询条件，简化代码的编写：

   @Test
    public void test08UseCondition() {

        //定义查询条件，有可能为null（用户未输入或未选择）
        String name = null;
        Integer ageBegin = 10;
        Integer ageEnd = 24;
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成
        queryWrapper
                .like(StringUtils.isNotBlank(name), "name", "a")
                .ge(ageBegin != null, "age", ageBegin)
                .le(ageEnd != null, "age", ageEnd);
        /* SELECT id,name AS name,age,email,deleted FROM user WHERE (age >=? AND age <= ?) */
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

5、LambdaQueryWrapper

 @Test
    public void test09() {

        //定义查询条件，有可能为null（用户未输入）
        String name = "a";
        Integer ageBegin = 10;
        Integer ageEnd = 24;
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        //避免使用字符串表示字段，防止运行时错误
        queryWrapper
                .like(StringUtils.isNotBlank(name), User::getName, name)
                .ge(ageBegin != null, User::getAge, ageBegin)
                .le(ageEnd != null, User::getAge, ageEnd);
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

6、LambdaUpdateWrapper

  @Test
    public void test10() {

        //组装set子句
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper
                .set(User::getAge, 18)
                .set(User::getEmail, "1811421199@ccit.stu.edu")
                .like(User::getName, "a")
                .and(i -> i.lt(User::getAge, 24).or().isNull(User::getEmail));
        //lambda表达式内的逻辑优先运算
        User user = new User();
        int result = userMapper.update(user, updateWrapper);
        System.out.println("受影响的行数：" + result);
    }

7.测试用例

1.ge、gt、le、lt、isNull、isNotNull
分别代表>=、>、<=、<、isNull、isNotNUll
首先需要构建条件查询器QueryWrapper queryWrapper = new QueryWrapper<>();

  @Test
    public void select() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        // ge、gt、le、lt
        queryWrapper.ge("age", 18);
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);

    }

2.eq、ne
分别代表=、!=

@Test
    public void select2() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        // eq、ne 分别代表  = , !=
        //在这里eq就代表查询年龄为20岁的用户
        queryWrapper.eq("age", 20);
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);

    }

3.between、notBetween
between、notBetween分别代表包含和不包含。还需要注意：between、notBetween包含大小边界

    @Test
    public void select3() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //between、notBetween分别代表包含和不包含
        //在这里eq就代表查询年龄在18岁和21之岁间的用户(包括18岁和21岁)
        queryWrapper.between("age", 18,21);
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);

    }

4.like、notLike、likeLeft、likeRight 模糊查询双非模糊查询左边模糊查询右边模糊查询
%表示匹配任意字符
abc%表示左边是abc，右边是任意字符
%abc表示左边是任意字符，右边是abc
abc%abc表示左右两边是abc，中间是任意字符
%abc%表示中间是abc，左右两边是任意字符
它们分别代表%列值%、%列值、列值%
selectMaps()返回Map集合，通常配合select()使用

   @Test
    public void select4() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //它们分别代表
        //在这里like就代表模糊查询名字中含“a”的用户
        queryWrapper.likeLeft("name", "a");
        List<Map<String, Object>> usersMaps = userMapper.selectMaps(queryWrapper);
        usersMaps.forEach(System.out::println);

    }

5.orderBy、orderByDesc、orderByAsc
它们分别代表排序依据、降序排列 、升序排列

    @Test
    public void select5() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //  以年龄为分组,查询用户情况，降序排列
        queryWrapper.orderByDesc("age")
        List<User> usersList = userMapper.selectList(queryWrapper);
        usersList.forEach(System.out::println);
    }

其实，还有一些细节没有介绍到，如 or 和 and 、拼接、子查询、嵌套等条件。
到这里，您已经基本上掌握Mybatis-plus基础知识。如若您想了解更加全民、更加复杂的应用，情投入到实际开发中。实际的开发的SQL会更加复杂多样，因此您还需要熟练SQL语句。学习Mybatish或者Mybatis-plus等ORM框架并不意味着，我们不需要编写SQL语句。Mybatis-plus太方便了，它确实减少了我们的工作量，但它也是危险的。太过于依赖Mybatis-plus框架，兴许导致我们最后只会写CRUD代码了。
如有错误的地方，请指出

参考

建议您到Mybatis-plus官网上学习，一切以官网的资料为准。在不同的版本，有一些方法有弃用、更改、补充。例如在本教程中，Mybatis-plus中的分页插件在3.4.0已经更改。
如果您不遗忘或者不了解Mybatis,您也可以浏览我的博客文章。→Mybatis学习笔记
也可以了解Mybatis官网