文章目录
介绍
MyBatis-Plus 是一个 MyBatis 的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。
特性
- 无侵入:只做增强不做改变,引入它不会对现有工程产生影响,如丝般顺滑
- 损耗小:启动即会自动注入基本
**CURD**
,性能基本无损耗,直接面向对象操作 - 强大的 CRUD 操作:内置通用
Mapper
、通用Service
,仅仅通过少量配置即可实现单表大部分CRUD
操作,更有强大的条件构造器,满足各类使用需求 - 支持 Lambda 形式调用:通过
Lambda
表达式,方便的编写各类查询条件,无需再担心字段写错 - 支持主键自动生成:支持多达 4 种主键策略(内含分布式唯一 ID 生成器 -
Sequenc
e),可自由配置,完美解决主键问题 - 支持 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