一、queryWrapper介绍

queryWrapper是mybatis plus中实现查询的对象封装操作类，可以封装sql对象，包括where条件，order by排序，select哪些字段等等，他的层级关系如下：

Wrapper：条件构造抽象类，最顶端父类；
AbstractWrapper：用于查询条件封装，生成sql的where条件；
AbstractLambdaWrapper：Lambda语法使用Wrapper统一处理解析lambda获取column。
LambdaQueryWrapper：用于lambda语法使用的查询Wrapper； 
LambdaUpdateWrapper:Lambda更新封装Wrapper;
QueryWrapper:Entity对象封装操作类，不是用lambda；
UpdateWrapper:Update条件封装，用于Entity对象更新操作。

二、环境搭建

1.创建数据库表并添加几条数据：

1. CREATE TABLE `t_user` (

2. `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户id',

3. `name` varchar(255) DEFAULT NULL COMMENT '用户姓名',

4. `age` int(2) DEFAULT NULL COMMENT '用户年龄',

5. `email` varchar(255) DEFAULT NULL COMMENT '邮箱',

6. `del_flag` int(1) DEFAULT '0' COMMENT '删除标识 0：正常 1：删除 默认0',

7. `create_time` datetime DEFAULT NULL COMMENT '创建时间',

8. `update_time` datetime DEFAULT NULL COMMENT '更新时间',

9. PRIMARY KEY (`id`)

10. ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='用户表';

数据如下：

2.创建Springboot项目

创建Springboot项目，集成mybatis-plus、web、mysql等相关依赖；搭建基础的demo操作：
（1）pom.xml:

1. <!--web-->

2. <dependency>

3. <groupId>org.springframework.boot</groupId>

4. <artifactId>spring-boot-starter-web</artifactId>

5. </dependency>

6. <!--热部署-->

7. <dependency>

8. <groupId>org.springframework.boot</groupId>

9. <artifactId>spring-boot-devtools</artifactId>

10. <scope>runtime</scope>

11. <optional>true</optional>

12. </dependency>

13. <!--mybatis-plus自动的维护了mybatis以及mybatis-spring的依赖，

14. 在springboot中这三者不能同时的出现，避免版本的冲突，表示：跳进过这个坑-->

15. <!--mybatis-plus-->

16. <dependency>

17. <groupId>com.baomidou</groupId>

18. <artifactId>mybatis-plus-boot-starter</artifactId>

19. <version>3.4.3</version>

20. </dependency>

21. <!--mysql驱动-->

22. <dependency>

23. <groupId>mysql</groupId>

24. <artifactId>mysql-connector-java</artifactId>

25. <scope>runtime</scope>

26. </dependency>

27. <!-- alibaba的druid数据库连接池 -->

28. <dependency>

29. <groupId>com.alibaba</groupId>

30. <artifactId>druid</artifactId>

31. <version>1.1.20</version>

32. </dependency>

33. <!-- alibaba的druid数据库连接池 -->

34. <dependency>

35. <groupId>com.alibaba</groupId>

36. <artifactId>druid-spring-boot-starter</artifactId>

37. <version>1.1.20</version>

38. </dependency>

39. <!--lombok-->

40. <dependency>

41. <groupId>org.projectlombok</groupId>

42. <artifactId>lombok</artifactId>

43. <optional>true</optional>

44. </dependency>

45. <!--工具类-->

46. <dependency>

47. <groupId>org.apache.commons</groupId>

48. <artifactId>commons-lang3</artifactId>

49. </dependency>

50. <dependency>

51. <groupId>org.springframework.boot</groupId>

52. <artifactId>spring-boot-starter-test</artifactId>

53. <scope>test</scope>

54. </dependency>

 （2）配置application.yml

3. # 服务端口

4. server:

5. port: 8083

7. # 数据源配置

8. spring:

9. datasource:

10. name: test

11. url: jdbc:mysql://localhost:3306/db_order?&allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSl=false

12. username: root

13. password: root

14. driver-class-name: com.mysql.jdbc.Driver

15. type: com.alibaba.druid.pool.DruidDataSource

17. ## 配置连接池信息

18. ## 初始化大小，最小，最大

19. initialSize: 5

20. minIdle: 5

21. maxActive: 30

22. ## 配置获取连接等待超时的时间

23. maxWait: 60000

24. # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒

25. timeBetweenEvictionRunsMillis: 60000

26. # 配置一个连接在池中最小生存的时间，单位是毫秒

27. minEvictableIdleTimeMillis: 300000

28. validationQuery: SELECT 1 FROM DUAL

29. testWhileIdle: true

30. testOnBorrow: false

31. testOnReturn: false

32. poolPreparedStatements: true

33. maxPoolPreparedStatementPerConnectionSize: 20

34. # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙

35. filters: stat,wall

36. # 通过connectProperties属性来打开mergeSql功能；慢SQL记录

37. connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

39. # 超过时间限制是否回收

40. removeAbandoned: true

41. # 超时时间；单位为秒。180秒=3分钟

42. removeAbandonedTimeout: 180

43. # 关闭abanded连接时输出错误日志

44. logAbandoned: true

46. # mybatis-plus 默认扫描mapper.xml的目录

47. mybatis-plus:

48. mapper-locations: classpath*:/mapper/*.xml

49. #配置sql打印日志

50. configuration:

51. log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

（3）创建一个实体类：

1. /**

2. * @author qzz

3. */

4. @Data

5. @TableName("t_user")

6. public class User implements Serializable {

7. private static final long serialVersionUID = 1L;

9. /**

10. * 用户id

11. */

12. @TableId(value="id", type = IdType.AUTO)

13. private Integer id;

14. /**

15. * 名称

16. */

17. @TableField("name")

18. private String name;

20. /**

21. * 年龄

22. */

23. @TableField("age")

24. private Integer age;

26. /**

27. * 删除标识 0：正常 1：删除 默认0

28. */

29. @TableField("del_flag")

30. private Integer del_flag;

32. /**

33. * 邮箱

34. */

35. @TableField("email")

36. private String email;

38. /**

39. * 创建时间

40. */

41. @TableField(value = "create_time", fill = FieldFill.INSERT)

42. private Date create_time;

44. /**

45. * 修改时间

46. */

47. @TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)

48. private Date update_time;

49. }

 （4）编写一个mapper接口，只需继承BaseMapper，基本的单表查询都给你封装好了。

1. /**

2. * @author qzz

3. */

4. @Repository

5. public interface UserMapper extends BaseMapper<User> {

6. }

三、queryWrapper示例

官网上可以看到有很多条件构造器，下面将使用几个常用的作为示例进行使用，其实本质还是sql语句，如果想要打印sql日志，可以在application.yml文件中进行如下的配置：

1. mybatis-plus:

2. #配置sql打印日志

3. configuration:

4. log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

Wrapper是一个接口，官方提供了很多的实现类，我们通过其实现类去构造wrapper对象即可。 

1.案例一：根据name模糊查看未删除的用户列表信息

过滤条件：

• name 用户名称 ，模糊查看
• del_flag = 0
• 按照create_time创建时间降序

sql实现:

1. select * from t_user

2. where del_flag = 0

3. <if test ="name!=null and ''!=name">

4. and name like concat('%',#{name},'%')

5. </if>

6. order by create_time desc

queryWrapper实现：

1. /**

2. * 案例一：根据name模糊查看未删除的用户列表信息

3. * @param name

4. * @return

5. */

6. @RequestMapping("/list")

7. public Map<String,Object> getList(@RequestParam String name){

8. Map<String,Object> result = new HashMap<>();

10. //构建一个查询的wrapper

11. QueryWrapper<User> wrapper = new QueryWrapper<User>();

12. //name不为空时，组装模糊查询条件

13. wrapper.like(StringUtils.isNotBlank(name),"name",name);

14. //未删除

15. wrapper.eq("del_flag",0);

16. //创建时间降序

17. wrapper.orderByDesc("create_time");

19. List<User> list = userMapper.selectList(wrapper);

20. result.put("data",list);

21. return result;

22. }

启动项目，运行接口http://localhost:8083/user/list?name=小测试，控制台sql如下：

2.案例二：查看姓李的并且邮箱不为空的用户列表

sql实现:

1. select * from t_user

2. where del_flag = 0

3. and name like concat('李','%')

4. and email is not null

5. order by create_time desc

 queryWrapper实现：

1. /**

2. * 案例二：查看姓张的并且邮箱不为空的用户列表

3. * @return

4. */

5. @RequestMapping("/list2")

6. public Map<String,Object> getList2(){

7. Map<String,Object> result = new HashMap<>();

9. //构建一个查询的wrapper

10. QueryWrapper<User> wrapper = new QueryWrapper<User>();

11. //姓张的

12. wrapper.likeRight("name","张");

13. //邮箱不为空

14. wrapper.isNotNull("email");

15. //未删除

16. wrapper.eq("del_flag",0);

17. //创建时间降序

18. wrapper.orderByDesc("create_time");

20. List<User> list = userMapper.selectList(wrapper);

21. result.put("data",list);

22. return result;

23. }

控制台结果：

3.案例三：年龄范围查询（20-30之间的）

sql实现:

1. select * from t_user

2. where del_flag=0

3. and age between 20 and 30

4. order by create_time desc

 queryWrapper实现：

1. /**

2. * 案例三：年龄范围查询（20-30之间的）

3. * @return

4. */

5. @RequestMapping("/list3")

6. public Map<String,Object> getList3(){

7. Map<String,Object> result = new HashMap<>();

9. //构建一个查询的wrapper

10. QueryWrapper<User> wrapper = new QueryWrapper<User>();

11. //年龄20-30之间的

12. wrapper.between("age",20,30);

13. //未删除

14. wrapper.eq("del_flag",0);

15. //创建时间降序

16. wrapper.orderByDesc("create_time");

18. List<User> list = userMapper.selectList(wrapper);

19. result.put("data",list);

20. return result;

21. }

控制台结果： 

4.案例四：根据createTime查看当日的用户列表

sql实现:

1. select * from t_user

2. where del_flag=0

3. and DATE(create_time) = STR_TO_DATE('2021-08-13','%Y-%m-%d')

4. order by create_time desc

queryWrapper实现：

1. /**

2. * 案例四：根据createTime查看当日的用户列表

3. * @return

4. */

5. @RequestMapping("/list4")

6. public Map<String,Object> getList4(@RequestParam String createTime){

7. Map<String,Object> result = new HashMap<>();

9. //构建一个查询的wrapper

10. QueryWrapper<User> wrapper = new QueryWrapper<User>();

11. //查询条件为创建时间

12. wrapper.apply(StringUtils.isNotBlank(createTime),"DATE(create_time) = STR_TO_DATE('"+createTime+"','%Y-%m-%d')");

13. //未删除

14. wrapper.eq("del_flag",0);

15. //创建时间降序

16. wrapper.orderByDesc("create_time");

18. List<User> list = userMapper.selectList(wrapper);

19. result.put("data",list);

20. return result;

21. }

控制台结果：

5.案例五：查看某个时间段内的用户列表

sql实现:

1. select * from t_user

2. where del_flag=0

3. and DATE(create_time) >= STR_TO_DATE('2021-08-01','%Y-%m-%d')

4. AND DATE(create_time) <= STR_TO_DATE('2021-08-13','%Y-%m-%d')

5. order by create_time desc

 queryWrapper实现：

2. /**

3. * 案例五：查看某个时间段内的用户列表

4. * @return

5. */

6. @RequestMapping("/list5")

7. public Map<String,Object> getList5(@RequestParam String startTime,@RequestParam String endTime){

8. Map<String,Object> result = new HashMap<>();

10. //构建一个查询的wrapper

11. QueryWrapper<User> wrapper = new QueryWrapper<User>();

12. //查询条件为创建时间

13. wrapper.apply(StringUtils.isNotBlank(startTime),"DATE(create_time) >= STR_TO_DATE('"+startTime+"','%Y-%m-%d')");

14. wrapper.apply(StringUtils.isNotBlank(endTime),"DATE(create_time) <= STR_TO_DATE('"+endTime+"','%Y-%m-%d')");

15. //未删除

16. wrapper.eq("del_flag",0);

17. //创建时间降序

18. wrapper.orderByDesc("create_time");

20. List<User> list = userMapper.selectList(wrapper);

21. result.put("data",list);

22. return result;

23. }

控制台结果：

6.案例六：查询姓李的并且邮箱不为空或者是年龄大于16的用户

sql实现:

1. select * from t_user

2. where del_flag=0

3. and name like concat('李','%')

4. and (email is not null or age>16)

5. order by create_time desc

 queryWrapper实现：
and方法嵌套使用

1. /**

2. * 案例六：查询姓李的并且邮箱不为空或者是年龄大于16的用户

3. * @return

4. */

5. @RequestMapping("/list6")

6. public Map<String,Object> getList6(){

7. Map<String,Object> result = new HashMap<>();

9. //构建一个查询的wrapper

10. QueryWrapper<User> wrapper = new QueryWrapper<User>();

11. //and方法嵌套

12. wrapper.likeRight("name","李").and(

13. userQueryWrapper -> userQueryWrapper.isNotNull("email")

14. .or().lt("age",16)

15. );

16. //未删除

17. wrapper.eq("del_flag",0);

18. //创建时间降序

19. wrapper.orderByDesc("create_time");

21. List<User> list = userMapper.selectList(wrapper);

22. result.put("data",list);

23. return result;

24. }

控制台结果：

7.案例七：查询id为1,2,3的用户列表信息

sql实现:

1. select * from t_user

2. where del_flag=0

3. and id in(1,2,3)

4. order by create_time desc

 queryWrapper实现：

1. /**

2. * 案例七：根据ids查看用户列表信息

3. * @return

4. */

5. @RequestMapping("/list7")

6. public Map<String,Object> getList7(@RequestParam String ids){

7. Map<String,Object> result = new HashMap<>();

9. //构建一个查询的wrapper

10. QueryWrapper<User> wrapper = new QueryWrapper<User>();

12. if(StringUtils.isNotBlank(ids)){

13. //字符串转数组再转List

14. Collection<String> collection = Arrays.asList(ids.split(","));

15. //in方法

16. wrapper.in(collection.size()>0,"id",collection);

17. }

19. //未删除

20. wrapper.eq("del_flag",0);

21. //创建时间降序

22. wrapper.orderByDesc("create_time");

24. List<User> list = userMapper.selectList(wrapper);

25. result.put("data",list);

26. return result;

27. }

控制台结果：

四、示例源码

可点击此处下载！

本文介绍就到这里了，感兴趣的小伙伴可以自行测试哦。

来源：Mybatis-plus 动态条件查询QueryWrapper的使用_wounler的博客-CSDN博客_querywrapper条件查询