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

ゞ浴缸里的玫瑰 2022-09-05 11:27 62阅读 0赞

## 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的配置请查看以下博客。

[Spring Boot 配置MyBatis-Plus（实现查询、新增、更新、删除）][Spring Boot _MyBatis-Plus]

[Spring Boot _MyBatis-Plus]: https://blog.csdn.net/qq_38974638/article/details/119698988