三，MyBatis-Plus 的各种查询的“超详细阐明”，比如(等值查询，范围查询， ...

三，MyBatis-Plus 的各种查询的“超详细阐明”，比如(等值查询，范围查询，模糊查询...)

@
目录

• 三，MyBatis-Plus 的各种查询的“超详细阐明”，比如(等值查询，范围查询，模糊查询...)
  
• 1. 条件构造器介绍
  
• 2. 准备工作：
  
• 3. 等值查询
  
  
  
  • 3.1 eq (条件筛选属性 = ?)
    
  • 3.2 allEq(满意多个条件字段的值的筛选)
    
  • 3.3 ne (不等于)
    
  
  
• 4. 范围查询
  
  
  
  • 4.1 gt( > 大于的范围)
    
  • 4.2 ge(>= 大于等于的范围)
    
  • 4.3 lt(< 小于的范围)
    
  • 4.4 le(小于等于的范围)
    
  • 4.5 between(在该区间的范围)
    
  • 4.6 notBetween(不在该区间的范围)
    
  
  
• 5. 模糊查询
  
  
  
  • 5.1 like( %值%)
    
  • 5.2 notLike(不满意 %值%)
    
  • 5.3 likeLeft（%值）
    
  • 5.4 likeRight(值%)
    
  
  
• 6. 判空查询
  
  
  
  • 6.1 isNUll(判断是否为 Null )
    
  • 6.2 isNotNull
    
  
  
• 7. 包含查询
  
  
  
  • 7.1 in（包含该内容的字段）
    
  • 7.2 notIn(不包含该内容的字段)
    
  • 7.3 inSql(包含该内容的字段)
    
  • 7.4 notInSql(不包含该内容的字段)
    
  
  
• 8. 分组查询
  
  
  
  • 8.1 groupBy(分组的字段)
    
  
  
• 9. 聚合查询
  
  
  
  • 9.1 having(聚合的字段)
    
  
  
• 10. 排序查询
  
  
  
  • 10.1 orderByAsc(升序)
    
  • 10.2 orderByDesc(降序)
    
  • 10.3 orderBy(多字段排序定义)
    
  
  
• 11. func 查询
  
• 12. 逻辑查询
  
  
  
  • 12.1 and(与)
    
  • 12.2 or(或)
    
  • 12.3 nested(非)
    
  
  
• 13. 自定义条件查询
  
  
  
  • 13.1 apply(自定义查询条件)
    
  
  
• 14. last 查询(在sql语句的最末尾拼接“字符串”)
  
• 15. exists查询
  
  
  
  • 15.1 exists(存在查询)
    
  • 15.2 notExists(不存在查询)
    
  
  
• 16. 字段查询
  
  
  
  • 16.1 select(字段查询)
    
  
  
• 17. 末了：
  

1. 条件构造器介绍

在实际开发需求中条件查询黑白常普遍的，接下来我们就来讲解如何使用 MyBatis Plus 完成条件查询。
首先，想要使用 MyBatis Plus 完成条件查询，基于面向对象的头脑，万物皆对象 ，那么查询条件，也需要使用对象来完成封装。我们可以先看看，在 MyBatis Plus 中和条件有关的类有哪些，他们之间有什么关系，理清晰了这个，我们在传递条件对象的时候，就很清晰了。
Wrapper  抽象类，条件类的顶层，提供了一些获取和判断相干的方法。

AbstractWrapper  抽象类，Wrapper 的子类，提供了所有的条件相干方法。

AbstractLambdaWrapper 抽象类，AbstractWrapper 的子类，确定字段参数为方法引用范例。

QueryWrapper 类，AbstractWrapper 的子类，如果我们需要传递 String 范例的字段信息，创建该对象。

LambdaQueryWrapper  类，AbstractLambdaWrapper 的子类，如果我们需要传递方法引用方式的字段信息，创建该对象。

该图为以上各类的关系，我们在编写代码的时候，只需要关注 QueryWrapper 和LambdaQueryWrapper

2. 准备工作：

引入相干的jar 依靠。在 pom.xml 文件当中；

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
5.     <parent>
6.         <groupId>org.springframework.boot</groupId>
7.         <artifactId>spring-boot-starter-parent</artifactId>
8.         <version>2.5.3</version>
9.         <relativePath/>
10.     </parent>
11.     <groupId>com.rainbowsea</groupId>
12.     <artifactId>mp03</artifactId>
13.     <version>0.0.1-SNAPSHOT</version>
14.     <name>mp03</name>
15.     <description>mp03</description>
16.     <url/>
17.     <licenses>
18.         <license/>
19.     </licenses>
20.     <developers>
21.         <developer/>
22.     </developers>
23.     <scm>
24.         <connection/>
25.         <developerConnection/>
26.         <tag/>
27.         <url/>
28.     </scm>
29.     <properties>
30.         <java.version>8</java.version>
31.     </properties>
32.     <dependencies>
33.         <dependency>
34.             <groupId>org.springframework.boot</groupId>
35.             <artifactId>spring-boot-starter</artifactId>
36.         </dependency>
38.         <dependency>
39.             <groupId>org.springframework.boot</groupId>
40.             <artifactId>spring-boot-starter-test</artifactId>
41.             <scope>test</scope>
42.         </dependency>
44.         
45.         <dependency>
46.             <groupId>org.springframework.boot</groupId>
47.             <artifactId>spring-boot-starter-web</artifactId>
48.         </dependency>
50.         
51.         <dependency>
52.             <groupId>mysql</groupId>
53.             <artifactId>mysql-connector-java</artifactId>
54.         </dependency>
58.         
59.         <dependency>
60.             <groupId>org.projectlombok</groupId>
61.             <artifactId>lombok</artifactId>
62.         </dependency>
64.         
65.         <dependency>
66.             <groupId>com.alibaba</groupId>
67.             <artifactId>druid</artifactId>
68.             <version>1.2.8</version>
69.         </dependency>
71.         
72.         <dependency>
73.             <groupId>com.baomidou</groupId>
74.             <artifactId>mybatis-plus-boot-starter</artifactId>
75.             <version>3.4.3</version>
76.         </dependency>
78.     </dependencies>
80.     <build>
81.         <plugins>
82.             <plugin>
83.                 <groupId>org.springframework.boot</groupId>
84.                 <artifactId>spring-boot-maven-plugin</artifactId>
85.             </plugin>
86.         </plugins>
87.     </build>
88.     <repositories>
89.         <repository>
90.             <id>spring-snapshots</id>
91.             <name>Spring Snapshots</name>
92.             <url>https://repo.spring.io/snapshot</url>
93.             <releases>
94.                 <enabled>false</enabled>
95.             </releases>
96.         </repository>
97.     </repositories>
98.     <pluginRepositories>
99.         <pluginRepository>
100.             <id>spring-snapshots</id>
101.             <name>Spring Snapshots</name>
102.             <url>https://repo.spring.io/snapshot</url>
103.             <releases>
104.                 <enabled>false</enabled>
105.             </releases>
106.         </pluginRepository>
107.     </pluginRepositories>
109. </project>

复制代码

编写项目的场景启动器：

1. package com.rainbowsea;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. @SpringBootApplication
7. public class Mp03Application {
9.     public static void main(String[] args) {
10.         SpringApplication.run(Mp03Application.class, args);
11.     }
13. }

复制代码

创建的数据库表和布局。如下：

编写对应 数据表的 Java Bean 类对象。

1. package com.rainbowsea.bean;
4. import com.baomidou.mybatisplus.annotation.TableField;
5. import com.baomidou.mybatisplus.annotation.TableName;
6. import lombok.AllArgsConstructor;
7. import lombok.Data;
8. import lombok.NoArgsConstructor;
10. @Data
11. @NoArgsConstructor
12. @AllArgsConstructor
13. public class User {
15.     private Long id;
16.     //@TableField(value = "username")
17.     private String name;
19.     //@TableField(select = false)  // 查询时，不对age 字段进行查询
20.     private Integer age;
21.     private String email;
23.     @TableField(value = "`desc`") // 注意：有两层，但最里面的哪个不是引号
24.     private String desc;
27.     @TableField(exist = false)  // 表示// ，不让该 online 属性，作为 SQL语句当中的查询字段
28.     private Integer online;
30. }

复制代码

在 resources 类路径下，创建一个名为 application.yaml 的yaml文件，编写连接数据库的信息内容。

1. spring:
2.   datasource:
3.     driver-class-name: com.mysql.cj.jdbc.Driver
4.     url: jdbc:mysql://localhost:3306/mybatisplus?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
5.     username: root
6.     password: MySQL123
7.   main:
8.     banner-mode: off  #关闭 spring boot  在命令行当中的图标显示
11. mybatis-plus:
12.   global-config:
13.     banner: false  # 关闭 mybatis-plus 在命令行当中的图标显示
14.     db-config:
15.       table-prefix: rainbowsea_ # 还可以通过统一添加前缀的方式：
17.   configuration:
18.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  # 开启 Log 日志信息打印
19.     map-underscore-to-camel-case: true # 开启驼峰，下划线映射规则

复制代码

编写配置类，通过配置类的方式，将数据库连接池换成为 Druid 数据库连接池。

1. package com.rainbowsea.config;
4. import com.alibaba.druid.pool.DruidDataSource;
5. import org.springframework.boot.context.properties.ConfigurationProperties;
6. import org.springframework.context.annotation.Bean;
7. import org.springframework.context.annotation.Configuration;
9. import javax.sql.DataSource;
11. @Configuration  // 标注配置类
12. public class DruidDataSourceConfig {
14.     @Bean
15.     @ConfigurationProperties(value = "spring.datasource")
16.     public DataSource getDataSource() {
17.         DruidDataSource druidDataSource = new DruidDataSource();
19.         return druidDataSource;
20.     }
21. }

复制代码

运行测试：看看是否切换为了 Druid 数据库连接池

1. package com.rainbowsea;
3. import org.junit.jupiter.api.Test;
4. import org.springframework.beans.factory.annotation.Autowired;
5. import org.springframework.boot.test.context.SpringBootTest;
6. import org.springframework.jdbc.core.JdbcTemplate;
8. import javax.annotation.Resource;
10. @SpringBootTest
11. class Mp03ApplicationTests {
14.     @Resource
15.     //@Autowired
16.     private JdbcTemplate jdbcTemplate;
18.     @Test
19.     void getDataSourceTest() {
20.         System.out.println(jdbcTemplate.getDataSource().getClass());
21.     }
23. }

复制代码

编写：该User表的 mapper 方法。

1. package com.rainbowsea.mapper;
3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4. import com.rainbowsea.bean.User;
5. import org.apache.ibatis.annotations.Mapper;
8. @Mapper  // 包扫描路径
9. public interface UserMapper extends BaseMapper<User> {
12. }

复制代码

3. 等值查询

3.1 eq (条件筛选属性 = ?)

使用QueryWrapper对象，构建查询条件

等值查询使用：userQueryWrapper.eq()

1. default Children eq(R column, Object val) {
2.    return eq(true, column, val);
3. }

复制代码

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
16.     @Autowired
17.     private UserMapper userMapper;
19.     @Test
20.     void eq() {
21.         // 1.创建条件查询对象
22.         QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
23.         // 2. 设置查询条件，指定查询的字段和匹配的值
24.         QueryWrapper<User> eq = userQueryWrapper.eq("name", "Jone");
26.         // 3. 进行条件查询
27.         User user = userMapper.selectOne(eq);
28.         System.out.println(user);
29.     }
30. }

复制代码

我们思考如果每次都是自己进行字段名称的编写，有可能会出现名称写错的情况，怎么避免这种情况呢，我们可以使用LambdaQueryWrapper对象，在构建字段时，使用方法引用的方式来选择字段，如许做可以避免字段拼写错误出现问题。
代码如下：

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
16.     @Autowired
17.     private UserMapper userMapper;
19.     // 使用: LambdaQueryWrapper 进行引用查询，防止报错
20.     @Test
21.     void eq2() {
22.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
23.         LambdaQueryWrapper<User> queryWrapper = lambdaQueryWrapper.eq(User::getName, "Jone");
25.         User user = userMapper.selectOne(queryWrapper);
26.         System.out.println(user);
27.     }
28. }

复制代码

还要考虑一种情况，我们构建的条件是从哪里来的？应该是从客户端通过请求发送过来的，
由服务端接收的。在网站中一般都会有多个条件入口，用户可以选择一个或多个条件进行查询，那这个时候在请求时，我们不能确定所有的条件都是有值的，部门条件可能用户没有传值，那该条件就为null。
​                        比如在电商网站中，可以选择多个查询条件。

那为null的条件，我们是不需要进行查询条件拼接的，否则就会出现如下情况，将为null的条件进行拼接，筛选后无法查询出结果。

当然我们要办理这个问题，可以先判断是否为空，根据判断结果选择是否拼接该字段，这个功能其实不需要我们写，由MybatisPlus的方法已经提供好了。

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
16.     @Autowired
17.     private UserMapper userMapper;
19.     // 字段名为 不null的
20.     @Test
21.     void isNull2() {
22.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
23.         String name = null;
24.         //String name = "Jone";
26.         //  public Children eq(boolean condition, R column, Object val) {
27.         lambdaQueryWrapper.eq(name != null, User::getName, name);
28.         //User user = userMapper.selectOne(lambdaQueryWrapper);
29.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
30.         System.out.println(users);
32.     }
33. }

复制代码

3.2 allEq(满意多个条件字段的值的筛选)

先演示一下如何通过多个eq,构建多条件查询。

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // and 满足多个条件
21.     @Test
22.     void allEql() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         lambdaQueryWrapper.eq(User::getName, "Tom");
25.         lambdaQueryWrapper.eq(User::getAge, 18);
26.         User user = userMapper.selectOne(lambdaQueryWrapper);
27.         System.out.println(user);
28.     }
29. }

复制代码

如果此时有多个条件需要同时判断，我们可以将这多个条件放入到Map聚会合，更加的方便

1. allEq(Map<R, V> params, boolean null2IsNull)
2. 参数params:表示传递的Map集合
3. 参数null2IsNull:表示对于为null的条件是否判断isNull

复制代码

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // 属性值为 null 的查询，属性值不为 Null的不查询该字段
21.     @Test
22.     void allEq2() {
24.         HashMap<String, Object> hashMap = new HashMap<>();
26.         hashMap.put("name", "Tom");
27.         hashMap.put("age",18);
28.         //hashMap.put("age", null);  // 为null 的属性值，则会不查询
30.         QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
31.         //userQueryWrapper.allEq(hashMap,false); //  // 为null 的属性值，则会不查询
32.         userQueryWrapper.allEq(hashMap, true);  // 为null,(name = ? AND age IS NULL) 查询
34.         User user = userMapper.selectOne(userQueryWrapper);
35.         System.out.println(user);
36.     }
37. }

复制代码

3.3 ne (不等于)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // 不等于数值的
21.     @Test
22.     void ne() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         lambdaQueryWrapper.ne(User::getName, "Tom");
25.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
26.         System.out.println(users);
28.     }
29. }

复制代码

4. 范围查询

4.1 gt( > 大于的范围)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // > 查询
21.     @Test
22.     void gt() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         Integer age = 18;
25.         lambdaQueryWrapper.gt(User::getAge, age);
26.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
27.         System.out.println(users);
28.     }
29. }

复制代码

4.2 ge(>= 大于等于的范围)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // >=查询
21.     @Test
22.     void ge() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         Integer age = 18;
25.         lambdaQueryWrapper.ge(User::getAge, age);
26.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
27.         System.out.println(users);
28.     }
29. }

复制代码

4.3 lt(< 小于的范围)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
21.     // <
22.     @Test
23.     void lt() {
24.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
25.         Integer age = 20;
26.         lambdaQueryWrapper.lt(User::getAge, age);
27.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
28.         System.out.println(users);
29.     }
30. }

复制代码

4.4 le(小于等于的范围)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // <=
21.     @Test
22.     void le() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         Integer age = 20;
25.         LambdaQueryWrapper<User> lambdaQueryWrapper1 = lambdaQueryWrapper.le(User::getAge, age);
27.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
28.         System.out.println(users);
29.     }
30. }

复制代码

7.2 notIn(不包含该内容的字段)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // 范围之间
21.     @Test
22.     void between() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         lambdaQueryWrapper.between(User::getAge, 10, 20);
25.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
26.         System.out.println(users);
28.     }
29. }

复制代码

7.3 inSql(包含该内容的字段)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // 不在范围的：  (age NOT BETWEEN ? AND ?)
21.     @Test
22.     void notBetween() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         lambdaQueryWrapper.notBetween(User::getAge,10,18);
25.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
26.         System.out.println(users);
27.     }
28. }

复制代码

7.4 notInSql(不包含该内容的字段)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // 模糊查询: %J%(String)
21.     @Test
22.     void like() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         lambdaQueryWrapper.like(User::getName,"J");
25.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
26.         System.out.println(users);
27.     }
28. }

复制代码

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.util.HashMap;
10. import java.util.List;
13. @SpringBootTest  // 注意这个测试必须要有一个场景类才行，不然是无法运行的。测试的类不同的话，还需要指明
14. // 包
15. public class QueryTest {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // 模糊查询:  %e(String) 左边
21.     @Test
22.     void likeft() {
23.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
24.         lambdaQueryWrapper.likeLeft(User::getName,"e");
25.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
26.         System.out.println(users);
28.     }
29. }

复制代码

8. 分组查询

8.1 groupBy(分组的字段)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.rainbowsea.bean.User;
3. import com.rainbowsea.mapper.UserMapper;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.boot.test.context.SpringBootTest;
7. import javax.annotation.Resource;
8. import java.util.ArrayList;
9. import java.util.Collections;
10. import java.util.List;
12. @SpringBootTest
13. public class QueryTest02 {
14.     @Resource
15.    private UserMapper userMapper;
17.     // 判断是否为 null  WHERE (name IS NULL)
18.     @Test
19.     void isNUll3() {
20.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
21.         lambdaQueryWrapper.isNull(User::getName);
22.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
23.         System.out.println(users);
24.     }
25. }

复制代码

9. 聚合查询

9.1 having(聚合的字段)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.rainbowsea.bean.User;
3. import com.rainbowsea.mapper.UserMapper;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.boot.test.context.SpringBootTest;
7. import javax.annotation.Resource;
8. import java.util.ArrayList;
9. import java.util.Collections;
10. import java.util.List;
12. @SpringBootTest
13. public class QueryTest02 {
14.     @Resource
15.     private UserMapper userMapper;
17.     //  WHERE (name IS NULL)
18.     @Test
19.     void isNotNull() {
20.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
21.         lambdaQueryWrapper.isNotNull(User::getName);
22.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
23.         System.out.println(users);
24.     }
25. }

复制代码

10. 排序查询

10.1 orderByAsc(升序)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.rainbowsea.bean.User;
3. import com.rainbowsea.mapper.UserMapper;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.boot.test.context.SpringBootTest;
7. import javax.annotation.Resource;
8. import java.util.ArrayList;
9. import java.util.Collections;
10. import java.util.List;
12. @SpringBootTest
13. public class QueryTest02 {
14.     @Resource
15.     private UserMapper userMapper;
17.     // 字段 = 值 or 字段 = 值 ->in
18.     // r WHERE (age IN (?,?,?))
19.     @Test
20.     void in() {
21.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
22.         ArrayList<Object> arrayList = new ArrayList<>();
23.         Collections.addAll(arrayList, 18, 20, 22);
24.         lambdaQueryWrapper.in(User::getAge, arrayList);
25.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
26.         System.out.println(users);
28.     }
29. }

复制代码

10.2 orderByDesc(降序)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.rainbowsea.bean.User;
3. import com.rainbowsea.mapper.UserMapper;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.boot.test.context.SpringBootTest;
7. import javax.annotation.Resource;
8. import java.util.ArrayList;
9. import java.util.Collections;
10. import java.util.List;
12. @SpringBootTest
13. public class QueryTest02 {
14.     @Resource
15.     private UserMapper userMapper;
17.     // 字段！=值 and 字段！=值 ->not in
18.     //  WHERE (age NOT IN (?,?,?))
19.     @Test
20.     void notIn() {
21.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
22.         ArrayList<Integer> arrayList = new ArrayList<>();
23.         Collections.addAll(arrayList, 18, 20, 22);
24.         lambdaQueryWrapper.notIn(User::getAge, arrayList);
25.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
26.         System.out.println(users);
27.     }
28. }

复制代码

10.3 orderBy(多字段排序定义)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.rainbowsea.bean.User;
3. import com.rainbowsea.mapper.UserMapper;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.boot.test.context.SpringBootTest;
7. import javax.annotation.Resource;
8. import java.util.ArrayList;
9. import java.util.Collections;
10. import java.util.List;
12. @SpringBootTest
13. public class QueryTest02 {
14.     @Resource
15.     private UserMapper userMapper;
17.     // er WHERE (age IN (18,20,22))
18.     @Test
19.     void inSql() {
20.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
21.         lambdaQueryWrapper.inSql(User::getAge, "18,20,22");
22.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
23.         System.out.println(users);
24.     }
25. }

复制代码

11. func 查询

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.rainbowsea.bean.User;
3. import com.rainbowsea.mapper.UserMapper;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.boot.test.context.SpringBootTest;
7. import javax.annotation.Resource;
8. import java.util.ArrayList;
9. import java.util.Collections;
10. import java.util.List;
12. @SpringBootTest
13. public class QueryTest02 {
14.     @Resource
15.     private UserMapper userMapper;
17.     // age NOT IN (18,20,22))
18.     @Test
19.     void notInsql() {
20.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
21.         lambdaQueryWrapper.notInSql(User::getAge, "18,20,22");
22.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
23.         System.out.println(users);
24.     }
25. }

复制代码

12. 逻辑查询

12.1 and(与)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.rainbowsea.bean.User;
3. import com.rainbowsea.mapper.UserMapper;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.boot.test.context.SpringBootTest;
7. import javax.annotation.Resource;
8. import java.util.ArrayList;
9. import java.util.Collections;
10. import java.util.List;
12. @SpringBootTest
13. public class QueryTest02 {
14.     @Resource
15.     private UserMapper userMapper;
18.     // RE (age NOT IN (select age from rainbowsea_user where age > 20))
19.     @Test
20.     void notInSql2() {
21.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
22.         lambdaQueryWrapper.notInSql(User::getAge, "select age from rainbowsea_user where age > 20");
23.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
24.         System.out.println(users);
25.     }
26. }

复制代码

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.awt.*;
10. import java.util.List;
11. import java.util.Map;
12. import java.util.function.Consumer;
14. @SpringBootTest
15. public class QueryTest03 {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // select age,count(*) as field_count from rainbowsea_user group by age;
21.     // 分组查询
22.     @Test
23.     void groupBy() {
24.         QueryWrapper<User> queryWrapper = new QueryWrapper<>();
25.         // 分组字段
26.         queryWrapper.groupBy("age");
27.         // 查询字段
28.         queryWrapper.select("age,count(*) as field_count");
29.         List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
30.         System.out.println(maps);
31.     }
32. }

复制代码

12.2 or(或)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.awt.*;
10. import java.util.List;
11. import java.util.Map;
12. import java.util.function.Consumer;
14. @SpringBootTest
15. public class QueryTest03 {
17.     @Autowired
18.     private UserMapper userMapper;
20.     // select age,count(*) as field_count from rainbowsea_user group by age HAVING field_count >=2;
21.     // 聚合查询
22.     @Test
23.     void having() {
24.         QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
25.         // 查询字段
26.         userQueryWrapper.select("age,count(*) as field_count");
27.         // 聚合条件筛选
28.         userQueryWrapper.having("field_count = 1");
29.         List<Map<String, Object>> maps = userMapper.selectMaps(userQueryWrapper);
30.         System.out.println(maps);
31.     }
32. }

复制代码

12.3 nested(非)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.awt.*;
10. import java.util.List;
11. import java.util.Map;
12. import java.util.function.Consumer;
16. @SpringBootTest
17. public class QueryTest03 {
19.     @Autowired
20.     private UserMapper userMapper;
22.     // 降序
23.     @Test
24.     void orderByAsc() {
25.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
26.         lambdaQueryWrapper.orderByAsc(User::getAge, User::getId);
27.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
28.         System.out.println(users);
29.     }
30. }

复制代码

13. 自定义条件查询

13.1 apply(自定义查询条件)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.awt.*;
10. import java.util.List;
11. import java.util.Map;
12. import java.util.function.Consumer;
16. @SpringBootTest
17. public class QueryTest03 {
19.     @Autowired
20.     private UserMapper userMapper;
22.     // 升序
23.     @Test
24.     void orderByDesc() {
25.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
26.         lambdaQueryWrapper.orderByDesc(User::getAge, User::getId);
27.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
28.         System.out.println(users);
29.     }
30. }

复制代码

14. last 查询(在sql语句的最末尾拼接“字符串”)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.awt.*;
10. import java.util.List;
11. import java.util.Map;
12. import java.util.function.Consumer;
18. @SpringBootTest
19. public class QueryTest03 {
21.     @Autowired
22.     private UserMapper userMapper;
24.     @Test
25.     void orderBy() {
26.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
27.         // 设置排序字段和排序的方式
28.         // 参数1：如果排序字段的值为null的时候，是否还要作为排序字段参与排序
29.         // 参数2：是否升序排序，
30.         // 参数3: 排序字段
31.         //lambdaQueryWrapper.orderBy(true, true, User::getAge);
32.         lambdaQueryWrapper.orderBy(false, true, User::getAge);
33.         lambdaQueryWrapper.orderBy(true, false, User::getId);
34.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
35.         System.out.println(users);
36.     }
37. }

复制代码

15. exists查询

15.1 exists(存在查询)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.awt.*;
10. import java.util.List;
11. import java.util.Map;
12. import java.util.function.Consumer;
16. @SpringBootTest
17. public class QueryTest03 {
19.     @Autowired
20.     private UserMapper userMapper;
22.     //   // 可能会根据不同的请情况选择拼接不同的查询条件
23.     @Test
24.     void func() {
25.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
27.         // 可能会根据不同的请情况选择拼接不同的查询条件
28.       /*  lambdaQueryWrapper.func(new Consumer<LambdaQueryWrapper<User>>() {
29.             @Override
30.             public void accept(LambdaQueryWrapper<User> userLambdaQueryWrapper) {
31.                 //if (true) {
32.                 if (false) {
33.                     userLambdaQueryWrapper.eq(User::getId,1);
34.                 } else {
35.                     userLambdaQueryWrapper.ne(User::getId,1);
36.                 }
37.             }
38.         });*/
40.         // 使用lambad表达式
41.         lambdaQueryWrapper.func(userLambdaQueryWrapper -> {
42.             if (false) {
43.                 userLambdaQueryWrapper.eq(User::getId, 1);
44.             } else {
45.                 userLambdaQueryWrapper.ne(User::getId, 1);
46.             }
47.         });
48.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
49.         System.out.println(users);
50.     }
51. }

复制代码

15.2 notExists(不存在查询)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.awt.*;
10. import java.util.List;
11. import java.util.Map;
12. import java.util.function.Consumer;
16. @SpringBootTest
17. public class QueryTest03 {
19.     @Autowired
20.     private UserMapper userMapper;
22.     //  WHERE (age > ? AND age < ?)
23.     @Test
24.     void and() {
25.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
26.         lambdaQueryWrapper.gt(User::getAge, 22).lt(User::getAge, 30);
27.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
28.         System.out.println(users);
29.     }
30. }

复制代码

16. 字段查询

16.1 select(字段查询)

1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. import com.rainbowsea.bean.User;
4. import com.rainbowsea.mapper.UserMapper;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
9. import java.awt.*;
10. import java.util.List;
11. import java.util.Map;
12. import java.util.function.Consumer;
16. @SpringBootTest
17. public class QueryTest03 {
19.     @Autowired
20.     private UserMapper userMapper;
23.     // WHERE (name = ? AND (age > ? OR age < ?))
24.     @Test
25.     void add2() {
26.         LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
27.         lambdaQueryWrapper.eq(User::getName, "wang").and(i -> i.gt(User::getAge, 26).or().lt(User::getAge, 22));
28.         List<User> users = userMapper.selectList(lambdaQueryWrapper);
29.         System.out.println(users);
30.     }
31. }

复制代码

17. 末了：

“在这个末了的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时候再次相遇。”

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。