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);
    }

其他不錯的推薦文章：

MyBatis-Plus官網教程
美團文章聊聊 clean code
阿里巴巴Java開發手冊
阿里巴巴Android開發手冊
Java8 Stream：集合的篩選、歸約、分組、聚合等...