MyBatis-Plus 条件构造器常用方法使用（相等判断、范围判断、模糊匹配、非空判断、in判断、分组、排序、条件判断、逻辑判断、存在判断、查询字段）

1 相等判断

1.1 allEq

全部条件都相等。

    /**
     * 使用条件构造器的allEq()方法
     *
     * @return
     */
    public List<UserEntity> getListByAllEq() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        Map<String, Object> paramsMap = new HashMap<>();
        paramsMap.put("username", "1");
        paramsMap.put("pickname", "张三");
        queryWrapper.allEq(paramsMap);
        return userService.list(queryWrapper);
    }

1.2 eq

指定条件相等。

    /**
     * 使用条件构造器的eq()方法
     *
     * @return
     */
    public List<UserEntity> getListByEq() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().eq(UserEntity::getUsername, "123");
        return userService.list(queryWrapper);
    }

1.3 ne

指定条件不相等。

    /**
     * 使用条件构造器的ne()方法
     *
     * @return
     */
    @GetMapping("/getListByNe")
    public List<UserEntity> getListByNe() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().ne(UserEntity::getUsername, "123");
        return userService.list(queryWrapper);
    }

2 范围判断

2.1 gt

大于指定条件。

    /**
     * 使用条件构造器的gt()方法
     *
     * @return
     */
    public List<UserEntity> getListByGt() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().gt(UserEntity::getUsername, "123");
        return userService.list(queryWrapper);
    }

2.2 ge

大于等于指定条件。

    /**
     * 使用条件构造器的ge()方法
     *
     * @return
     */
    @GetMapping("/getListByGe")
    public List<UserEntity> getListByGe() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().ge(UserEntity::getUsername, "123");
        return userService.list(queryWrapper);
    }

2.3 lt

小于指定条件。

    /**
     * 使用条件构造器的lt()方法
     *
     * @return
     */
    @GetMapping("/getListByLt")
    public List<UserEntity> getListByLt() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().lt(UserEntity::getUsername, "123");
        return userService.list(queryWrapper);
    }

2.4 le

小于等于指定条件。

    /**
     * 使用条件构造器的le()方法
     *
     * @return
     */
    @GetMapping("/getListByLe")
    public List<UserEntity> getListByLe() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().le(UserEntity::getUsername, "123");
        return userService.list(queryWrapper);
    }

2.5 between

介于指定范围之间。

    /**
     * 使用条件构造器的between()方法
     *
     * @return
     */
    @GetMapping("/getListByBetween")
    public List<UserEntity> getListByBetween() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().between(UserEntity::getUsername, "111", "123");
        return userService.list(queryWrapper);
    }

2.6 notBetween

不介于指定范围之间。

    /**
     * 使用条件构造器的notBetween()方法
     *
     * @return
     */
    @GetMapping("/getListByNotBetween")
    public List<UserEntity> getListByNotBetween() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().notBetween(UserEntity::getUsername, "111", "123");
        return userService.list(queryWrapper);
    }

3 模糊匹配

3.1 like

某个字符串包含指定字符串。

    /**
     * 使用条件构造器的like()方法
     *
     * @return
     */
    @GetMapping("/getListByLike")
    public List<UserEntity> getListByLike() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().like(UserEntity::getUsername, "11");
        return userService.list(queryWrapper);
    }

3.2 notLike

某个字符串不包含指定字符串。

    /**
     * 使用条件构造器的notLike()方法
     *
     * @return
     */
    @GetMapping("/getListByNotLike")
    public List<UserEntity> getListByNotLike() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().notLike(UserEntity::getUsername, "11");
        return userService.list(queryWrapper);
    }

3.3 likeLeft

某个字符串以指定字符串结尾。

    /**
     * 使用条件构造器的likeLeft()方法
     *
     * @return
     */
    @GetMapping("/getListByLikeLeft")
    public List<UserEntity> getListByLikeLeft() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().likeLeft(UserEntity::getUsername, "12");
        return userService.list(queryWrapper);
    }

3.4 likeRight

某个字符串以指定字符串开头。

    /**
     * 使用条件构造器的likeRight()方法
     *
     * @return
     */
    @GetMapping("/getListByLikeRight")
    public List<UserEntity> getListByLikeRight() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().likeRight(UserEntity::getUsername, "12");
        return userService.list(queryWrapper);
    }

4 非空判断

4.1 isNull

指定字段为null。

    /**
     * 使用条件构造器的isNull()方法
     *
     * @return
     */
    @GetMapping("/getListByIsNull")
    public List<UserEntity> getListByIsNull() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().isNull(UserEntity::getSex);
        return userService.list(queryWrapper);
    }

4.2 isNotNull

指定字段不为null。

    /**
     * 使用条件构造器的isNotNull()方法
     *
     * @return
     */
    @GetMapping("/getListByIsNotNull")
    public List<UserEntity> getListByIsNotNull() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().isNotNull(UserEntity::getSex);
        return userService.list(queryWrapper);
    }

5 in判断

5.1 in

满足指定条件之一。

    /**
     * 使用条件构造器的in()方法
     *
     * @return
     */
    @GetMapping("/getListByIn")
    public List<UserEntity> getListByIn() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().in(UserEntity::getUsername, "11", "123");
        return userService.list(queryWrapper);
    }

5.2 notIn

不满足指定条件之一。

    /**
     * 使用条件构造器的notIn()方法
     *
     * @return
     */
    @GetMapping("/getListByNotIn")
    public List<UserEntity> getListByNotIn() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().notIn(UserEntity::getUsername, "11", "123");
        return userService.list(queryWrapper);
    }

5.3 inSql

满足指定条件之一。

    /**
     * 使用条件构造器的inSql()方法
     *
     * @return
     */
    @GetMapping("/getListByInSql")
    public List<UserEntity> getListByInSql() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().inSql(UserEntity::getUsername, "11,123");
        return userService.list(queryWrapper);
    }

5.4 notInSql

不满足指定条件之一。

    /**
     * 使用条件构造器的notInSql()方法
     *
     * @return
     */
    @GetMapping("/getListByNotInSql")
    public List<UserEntity> getListByNotInSql() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().notInSql(UserEntity::getUsername, "11,123");
        return userService.list(queryWrapper);
    }

6 分组

6.1 groupBy

按字段值分组，每一组只会出现一条数据。

    /**
     * 使用条件构造器的groupBy()方法
     *
     * @return
     */
    @GetMapping("/getListByGroupBy")
    public List<UserEntity> getListByGroupBy() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().groupBy(UserEntity::getSex);
        return userService.list(queryWrapper);
    }

7 排序

7.1 orderByAsc

根据指定字段升序排序。

    /**
     * 使用条件构造器的orderByAsc()方法
     *
     * @return
     */
    @GetMapping("/getListByOrderByAsc")
    public List<UserEntity> getListByOrderByAsc() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().orderByAsc(UserEntity::getUsername);
        return userService.list(queryWrapper);
    }

7.2 orderByDesc

根据指定字段降序排序。

    /**
     * 使用条件构造器的orderByDesc()方法
     *
     * @return
     */
    @GetMapping("/getListByOrderByDesc")
    public List<UserEntity> getListByOrderByDesc() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().orderByDesc(UserEntity::getUsername);
        return userService.list(queryWrapper);
    }

7.3 orderBy

根据指定字段升序/降序排序。

    /**
     * 使用条件构造器的orderBy()方法
     *
     * @return
     */
    @GetMapping("/getListByOrderBy")
    public List<UserEntity> getListByOrderBy() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().orderBy(true, false, UserEntity::getUsername);
        return userService.list(queryWrapper);
    }

注：

（1）第一个参数必须为true。
（2）第二个参数为true则升序排序，为false则降序排序。

8 条件判断

8.1 having

跟sql里面的having类似。

    /**
     * 使用条件构造器的having()方法
     *
     * @return
     */
    @GetMapping("/getListByHaving")
    public List<Map<String, Object>> getListByHaving() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.select("password,count(*) as sexCount")
                .groupBy("password")
                .having("count(*)>1");
        return userService.listMaps(queryWrapper);
    }

注：

（1）having()需要配合select()、groupBy()一起配合使用。

（2）having里面只能使用聚合函数。

8.2 func

主要方便在出现if...else下调用不同方法能不断链。

    /**
     * 使用条件构造器的func()方法
     *
     * @return
     */
    @GetMapping("/getListByFunc")
    public List<UserEntity> getListByFunc() {
        LambdaQueryWrapper<UserEntity> queryWrapper = Wrappers.<UserEntity>lambdaQuery();
        queryWrapper.func(x -> {
            if (true) {
                x.eq(UserEntity::getUsername, 1);
            } else {
                x.eq(UserEntity::getUsername, 1);
            }
        });
        return userService.list(queryWrapper);
    }

9 逻辑判断

9.1 and

与逻辑判断。

    /**
     * 使用条件构造器的and()方法
     *
     * @return
     */
    @GetMapping("/getListByAnd")
    public List<UserEntity> getListByAnd() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().eq(UserEntity::getPassword, "123456")
                .and(t -> t.eq(UserEntity::getSex, "02"));
        return userService.list(queryWrapper);
    }

9.2 or

或逻辑判断。

    /**
     * 使用条件构造器的or()方法
     *
     * @return
     */
    @GetMapping("/getListByOr")
    public List<UserEntity> getListByOr() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.lambda().eq(UserEntity::getPassword, "123")
                .or(t -> t.eq(UserEntity::getSex, "02"));
        return userService.list(queryWrapper);
    }

10 存在判断

10.1 exists

exists用于检查子查询是否会返回数据，该子查询实际上并不返回任何数据，有查询数据返回值为true，没有查询数据返回值为false。

    /**
     * 使用条件构造器的exists()方法
     *
     * @return
     */
    @GetMapping("/getListByExists")
    public List<UserEntity> getListByExists() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.exists("select * from users where password='123'");
        return userService.list(queryWrapper);
    }

10.2 notExists

notExists用于检查子查询是否不会返回数据，该子查询实际上并不返回任何数据，有查询数据返回值为false，没有查询数据返回值为true。

    /**
     * 使用条件构造器的notExists()方法
     *
     * @return
     */
    @GetMapping("/getListByNotExists")
    public List<UserEntity> getListByNotExists() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.notExists("select * from users where password='123111'");
        return userService.list(queryWrapper);
    }

11 查询字段

11.1 select

    /**
     * 使用条件构造器的select()方法
     *
     * @return
     */
    @GetMapping("/getListBySelect")
    public List<UserEntity> getListBySelect() {
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper();
        queryWrapper.select("username,password");
        return userService.list(queryWrapper);
    }