MyBatis-Plus 使用条件构造器进行查询

小咪咪 2022-12-12 15:17 166阅读 0赞

推荐：[MyBatis Plus汇总][MyBatis Plus]

## MyBatis-Plus 使用条件构造器进行查询 ##

首先创建一个数据库表，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70]

然后创建一个Spring Boot项目，pom.xml和配置如下：

<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 
 <groupId>org.kaven</groupId>
 <artifactId>mybatis-plus</artifactId>
 <version>1.0-SNAPSHOT</version>
 
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.3.4.RELEASE</version>
 <relativePath/>
 </parent>
 
 <properties>
 <java.version>1.8</java.version>
 </properties>
 
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-webflux</artifactId>
 </dependency>
 <dependency>
 <groupId>com.baomidou</groupId>
 <artifactId>mybatis-plus-boot-starter</artifactId>
 <version>3.4.0</version>
 </dependency>
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>5.1.49</version>
 </dependency>
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </dependency>
 </dependencies>
 
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>
 </project>

spring:
      application:
        name: mybatis-plus
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        username: root
        password: ITkaven@123
        url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf-8&useSSL=false
    
    server:
      port: 8085
    
    logging:
      level:
        root: warn
        com.kaven.mybatisplus.dao: trace
      pattern:
        console: '%p%m%n'
    
    mybatis-plus:
      mapper-locations: classpath:mappers/*.xml

实体类User：

package com.kaven.mybatisplus.entity;
    
    import com.baomidou.mybatisplus.annotation.TableField;
    import com.baomidou.mybatisplus.annotation.TableId;
    import com.baomidou.mybatisplus.annotation.TableName;
    import lombok.Data;
    
    @TableName("user")
    @Data
    public class User { 
    
        @TableId
        private String id;
    
        @TableField("username")
        private String username;
    
        @TableField("password")
        private String password;
    
        @TableField("age")
        private Integer age;
    
        /** * 使用 @TableField(exist = false) ，表示该字段在数据库中不存在 ，所以不会插入数据库中 * 使用 transient 、 static 修饰属性也不会插入数据库中 */
        @TableField(exist = false)
        private String phone;
    }

Mapper接口UserMapper：

package com.kaven.mybatisplus.dao;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.kaven.mybatisplus.entity.User;
 import org.springframework.stereotype.Component;
 
 
 @Component
 public interface UserMapper extends BaseMapper<User> { }

启动类：

package com.kaven.mybatisplus;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    @MapperScan(basePackages = "com.kaven.mybatisplus.dao")
    public class AppRun { 
        public static void main(String[] args) { 
            SpringApplication.run(AppRun.class , args);
        }
    }

`@MapperScan(basePackages = "com.kaven.mybatisplus.dao")`这个一定要加上。

我们先在数据库中添加几行数据，方便演示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 1]

*  查询`username`包含字符`k`，并且`age`要小于`35`。

package com.kaven.mybatisplus.dao;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.kaven.mybatisplus.entity.User;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.util.List;
 
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserMapperWrapperTest { 
 
 @Autowired
 private UserMapper userMapper;
 
 @Test
 public void selectList(){ 
 QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
 // QueryWrapper<User> userQueryWrapper = Wrappers.query(); 和上面一样的效果
 userQueryWrapper.like("username" , "k").lt("age" , 35);
 List<User> userList = userMapper.selectList(userQueryWrapper);
 userList.forEach(System.out::println);
 }
 }

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center]

很明显，结果是正确的，MyBatis-Plus使用条件构造器进行查询非常简单，通过链式调用即可。 
关键是 `QueryWrapper<T>`这个类，而它则继承了`AbstractWrapper<T, String, QueryWrapper<T>>`这个类。 
`AbstractWrapper<T, String, QueryWrapper<T>>`的源码如下，其实就是实现了一些条件判断方法，自己可以去看一看。

package com.baomidou.mybatisplus.core.conditions;
 
 import com.baomidou.mybatisplus.core.conditions.interfaces.Compare;
 import com.baomidou.mybatisplus.core.conditions.interfaces.Func;
 import com.baomidou.mybatisplus.core.conditions.interfaces.Join;
 import com.baomidou.mybatisplus.core.conditions.interfaces.Nested;
 import com.baomidou.mybatisplus.core.conditions.segments.MergeSegments;
 import com.baomidou.mybatisplus.core.enums.SqlKeyword;
 import com.baomidou.mybatisplus.core.enums.SqlLike;
 import com.baomidou.mybatisplus.core.toolkit.*;
 import com.baomidou.mybatisplus.core.toolkit.sql.SqlUtils;
 import com.baomidou.mybatisplus.core.toolkit.sql.StringEscape;
 
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiPredicate;
 import java.util.function.Consumer;
 
 import static com.baomidou.mybatisplus.core.enums.SqlKeyword.*;
 import static com.baomidou.mybatisplus.core.enums.WrapperKeyword.APPLY;
 import static java.util.stream.Collectors.joining;
 
 /** * 查询条件封装 * * @author hubin miemie HCL * @since 2017-05-26 */
 @SuppressWarnings({ "serial", "unchecked"})
 public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T, R, Children>> extends Wrapper<T>
 implements Compare<Children, R>, Nested<Children, Children>, Join<Children>, Func<Children, R> { 
 
 /** * 占位符 */
 protected final Children typedThis = (Children) this;
 /** * 必要度量 */
 protected AtomicInteger paramNameSeq;
 protected Map<String, Object> paramNameValuePairs;
 protected SharedString lastSql;
 /** * SQL注释 */
 protected SharedString sqlComment;
 /** * SQL起始语句 */
 protected SharedString sqlFirst;
 /** * ß * 数据库表映射实体类 */
 private T entity;
 protected MergeSegments expression;
 /** * 实体类型(主要用于确定泛型以及取TableInfo缓存) */
 private Class<T> entityClass;
 
 @Override
 public T getEntity() { 
 return entity;
 }
 
 public Children setEntity(T entity) { 
 this.entity = entity;
 return typedThis;
 }
 
 protected Class<T> getEntityClass() { 
 if (entityClass == null && entity != null) { 
 entityClass = (Class<T>) entity.getClass();
 }
 return entityClass;
 }
 
 public Children setEntityClass(Class<T> entityClass) { 
 if (entityClass != null) { 
 this.entityClass = entityClass;
 }
 return typedThis;
 }
 
 @Override
 public <V> Children allEq(boolean condition, Map<R, V> params, boolean null2IsNull) { 
 if (condition && CollectionUtils.isNotEmpty(params)) { 
 params.forEach((k, v) -> { 
 if (StringUtils.checkValNotNull(v)) { 
 eq(k, v);
 } else { 
 if (null2IsNull) { 
 isNull(k);
 }
 }
 });
 }
 return typedThis;
 }
 
 @Override
 public <V> Children allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull) { 
 if (condition && CollectionUtils.isNotEmpty(params)) { 
 params.forEach((k, v) -> { 
 if (filter.test(k, v)) { 
 if (StringUtils.checkValNotNull(v)) { 
 eq(k, v);
 } else { 
 if (null2IsNull) { 
 isNull(k);
 }
 }
 }
 });
 }
 return typedThis;
 }
 
 @Override
 public Children eq(boolean condition, R column, Object val) { 
 return addCondition(condition, column, EQ, val);
 }
 
 @Override
 public Children ne(boolean condition, R column, Object val) { 
 return addCondition(condition, column, NE, val);
 }
 
 @Override
 public Children gt(boolean condition, R column, Object val) { 
 return addCondition(condition, column, GT, val);
 }
 
 @Override
 public Children ge(boolean condition, R column, Object val) { 
 return addCondition(condition, column, GE, val);
 }
 
 @Override
 public Children lt(boolean condition, R column, Object val) { 
 return addCondition(condition, column, LT, val);
 }
 
 @Override
 public Children le(boolean condition, R column, Object val) { 
 return addCondition(condition, column, LE, val);
 }
 
 @Override
 public Children like(boolean condition, R column, Object val) { 
 return likeValue(condition, LIKE, column, val, SqlLike.DEFAULT);
 }
 
 @Override
 public Children notLike(boolean condition, R column, Object val) { 
 return likeValue(condition, NOT_LIKE, column, val, SqlLike.DEFAULT);
 }
 
 @Override
 public Children likeLeft(boolean condition, R column, Object val) { 
 return likeValue(condition, LIKE, column, val, SqlLike.LEFT);
 }
 
 @Override
 public Children likeRight(boolean condition, R column, Object val) { 
 return likeValue(condition, LIKE, column, val, SqlLike.RIGHT);
 }
 
 @Override
 public Children between(boolean condition, R column, Object val1, Object val2) { 
 return doIt(condition, () -> columnToString(column), BETWEEN, () -> formatSql("{0}", val1), AND,
 () -> formatSql("{0}", val2));
 }
 
 @Override
 public Children notBetween(boolean condition, R column, Object val1, Object val2) { 
 return doIt(condition, () -> columnToString(column), NOT_BETWEEN, () -> formatSql("{0}", val1), AND,
 () -> formatSql("{0}", val2));
 }
 
 @Override
 public Children and(boolean condition, Consumer<Children> consumer) { 
 return and(condition).addNestedCondition(condition, consumer);
 }
 
 @Override
 public Children or(boolean condition, Consumer<Children> consumer) { 
 return or(condition).addNestedCondition(condition, consumer);
 }
 
 @Override
 public Children nested(boolean condition, Consumer<Children> consumer) { 
 return addNestedCondition(condition, consumer);
 }
 
 @Override
 public Children not(boolean condition, Consumer<Children> consumer) { 
 return not(condition).addNestedCondition(condition, consumer);
 }
 
 @Override
 public Children or(boolean condition) { 
 return doIt(condition, OR);
 }
 
 @Override
 public Children apply(boolean condition, String applySql, Object... value) { 
 return doIt(condition, APPLY, () -> formatSql(applySql, value));
 }
 
 @Override
 public Children last(boolean condition, String lastSql) { 
 if (condition) { 
 this.lastSql.setStringValue(StringPool.SPACE + lastSql);
 }
 return typedThis;
 }
 
 @Override
 public Children comment(boolean condition, String comment) { 
 if (condition) { 
 this.sqlComment.setStringValue(comment);
 }
 return typedThis;
 }
 
 @Override
 public Children first(boolean condition, String firstSql) { 
 if (condition) { 
 this.sqlFirst.setStringValue(firstSql);
 }
 return typedThis;
 }
 
 @Override
 public Children exists(boolean condition, String existsSql) { 
 return doIt(condition, EXISTS, () -> String.format("(%s)", existsSql));
 }
 
 @Override
 public Children notExists(boolean condition, String existsSql) { 
 return not(condition).exists(condition, existsSql);
 }
 
 @Override
 public Children isNull(boolean condition, R column) { 
 return doIt(condition, () -> columnToString(column), IS_NULL);
 }
 
 @Override
 public Children isNotNull(boolean condition, R column) { 
 return doIt(condition, () -> columnToString(column), IS_NOT_NULL);
 }
 
 @Override
 public Children in(boolean condition, R column, Collection<?> coll) { 
 return doIt(condition, () -> columnToString(column), IN, inExpression(coll));
 }
 
 @Override
 public Children notIn(boolean condition, R column, Collection<?> coll) { 
 return doIt(condition, () -> columnToString(column), NOT_IN, inExpression(coll));
 }
 
 @Override
 public Children inSql(boolean condition, R column, String inValue) { 
 return doIt(condition, () -> columnToString(column), IN, () -> String.format("(%s)", inValue));
 }
 
 @Override
 public Children notInSql(boolean condition, R column, String inValue) { 
 return doIt(condition, () -> columnToString(column), NOT_IN, () -> String.format("(%s)", inValue));
 }
 
 @Override
 public Children groupBy(boolean condition, R... columns) { 
 if (ArrayUtils.isEmpty(columns)) { 
 return typedThis;
 }
 return doIt(condition, GROUP_BY,
 () -> columns.length == 1 ? columnToString(columns[0]) : columnsToString(columns));
 }
 
 @Override
 public Children orderBy(boolean condition, boolean isAsc, R... columns) { 
 if (ArrayUtils.isEmpty(columns)) { 
 return typedThis;
 }
 SqlKeyword mode = isAsc ? ASC : DESC;
 for (R column : columns) { 
 doIt(condition, ORDER_BY, () -> columnToString(column), mode);
 }
 return typedThis;
 }
 
 @Override
 public Children having(boolean condition, String sqlHaving, Object... params) { 
 return doIt(condition, HAVING, () -> formatSqlIfNeed(condition, sqlHaving, params));
 }
 
 @Override
 public Children func(boolean condition, Consumer<Children> consumer) { 
 if (condition) { 
 consumer.accept(typedThis);
 }
 return typedThis;
 }
 
 /** * 内部自用 * NOT 关键词 */
 protected Children not(boolean condition) { 
 return doIt(condition, NOT);
 }
 
 /** * 内部自用 * 拼接 AND */
 protected Children and(boolean condition) { 
 return doIt(condition, AND);
 }
 
 /** * 内部自用 * 拼接 LIKE 以及 值 */
 protected Children likeValue(boolean condition, SqlKeyword keyword, R column, Object val, SqlLike sqlLike) { 
 return doIt(condition, () -> columnToString(column), keyword, () -> formatSql("{0}", SqlUtils.concatLike(val, sqlLike)));
 }
 
 /** * 普通查询条件 * * @param condition 是否执行 * @param column 属性 * @param sqlKeyword SQL 关键词 * @param val 条件值 */
 protected Children addCondition(boolean condition, R column, SqlKeyword sqlKeyword, Object val) { 
 return doIt(condition, () -> columnToString(column), sqlKeyword, () -> formatSql("{0}", val));
 }
 
 /** * 多重嵌套查询条件 * * @param condition 查询条件值 */
 protected Children addNestedCondition(boolean condition, Consumer<Children> consumer) { 
 if (condition) { 
 final Children instance = instance();
 consumer.accept(instance);
 return doIt(true, APPLY, instance);
 }
 return typedThis;
 }
 
 /** * 子类返回一个自己的新对象 */
 protected abstract Children instance();
 
 /** * 格式化SQL * * @param sqlStr SQL语句部分 * @param params 参数集 * @return sql */
 protected final String formatSql(String sqlStr, Object... params) { 
 return formatSqlIfNeed(true, sqlStr, params);
 }
 
 /** * * 根据需要格式化SQL * * Format SQL for methods: EntityQ<T>.where/and/or...("name={0}", value); * ALL the {i} will be replaced with #{MPGENVALi} * * ew.where("sample_name={0}", "haha").and("sample_age >{0} * and sample_age<{1}", 18, 30) TO * sample_name=#{MPGENVAL1} and sample_age>#{MPGENVAL2} and * sample_age<#{MPGENVAL3} * * * @param need 是否需要格式化 * @param sqlStr SQL语句部分 * @param params 参数集 * @return sql */
 protected final String formatSqlIfNeed(boolean need, String sqlStr, Object... params) { 
 if (!need || StringUtils.isBlank(sqlStr)) { 
 return null;
 }
 if (ArrayUtils.isNotEmpty(params)) { 
 for (int i = 0; i < params.length; ++i) { 
 String genParamName = Constants.WRAPPER_PARAM + paramNameSeq.incrementAndGet();
 sqlStr = sqlStr.replace(String.format("{%s}", i),
 String.format(Constants.WRAPPER_PARAM_FORMAT, Constants.WRAPPER, genParamName));
 paramNameValuePairs.put(genParamName, params[i]);
 }
 }
 return sqlStr;
 }
 
 /** * 获取in表达式 包含括号 * * @param value 集合 */
 private ISqlSegment inExpression(Collection<?> value) { 
 return () -> value.stream().map(i -> formatSql("{0}", i))
 .collect(joining(StringPool.COMMA, StringPool.LEFT_BRACKET, StringPool.RIGHT_BRACKET));
 }
 
 /** * 必要的初始化 */
 protected void initNeed() { 
 paramNameSeq = new AtomicInteger(0);
 paramNameValuePairs = new HashMap<>(16);
 expression = new MergeSegments();
 lastSql = SharedString.emptyString();
 sqlComment = SharedString.emptyString();
 sqlFirst = SharedString.emptyString();
 }
 
 @Override
 public void clear() { 
 entity = null;
 paramNameSeq.set(0);
 paramNameValuePairs.clear();
 expression.clear();
 lastSql.toEmpty();
 sqlComment.toEmpty();
 sqlFirst.toEmpty();
 }
 
 /** * 对sql片段进行组装 * * @param condition 是否执行 * @param sqlSegments sql片段数组 * @return children */
 protected Children doIt(boolean condition, ISqlSegment... sqlSegments) { 
 if (condition) { 
 expression.add(sqlSegments);
 }
 return typedThis;
 }
 
 @Override
 public String getSqlSegment() { 
 return expression.getSqlSegment() + lastSql.getStringValue();
 }
 
 @Override
 public String getSqlComment() { 
 if (StringUtils.isNotBlank(sqlComment.getStringValue())) { 
 return "/*" + StringEscape.escapeRawString(sqlComment.getStringValue()) + "*/";
 }
 return null;
 }
 
 @Override
 public String getSqlFirst() { 
 if (StringUtils.isNotBlank(sqlFirst.getStringValue())) { 
 return StringEscape.escapeRawString(sqlFirst.getStringValue());
 }
 return null;
 }
 
 @Override
 public MergeSegments getExpression() { 
 return expression;
 }
 
 public Map<String, Object> getParamNameValuePairs() { 
 return paramNameValuePairs;
 }
 
 /** * 获取 columnName */
 protected String columnToString(R column) { 
 return (String) column;
 }
 
 /** * 多字段转换为逗号 "," 分割字符串 * * @param columns 多字段 */
 protected String columnsToString(R... columns) { 
 return Arrays.stream(columns).map(this::columnToString).collect(joining(StringPool.COMMA));
 }
 
 @Override
 @SuppressWarnings("all")
 public Children clone() { 
 return SerializationUtils.clone(typedThis);
 }
 }

*  查询`username`包含字符`k`，并且`age`要大于等于`25`并且小于等于`35`、`password`不能为`null`。

package com.kaven.mybatisplus.dao;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.kaven.mybatisplus.entity.User;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.util.List;
 
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserMapperWrapperTest { 
 
 @Autowired
 private UserMapper userMapper;
 
 @Test
 public void selectList2(){ 
 QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
 // QueryWrapper<User> userQueryWrapper = Wrappers.query(); 和上面一样的效果
 userQueryWrapper.like("username" , "k")
 .between("age" , 25 , 35)
 .isNotNull("password");
 List<User> userList = userMapper.selectList(userQueryWrapper);
 userList.forEach(System.out::println);
 }
 }

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 1]

很明显，结果也是正确的。

*  查询`username`首字符为`k`，或者`age`要大于等于`20`，再按照`age`降序排列，`age`相同时按照`id`升序排列。

package com.kaven.mybatisplus.dao;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.kaven.mybatisplus.entity.User;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.util.List;
 
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserMapperWrapperTest { 
 
 @Autowired
 private UserMapper userMapper;
 
 @Test
 public void selectList3(){ 
 QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
 // QueryWrapper<User> userQueryWrapper = Wrappers.query(); 和上面一样的效果
 userQueryWrapper.likeRight("username" , "k")
 .or()
 .ge("age" , 20)
 .orderByDesc("age")
 .orderByAsc("id");
 List<User> userList = userMapper.selectList(userQueryWrapper);
 userList.forEach(System.out::println);
 }
 }

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 2]

很明显，结果也是正确的（`id`是字符串，不是整型）。

*  查询`username`首字符为`k`，或者（`age`要大于等于`22`并且小于等于`40`，并且`password`不能为`null`）。

package com.kaven.mybatisplus.dao;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.kaven.mybatisplus.entity.User;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.util.List;
 
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserMapperWrapperTest { 
 
 @Autowired
 private UserMapper userMapper;
 
 @Test
 public void selectList4(){ 
 QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
 // QueryWrapper<User> userQueryWrapper = Wrappers.query(); 和上面一样的效果
 userQueryWrapper.likeRight("username" , "k")
 .or(e -> e.between("age" , 22 , 40)
 .isNotNull("password"));
 List<User> userList = userMapper.selectList(userQueryWrapper);
 userList.forEach(System.out::println);
 }
 }

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 3]

很明显，结果也是正确的。

*  查询（`age`要大于等于`22`并且小于等于`40`，并且`password`不能为`null`）并且`username`首字符为`k`。这个例子不太好，看懂意思就行了。

package com.kaven.mybatisplus.dao;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.kaven.mybatisplus.entity.User;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.util.List;
 
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserMapperWrapperTest { 
 
 @Autowired
 private UserMapper userMapper;
 
 @Test
 public void selectList5(){ 
 QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
 // QueryWrapper<User> userQueryWrapper = Wrappers.query(); 和上面一样的效果
 userQueryWrapper.nested(e -> e.between("age" , 22 , 40)
 .isNotNull("password"))
 .and(e -> e.likeRight("username" , "k"));
 // and()其实没必要写，这里只是为了演示，因为这里sql默认就是按照and连接的
 
 List<User> userList = userMapper.selectList(userQueryWrapper);
 userList.forEach(System.out::println);
 }
 }

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 4]

这里结果也是正确的。

从`AbstractWrapper<T, String, QueryWrapper<T>>`的源码也可以看到，`or()`、`and()`、`nested()`方法都可以传`Consumer<T>`类型的参数，这是一个函数式接口，想了解可以去看一下这篇博客。

[Consumer 接口 、 Predicate 接口初使用][Consumer _ _ Predicate]

*  查询`age`属于\[22 , 20 , 30 , 45\]。

package com.kaven.mybatisplus.dao;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.kaven.mybatisplus.entity.User;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.util.Arrays;
 import java.util.List;
 
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserMapperWrapperTest { 
 
 @Autowired
 private UserMapper userMapper;
 
 @Test
 public void selectList6(){ 
 QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
 // QueryWrapper<User> userQueryWrapper = Wrappers.query(); 和上面一样的效果
 userQueryWrapper.in("age" , Arrays.asList(22 , 20 , 30 , 45));
 
 List<User> userList = userMapper.selectList(userQueryWrapper);
 userList.forEach(System.out::println);
 
 }
 }

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 5]

同样结果也是正确的。

*  查询`age`属于\[22 , 20 , 30 , 45\]，并且只输出一个。

package com.kaven.mybatisplus.dao;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.kaven.mybatisplus.entity.User;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import java.util.Arrays;
 import java.util.List;
 
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserMapperWrapperTest { 
 
 @Autowired
 private UserMapper userMapper;
 
 @Test
 public void selectList7(){ 
 QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
 // QueryWrapper<User> userQueryWrapper = Wrappers.query(); 和上面一样的效果
 userQueryWrapper.in("age" , Arrays.asList(22 , 20 , 30 , 45)).last("limit 1");
 
 List<User> userList = userMapper.selectList(userQueryWrapper);
 userList.forEach(System.out::println);
 }
 }

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 2]  
显然也是正确的。

我们这里先不讨论方法是否有`sql`注入的风险。

这就是MyBatis-Plus使用条件构造器进行查询，是不是很方便，这里只演示了查询的条件构造器，其他条件构造器也是差不多的用法，只是个别方法有区别而已，以后的MyBatis-Plus学习博客也只以查询方法进行介绍。

写博客是博主记录自己的学习过程，如果有错误，请指正，谢谢！

[MyBatis Plus]: https://kaven.blog.csdn.net/article/details/108982474
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70]: /images/20221123/d47e299cb80b465bbe3df1c932cc72b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 1]: /images/20221123/16a34123c4ce4ca483632292150362c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/5180486759a849a9b01858621ac43c4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/be889833b8ef4b77b231bf7097a8454a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/c2e68bea3776468c8caf4c9dd34f7c2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/8900173c9b254d088d0d690b2ec4efa4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/9b116f0093784ed0ae3756109de1a67c.png
[Consumer _ _ Predicate]: https://blog.csdn.net/qq_37960603/article/details/85054409
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/5ae6ae17f720412287078615b29adff1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 2]: /images/20221123/814a370011124020be07b8f2e60f6a8a.png