MybatisPlus的基本使用

于 2024-08-31 17:02:31 发布
阅读量645 收藏 4
点赞数 18
文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80093566/article/details/141754491
版权

文章目录

介绍

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 操作智能分析阻断，也可自定义拦截规则，预防误操作


工作流程图

屏幕截图 2024-08-29 162823.png


添加依赖

在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所提供的方法，这意味着像下面一样功能的函数无需我们自己定义，直接使用便可，非常的方便👍。
image.png




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

NHuan^_^
关注
  • 18
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MybatisPlus基本使用完成CRUD
LemonAndLemons的博客
06-12 300
Pom文件 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.0.RELEASE</version> <relativePath /> </parent> <propertie
MyBatisPlus基本配置与使用
C_r_ush的博客
11-15 528
MyBatisPlus基本配置与使用
MybatisPlus基本使用（MP快速上手）
maohe的博客
11-04 6234
MP的基本使用方法，用于快速上手，MP基本CRUD操作，条件查询，字段映射和表名映射，ID生成策略....
MyBatisPlus基本使用
zhmq_top的博客
03-12 204
文章目录[隐藏] 导入依赖 编写实体类 编写Mapper接口 编写单元测试 注意 其他 导入依赖 <dependency> <groupId>com.baomidou</groupId&g...
mybatisplus基本使用
Niall_的博客
12-11 45
【代码】mybatisplus基本使用。
MybatisPlus快速使用
m0_71494074的博客
12-07 1929
MyBatis Plus是一个基于MyBatis的增强工具，旨在简化和增强与数据库交互的开发过程。它提供了一系列的功能和特性，使得使用MyBatis更加便捷和高效。简化的CRUD操作：MyBatis Plus提供了一组简化的API，使得进行常见的CRUD操作变得更加简单和直观。你可以使用它提供的方法来执行插入、更新、删除和查询操作，而无需编写繁琐的SQL语句。自动生成代码：MyBatis Plus可以根据数据库表结构自动生成实体类、Mapper接口和XML映射文件，大大减少了手动编写这些代码的工作量。
MybatisPlus基本使用、多表查询和分页查询
YUMIAloogy的博客~
05-16 2348
MybatisPlus基本使用、多表查询和分页查询(附上项目部分源码)
MyBatisPlus基础使用代码
02-25
下面将详细介绍 MyBatisPlus 的基础使用和在 SpringBoot 中的集成。 首先，我们需要引入 MyBatisPlus 和 SpringBoot 的依赖。在 Maven 的 `pom.xml` 文件中添加以下依赖： ```xml <groupId>...
MybatisPlus使用手册.docx
04-22
MybatisPlus 使用手册 MybatisPlus 是一个基于 MyBatis 的增强工具，旨在简化开发、提高效率。它具有无侵入、损耗小、强大的 CRUD 操作、支持 Lambda 形式调用、支持主键自动生成、支持 ActiveRecord 模式、支持...
MybatisPlus使用实战，MybatisPlus简介和使用示例
03-17
这篇文章将深入探讨MybatisPlus的基本概念、核心特性以及使用示例，帮助开发者更好地理解和运用这个工具。 一、MybatisPlus简介 MybatisPlus是由百度开源的一个轻量级框架，它的主要目标是简化Mybatis的常规操作，...
Spring Boot中处理JSON日期格式
fengyanglian的博客
08-30 405
Spring Boot中处理JSON日期格式
在Spring Boot项目中使用MySQL数据库
qq_62512874的博客
08-30 476
通过本文，你已经了解了如何在 Spring Boot 项目中集成 MySQL 数据库，并通过简单的 API 来管理用户数据。Spring Boot 的简洁性和 MySQL 的强大功能结合，使得开发高效且愉快。
Spring Boot 集成 JdbcTemplate（盘它！）
08-24 1489
SpringBoot 整合 JdbcTemplate，看完还不会你别来打我。
mybatisplus + oracle + spring boot遇到的一些问题
08-27 298
百度很多方法有的需要重写保存和更新方法，写注解，Date转String，试了很多不好使，在使用到oracle的字段涉及到Date， 报错。-- 集成Oracle字符集 -->-- 集成Oracle -->最后升级oracle依赖解决。
Spring Boot如何压缩Json并写入redis？
HBLOG
08-27 988
由于业务需要，存入redis中的缓存数据过大，占用了10+G的内存，内存作为重要资源，需要优化一下大对象缓存，采用gzip压缩存储，可以将 redis 的 kv 对大小缩小大约 7-8 倍，加快存储、读取速度。JSON经过gzip压缩，371-->58, 数据大小减少7-8倍。以上只是一些关键代码，所有代码请参见下面代码仓库。可以看到redis里面存储的是gzip压缩的内容。详建redis模块的docker目录。
【实战】Spring Boot 嵌套事务REQUIRES_NEW与NESTED在项目中的运用
勤于笔记，成于点滴。
08-27 1283
通过使用REQUIRES_NEW或者NESTED，我们可以轻松地在现有事务中创建新的事务传播机制，其中REQUIRES_NEW不受外部事务影响，NESTED则是会受到外部事务影响。所以，在实际的开发中我们也需要注意嵌套事务的局限性和潜在的性能问题，以确保应用程序的高效运行。
Spring Boot 启动时循环依赖的详细排查和解决步骤
qq_42631788的博客
08-30 618
使用 IDE 工具：可以使用Spring工具窗口来查看 Bean 的依赖关系。Eclipse：可以使用插件来查看 Bean 依赖图。手动检查查看所有@Component@Service和注解的类，检查它们的依赖关系。分析和排查：查看日志、使用 IDE 工具、检查 Bean 定义和依赖注入方式。解决策略：使用@Lazy注解、改用 Setter 注入、重构 Bean 设计、在类中定义 Bean。通过这些步骤，你可以有效地解决 Spring Boot 应用中的循环依赖问题，确保应用能够顺利启动。
深入解析 Spring Boot 中 MyBatis 自动配置的流程
weixin_54574094的博客
08-30 1200
标记当前类为配置类，相当于。：启用自动配置机制。：自动扫描并加载指定包及其子包中的组件。这些注解共同作用，启动并配置 Spring Boot 应用。Spring Boot 启动注解启动了整个 Spring Boot 应用，触发机制。读取配置类从文件中读取 MyBatis 的自动配置类，并将其注入 Spring 容器。自动配置 MyBatis根据项目中的配置和依赖，自动配置 MyBatis 的核心组件。配置数据源：通过引入。
Spring Boot 项目中，配合 Nacos 、Gateway使用 MinIO
最新发布
m0_57083961的博客
08-30 759
在现代微服务架构中，将不同服务整合并高效地管理配置和流量是至关重要的。Spring Cloud Gateway、Nacos 和 MinIO 是三个关键组件
MyBatisPlus如何使用
06-09
MyBatisPlus 是 MyBatis 的增强工具，可以简化 MyBatis 的开发过程。使用 MyBatisPlus 可以省去很多繁琐的 SQL 操作，提高开发效率。下面是 MyBatisPlus 的使用步骤： 1. 引入 MyBatisPlus 的依赖 在项目的 pom.xml 文件中添加 MyBatisPlus 的依赖： ```xml <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.0.7.1</version> </dependency> ``` 2. 配置 MyBatisPlus 在项目的 application.properties 或 application.yml 文件中添加 MyBatisPlus 的配置： ```yaml mybatis-plus: mapper-locations: classpath:mapper/*.xml global-config: db-config: id-type: auto ``` 3. 创建实体类 创建与数据库表对应的实体类，并使用注解 @TableName 指定表名，@TableId 指定主键。 ```java @Data @TableName("user") public class User { @TableId(type = IdType.AUTO) private Long id; private String name; private Integer age; private String email; } ``` 4. 创建 Mapper 接口 创建继承 BaseMapper 的 Mapper 接口，BaseMapper 中已经封装了常用的 CRUD 操作。 ```java public interface UserMapper extends BaseMapper<User> { } ``` 5. 使用 MyBatisPlus 进行操作 使用 MyBatisPlus 提供的 API 进行数据库操作。 ```java @Autowired private UserMapper userMapper; public void addUser(User user) { userMapper.insert(user); } public User getUserById(Long id) { return userMapper.selectById(id); } public void updateUser(User user) { userMapper.updateById(user); } public void deleteUserById(Long id) { userMapper.deleteById(id); } ``` 以上就是使用 MyBatisPlus 的基本步骤，当然还有很多高级用法和扩展功能，可以根据具体需求进行学习和使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值