介绍

MyBatis-Plus 是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

特性

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本 **CURD**，性能基本无损耗，直接面向对象操作
• 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
• 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
• 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
• 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承Model类即可进行强大的 CRUD 操作
• 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
• 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
• 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
• 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
• 内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
• 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
  
  
  

工作流程图

添加依赖

在pom.xml中引入 **MyBatis-Plus Starter **依赖

Spring Boot2

<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.5.7</version>
</dependency>

Spring Boot3

<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
  <version>3.5.7</version>
</dependency>

配置

在 application.yml 配置文件中添加数据库及mybatis-plus的相关配置：

# DataSource Config
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/your_data_base_name?useSSL=false&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver		# 数据库类型的 JDBC 驱动程序,需要添加MySQL依赖
    username: root	# 连接数据库的用户名
    password: test	# 密码
  sql:
    init:
      mode: always
      
mybatis-plus:
  mapper-locations: classpath*:mapper/*.xml
  type-aliases-package: com.nskm.entity	# 扫描实体，这里是实体类存放的包名
  configuration:
      map-underscore-to-camel-case: true # 是否开启下划线和驼峰的映射，true表示开启
  global-config:
    db-config:
      logic-delete-field: deleted # 全局逻辑删除字段名
      logic-delete-value: 0 # 逻辑已删除值
      logic-not-delete-value: 1 # 逻辑未删除值

spring.datasource.driver-class-name 的配置取决于使用的数据库类型。不同的数据库有不同的 JDBC 驱动程序。
MySQL:

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

PostgreSQL:

driver-class-name: org.postgresql.Driver

SQL Server:

driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver

Oracle:

driver-class-name: oracle.jdbc.OracleDriver

H2（内存数据库，通常用于开发和测试）:

driver-class-name: org.h2.Driver

定义Mapper接口并继承BaseMapper

MybatisPlus通过扫描实体类，并基于反射获取实体类信息作为数据库信息。

public interface UserMapper extends BaseMapper<User> {

}

通过继承BaseMapper，Server层可以直接使用BaseMapper所提供的方法，这意味着像下面一样功能的函数无需我们自己定义，直接使用便可，非常的方便👍。

Server 接口

自定义 Service 接口继承 IServie 接口

public interface IUserService extends IService<User> {

}

自定义 Service 实现类，实现自定义接口并继承 ServiceImpl

public class userServiceImpl extends ServiceImpl<UserMapper, User> impements IUserService {

}

添加Config类

在程序中添加MybatisPlusConfig类。例如，可以新建一个config软件包，在里面新建MybatisPlusConfig类

@Configuration
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 这里根据数据库类型而定，这里的连接的数据库类型为POSTGRE_SQL，如果是MYSQL就将POSTGRE_SQL更改为MYSQL
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.POSTGRE_SQL));
        return interceptor;
    }
}

常用注解:

@TableName

用于指定数据库表名, 通常在实体类Entity上使用，说明这个类和指定的数据库相关联
例如: @TableName("user")，表明了该类与user数据库相关联

@TableId

用于指定表中的主键字段, 通常在实体类的主键属性上使用
例如: @TableId(value = "id", type = IdType.AUTO)，其中 value 表示主键字段名, type 表示主键生成策略

@TableField

用于指定表中的非主键字段, 可以用于实体类的属性上, 以映射属性和数据库字段
例如: @TableField(value = "user_name", exist = true)，value 表示数据库中的字段名，exist 表示该字段是否存在, 默认为true, 设置为false表示在数据库中不存在该字段

@TableLogic

用于指定逻辑删除字段，逻辑删除是指在数据库中标记某个记录已删除,，而不是真正删除
例如: @TableLogic(value = "0", delval = "1")，value 表示未删除状态的默认值，delval 表示删除状态的值

@Version

用于指定乐观锁字段，乐观锁是一种并发控制策略，用于解决多线程同时修改同一条记录的问题
例如: @Version private Integer version

@EnumValue

用于指定枚举类型字段的映射
例如: @EnumValue private Integer status

@InterceptorIgnore

用于忽略MP拦截器的处理
例如: @InterceptorIgnore(tenantLine = "true")，表示忽略拦截器

示例代码

import com.baomidou.mybatisplus.annotation.*;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

// 1. 使用 Lombok 提供的注解来生成常用的代码，如 get/set 方法、无参和有参构造函数
@Data
@NoArgsConstructor
@AllArgsConstructor

// 2. 使用 @TableName 注解将实体类与数据库表进行关联
@TableName("user")
public class User implements Serializable {

    // 3. 使用 @TableId 注解指定主键字段，并定义主键生成策略为自动递增
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    // 4. 使用 @TableField 注解将实体类的属性与数据库中的字段进行映射
    @TableField("user_name")
    private String userName;

    @TableField("email")
    private String email;

    // 5. 使用 @TableLogic 注解指定逻辑删除字段，用于软删除数据
    @TableLogic(value = "0", delval = "1")
    @TableField("deleted")
    private Integer deleted;

    // 6. 使用 @Version 注解指定乐观锁字段，以支持并发控制
    @Version
    @TableField("version")
    private Integer version;

    // 7. 使用 @EnumValue 注解将枚举类型的属性映射为数据库字段的值
    public enum UserStatus {
        ACTIVE(1), INACTIVE(0);

        @EnumValue
        private final int value;

        UserStatus(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    }

    @TableField("status")
    private UserStatus status;
}

条件构造器

简介

MyBatis-Plus 提供了一套强大的条件构造器（Wrapper），用于构建复杂的数据库查询条件。Wrapper 类允许开发者以链式调用的方式构造查询条件，无需编写繁琐的 SQL 语句，从而提高开发效率并减少 SQL 注入的风险。

主要的Wrapper类

AbstractWrapper

• 是一个抽象基类，提供了所有 Wrapper 类共有的方法和属性。
• 定义了条件构造的基本逻辑，包括字段（column）、值（value）、操作符（condition）等。
• 所有的 QueryWrapper、UpdateWrapper、LambdaQueryWrapper 和 LambdaUpdateWrapper 都继承自 AbstractWrapper。
  
  
  

QueryWrapper

• 专门用于构造查询条件，支持基本的等于、不等于、大于、小于等各种常见操作。
• 允许以链式调用的方式添加多个查询条件，并且可以组合使用 and 和 or 逻辑。

示例

// 创建一个 QueryWrapper 对象，用于构造查询条件
QueryWrapper<User> queryWrapper = new QueryWrapper<>();

// 添加查询条件：user_name 等于 "Alice"
queryWrapper.eq("user_name", "Alice")
            // 添加查询条件：age 大于等于 18
            .ge("age", 18)
            // 添加查询条件：模糊查询，email 包含 "example.com" 
            .like("email", "example.com");

// 使用构造的条件查询用户列表
List<User> users = userMapper.selectList(queryWrapper);

UpdateWrapper

• 用于构造更新条件，可以在更新数据时指定条件。
• 与 QueryWrapper 类似，它也支持链式调用和逻辑组合。
• 使用 UpdateWrapper 可以在不创建实体对象的情况下，直接设置更新字段和条件。
  
  

示例

// 创建一个 UpdateWrapper 对象，用于构造更新条件
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();

// 添加查询条件：user_name 等于 "Alice"
updateWrapper.eq("user_name", "Alice")
             // 设置 email 字段为 "newemail@example.com"
             .set("email", "newemail@example.com");

// 根据构造的条件更新用户信息
int rows = userMapper.update(null, updateWrapper);

QueryWrapper

• 一个基于 Lambda 表达式的查询条件构造器，通过 Lambda 表达式来引用实体类的属性，从而避免了硬编码字段名。
• 提高了代码的可读性和可维护性，尤其是在字段名可能发生变化的情况下。

示例

// 创建一个 LambdaQueryWrapper 对象，用于构造查询条件
LambdaQueryWrapper<User> lambdaQuery = new LambdaQueryWrapper<>();

// 添加查询条件：userName 等于 "Alice"
lambdaQuery.eq(User::getUserName, "Alice")
           // 添加查询条件：age 大于等于 18
           .ge(User::getAge, 18)
           // 添加查询条件：email 包含 "example.com"
           .like(User::getEmail, "example.com");

// 使用构造的条件查询用户列表
List<User> users = userMapper.selectList(lambdaQuery);

UpdateWrapper

• 类似于 LambdaQueryWrapper，LambdaUpdateWrapper 是基于 Lambda 表达式的更新条件构造器。
• 允许使用 Lambda 表达式来指定更新字段和条件，同样避免了硬编码字段名的问题。
  
  

// 创建一个 LambdaUpdateWrapper 对象，用于构造更新条件
LambdaUpdateWrapper<User> lambdaUpdate = new LambdaUpdateWrapper<>();

// 添加查询条件：userName 等于 "Alice"
lambdaUpdate.eq(User::getUserName, "Alice")
            // 设置 email 字段为 "newemail@example.com"
            .set(User::getEmail, "newemail@example.com");

// 根据构造的条件更新用户信息
int rows = userMapper.update(null, lambdaUpdate);

条件构造器的用法

QueryWrapper和QueryWrapper

通常用来构建select、delete、update的where条件部分。

UpdateWrapper和UpdateWrapper

通常只有在set语句比较特殊才使用。

注意

尽量使用LambdaQueryWrapper和LambdateWrapper，避免硬编码。

常用功能详解

eq

eq 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的相等条件。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置指定字段的相等条件
eq(R column, Object val)

// 根据条件设置指定字段的相等条件
eq(boolean condition, R column, Object val)

参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• val：与字段名对应的值。
• condition：一个布尔值，用于控制是否应用这个相等条件。
  
  

示例

简单使用 eq 设置字段的相等条件

假设我们有一个用户表 user，其中有字段 age 和 name，我们希望查询所有年龄为 25 的用户。

普通 Wrapper (QueryWrapper)：

// 查询 age 等于 25 的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 25);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询 age 等于 25 的用户
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getAge, 25);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL：

SELECT * FROM user WHERE age = 25;

根据条件动态设置相等条件

在一些情况下，我们可能希望在某个条件满足时才设置相等条件。例如，我们只在 name 不为空时才查询 name 为指定值的用户。

普通 Wrapper (QueryWrapper)：

String name = "John";
boolean isNameNotNull = name != null;

// 查询 age 等于 25 并且 name 等于 "John" 的用户（仅当 isNameNotNull 为 true 时才加入 name 条件）
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 25)
.eq(isNameNotNull, "name", name);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

String name = "John";
boolean isNameNotNull = name != null;

// 使用 LambdaQueryWrapper 查询 age 等于 25 并且 name 等于 "John" 的用户（仅当 isNameNotNull 为 true 时才加入 name 条件）
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getAge, 25)
            .eq(isNameNotNull, User::getName, name);

List<User> users = userMapper.selectList(queryWrapper);

如果 name 为 "John"，生成的 SQL ：

SELECT * FROM user WHERE age = 25 AND name = 'John';

如果 name 为 null，则生成的 SQL 语句如下：

SELECT * FROM user WHERE age = 25;

---

gt

gt 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的大于条件。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置指定字段的大于条件
gt(R column, Object val)

// 根据条件设置指定字段的大于条件
gt(boolean condition, R column, Object val)

参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• val：与字段名对应的值。
• condition：一个布尔值，用于控制是否应用这个大于条件。
  
  

示例

使用 gt 设置指定字段的大于条件

假设我们有一个用户表 user，其中有字段 age。查询所有年龄大于 25 的用户。

普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询 age 大于 25 的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询 age 大于 25 的用户
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.gt(User::getAge, 25);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL ：

SELECT * FROM user WHERE age > 25;

动态根据条件设置 gt 大于条件

有时候，我们希望根据某个条件动态设置大于条件。例如，如果 minAge 不为 null，则查询年龄大于 minAge 的用户。

普通Wrapper （QueryWrapper)：

Integer minAge = 25;
boolean hasMinAge = minAge != null;

// 使用 QueryWrapper 动态查询 age 大于 minAge 的用户（仅当 hasMinAge 为 true 时才加入条件）
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt(hasMinAge, "age", minAge);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

Integer minAge = 25;
boolean hasMinAge = minAge != null;

// 使用 LambdaQueryWrapper 动态查询 age 大于 minAge 的用户（仅当 hasMinAge 为 true 时才加入条件）
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.gt(hasMinAge, User::getAge, minAge);

List<User> users = userMapper.selectList(queryWrapper);

如果 minAge 为 25，生成的 SQL 语句如下：

SELECT * FROM user WHERE age > 25;

如果 minAge 为 null，生成的 SQL 语句如下：

SELECT * FROM user;

---

ge

ge 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的大于等于条件。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置指定字段的大于等于条件
ge(R column, Object val)

// 根据条件设置指定字段的大于等于条件
ge(boolean condition, R column, Object val)

参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• val：与字段名对应的值。
• condition：一个布尔值，用于控制是否应用这个大于等于条件。
  
  

示例

我们还是以用户表 user 为例，查询所有年龄大于等于 25 岁的用户。

使用 ge 设置指定字段的大于等于条件

普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询 age 大于等于 25 的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ge("age", 25);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询 age 大于等于 25 的用户
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.ge(User::getAge, 25);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE age >= 25;

动态根据条件设置 ge 大于等于条件

普通 Wrapper (QueryWrapper)：

Integer minAge = 25;
boolean hasMinAge = minAge != null;

// 使用 QueryWrapper 动态查询 age 大于等于 minAge 的用户（仅当 hasMinAge 为 true 时才加入条件）
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ge(hasMinAge, "age", minAge);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

Integer minAge = 25;
boolean hasMinAge = minAge != null;

// 使用 LambdaQueryWrapper 动态查询 age 大于等于 minAge 的用户（仅当 hasMinAge 为 true 时才加入条件）
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.ge(hasMinAge, User::getAge, minAge);

List<User> users = userMapper.selectList(queryWrapper);

如果 minAge 为 25，生成的 SQL 语句如下：

SELECT * FROM user WHERE age >= 25;

如果 minAge 为 null，生成的 SQL 语句如下：

SELECT * FROM user;

---

between

between 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 BETWEEN 条件。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置指定字段的 BETWEEN 条件
between(R column, Object val1, Object val2)

// 根据条件设置指定字段的 BETWEEN 条件
between(boolean condition, R column, Object val1, Object val2)

参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• val1：与字段名对应的第一个值，表示 BETWEEN 条件的起始值。
• val2：与字段名对应的第二个值，表示 BETWEEN 条件的结束值。
• condition：一个布尔值，用于控制是否应用这个 BETWEEN 条件。
  
  

示例

使用 between 设置指定字段的 BETWEEN 条件

查询年龄在 20 到 30 岁之间的用户。

普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询 age 在 20 到 30 之间的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.between("age", 20, 30);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询 age 在 20 到 30 之间的用户
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.between(User::getAge, 20, 30);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE age BETWEEN 20 AND 30;

动态根据条件设置 between 条件

现在我们希望根据动态条件来设置 BETWEEN 条件。例如，如果条件成立，则查询年龄在 20 到 30 岁之间的用户。

动态设置 between 条件

普通 Wrapper (QueryWrapper)：

Integer minAge = 20;
Integer maxAge = 30;
boolean hasAgeRange = minAge != null && maxAge != null;

// 使用 QueryWrapper 动态查询 age 在 minAge 和 maxAge 之间的用户（仅当 hasAgeRange 为 true 时才加入条件）
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.between(hasAgeRange, "age", minAge, maxAge);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

Integer minAge = 20;
Integer maxAge = 30;
boolean hasAgeRange = minAge != null && maxAge != null;

// 使用 LambdaQueryWrapper 动态查询 age 在 minAge 和 maxAge 之间的用户（仅当 hasAgeRange 为 true 时才加入条件）
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.between(hasAgeRange, User::getAge, minAge, maxAge);

List<User> users = userMapper.selectList(queryWrapper);

如果 minAge为 20，maxAge 为 30，生成的 SQL 语句如下：

SELECT * FROM user WHERE age BETWEEN 20 AND 30;

如果 minAge 或 maxAge 为 null，生成的 SQL 语句如下：

SELECT * FROM user;

---

notBetween

notBetween 方法是 MyBatis-Plus 中用于构建查询条件的另一个基本方法，它用于设置单个字段的 NOT BETWEEN 条件。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置指定字段的 NOT BETWEEN 条件
notBetween(R column, Object val1, Object val2)

// 根据条件设置指定字段的 NOT BETWEEN 条件
notBetween(boolean condition, R column, Object val1, Object val2)

##### 参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• val1：与字段名对应的第一个值，表示 NOT BETWEEN 条件的起始值。
• val2：与字段名对应的第二个值，表示 NOT BETWEEN 条件的结束值。
• condition：一个布尔值，用于控制是否应用这个 NOT BETWEEN 条件。
  
  

示例

使用 notBetween 设置指定字段的 NOT BETWEEN 条件

查询年龄不在 20 到 30 岁之间的用户。

普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询 age 不在 20 到 30 之间的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notBetween("age", 20, 30);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询 age 不在 20 到 30 之间的用户
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.notBetween(User::getAge, 20, 30);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE age NOT BETWEEN 20 AND 30;

动态根据条件设置 notBetween NOT BETWEEN 条件

现在我们希望根据动态条件来设置 NOT BETWEEN 条件。例如，如果条件成立，则查询年龄不在 20 到 30 岁之间的用户。


普通 Wrapper (QueryWrapper)：

Integer minAge = 20;
Integer maxAge = 30;
boolean hasAgeRange = minAge != null && maxAge != null;

// 使用 QueryWrapper 动态查询 age 不在 minAge 和 maxAge 之间的用户（仅当 hasAgeRange 为 true 时才加入条件）
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notBetween(hasAgeRange, "age", minAge, maxAge);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

Integer minAge = 20;
Integer maxAge = 30;
boolean hasAgeRange = minAge != null && maxAge != null;

// 使用 LambdaQueryWrapper 动态查询 age 不在 minAge 和 maxAge 之间的用户（仅当 hasAgeRange 为 true 时才加入条件）
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.notBetween(hasAgeRange, User::getAge, minAge, maxAge);

List<User> users = userMapper.selectList(queryWrapper);

如果 minAge 为 20，maxAge为 30，生成的 SQL 语句如下：

SELECT * FROM user WHERE age NOT BETWEEN 20 AND 30;

如果 minAge 或 maxAge 为 null，生成的 SQL 语句如下：

SELECT * FROM user;

---

like

like 方法是 **MyBatis-Plus **中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的 LIKE 条件。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置指定字段的 LIKE 条件
like(R column, Object val)

// 根据条件设置指定字段的 LIKE 条件
like(boolean condition, R column, Object val)

参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• val：与字段名对应的值，表示 LIKE 条件中的搜索值。
• condition：一个布尔值，用于控制是否应用这个 LIKE 条件。
  
  

示例

使用 like 设置指定字段的 LIKE 条件

查询用户名中包含 “admin” 的用户。

普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询 username 包含 "admin" 的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("username", "admin");

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询 username 包含 "admin" 的用户
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(User::getUsername, "admin");

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE username LIKE '%admin%';

动态根据条件设置 like 条件

现在我们希望根据动态条件来设置 LIKE 条件。例如，如果条件成立，则查询用户名中包含 “admin” 的用户。

普通 Wrapper (QueryWrapper)：

String username = "admin";
boolean hasUsername = username != null && !username.isEmpty();

// 使用 QueryWrapper 动态查询 username 包含 username 的用户（仅当 hasUsername 为 true 时才加入条件）
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like(hasUsername, "username", username);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

String username = "admin";
boolean hasUsername = username != null && !username.isEmpty();

// 使用 LambdaQueryWrapper 动态查询 username 包含 username 的用户（仅当 hasUsername 为 true 时才加入条件）
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(hasUsername, User::getUsername, username);

List<User> users = userMapper.selectList(queryWrapper);

如果 username 为 “admin”，生成的 SQL 语句如下：

SELECT * FROM user WHERE username LIKE '%admin%';

如果 username 为 null 或空字符串，生成的 SQL 语句如下：

SELECT * FROM user;

---

in

in 方法是 **MyBatis-Plus **中用于构建查询条件的基本方法之一，它用于设置单个字段的 IN 条件，即字段的值在给定的集合中。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置指定字段的 IN 条件，使用集合、
in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)

// 设置指定字段的 IN 条件，使用可变参数
in(R column, Object... values)
in(boolean condition, R column, Object... values)

参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• value：一个集合，包含 IN 条件中字段可能的值。
• values：一个可变参数列表，包含 IN 条件中字段可能的值。
• condition：一个布尔值，用于控制是否应用这个 IN 条件。
  
  

示例

使用集合的 in 设置指定字段的 IN 条件

查询用户 ID 在指定集合中的用户。

普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询用户 ID 在集合中的用户
List<Integer> userIds = Arrays.asList(1, 2, 3);
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.in("id", userIds);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询用户 ID 在集合中的用户
List<Integer> userIds = Arrays.asList(1, 2, 3);
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(User::getId, userIds);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE id IN (1, 2, 3);

使用可变参数的 in 设置指定字段的 IN 条件

普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询用户 ID 在指定参数中的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.in("id", 1, 2, 3);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询用户 ID 在指定参数中的用户
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(User::getId, 1, 2, 3);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE id IN (1, 2, 3);

动态根据条件设置 in 条件

根据动态条件来设置 IN 条件。例如，只有在集合非空时才加入 IN 条件。

普通 Wrapper (QueryWrapper)：

List<Integer> userIds = Arrays.asList(1, 2, 3);
boolean hasUserIds = userIds != null && !userIds.isEmpty();

// 使用 QueryWrapper 动态查询用户 ID 在集合中的用户（仅当 hasUserIds 为 true 时才加入条件）
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.in(hasUserIds, "id", userIds);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

List<Integer> userIds = Arrays.asList(1, 2, 3);
boolean hasUserIds = userIds != null && !userIds.isEmpty();

// 使用 LambdaQueryWrapper 动态查询用户 ID 在集合中的用户（仅当 hasUserIds 为 true 时才加入条件）
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(hasUserIds, User::getId, userIds);

List<User> users = userMapper.selectList(queryWrapper);

如果 userIds 为 [1, 2, 3]，生成的 SQL 语句如下：

SELECT * FROM user WHERE id IN (1, 2, 3);

如果 userIds 为空或为 null，生成的 SQL 语句如下：

SELECT * FROM user;

---

notIn

notIn 方法是 **MyBatis-Plus **中用于构建查询条件的基本方法之一，它用于设置单个字段的 NOT IN 条件，即字段的值不在给定的集合中。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置指定字段的 NOT IN 条件，使用集合
notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)

// 设置指定字段的 NOT IN 条件，使用可变参数
notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• value：一个集合，包含 NOT IN 条件中字段可能的值。
• values：一个可变参数列表，包含 NOT IN 条件中字段可能的值。
• condition：一个布尔值，用于控制是否应用这个 NOT IN 条件。
  
  

示例

使用 notIn 设置指定字段的 NOT IN 条件

我们希望查询用户 ID 不在指定集合中的用户。


普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询用户 ID 不在集合中的用户
List<Integer> userIds = Arrays.asList(1, 2, 3);
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notIn("id", userIds);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询用户 ID 不在集合中的用户
List<Integer> userIds = Arrays.asList(1, 2, 3);
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.notIn(User::getId, userIds);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE id NOT IN (1, 2, 3);

使用可变参数的 notIn 设置指定字段的 NOT IN 条件

普通 Wrapper (QueryWrapper)：

// 使用 QueryWrapper 查询用户 ID 不在指定参数中的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notIn("id", 1, 2, 3);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 使用 LambdaQueryWrapper 查询用户 ID 不在指定参数中的用户
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.notIn(User::getId, 1, 2, 3);

List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE id NOT IN (1, 2, 3);

动态根据条件设置 notIn 条件

根据动态条件来设置 NOT IN 条件。例如，只有在集合非空时才加入 NOT IN 条件。

普通 Wrapper (QueryWrapper)：

List<Integer> userIds = Arrays.asList(1, 2, 3);
boolean hasUserIds = userIds != null && !userIds.isEmpty();

// 使用 QueryWrapper 动态查询用户 ID 不在集合中的用户（仅当 hasUserIds 为 true 时才加入条件）
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notIn(hasUserIds, "id", userIds);

List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

List<Integer> userIds = Arrays.asList(1, 2, 3);
boolean hasUserIds = userIds != null && !userIds.isEmpty();

// 使用 LambdaQueryWrapper 动态查询用户 ID 不在集合中的用户（仅当 hasUserIds 为 true 时才加入条件）
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.notIn(hasUserIds, User::getId, userIds);

List<User> users = userMapper.selectList(queryWrapper);

如果 userIds 为 [1, 2, 3]，生成的 SQL 语句如下：

SELECT * FROM user WHERE id NOT IN (1, 2, 3);

如果 userIds 为空或为 null，生成的 SQL 语句如下：

SELECT * FROM user;

---

groupBy

groupBy 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的分组条件。通过指定一个或多个字段，groupBy 方法可以生成 SQL 语句中的 GROUP BY 子句。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置分组条件，使用字段名
groupBy(R... columns)
groupBy(boolean condition, R... columns)

参数说明

• columns：一个可变参数列表，包含用于分组的字段名。
• condition：一个布尔值，用于控制是否应用这个分组条件。
  
  

示例

假设我们有一个 Order 表，其中包含字段 order_date 和 total_amount。我们希望根据 order_date 对订单进行分组。

根据指定条件设置分组条件

普通 Wrapper (QueryWrapper)：

// 创建 QueryWrapper 实例
QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
// 设置分组条件，按 order_date 分组
queryWrapper.groupBy("order_date");

// 执行查询，获取按日期分组后的结果
List<Order> orders = orderMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();
// 设置分组条件，按 order_date 分组
queryWrapper.groupBy(Order::getOrderDate);

// 执行查询，获取按日期分组后的结果
List<Order> orders = orderMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM order GROUP BY order_date;

动态根据条件设置分组条件

现在，我们希望根据动态条件来设置分组条件。例如，如果条件成立，则按 order_date 分组。

普通 Wrapper (QueryWrapper)：

// 动态设置分组条件
boolean shouldGroupByDate = true; // 例如从外部条件中获得

// 创建 QueryWrapper 实例
QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
// 根据条件动态设置分组条件
queryWrapper.groupBy(shouldGroupByDate, "order_date");

// 执行查询，获取分组后的结果
List<Order> orders = orderMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 动态设置分组条件
boolean shouldGroupByDate = true; // 例如从外部条件中获得

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();
// 根据条件动态设置分组条件
queryWrapper.groupBy(shouldGroupByDate, Order::getOrderDate);

// 执行查询，获取分组后的结果
List<Order> orders = orderMapper.selectList(queryWrapper);

如果 shouldGroupByDate 为 true，生成的 SQL 语句如下：

SELECT * FROM order GROUP BY order_date;

如果 shouldGroupByDate 为 false，生成的 SQL 语句如下：

SELECT * FROM order;

---

orderByAsc

orderByAsc 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的升序排序条件。通过指定一个或多个字段，orderByAsc 方法可以生成 SQL 语句中的 ORDER BY 子句，并指定升序排序。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置升序排序条件，使用字段名
orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)

参数说明

• columns：一个可变参数列表，包含用于排序的字段名。
• condition：一个布尔值，用于控制是否应用这个排序条件。
  
  

示例

假设我们有一个 Employee 表，其中包含字段 name 和 salary。我们希望根据 salary 对员工进行升序排序。

根据指定条件设置升序排序条件

普通 Wrapper (QueryWrapper)：

// 创建 QueryWrapper 实例
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
// 设置升序排序条件，按 salary 升序排序
queryWrapper.orderByAsc("salary");

// 执行查询，获取排序后的结果
List<Employee> employees = employeeMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
// 设置升序排序条件，按 salary 升序排序
queryWrapper.orderByAsc(Employee::getSalary);

// 执行查询，获取排序后的结果
List<Employee> employees = employeeMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM employee ORDER BY salary ASC;

动态根据条件设置升序排序条件

现在，我们希望根据动态条件来设置升序排序条件。例如，如果条件成立，则按 salary 升序排序。

普通 Wrapper (QueryWrapper)：

// 动态设置排序条件
boolean shouldOrderBySalary = true; // 例如从外部条件中获得

// 创建 QueryWrapper 实例
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
// 根据条件动态设置升序排序条件
queryWrapper.orderByAsc(shouldOrderBySalary, "salary");

// 执行查询，获取排序后的结果
List<Employee> employees = employeeMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 动态设置排序条件
boolean shouldOrderBySalary = true; // 例如从外部条件中获得

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
// 根据条件动态设置升序排序条件
queryWrapper.orderByAsc(shouldOrderBySalary, Employee::getSalary);

// 执行查询，获取排序后的结果
List<Employee> employees = employeeMapper.selectList(queryWrapper);

如果 shouldOrderBySalary 为 true，生成的 SQL 语句如下：

SELECT * FROM employee ORDER BY salary ASC;

如果 shouldOrderBySalary 为 false，生成的 SQL 语句如下：

SELECT * FROM employee;

---

orderByDesc

orderByDesc 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的降序排序条件。通过指定一个或多个字段，orderByDesc 方法可以生成 SQL 语句中的 ORDER BY 子句，并指定降序排序。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置降序排序条件，使用字段名
orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)

参数说明

• columns：一个可变参数列表，包含用于排序的字段名。
• condition：一个布尔值，用于控制是否应用这个排序条件。
• 
  

示例

与 orderByAsc 基本一致，照葫芦画瓢。

---

orderBy

orderBy 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的排序条件。通过指定一个或多个字段以及排序方向（升序或降序），orderBy 方法可以生成 SQL 语句中的 ORDER BY 子句。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置排序条件，使用字段名和排序方向
orderBy(boolean condition, boolean isAsc, R... columns)

参数说明

• condition：一个布尔值，用于控制是否应用这个排序条件。
• isAsc：一个布尔值，表示排序方向。true 表示升序（ASC），false 表示降序（DESC）。
• columns：一个可变参数列表，包含用于排序的字段名。
  
  

示例

假设我们有一个 Product 表，其中包含字段 name 和 price。我们希望根据 price 对产品进行排序，并且可以选择升序或降序。

普通 Wrapper (QueryWrapper)：

// 动态设置排序条件
boolean shouldOrderByPrice = true; // 例如从外部条件中获得
boolean isAsc = true; // 是否升序排序，true 为升序，false 为降序

// 创建 QueryWrapper 实例
QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
// 根据条件动态设置排序条件，按 price 排序，指定排序方向
queryWrapper.orderBy(shouldOrderByPrice, isAsc, "price");

// 执行查询，获取排序后的结果
List<Product> products = productMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 动态设置排序条件
boolean shouldOrderByPrice = true; // 例如从外部条件中获得
boolean isAsc = true; // 是否升序排序，true 为升序，false 为降序

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
// 根据条件动态设置排序条件，按 price 排序，指定排序方向
queryWrapper.orderBy(shouldOrderByPrice, isAsc, Product::getPrice);

// 执行查询，获取排序后的结果
List<Product> products = productMapper.selectList(queryWrapper);

生成的 SQL 语句
如果 shouldOrderByPrice 为 true 和 isAsc 为 true，生成的 SQL 语句如下：

SELECT * FROM product ORDER BY price ASC;

如果 shouldOrderByPrice 为 true 和 isAsc 为 false，生成的 SQL 语句如下：

SELECT * FROM product ORDER BY price DESC;

如果 shouldOrderByPrice 为 false，无论 isAsc 的值如何，生成的 SQL 语句如下：

SELECT * FROM product;

---

or

or 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于在查询条件中添加 OR 逻辑。通过调用 or 方法，可以改变后续查询条件的连接方式，从默认的 AND 连接变为 OR 连接。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 改变后续查询条件的连接方式为 OR
or()
or(boolean condition)

// 添加 OR 嵌套条件
or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)

参数说明

• condition：一个布尔值，用于控制是否应用这个 OR 逻辑。
• consumer：一个 Consumer 函数式接口，它接受一个 Param 类型的参数，并可以调用 Param 对象上的方法来构建 OR 嵌套条件。
• 
  

示例

使用 or 改变查询条件的连接方式为 OR

假设我们有一个 User 表，其中包含字段 username 和 email。我们希望查询 username 为 “admin” 或 email 为 “admin@example.com” 的用户。

普通 Wrapper (QueryWrapper)：

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 设置查询条件，username 为 "admin" 或 email 为 "admin@example.com"
queryWrapper.eq("username", "admin").or().eq("email", "admin@example.com");

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 设置查询条件，username 为 "admin" 或 email 为 "admin@example.com"
queryWrapper.eq(User::getUsername, "admin").or().eq(User::getEmail, "admin@example.com");

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE username = 'admin' OR email = 'admin@example.com';

动态根据条件改变查询条件的连接方式为 OR

现在，我们希望根据动态条件来决定是否使用 OR 连接查询条件。

普通 Wrapper (QueryWrapper)：

// 动态设置 OR 连接条件
boolean useOr = true; // 例如从外部条件中获得

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 根据条件动态设置查询条件，使用 OR 连接
queryWrapper.eq("username", "admin").or(useOr).eq("email", "admin@example.com");

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 动态设置 OR 连接条件
boolean useOr = true; // 例如从外部条件中获得

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 根据条件动态设置查询条件，使用 OR 连接
queryWrapper.eq(User::getUsername, "admin").or(useOr).eq(User::getEmail, "admin@example.com");

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

如果 useOr 为 true，生成的 SQL 语句如下：

SELECT * FROM user WHERE username = 'admin' OR email = 'admin@example.com';

如果 useOr 为 false，生成的 SQL 语句如下：

SELECT * FROM user WHERE username = 'admin' AND email = 'admin@example.com';

使用 or(Consumer<Param> consumer) 添加 OR 嵌套条件

现在，我们希望查询 username 为 “admin”，或者 (email 为 “admin@example.com” 并且 status 为 “active”) 的用户。

普通 Wrapper (QueryWrapper)：

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 设置查询条件，username 为 "admin" 或者 (email 为 "admin@example.com" 并且 status 为 "active")
queryWrapper.eq("username", "admin")
.or(wrapper -> wrapper.eq("email", "admin@example.com").eq("status", "active"));

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 设置查询条件，username 为 "admin" 或者 (email 为 "admin@example.com" 并且 status 为 "active")
queryWrapper.eq(User::getUsername, "admin")
.or(wrapper -> wrapper.eq(User::getEmail, "admin@example.com").eq(User::getStatus, "active"));

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE username = 'admin' OR (email = 'admin@example.com' AND status = 'active');

动态根据条件添加 OR 嵌套条件

现在，我们希望根据动态条件来决定是否使用 OR 嵌套条件。

普通 Wrapper (QueryWrapper)：

// 动态设置嵌套 OR 条件
boolean useNestedOr = true; // 例如从外部条件中获得

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 根据条件动态设置查询条件，使用 OR 嵌套条件
queryWrapper.eq("username", "admin")
.or(useNestedOr, wrapper -> wrapper.eq("email", "admin@example.com").eq("status", "active"));

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 动态设置嵌套 OR 条件
boolean useNestedOr = true; // 例如从外部条件中获得

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 根据条件动态设置查询条件，使用 OR 嵌套条件
queryWrapper.eq(User::getUsername, "admin")
.or(useNestedOr, wrapper -> wrapper.eq(User::getEmail, "admin@example.com").eq(User::getStatus, "active"));

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

如果 useNestedOr 为 true，生成的 SQL 语句如下：

SELECT * FROM user WHERE username = 'admin' OR (email = 'admin@example.com' AND status = 'active');

如果 useNestedOr 为 false，生成的 SQL 语句如下：

SELECT * FROM user WHERE username = 'admin' AND email = 'admin@example.com' AND status = 'active';

---

and

and 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于在查询条件中添加 AND 逻辑。通过调用 and 方法，可以创建 AND 嵌套条件，即在一个 AND 逻辑块中包含多个查询条件。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 添加 AND 嵌套条件
and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

参数说明

• consumer：一个 Consumer 函数式接口，它接受一个 Param 类型的参数，并可以调用 Param 对象上的方法来构建 AND 嵌套条件。
• condition：一个布尔值，用于控制是否应用这个 AND 嵌套逻辑。

示例

假设我们有一个 User 表，其中包含字段 username、email 和 status。我们希望查询 username 为 “admin”，并且 email 为 “admin@example.com” 且 status 为 “active” 的用户。

普通 Wrapper (QueryWrapper)：

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 设置查询条件，username 为 "admin" 并且 (email 为 "admin@example.com" 且 status 为 "active")
queryWrapper.eq("username", "admin")
.and(wrapper -> wrapper.eq("email", "admin@example.com").eq("status", "active"));

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 设置查询条件，username 为 "admin" 并且 (email 为 "admin@example.com" 且 status 为 "active")
queryWrapper.eq(User::getUsername, "admin")
.and(wrapper -> wrapper.eq(User::getEmail, "admin@example.com").eq(User::getStatus, "active"));

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE username = 'admin' AND (email = 'admin@example.com' AND status = 'active');

动态根据条件添加 AND 嵌套条件

现在，我们希望根据动态条件来决定是否使用 AND 嵌套条件。

普通 Wrapper (QueryWrapper)：

// 动态设置嵌套 AND 条件
boolean useNestedAnd = true; // 例如从外部条件中获得

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 根据条件动态设置查询条件，使用 AND 嵌套条件
queryWrapper.eq("username", "admin")
.and(useNestedAnd, wrapper -> wrapper.eq("email", "admin@example.com").eq("status", "active"));

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 动态设置嵌套 AND 条件
boolean useNestedAnd = true; // 例如从外部条件中获得

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 根据条件动态设置查询条件，使用 AND 嵌套条件
queryWrapper.eq(User::getUsername, "admin")
.and(useNestedAnd, wrapper -> wrapper.eq(User::getEmail, "admin@example.com").eq(User::getStatus, "active"));

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句
如果 useNestedAnd 为 true，生成的 SQL 语句如下：

SELECT * FROM user WHERE username = 'admin' AND (email = 'admin@example.com' AND status = 'active');

如果 useNestedAnd 为 false，生成的 SQL 语句如下：

SELECT * FROM user WHERE username = 'admin' AND email = 'admin@example.com' AND status = 'active';

---

exists

exists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 EXISTS 子查询。通过调用 exists 方法，可以将一个完整的 SQL 子查询作为 EXISTS 条件添加到主查询中。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 添加 EXISTS 子查询
exists(String existsSql)
exists(boolean condition, String existsSql)

参数说明

• existsSql：一个字符串，包含要作为 EXISTS 条件的 SQL 子查询。
• condition：一个布尔值，用于控制是否应用这个 EXISTS 条件。
  
  

示例

假设我们有两个表：User 表和 Order 表。我们希望查询那些至少有一笔订单的用户，即查询 User 表中存在与 Order 表关联的记录的用户。

普通 Wrapper (QueryWrapper )：

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 添加 EXISTS 子查询，查询至少有一笔订单的用户
queryWrapper.exists("SELECT 1 FROM orders WHERE orders.user_id = user.id");

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 添加 EXISTS 子查询，查询至少有一笔订单的用户
queryWrapper.exists("SELECT 1 FROM orders WHERE orders.user_id = user.id");

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT * FROM user WHERE EXISTS (SELECT 1 FROM orders WHERE orders.user_id = user.id);

动态根据条件添加 EXISTS 子查询

现在，我们希望根据动态条件来决定是否使用 EXISTS 子查询。

普通 Wrapper (QueryWrapper)：

// 动态设置 EXISTS 条件
boolean useExists = true; // 例如从外部条件中获得

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 根据条件动态设置 EXISTS 子查询，查询至少有一笔订单的用户
queryWrapper.exists(useExists, "SELECT 1 FROM orders WHERE orders.user_id = user.id");

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 动态设置 EXISTS 条件
boolean useExists = true; // 例如从外部条件中获得

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 根据条件动态设置 EXISTS 子查询，查询至少有一笔订单的用户
queryWrapper.exists(useExists, "SELECT 1 FROM orders WHERE orders.user_id = user.id");

// 执行查询，获取符合条件的用户列表
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句

如果 useExists 为 true，生成的 SQL 语句如下：

SELECT * FROM user WHERE EXISTS (SELECT 1 FROM orders WHERE orders.user_id = user.id);

如果 useExists 为 false，生成的 SQL 语句如下：

SELECT * FROM user;

---

notExists

notExists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 NOT EXISTS 子查询。通过调用 notExists 方法，可以将一个完整的 SQL 子查询作为 NOT EXISTS 条件添加到主查询中。

使用范围

• QueryWrapper
• LambdaQueryWrapper
• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 添加 NOT EXISTS 子查询
notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)

参数说明

• notExistsSql：一个字符串，包含要作为 NOT EXISTS 条件的 SQL 子查询。
• condition：一个布尔值，用于控制是否应用这个 NOT EXISTS 条件。
  
  

示例

与 exist 基本一致，照猫画虎。

---

select

select 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询的字段。通过调用 select 方法，可以指定在查询结果中包含哪些字段，从而实现字段级别的查询定制。

使用范围

• QueryWrapper
• LambdaQueryWrapper
  
  

方法签名

// 设置查询字段
select(String... sqlSelect)

// 过滤查询字段（主键除外）
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

参数说明

• sqlSelect：一个字符串数组，包含要查询的字段名。
• predicate：一个 Predicate 函数式接口，用于过滤查询字段。它接受一个 TableFieldInfo 类型的参数，并返回一个布尔值，表示是否选择该字段。
• entityClass：实体类的类型，用于获取字段信息。
  
  

示例

假设我们有一个 User 表，其中包含字段 id、username 和 email。我们希望查询 username 和 email 字段。

普通 Wrapper (QueryWrapper)：

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 设置查询字段，查询 username 和 email
queryWrapper.select("username", "email");

// 执行查询，获取结果
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 设置查询字段，查询 username 和 email
queryWrapper.select(User::getUsername, User::getEmail);

// 执行查询，获取结果
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT username, email FROM user;

过滤查询字段（主键除外）

假设我们希望查询字段，但排除主键字段 id。

普通 Wrapper (QueryWrapper)：

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 过滤查询字段，排除主键字段 id
queryWrapper.select(fieldInfo -> !"id".equals(fieldInfo.getColumn()));
// 或者直接指定查询字段排除主键
queryWrapper.select("username", "email");

// 执行查询，获取结果
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 过滤查询字段，排除主键字段 id
queryWrapper.select(fieldInfo -> !"id".equals(fieldInfo.getColumn()));
// 或者直接指定查询字段排除主键
queryWrapper.select(User::getUsername, User::getEmail);

// 执行查询，获取结果
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句（假设主键字段是 id）：

SELECT username, email FROM user;

选择特定字段并过滤字段（主键除外）

现在，我们希望根据特定的条件来选择字段，并且排除主键字段。

普通 Wrapper (QueryWrapper)：

// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 根据特定条件选择字段，排除主键字段 id
queryWrapper.select(fieldInfo -> {
    // 只选择 username 和 email 字段
    return "username".equals(fieldInfo.getColumn()) || "email".equals(fieldInfo.getColumn());
});

// 执行查询，获取结果
List<User> users = userMapper.selectList(queryWrapper);

Lambda Wrapper (LambdaQueryWrapper)：

// 创建 LambdaQueryWrapper 实例
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
// 根据特定条件选择字段，排除主键字段 id
queryWrapper.select(fieldInfo -> {
    // 只选择 username 和 email 字段
    return "username".equals(fieldInfo.getColumn()) || "email".equals(fieldInfo.getColumn());
});

// 执行查询，获取结果
List<User> users = userMapper.selectList(queryWrapper);

生成的 SQL 语句：

SELECT username, email FROM user;

---

set

set 方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一，它用于设置更新语句中的 SET 字段。通过调用 set 方法，可以指定在更新操作中要修改的字段及其新值。

使用范围

• UpdateWrapper
• LambdaUpdateWrapper
  
  

方法签名

// 设置更新语句中的 SET 字段
set(R column, Object val)
set(R column, Object val, String mapping)
set(boolean condition, R column, Object val)
set(boolean condition, R column, Object val, String mapping)

参数说明

• column：数据库字段名或使用 Lambda 表达式的字段名。
• condition：一个布尔值，用于控制是否应用这个 SET 字段。
• val：一个对象，表示要更新到字段的新值。
• mapping：额外指定,例如: javaType=int,jdbcType=NUMERIC,typeHandler=xxx.xxx.MyTypeHandler

示例

假设我们有一个 Employee 表，其中包含字段 salary 和 status。我们希望更新员工的 salary 和 status 字段。

普通 Wrapper (UpdateWrapper)：

// 创建 UpdateWrapper 实例
UpdateWrapper<Employee> updateWrapper = new UpdateWrapper<>();
// 设置更新字段，salary 更新为 5000，status 更新为 "active"
updateWrapper.set("salary", 5000).set("status", "active");

// 设置更新条件，例如更新 id 为 1 的员工
updateWrapper.eq("id", 1);

// 执行更新操作
employeeMapper.update(null, updateWrapper);

Lambda Wrapper (LambdaUpdateWrapper)：

// 创建 LambdaUpdateWrapper 实例
LambdaUpdateWrapper<Employee> updateWrapper = new LambdaUpdateWrapper<>();
// 设置更新字段，salary 更新为 5000，status 更新为 "active"
updateWrapper.set(Employee::getSalary, 5000).set(Employee::getStatus, "active");

// 设置更新条件，例如更新 id 为 1 的员工
updateWrapper.eq(Employee::getId, 1);

// 执行更新操作
employeeMapper.update(null, updateWrapper);

生成的 SQL 语句：

UPDATE employee SET salary = 5000, status = 'active' WHERE id = 1;

动态根据条件设置更新字段

现在，我们希望根据动态条件来决定是否更新某些字段。例如，如果某个条件为 true，我们才更新 salary 字段。

普通 Wrapper (UpdateWrapper)：

// 动态设置更新字段
boolean updateSalary = true; // 例如从外部条件中获得
boolean updateStatus = true; // 例如从外部条件中获得

// 创建 UpdateWrapper 实例
UpdateWrapper<Employee> updateWrapper = new UpdateWrapper<>();
// 根据条件动态设置更新字段
updateWrapper.set(updateSalary, "salary", 5000)
.set(updateStatus, "status", "active");

// 设置更新条件，例如更新 id 为 1 的员工
updateWrapper.eq("id", 1);

// 执行更新操作
employeeMapper.update(null, updateWrapper);

Lambda Wrapper (LambdaUpdateWrapper)：

// 动态设置更新字段
boolean updateSalary = true; // 例如从外部条件中获得
boolean updateStatus = true; // 例如从外部条件中获得

// 创建 LambdaUpdateWrapper 实例
LambdaUpdateWrapper<Employee> updateWrapper = new LambdaUpdateWrapper<>();
// 根据条件动态设置更新字段
updateWrapper.set(updateSalary, Employee::getSalary, 5000)
.set(updateStatus, Employee::getStatus, "active");

// 设置更新条件，例如更新 id 为 1 的员工
updateWrapper.eq(Employee::getId, 1);

// 执行更新操作
employeeMapper.update(null, updateWrapper);

生成的 SQL 语句：
如果 updateSalary 和 updateStatus 都为 true，生成的 SQL 语句如下：

UPDATE employee SET salary = 5000, status = 'active' WHERE id = 1;

如果 updateSalary 为 false，updateStatus为 true，生成的 SQL 语句如下：

UPDATE employee SET status = 'active' WHERE id = 1;

如果 updateSalary 为 true，updateStatus*为 false，生成的 SQL 语句如下：

UPDATE employee SET salary = 5000 WHERE id = 1;

如果 updateSalary 和 updateStatus 都为 false，生成的 SQL 语句如下：

UPDATE employee WHERE id = 1;

使用映射设置字段

如果字段名称在数据库和对象模型中不同，我们可以使用映射名称进行更新。

普通 Wrapper (UpdateWrapper)：

// 创建 UpdateWrapper 实例
UpdateWrapper<Employee> updateWrapper = new UpdateWrapper<>();
// 设置更新字段，映射名称为 "salary_field"，实际字段为 "salary"
updateWrapper.set("salary_field", 5000, "salary")
.set("status_field", "active", "status");

// 设置更新条件，例如更新 id 为 1 的员工
updateWrapper.eq("id", 1);

// 执行更新操作
employeeMapper.update(null, updateWrapper);

Lambda Wrapper (LambdaUpdateWrapper)：

// 创建 LambdaUpdateWrapper 实例
LambdaUpdateWrapper<Employee> updateWrapper = new LambdaUpdateWrapper<>();
// 设置更新字段，映射名称为 "salary_field"，实际字段为 "salary"
updateWrapper.set(Employee::getSalary, 5000, "salary_field")
.set(Employee::getStatus, "active", "status_field");

// 设置更新条件，例如更新 id 为 1 的员工
updateWrapper.eq(Employee::getId, 1);

// 执行更新操作
employeeMapper.update(null, updateWrapper);

生成的 SQL 语句：

UPDATE employee SET salary = 5000, status = 'active' WHERE id = 1;

更多功能详解

https://baomidou.com/guides/wrapper/#%E5%8A%9F%E8%83%BD%E8%AF%A6%E8%A7%A3