mysql能用parallel用法 mysql plus使用querywrapper

一、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

1. 
2. 
3. # 服务端口
4. server:
5. port: 8083
6. 
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
16. 
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
38. 
39. # 超过时间限制是否回收
40. removeAbandoned: true
41. # 超时时间；单位为秒。180秒=3分钟
42. removeAbandonedTimeout: 180
43. # 关闭abanded连接时输出错误日志
44. logAbandoned: true
45. 
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
52. 
53.

（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;
8. 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;
19. 20. /**
21. * 年龄
22. */
23. @TableField("age")
24. private Integer age;
25. 26. /**
27. * 删除标识 0：正常 1：删除 默认0
28. */
29. @TableField("del_flag")
30. private Integer del_flag;
31. 32. /**
33. * 邮箱
34. */
35. @TableField("email")
36. private String email;
37. 38. /**
39. * 创建时间
40. */
41. @TableField(value = "create_time", fill = FieldFill.INSERT)
42. private Date create_time;
43. 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. }
7.

三、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<>();
9. 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");
18. 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<>();
8. 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");
19. 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<>();
8. 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");
17. 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<>();
8. 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");
17. 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实现：

1. 
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<>();
9. 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");
19. 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<>();
8. 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");
20. 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<>();
8. 9. //构建一个查询的wrapper
10. QueryWrapper<User> wrapper = new QueryWrapper<User>();
11. 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. }
18. 19. //未删除
20. wrapper.eq("del_flag",0);
21. //创建时间降序
22. wrapper.orderByDesc("create_time");
23. 24. List<User> list = userMapper.selectList(wrapper);
25. result.put("data",list);
26. return result;
27. }

控制台结果：

四、示例源码

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