MyBatis-Plus 用起来真的很舒服

╰半橙微兮° 2023-09-30 21:11 8阅读 0赞

### 一、MyBatis-Plus ###

### 1、简介 ###

MyBatis-Plus 是一个 Mybatis 增强版工具，在 MyBatis 上扩充了其他功能没有改变其基本功能，为了简化开发提交效率而存在。

官网文档地址：  
  
[https://mp.baomidou.com/guide/][https_mp.baomidou.com_guide]

MyBatis-Plus 特性：  
  
[https://mp.baomidou.com/guide/\#%E7%89%B9%E6%80%A7][https_mp.baomidou.com_guide_E7_89_B9_E6_80_A7]

### 2、使用 SpringBoot 快速使用 MyBatis-Plus ###

（1）准备工作  
　　需要 Java 开发环境（JDK）以及相应的开发工具（IDE）。  
　　需要 maven（用来下载相关依赖的 jar 包）。  
　　需要 SpringBoot。  
　　可以使用 IDEA 安装一个 mybatis-plus 插件。

![format_png][]

（2）创建一个 SpringBoot 项目。  
　　方式一：去官网 [https://start.spring.io/][https_start.spring.io] 初始化一个，然后导入 IDE 工具即可。  
　　方式二：直接使用 IDE 工具创建一个。 Spring Initializer。

![format_png 1][]

![c4c7e28f34078efb1d44a7e545b12461.png][]

（3）添加 MyBatis-Plus 依赖（mybatis-plus-boot-starter）

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

（4）为了测试开发，此处使用 mysql 8，需要引入 mysql 相关依赖。  
　　为了简化代码，引入 lombok 依赖（减少 getter、setter 等方法）。

![85d08b660fc428f85d4c6969d5dbf1fb.jpeg][]

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.18</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
    </dependency>

![9525eef5f6e68c090ebfb8219bf40bd7.jpeg][]

（5）完整依赖文件（pom.xml）

![01781f38b5672c1d094d9cc0bd477311.jpeg][]

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.6.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.lyh.test</groupId>
        <artifactId>test-mybatis-plus</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>test-mybatis-plus</name>
        <description>测试 -- 测试 MyBatis-Plus 功能</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.3.1.tmp</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.18</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.10</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

![969960c530f6be345b33ecc321c9e78d.jpeg][]

（6）使用一个表进行测试。

仅供参考，可以定义 创建时间、修改时间等字段。

![e200c6ee587a124f0c292acaf7102132.jpeg][]

DROP DATABASE IF EXISTS testMyBatisPlus;
    
    CREATE DATABASE testMyBatisPlus;
    
    USE testMyBatisPlus;
    
    DROP TABLE IF EXISTS user;
    
    CREATE TABLE user
    (
        id BIGINT(20) NOT NULL COMMENT '主键ID',
        name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
        age INT(11) NULL DEFAULT NULL COMMENT '年龄',
        email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
        PRIMARY KEY (id)
    );
    
    INSERT INTO user (id, name, age, email) VALUES
    (1, 'Jone', 18, 'test1@baomidou.com'),
    (2, 'Jack', 20, 'test2@baomidou.com'),
    (3, 'Tom', 28, 'test3@baomidou.com'),
    (4, 'Sandy', 21, 'test4@baomidou.com'),
    (5, 'Billie', 24, 'test5@baomidou.com');

![47cc10ab6c6f1c90d1d3e9b02aadc08a.jpeg][]

![format_png 2][]

（7）在 application.yml 文件中配置 mysql 数据源信息。

spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        username: root
        password: 123456
        url: jdbc:mysql://localhost:3306/testMyBatisPlus?useUnicode=true&characterEncoding=utf8

![format_png 3][]

（8）编写表对应的 实体类。

![d388b9ea09454184d009bae44d5bc83f.jpeg][]

package entity;
    
    import lombok.Data;
    
    @Data
    public class User {
        private Long id;
        private String name;
        private int age;
        private String email;
    }

![dc1eb2940a4909400236a3bd8cd33351.jpeg][]

![format_png 4][]

（9）编写操作实体类的 Mapper 类。  
　　直接继承 BaseMapper，这是 mybatis-plus 封装好的类。

![d125110400a8080c8722b4e689a60320.jpeg][]

package mapper;
    
    import bean.User;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    
    public interface UserMapper extends BaseMapper<User> {
    }

![231c1af84c1e67b1cfd8c3cf4567d0e5.jpeg][]

![format_png 5][]

![format_png 6][]

（10）实体类、Mapper 类都写好了，就可以使用了。  
　　Step1：先得在启动类里扫描 Mapper 类，即添加 @MapperScan 注解

![8d519703f6aafe5db40c80af11f32af4.jpeg][]

package com.lyh.test.testmybatisplus;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @MapperScan("mapper")
    @SpringBootApplication
    public class TestMybatisPlusApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(TestMybatisPlusApplication.class, args);
        }
    
    }

![377e0e5bb7e61b738e37dafc9e9dd332.jpeg][]

Step2：写一个测试类测试一下。

![62ce36a6701d39da1814f583e045eccd.jpeg][]

package com.lyh.test.testmybatisplus;
    
    import bean.User;
    import mapper.UserMapper;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.util.List;
    
    @SpringBootTest
    class TestMybatisPlusApplicationTests {
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testSelect() {
            System.out.println(("----- selectAll method test ------"));
            List<User> userList = userMapper.selectList(null);
            for(User user:userList) {
                System.out.println(user);
            }
        }
    }

![11fe9744b112dd0cbe446eb6b024a876.jpeg][]

![format_png 7][]

（11）总结：  
　　通过以上简单操作，就能对 user 表进行 CRUD 操作，不需要去编写 xml 文件。  
注：  
　　若遇到 @Autowired 标记的变量出现 红色下划线，但是不影响 正常运行。

![format_png 8][]

可以进入 Settings，找到 Inspection，并选择其中的 Spring Core -> Code -> Autowiring for Bean Class,将 Error 改为 Warning，即可。

![format_png 9][]

回到顶部

### 二、Mybatis-Plus 常用操作 ###

### 1、配置日志 ###

【参考地址（两种方式配置日志）】
        https://blog.csdn.net/dfBeautifulLive/article/details/100700365

想要查看执行的 sql 语句，可以在 yml 文件中添加配置信息，如下。

mybatis-plus:
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

如下图所示：执行时会打印出 sql 语句。

![format_png 10][]

### 2、简单认识一下常用注解 ###

![5a583af8f49ac6c1d297f63ebf4833f4.jpeg][]

【@TableName 】
        @TableName               用于定义表名
    注：
        常用属性：
            value                用于定义表名
    
    【@TableId】
        @TableId                 用于定义表的主键
    注：
        常用属性：
            value           用于定义主键字段名
            type            用于定义主键类型（主键策略 IdType）
    
       主键策略：
          IdType.AUTO          主键自增，系统分配，不需要手动输入
          IdType.NONE          未设置主键
          IdType.INPUT         需要自己输入 主键值。
          IdType.ASSIGN_ID     系统分配 ID，用于数值型数据（Long，对应 mysql 中 BIGINT 类型）。
          IdType.ASSIGN_UUID   系统分配 UUID，用于字符串型数据（String，对应 mysql 中 varchar(32) 类型）。
    
    【@TableField】  
        @TableField            用于定义表的非主键字段。
    注：
        常用属性：
            value                用于定义非主键字段名
            exist                用于指明是否为数据表的字段， true 表示是，false 为不是。
            fill                 用于指定字段填充策略（FieldFill）。
            
        字段填充策略：（一般用于填充 创建时间、修改时间等字段）
            FieldFill.DEFAULT         默认不填充
            FieldFill.INSERT          插入时填充
            FieldFill.UPDATE          更新时填充
            FieldFill.INSERT_UPDATE   插入、更新时填充。
    
    【@TableLogic】
        @TableLogic           用于定义表的字段进行逻辑删除（非物理删除）
    注：
        常用属性：
            value            用于定义未删除时字段的值
            delval           用于定义删除时字段的值
            
    【@Version】
        @Version             用于字段实现乐观锁

![5c5dfe36c74800ebacbcec96ba281118.jpeg][]

### 3、代码生成器 ###

（1）AutoGenerator 简介  
　　AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。  
　　与 mybatis 中的 mybatis-generator-core 类似。

（2）添加依赖

![7fa0b7abced1a86fe14d0041e2d28e0d.jpeg][]

<dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-generator</artifactId>
        <version>3.3.1.tmp</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.velocity</groupId>
        <artifactId>velocity-engine-core</artifactId>
        <version>2.2</version>
    </dependency>

![dae4d2a2d97f612df9a73bb661e76803.jpeg][]

（3）代码分析  
Step1：  
　　创建一个 代码生成器。用于生成代码。  
　　此处不用修改。

// Step1：代码生成器
    AutoGenerator mpg = new AutoGenerator();

Step2：  
　　配置全局信息。指定代码输出路径，以及包名、作者等信息。  
　　此处按需添加，projectPath 需要修改，setAuthor 需要修改。

![b3bc3d493f0b638ff86cc257eac0c188.jpeg][]

// Step2：全局配置
    GlobalConfig gc = new GlobalConfig();
    // 填写代码生成的目录(需要修改)
    String projectPath = "E:\\myProject\\test\\test_mybatis_plus";
    // 拼接出代码最终输出的目录
    gc.setOutputDir(projectPath + "/src/main/java");
    // 配置开发者信息（可选）（需要修改）
    gc.setAuthor("lyh");
    // 配置是否打开目录，false 为不打开（可选）
    gc.setOpen(false);
    // 实体属性 Swagger2 注解，添加 Swagger 依赖，开启 Swagger2 模式（可选）
    //gc.setSwagger2(true);
    // 重新生成文件时是否覆盖，false 表示不覆盖（可选）
    gc.setFileOverride(false);
    // 配置主键生成策略，此处为 ASSIGN_ID（可选）
    gc.setIdType(IdType.ASSIGN_ID);
    // 配置日期类型，此处为 ONLY_DATE（可选）
    gc.setDateType(DateType.ONLY_DATE);
    // 默认生成的 service 会有 I 前缀
    gc.setServiceName("%sService");
    mpg.setGlobalConfig(gc);

![60046457717e78657d9d762d05237ecf.jpeg][]

Step3：  
　　配置数据源信息。用于指定 需要生成代码的 数据仓库、数据表。  
　　setUrl、setDriverName、setUsername、setPassword 均需修改。

![dae4d2a2d97f612df9a73bb661e76803.jpeg][]

// Step3：数据源配置（需要修改）
    DataSourceConfig dsc = new DataSourceConfig();
    // 配置数据库 url 地址
    dsc.setUrl("jdbc:mysql://localhost:3306/testMyBatisPlus?useUnicode=true&characterEncoding=utf8");
    // dsc.setSchemaName("testMyBatisPlus"); // 可以直接在 url 中指定数据库名
    // 配置数据库驱动
    dsc.setDriverName("com.mysql.cj.jdbc.Driver");
    // 配置数据库连接用户名
    dsc.setUsername("root");
    // 配置数据库连接密码
    dsc.setPassword("123456");
    mpg.setDataSource(dsc);

![1aa2d0200e61fa9eb3faa3722b3389b4.jpeg][]

Step4：  
　　配置包信息。  
　　setParent、setModuleName 均需修改。其余按需求修改.

![4d2ffb223ea29faa2be6fb453e3cec0c.jpeg][]

// Step:4：包配置
    PackageConfig pc = new PackageConfig();
    // 配置父包名（需要修改）
    pc.setParent("com.lyh.test");
    // 配置模块名（需要修改）
    pc.setModuleName("test_mybatis_plus");
    // 配置 entity 包名
    pc.setEntity("entity");
    // 配置 mapper 包名
    pc.setMapper("mapper");
    // 配置 service 包名
    pc.setService("service");
    // 配置 controller 包名
    pc.setController("controller");
    mpg.setPackageInfo(pc);

![21d408ad32ff77c80cb67fdafd80c142.jpeg][]

Step5：  
　　配置数据表映射信息。  
　　setInclude 需要修改，其余按实际开发修改。

![63915e534278ff59048852afa8c2ce5b.jpeg][]

// Step5：策略配置（数据库表配置）
    StrategyConfig strategy = new StrategyConfig();
    // 指定表名（可以同时操作多个表，使用 , 隔开）（需要修改）
    strategy.setInclude("test_mybatis_plus_user");
    // 配置数据表与实体类名之间映射的策略
    strategy.setNaming(NamingStrategy.underline_to_camel);
    // 配置数据表的字段与实体类的属性名之间映射的策略
    strategy.setColumnNaming(NamingStrategy.underline_to_camel);
    // 配置 lombok 模式
    strategy.setEntityLombokModel(true);
    // 配置 rest 风格的控制器（@RestController）
    strategy.setRestControllerStyle(true);
    // 配置驼峰转连字符
    strategy.setControllerMappingHyphenStyle(true);
    // 配置表前缀，生成实体时去除表前缀
    // 此处的表名为 test_mybatis_plus_user，模块名为 test_mybatis_plus，去除前缀后剩下为 user。
    strategy.setTablePrefix(pc.getModuleName() + "_");
    mpg.setStrategy(strategy);

![737777422ffe21921697053e44d5f93c.jpeg][]

Step6：  
　　执行代码生成操作。

此处不用修改。

// Step6：执行代码生成操作
    mpg.execute();

完整配置如下：

![7fb5f13a82426ed8ab35b1de3171a108.jpeg][]

package com.lyh.test.test_mybatis_plus;
    
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.generator.AutoGenerator;
    import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
    import com.baomidou.mybatisplus.generator.config.GlobalConfig;
    import com.baomidou.mybatisplus.generator.config.PackageConfig;
    import com.baomidou.mybatisplus.generator.config.StrategyConfig;
    import com.baomidou.mybatisplus.generator.config.rules.DateType;
    import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
    import org.junit.jupiter.api.Test;
    
    public class TestAutoGenerate {
        @Test
        public void autoGenerate() {
            // Step1：代码生成器
            AutoGenerator mpg = new AutoGenerator();
    
            // Step2：全局配置
            GlobalConfig gc = new GlobalConfig();
            // 填写代码生成的目录(需要修改)
            String projectPath = "E:\\myProject\\test\\test_mybatis_plus";
            // 拼接出代码最终输出的目录
            gc.setOutputDir(projectPath + "/src/main/java");
            // 配置开发者信息（可选）（需要修改）
            gc.setAuthor("lyh");
            // 配置是否打开目录，false 为不打开（可选）
            gc.setOpen(false);
            // 实体属性 Swagger2 注解，添加 Swagger 依赖，开启 Swagger2 模式（可选）
            //gc.setSwagger2(true);
            // 重新生成文件时是否覆盖，false 表示不覆盖（可选）
            gc.setFileOverride(false);
            // 配置主键生成策略，此处为 ASSIGN_ID（可选）
            gc.setIdType(IdType.ASSIGN_ID);
            // 配置日期类型，此处为 ONLY_DATE（可选）
            gc.setDateType(DateType.ONLY_DATE);
            // 默认生成的 service 会有 I 前缀
            gc.setServiceName("%sService");
            mpg.setGlobalConfig(gc);
    
            // Step3：数据源配置（需要修改）
            DataSourceConfig dsc = new DataSourceConfig();
            // 配置数据库 url 地址
            dsc.setUrl("jdbc:mysql://localhost:3306/testMyBatisPlus?useUnicode=true&characterEncoding=utf8");
            // dsc.setSchemaName("testMyBatisPlus"); // 可以直接在 url 中指定数据库名
            // 配置数据库驱动
            dsc.setDriverName("com.mysql.cj.jdbc.Driver");
            // 配置数据库连接用户名
            dsc.setUsername("root");
            // 配置数据库连接密码
            dsc.setPassword("123456");
            mpg.setDataSource(dsc);
    
            // Step:4：包配置
            PackageConfig pc = new PackageConfig();
            // 配置父包名（需要修改）
            pc.setParent("com.lyh.test");
            // 配置模块名（需要修改）
            pc.setModuleName("test_mybatis_plus");
            // 配置 entity 包名
            pc.setEntity("entity");
            // 配置 mapper 包名
            pc.setMapper("mapper");
            // 配置 service 包名
            pc.setService("service");
            // 配置 controller 包名
            pc.setController("controller");
            mpg.setPackageInfo(pc);
    
            // Step5：策略配置（数据库表配置）
            StrategyConfig strategy = new StrategyConfig();
            // 指定表名（可以同时操作多个表，使用 , 隔开）（需要修改）
            strategy.setInclude("test_mybatis_plus_user");
            // 配置数据表与实体类名之间映射的策略
            strategy.setNaming(NamingStrategy.underline_to_camel);
            // 配置数据表的字段与实体类的属性名之间映射的策略
            strategy.setColumnNaming(NamingStrategy.underline_to_camel);
            // 配置 lombok 模式
            strategy.setEntityLombokModel(true);
            // 配置 rest 风格的控制器（@RestController）
            strategy.setRestControllerStyle(true);
            // 配置驼峰转连字符
            strategy.setControllerMappingHyphenStyle(true);
            // 配置表前缀，生成实体时去除表前缀
            // 此处的表名为 test_mybatis_plus_user，模块名为 test_mybatis_plus，去除前缀后剩下为 user。
            strategy.setTablePrefix(pc.getModuleName() + "_");
            mpg.setStrategy(strategy);
    
            // Step6：执行代码生成操作
            mpg.execute();
        }
    }

![4d2ffb223ea29faa2be6fb453e3cec0c.jpeg][]

![format_png 11][]

### 4、自动填充数据功能 ###

（1）简介  
　　添加、修改数据时，每次都会使用相同的方式进行填充。比如 数据的创建时间、修改时间等。  
　　Mybatis-plus 支持自动填充这些字段的数据。

给之前的数据表新增两个字段：创建时间、修改时间。

![1ff97a1f83a3d2408efdd42aff01b911.jpeg][]

![99bf8709b3214b3671509f0f3779a44a.jpeg][]

并使用 代码生成器生成代码。

![format_png 12][]

（2）未使用自动填充时  
　　未使用 自动填充时，每次添加、修改数据都可以手动对其进行添加。

![da4e1f1aaee130809f5cdd7b4355bce7.jpeg][]

@SpringBootTest
    class TestMybatisPlusApplicationTests {
    
        @Autowired
        private UserService userService;
    
        @Test
        public void testUpdate() {
            User user = new User();
            user.setName("tom").setAge(20).setEmail("tom@163.com");
            // 手动添加数据
            user.setCreateTime(new Date()).setUpdateTime(new Date());
            if (userService.save(user)) {
                userService.list().forEach(System.out::println);
            } else {
                System.out.println("添加数据失败");
            }
        }
    }

![28a33686fbf4df117b6112c2c037f9e6.jpeg][]

![format_png 13][]

（3）使用自动填充功能。  
Step1：  
　　使用 @TableField 注解，标注需要进行填充的字段。

![cf37a7731ba861ed02422fb165a92260.jpeg][]

/**
     * 创建时间
     */
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    
    /**
     * 最后修改时间
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

![28a33686fbf4df117b6112c2c037f9e6.jpeg][]

![format_png 14][]

Step2：  
　　自定义一个类，实现 MetaObjectHandler 接口，并重写方法。  
　　添加 @Component 注解，交给 Spring 去管理。

![66a74bedcceaf2cf5f9306f2b1f8b4b6.jpeg][]

package com.lyh.test.test_mybatis_plus.handler;
    
    import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
    import org.apache.ibatis.reflection.MetaObject;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    
    @Component
    public class MyMetaObjectHandler implements MetaObjectHandler {
        @Override
        public void insertFill(MetaObject metaObject) {
            this.strictInsertFill(metaObject, "createTime", Date.class, new Date());
            this.strictInsertFill(metaObject, "updateTime", Date.class, new Date());
        }
    
        @Override
        public void updateFill(MetaObject metaObject) {
            this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
        }
    }

![65d1d823c1fc4d4c2a64aea6958d250d.jpeg][]

![format_png 15][]

Step3：  
　　简单测试一下。

![27815dcd91c9441c1ea41957298093f9.jpeg][]

@Test
    public void testAutoFill() {
        User user = new User();
        user.setName("tom").setAge(20).setEmail("tom@163.com");
        if (userService.save(user)) {
            userService.list().forEach(System.out::println);
        } else {
            System.out.println("添加数据失败");
        }
    }

![60e6f8e4d4e7501d10c47af79841012b.jpeg][]

![format_png 16][]

### 5、逻辑删除 ###

（1）简介  
　　删除数据，可以通过物理删除，也可以通过逻辑删除。  
　　物理删除指的是直接将数据从数据库中删除，不保留。  
　　逻辑删除指的是修改数据的某个字段，使其表示为已删除状态，而非删除数据，保留该数据在数据库中，但是查询时不显示该数据（查询时过滤掉该数据）。

给数据表增加一个字段：delete\_flag，用于表示该数据是否被逻辑删除。

![a21df8c9d6c7413dc6e3e28985c6a256.jpeg][]

CREATE TABLE test_mybatis_plus_user
    (
        id BIGINT NOT NULL COMMENT '主键ID',
        name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
        age INT(11) NULL DEFAULT NULL COMMENT '年龄',
        email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
        create_time timestamp NULL DEFAULT NULL COMMENT '创建时间',
        update_time timestamp NULL DEFAULT NULL COMMENT '最后修改时间', 
        delete_flag tinyint(1) NULL DEFAULT NULL COMMENT '逻辑删除（0 未删除、1 删除）',
        PRIMARY KEY (id)
    );

![7aff7ad516e26bdbe958486187f1fb86.jpeg][]

（2）使用逻辑删除。  
　　可以定义一个自动填充规则，初始值为 0。0 表示未删除， 1 表示删除。

![7b28cfa33eaf168f19e7a951fb1647d5.jpeg][]

/**
     * 逻辑删除（0 未删除、1 删除）
     */
    @TableLogic(value = "0", delval = "1")
    @TableField(fill = FieldFill.INSERT)
    private Integer deleteFlag;
    
    
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "deleteFlag", Integer.class, 0);
    }

![da8850f077be956ee87603fe9bf7ba6e.jpeg][]

![format_png 17][]

（3）简单测试  
　　使用 mybatis-plus 封装好的方法时，会自动添加逻辑删除的功能。  
　　若是自定义的 sql 语句，需要手动添加逻辑。

![1a02d9724160d0d7854414e3dfa02292.jpeg][]

@Test
    public void testDelete() {
        if (userService.removeById(1258924257048547329L)) {
            System.out.println("删除数据成功");
            userService.list().forEach(System.out::println);
        } else {
            System.out.println("删除数据失败");
        }
    }

![556e4418641b345bda6c8c4affadbc49.jpeg][]

现有数据

![34cbedd294caa539f147c92b8e830149.png][]

执行 testDelete 进行逻辑删除。

![format_png 18][]

![6b3682ef877cecfdb139edd86985f3db.png][]

若去除 TableLogic 注解，再执行 testDelete 时进行物理删除，直接删除这条数据。

![format_png 19][]

![6284f29270f35ccde19a3807a0efbd6a.png][]

### 6、分页插件的使用 ###

（1）简介  
　　与 mybatis 的插件 pagehelper 用法类似。  
　　通过简单的配置即可使用。

（2）使用  
Step1：  
　　配置分页插件。  
　　编写一个 配置类，内部使用 @Bean 注解将 PaginationInterceptor 交给 Spring 容器管理。

![fd146c48dbcd252510c36281601156b9.jpeg][]

package com.lyh.test.test_mybatis_plus.config;
    
    import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * 自定义一个配置类，mapper 扫描也可在此写上
     */
    @Configuration
    @MapperScan("com.lyh.test.test_mybatis_plus.mapper")
    public class Myconfig {
        /**
         * 分页插件
         * @return 分页插件的实例
         */
        @Bean
        public PaginationInterceptor paginationInterceptor() {
            return new PaginationInterceptor();
        }
    }

![cc3dc59c9c91275aa79f4701e2ec5545.jpeg][]

![format_png 20][]

Step2：  
　　编写分页代码。  
　　直接 new 一个 Page 对象，对象需要传递两个参数（当前页，每页显示的条数）。  
　　调用 mybatis-plus 提供的分页查询方法，其会将 分页查询的数据封装到 Page 对象中。

![1656b89a1fc4cf1bd098d117b9bb3a24.jpeg][]

@Test
    public void testPage() {
        // Step1：创建一个 Page 对象
        Page<User> page = new Page<>();
        // Page<User> page = new Page<>(2, 5);
        // Step2：调用 mybatis-plus 提供的分页查询方法
        userService.page(page, null);
        // Step3：获取分页数据
        System.out.println(page.getCurrent()); // 获取当前页
        System.out.println(page.getTotal()); // 获取总记录数
        System.out.println(page.getSize()); // 获取每页的条数
        System.out.println(page.getRecords()); // 获取每页数据的集合
        System.out.println(page.getPages()); // 获取总页数
        System.out.println(page.hasNext()); // 是否存在下一页
        System.out.println(page.hasPrevious()); // 是否存在上一页
    }

![25a078465b06df286d044f36884493c7.jpeg][]

![format_png 21][]

### 7、乐观锁的实现 ###

（1）首先认识一下 读问题、写问题？  
　　操作数据库数据时，遇到的最基本问题就是 读问题与写问题。  
　　读问题 指的是从数据库中读取数据时遇到的问题，比如：脏读、幻读、不可重复读。

【脏读、幻读、不可重复读 参考地址：】
        https://www.cnblogs.com/l-y-h/p/12458777.html#_label0_3

写问题 指的是数据写入数据库时遇到的问题，比如：丢失更新（多个线程同时对某条数据更新，无论执行顺序如何，都会丢失其他线程更新的数据）

（2）如何解决写问题？  
　　乐观锁、悲观锁就是为了解决 写问题而存在的。  
　　　　乐观锁：总是假设最好的情况，每次读取数据时认为数据不会被修改（即不加锁），当进行更新操作时，会判断这条数据是否被修改，未被修改，则进行更新操作。若被修改，则数据更新失败，可以对数据进行重试（重新尝试修改数据）。  
　　　　悲观锁：总是假设最坏的情况，每次读取数据时认为数据会被修改（即加锁），当进行更新操作时，直接更新数据，结束操作后释放锁（此处才可以被其他线程读取）。

（3）乐观锁、悲观锁使用场景？  
　　乐观锁一般用于读比较多的场合，尽量减少加锁的开销。  
　　悲观锁一般用于写比较多的场合，尽量减少 类似 乐观锁重试更新引起的性能开销。

（4）乐观锁两种实现方式  
方式一：通过版本号机制实现。  
　　在数据表中增加一个 version 字段。  
　　取数据时，获取该字段，更新时以该字段为条件进行处理（即set version = newVersion where version = oldVersion），若 version 相同，则更新成功（给新 version 赋一个值，一般加 1）。若 version 不同，则更新失败，可以重新尝试更新操作。

方式二：通过 CAS 算法实现。  
　　CAS 为 Compare And Swap 的缩写，即比较交换，是一种无锁算法（即在不加锁的情况实现多线程之间的变量同步）。  
　　CAS 操作包含三个操作数 —— 内存值（V）、预期原值（A）和新值(B)。如果内存地址里面的值 V 和 A 的值是一样的，那么就将内存里面的值更新成B。若 V 与 A 不一致，则不执行任何操作（可以通过自旋操作，不断尝试修改数据直至成功修改）。即 V == A ？ V = B ： V = V。  
　　CAS 可能导致 ABA 问题（两次读取数据时值相同，但不确定值是否被修改过），比如两个线程操作同一个变量，线程 A、线程B 初始读取数据均为 A，后来 线程B 将数据修改为 B，然后又修改为 A，此时线程 A 再次读取到的数据依旧是 A，虽然值相同但是中间被修改过，这就是 ABA 问题。可以加一个额外的标志位 C，用于表示数据是否被修改。当标志位 C 与预期标志位相同、且 V == A 时，则更新值 B。

（5）mybatis-plus 实现乐观锁（通过 version 机制）  
实现思路：  
　　Step1：取出记录时，获取当前version  
　　Step2：更新时，带上这个version  
　　Step3：执行更新时， set version = newVersion where version = oldVersion  
　　Step4：如果version不对，就更新失败

（6）mybatis-plus 代码实现乐观锁  
Step1：  
　　配置乐观锁插件。  
　　编写一个配置类（可以与上例的分页插件共用一个配置类），将  
OptimisticLockerInterceptor 通过 @Bean 交给 Spring 管理。

![4d2ffb223ea29faa2be6fb453e3cec0c.jpeg][]

/**
     * 乐观锁插件
     * @return 乐观锁插件的实例
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

![fd146c48dbcd252510c36281601156b9.jpeg][]

![format_png 22][]

Step2：  
　　定义一个数据库字段 version。

![7c41edb064e6222a694a7ba77d4515dc.jpeg][]

![823688e22adb1c14441c3968e19a4b1c.jpeg][]

Step3：  
　　使用 @Version 注解标注对应的实体类。  
　　可以通过 @TableField 进行数据自动填充。

![c77528d7f5745a741592692728136615.jpeg][]

/**
     * 版本号（用于乐观锁， 默认为 1）
     */
    @Version
    @TableField(fill = FieldFill.INSERT)
    private Integer version;
    
    
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "version", Integer.class, 1);
    }

![05df61cb65e24e790bd387968996d968.jpeg][]

![format_png 23][]

Step4：  
　　简单测试一下，可以看一下 控制台 打印的 sql 语句。

![db8b7b2d713a12f308309348969053dc.jpeg][]

@Test
    public void testVersion() {
        User user = new User();
        user.setName("tom").setAge(20).setEmail("tom@163.com");
        userService.save(user);
        userService.list().forEach(System.out::println);
        user.setName("jarry");
        userService.update(user, null);
        userService.list().forEach(System.out::println);
    }

![08490dd017a97a8c1fc87a9c13444d15.jpeg][]

![format_png 24][]

回到顶部

### 三、Mybatis-Plus CRUD 操作简单了解一下 ###

### 1、Mapper 接口方法（CRUD）简单了解一下 ###

（1）简介  
　　使用代码生成器生成的 mapper 接口中，其继承了 BaseMapper 接口。  
　　而 BaseMapper 接口中封装了一系列 CRUD 常用操作，可以直接使用，而不用自定义 xml 与 sql 语句进行 CRUD 操作（当然根据实际开发需要，自定义 sql 还是有必要的）。

此处简单介绍一下 BaseMapper 接口中的常用方法。

![format_png 25][]

![format_png 26][]

（2）方法介绍  
　　混个眼熟，用多了就记得了。

![920797f7c54620ac694e71f6ae9f8b55.jpeg][]

【添加数据：（增）】
        int insert(T entity);              // 插入一条记录
    注：
        T         表示任意实体类型
        entity    表示实体对象
    
    【删除数据：（删）】
        int deleteById(Serializable id);    // 根据主键 ID 删除
        int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);  // 根据 map 定义字段的条件删除
        int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper); // 根据实体类定义的 条件删除对象
        int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量删除
    注：
        id        表示 主键 ID
        columnMap 表示表字段的 map 对象
        wrapper   表示实体对象封装操作类，可以为 null。
        idList    表示 主键 ID 集合（列表、数组），不能为 null 或 empty
    
    【修改数据：（改）】
        int updateById(@Param(Constants.ENTITY) T entity); // 根据 ID 修改实体对象。
        int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper); // 根据 updateWrapper 条件修改实体对象
    注：
        update 中的 entity 为 set 条件，可以为 null。
        updateWrapper 表示实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
    
    【查询数据：（查）】
        T selectById(Serializable id); // 根据 主键 ID 查询数据
        List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量查询
        List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap); // 根据表字段条件查询
        T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 根据实体类封装对象 查询一条记录
        Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询记录的总条数
        List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合）
        List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合）
        List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（但只保存第一个字段的值）
        <E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合），分页
        <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合），分页
    注：
        queryWrapper 表示实体对象封装操作类（可以为 null）
        page 表示分页查询条件

![2e97a05c2057606f2dbfbcde36883c1f.jpeg][]

### 2、Service 接口方法（CRUD）简单了解一下 ###

（1）简介  
　　使用 代码生成器 生成的 service 接口中，其继承了 IService 接口。  
　　IService 内部进一步封装了 BaseMapper 接口的方法（当然也提供了更详细的方法）。  
　　使用时，可以通过 生成的 mapper 类进行 CRUD 操作，也可以通过 生成的 service 的实现类进行 CRUD 操作。（当然，自定义代码执行也可）  
此处简单介绍一下 IService 中封装的常用方法。

![format_png 27][]

![format_png 28][]

（2）方法介绍  
　　混个眼熟，用多了就记得了。  
　　内部封装了 BaseMapper 的方法，也提供了新的方法。  
比如：  
　　添加了 批量更新 方法、更新或修改方法等。  
　　对 查询方法 做了细化，使用 get 命名的方法查询一条数据，使用 list 命名的方法查询多条数据等。  
　　增加了链式调用的方法。

![37458606efb88d24f1329a7281a28c20.jpeg][]

【添加数据：（增）】
        default boolean save(T entity); // 调用 BaseMapper 的 insert 方法，用于添加一条数据。
        boolean saveBatch(Collection<T> entityList, int batchSize); // 批量插入数据
    注：
        entityList 表示实体对象集合 
        batchSize 表示一次批量插入的数据量，默认为 1000
    
    【添加或修改数据：（增或改）】
        boolean saveOrUpdate(T entity); // id 若存在，则修改， id 不存在则新增数据
       default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper); // 先根据条件尝试更新，然后再执行 saveOrUpdate 操作
       boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize); // 批量插入并修改数据 
    
    【删除数据：（删）】
        default boolean removeById(Serializable id); // 调用 BaseMapper 的 deleteById 方法，根据 id 删除数据。
        default boolean removeByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 deleteByMap 方法，根据 map 定义字段的条件删除
        default boolean remove(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 delete 方法，根据实体类定义的 条件删除对象。
        default boolean removeByIds(Collection<? extends Serializable> idList); // 用 BaseMapper 的 deleteBatchIds 方法, 进行批量删除。
        
    【修改数据：（改）】
        default boolean updateById(T entity); // 调用 BaseMapper 的 updateById 方法，根据 ID 选择修改。
        default boolean update(T entity, Wrapper<T> updateWrapper); // 调用 BaseMapper 的 update 方法，根据 updateWrapper 条件修改实体对象。
        boolean updateBatchById(Collection<T> entityList, int batchSize); // 批量更新数据
    
    【查找数据：（查）】
        default T getById(Serializable id); // 调用 BaseMapper 的 selectById 方法，根据 主键 ID 返回数据。
        default List<T> listByIds(Collection<? extends Serializable> idList); // 调用 BaseMapper 的 selectBatchIds 方法，批量查询数据。
        default List<T> listByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 selectByMap 方法，根据表字段条件查询
        default T getOne(Wrapper<T> queryWrapper); // 返回一条记录（实体类保存）。
        Map<String, Object> getMap(Wrapper<T> queryWrapper); // 返回一条记录（map 保存）。
        default int count(Wrapper<T> queryWrapper); // 根据条件返回 记录数。
        default List<T> list(); // 返回所有数据。
        default List<T> list(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectList 方法，查询所有记录（返回 entity 集合）。
        default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMaps 方法，查询所有记录（返回 map 集合）。
        default List<Object> listObjs(); // 返回全部记录，但只返回第一个字段的值。
        default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectPage 方法，分页查询
        default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMapsPage 方法，分页查询
    注：
        get 用于返回一条记录。
        list 用于返回多条记录。
        count 用于返回记录总数。
        page 用于分页查询。
        
    【链式调用：】
        default QueryChainWrapper<T> query(); // 普通链式查询
        default LambdaQueryChainWrapper<T> lambdaQuery(); // 支持 Lambda 表达式的修改
        default UpdateChainWrapper<T> update(); // 普通链式修改
        default LambdaUpdateChainWrapper<T> lambdaUpdate(); // 支持 Lambda 表达式的修改
    注：
        query 表示查询
        update 表示修改
        Lambda 表示内部支持 Lambda 写法。
    形如：
        query().eq("column", value).one();
        lambdaQuery().eq(Entity::getId, value).list();
        update().eq("column", value).remove();
        lambdaUpdate().eq(Entity::getId, value).update(entity);

![89767f643094f94a21f9dcc4f00ddcf9.jpeg][]

### 3、条件构造器（Wrapper，定义 where 条件） ###

（1）简介  
　　上面介绍的 接口方法的参数中，会出现各种 wrapper，比如 queryWrapper、updateWrapper 等。wrapper 的作用就是用于定义各种各样的查询条件（where）。

![925d35ec7cbab6144d8ab53b5f14784e.jpeg][]

Wrapper  条件构造抽象类
        -- AbstractWrapper 查询条件封装，用于生成 sql 中的 where 语句。
            -- QueryWrapper Entity 对象封装操作类，用于查询。
            -- UpdateWrapper Update 条件封装操作类，用于更新。
        -- AbstractLambdaWrapper 使用 Lambda 表达式封装 wrapper
            -- LambdaQueryWrapper 使用 Lambda 语法封装条件，用于查询。
            -- LambdaUpdateWrapper 使用 Lambda 语法封装条件，用于更新。

![fee97218e8a65ce10bcfedb10146023d.jpeg][]

![format_png 29][]

（2）常用条件  
　　参考源码以及官方文档总结的，还是一句话，混个眼熟，多用用就熟练了。

![ff61bff052d0ac5780ef9d4666dd96ce.jpeg][]

【通用条件：】
    【比较大小： ( =, <>, >, >=, <, <= )】
        eq(R column, Object val); // 等价于 =，例: eq("name", "老王") ---> name = '老王'
        ne(R column, Object val); // 等价于 <>，例: ne("name", "老王") ---> name <> '老王'
        gt(R column, Object val); // 等价于 >，例: gt("name", "老王") ---> name > '老王'
        ge(R column, Object val); // 等价于 >=，例: ge("name", "老王") ---> name >= '老王'
        lt(R column, Object val); // 等价于 <，例: lt("name", "老王") ---> name < '老王'
        le(R column, Object val); // 等价于 <=，例: le("name", "老王") ---> name <= '老王'
        
    【范围：（between、not between、in、not in）】
       between(R column, Object val1, Object val2); // 等价于 between a and b, 例： between("age", 18, 30) ---> age between 18 and 30
       notBetween(R column, Object val1, Object val2); // 等价于 not between a and b, 例： notBetween("age", 18, 30) ---> age not between 18 and 30
       in(R column, Object... values); // 等价于 字段 IN (v0, v1, ...),例: in("age",{1,2,3}) ---> age in (1,2,3)
       notIn(R column, Object... values); // 等价于 字段 NOT IN (v0, v1, ...), 例: notIn("age",{1,2,3}) ---> age not in (1,2,3)
       inSql(R column, Object... values); // 等价于 字段 IN (sql 语句), 例: inSql("id", "select id from table where id < 3") ---> id in (select id from table where id < 3)
       notInSql(R column, Object... values); // 等价于 字段 NOT IN (sql 语句)
       
    【模糊匹配：（like）】
        like(R column, Object val); // 等价于 LIKE '%值%'，例: like("name", "王") ---> name like '%王%'
        notLike(R column, Object val); // 等价于 NOT LIKE '%值%'，例: notLike("name", "王") ---> name not like '%王%'
        likeLeft(R column, Object val); // 等价于 LIKE '%值'，例: likeLeft("name", "王") ---> name like '%王'
        likeRight(R column, Object val); // 等价于 LIKE '值%'，例: likeRight("name", "王") ---> name like '王%'
        
    【空值比较：（isNull、isNotNull）】
        isNull(R column); // 等价于 IS NULL，例: isNull("name") ---> name is null
        isNotNull(R column); // 等价于 IS NOT NULL，例: isNotNull("name") ---> name is not null
    
    【分组、排序：（group、having、order）】
        groupBy(R... columns); // 等价于 GROUP BY 字段, ...， 例: groupBy("id", "name") ---> group by id,name
        orderByAsc(R... columns); // 等价于 ORDER BY 字段, ... ASC， 例: orderByAsc("id", "name") ---> order by id ASC,name ASC
        orderByDesc(R... columns); // 等价于 ORDER BY 字段, ... DESC， 例: orderByDesc("id", "name") ---> order by id DESC,name DESC
        having(String sqlHaving, Object... params); // 等价于 HAVING ( sql语句 )， 例: having("sum(age) > {0}", 11) ---> having sum(age) > 11
    
    【拼接、嵌套 sql：（or、and、nested、apply）】
       or(); // 等价于 a or b， 例：eq("id",1).or().eq("name","老王") ---> id = 1 or name = '老王'
       or(Consumer<Param> consumer); // 等价于 or(a or/and b)，or 嵌套。例: or(i -> i.eq("name", "李白").ne("status", "活着")) ---> or (name = '李白' and status <> '活着')
       and(Consumer<Param> consumer); // 等价于 and(a or/and b)，and 嵌套。例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status <> '活着')
       nested(Consumer<Param> consumer); // 等价于 (a or/and b)，普通嵌套。例: nested(i -> i.eq("name", "李白").ne("status", "活着")) ---> (name = '李白' and status <> '活着')
       apply(String applySql, Object... params); // 拼接sql（若不使用 params 参数，可能存在 sql 注入），例: apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08") ---> date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
       last(String lastSql); // 无视优化规则直接拼接到 sql 的最后，可能存若在 sql 注入。
       exists(String existsSql); // 拼接 exists 语句。例: exists("select id from table where age = 1") ---> exists (select id from table where age = 1)
       
    【QueryWrapper 条件：】
        select(String... sqlSelect); // 用于定义需要返回的字段。例： select("id", "name", "age") ---> select id, name, age
        select(Predicate<TableFieldInfo> predicate); // Lambda 表达式，过滤需要的字段。
        lambda(); // 返回一个 LambdaQueryWrapper
        
    【UpdateWrapper 条件：】
        set(String column, Object val); // 用于设置 set 字段值。例: set("name", null) ---> set name = null
        etSql(String sql); // 用于设置 set 字段值。例: setSql("name = '老李头'") ---> set name = '老李头'
        lambda(); // 返回一个 LambdaUpdateWrapper

![674e290a7246b463ddc33212250e21e2.jpeg][]

（3）简单使用，测试一下 QueryWrapper

![d4feace6ccd53b517a82291f393fa669.jpeg][]

@Test
    public void testQueryWrapper() {
        // Step1：创建一个 QueryWrapper 对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    
        // Step2： 构造查询条件
        queryWrapper
                .select("id", "name", "age")
                .eq("age", 20)
                .like("name", "j");
    
        // Step3：执行查询
        userService
                .list(queryWrapper)
                .forEach(System.out::println);
    }

![df0345999fcde60f642d625102bd3e92.jpeg][]

![4f4bde88ac763e135da43f871116a560.png][]

![format_png 30][]

别把自己太当回事，也别太把自己不当回事！Life is Fantastic!!!

[https_mp.baomidou.com_guide]: https://link.zhihu.com/?target=https%3A//mp.baomidou.com/guide/
[https_mp.baomidou.com_guide_E7_89_B9_E6_80_A7]: https://link.zhihu.com/?target=https%3A//mp.baomidou.com/guide/%23%25E7%2589%25B9%25E6%2580%25A7
[format_png]: https://img-blog.csdnimg.cn/img_convert/aa50e2f97911fa33d3355ece756bb24a.webp?x-oss-process=image/format,png
[https_start.spring.io]: https://link.zhihu.com/?target=https%3A//start.spring.io/
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/764c037394bfb35bd76bd37d484cc30f.webp?x-oss-process=image/format,png
[c4c7e28f34078efb1d44a7e545b12461.png]: https://img-blog.csdnimg.cn/img_convert/c4c7e28f34078efb1d44a7e545b12461.png
[85d08b660fc428f85d4c6969d5dbf1fb.jpeg]: https://img-blog.csdnimg.cn/img_convert/85d08b660fc428f85d4c6969d5dbf1fb.jpeg
[9525eef5f6e68c090ebfb8219bf40bd7.jpeg]: https://img-blog.csdnimg.cn/img_convert/9525eef5f6e68c090ebfb8219bf40bd7.jpeg
[01781f38b5672c1d094d9cc0bd477311.jpeg]: https://img-blog.csdnimg.cn/img_convert/01781f38b5672c1d094d9cc0bd477311.jpeg
[969960c530f6be345b33ecc321c9e78d.jpeg]: https://img-blog.csdnimg.cn/img_convert/969960c530f6be345b33ecc321c9e78d.jpeg
[e200c6ee587a124f0c292acaf7102132.jpeg]: https://img-blog.csdnimg.cn/img_convert/e200c6ee587a124f0c292acaf7102132.jpeg
[47cc10ab6c6f1c90d1d3e9b02aadc08a.jpeg]: https://img-blog.csdnimg.cn/img_convert/47cc10ab6c6f1c90d1d3e9b02aadc08a.jpeg
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/a2755429119b2022ad8bdff296438ecc.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/11a2200577a8e57b45248f541dda773c.webp?x-oss-process=image/format,png
[d388b9ea09454184d009bae44d5bc83f.jpeg]: https://img-blog.csdnimg.cn/img_convert/d388b9ea09454184d009bae44d5bc83f.jpeg
[dc1eb2940a4909400236a3bd8cd33351.jpeg]: https://img-blog.csdnimg.cn/img_convert/dc1eb2940a4909400236a3bd8cd33351.jpeg
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/1dcb9a2b8b93225ade70c74793bf5e36.webp?x-oss-process=image/format,png
[d125110400a8080c8722b4e689a60320.jpeg]: https://img-blog.csdnimg.cn/img_convert/d125110400a8080c8722b4e689a60320.jpeg
[231c1af84c1e67b1cfd8c3cf4567d0e5.jpeg]: https://img-blog.csdnimg.cn/img_convert/231c1af84c1e67b1cfd8c3cf4567d0e5.jpeg
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/077dc10912b778c43f07d7147eadc6f1.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/d6b67e3f906f360caaf866f5f8d66dd8.webp?x-oss-process=image/format,png
[8d519703f6aafe5db40c80af11f32af4.jpeg]: https://img-blog.csdnimg.cn/img_convert/8d519703f6aafe5db40c80af11f32af4.jpeg
[377e0e5bb7e61b738e37dafc9e9dd332.jpeg]: https://img-blog.csdnimg.cn/img_convert/377e0e5bb7e61b738e37dafc9e9dd332.jpeg
[62ce36a6701d39da1814f583e045eccd.jpeg]: https://img-blog.csdnimg.cn/img_convert/62ce36a6701d39da1814f583e045eccd.jpeg
[11fe9744b112dd0cbe446eb6b024a876.jpeg]: https://img-blog.csdnimg.cn/img_convert/11fe9744b112dd0cbe446eb6b024a876.jpeg
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/dd23b861468ae335eaad83b7f06fda4d.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/55b7ae27be823d86e44e47ae2dd47b2d.webp?x-oss-process=image/format,png
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/da226193620b2cdbced8328a7030bbb8.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/ffde8508cd5a25ba5aead745d7f8c3ec.webp?x-oss-process=image/format,png
[5a583af8f49ac6c1d297f63ebf4833f4.jpeg]: https://img-blog.csdnimg.cn/img_convert/5a583af8f49ac6c1d297f63ebf4833f4.jpeg
[5c5dfe36c74800ebacbcec96ba281118.jpeg]: https://img-blog.csdnimg.cn/img_convert/5c5dfe36c74800ebacbcec96ba281118.jpeg
[7fa0b7abced1a86fe14d0041e2d28e0d.jpeg]: https://img-blog.csdnimg.cn/img_convert/7fa0b7abced1a86fe14d0041e2d28e0d.jpeg
[dae4d2a2d97f612df9a73bb661e76803.jpeg]: https://img-blog.csdnimg.cn/img_convert/dae4d2a2d97f612df9a73bb661e76803.jpeg
[b3bc3d493f0b638ff86cc257eac0c188.jpeg]: https://img-blog.csdnimg.cn/img_convert/b3bc3d493f0b638ff86cc257eac0c188.jpeg
[60046457717e78657d9d762d05237ecf.jpeg]: https://img-blog.csdnimg.cn/img_convert/60046457717e78657d9d762d05237ecf.jpeg
[1aa2d0200e61fa9eb3faa3722b3389b4.jpeg]: https://img-blog.csdnimg.cn/img_convert/1aa2d0200e61fa9eb3faa3722b3389b4.jpeg
[4d2ffb223ea29faa2be6fb453e3cec0c.jpeg]: https://img-blog.csdnimg.cn/img_convert/4d2ffb223ea29faa2be6fb453e3cec0c.jpeg
[21d408ad32ff77c80cb67fdafd80c142.jpeg]: https://img-blog.csdnimg.cn/img_convert/21d408ad32ff77c80cb67fdafd80c142.jpeg
[63915e534278ff59048852afa8c2ce5b.jpeg]: https://img-blog.csdnimg.cn/img_convert/63915e534278ff59048852afa8c2ce5b.jpeg
[737777422ffe21921697053e44d5f93c.jpeg]: https://img-blog.csdnimg.cn/img_convert/737777422ffe21921697053e44d5f93c.jpeg
[7fb5f13a82426ed8ab35b1de3171a108.jpeg]: https://img-blog.csdnimg.cn/img_convert/7fb5f13a82426ed8ab35b1de3171a108.jpeg
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/9524a1fad55861871402479f68462f7d.webp?x-oss-process=image/format,png
[1ff97a1f83a3d2408efdd42aff01b911.jpeg]: https://img-blog.csdnimg.cn/img_convert/1ff97a1f83a3d2408efdd42aff01b911.jpeg
[99bf8709b3214b3671509f0f3779a44a.jpeg]: https://img-blog.csdnimg.cn/img_convert/99bf8709b3214b3671509f0f3779a44a.jpeg
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/4fca8d20a45c85266c52bd44ab754bae.webp?x-oss-process=image/format,png
[da4e1f1aaee130809f5cdd7b4355bce7.jpeg]: https://img-blog.csdnimg.cn/img_convert/da4e1f1aaee130809f5cdd7b4355bce7.jpeg
[28a33686fbf4df117b6112c2c037f9e6.jpeg]: https://img-blog.csdnimg.cn/img_convert/28a33686fbf4df117b6112c2c037f9e6.jpeg
[format_png 13]: https://img-blog.csdnimg.cn/img_convert/8113edd2ee8c73f8cb618ee52554fac2.webp?x-oss-process=image/format,png
[cf37a7731ba861ed02422fb165a92260.jpeg]: https://img-blog.csdnimg.cn/img_convert/cf37a7731ba861ed02422fb165a92260.jpeg
[format_png 14]: https://img-blog.csdnimg.cn/img_convert/e220397a5e02f8362674c03b76a324ce.webp?x-oss-process=image/format,png
[66a74bedcceaf2cf5f9306f2b1f8b4b6.jpeg]: https://img-blog.csdnimg.cn/img_convert/66a74bedcceaf2cf5f9306f2b1f8b4b6.jpeg
[65d1d823c1fc4d4c2a64aea6958d250d.jpeg]: https://img-blog.csdnimg.cn/img_convert/65d1d823c1fc4d4c2a64aea6958d250d.jpeg
[format_png 15]: https://img-blog.csdnimg.cn/img_convert/6934c9c6e172bd741800646581ba6c75.webp?x-oss-process=image/format,png
[27815dcd91c9441c1ea41957298093f9.jpeg]: https://img-blog.csdnimg.cn/img_convert/27815dcd91c9441c1ea41957298093f9.jpeg
[60e6f8e4d4e7501d10c47af79841012b.jpeg]: https://img-blog.csdnimg.cn/img_convert/60e6f8e4d4e7501d10c47af79841012b.jpeg
[format_png 16]: https://img-blog.csdnimg.cn/img_convert/5de898551e079c05dd54f58187dd127d.webp?x-oss-process=image/format,png
[a21df8c9d6c7413dc6e3e28985c6a256.jpeg]: https://img-blog.csdnimg.cn/img_convert/a21df8c9d6c7413dc6e3e28985c6a256.jpeg
[7aff7ad516e26bdbe958486187f1fb86.jpeg]: https://img-blog.csdnimg.cn/img_convert/7aff7ad516e26bdbe958486187f1fb86.jpeg
[7b28cfa33eaf168f19e7a951fb1647d5.jpeg]: https://img-blog.csdnimg.cn/img_convert/7b28cfa33eaf168f19e7a951fb1647d5.jpeg
[da8850f077be956ee87603fe9bf7ba6e.jpeg]: https://img-blog.csdnimg.cn/img_convert/da8850f077be956ee87603fe9bf7ba6e.jpeg
[format_png 17]: https://img-blog.csdnimg.cn/img_convert/b7200e9e0d7f0433df72bb69f4edfe76.webp?x-oss-process=image/format,png
[1a02d9724160d0d7854414e3dfa02292.jpeg]: https://img-blog.csdnimg.cn/img_convert/1a02d9724160d0d7854414e3dfa02292.jpeg
[556e4418641b345bda6c8c4affadbc49.jpeg]: https://img-blog.csdnimg.cn/img_convert/556e4418641b345bda6c8c4affadbc49.jpeg
[34cbedd294caa539f147c92b8e830149.png]: https://img-blog.csdnimg.cn/img_convert/34cbedd294caa539f147c92b8e830149.png
[format_png 18]: https://img-blog.csdnimg.cn/img_convert/e1f11fd69d92b5df7874a21e3fbca754.webp?x-oss-process=image/format,png
[6b3682ef877cecfdb139edd86985f3db.png]: https://img-blog.csdnimg.cn/img_convert/6b3682ef877cecfdb139edd86985f3db.png
[format_png 19]: https://img-blog.csdnimg.cn/img_convert/c61069c16e63d458795e8617d93f981f.webp?x-oss-process=image/format,png
[6284f29270f35ccde19a3807a0efbd6a.png]: https://img-blog.csdnimg.cn/img_convert/6284f29270f35ccde19a3807a0efbd6a.png
[fd146c48dbcd252510c36281601156b9.jpeg]: https://img-blog.csdnimg.cn/img_convert/fd146c48dbcd252510c36281601156b9.jpeg
[cc3dc59c9c91275aa79f4701e2ec5545.jpeg]: https://img-blog.csdnimg.cn/img_convert/cc3dc59c9c91275aa79f4701e2ec5545.jpeg
[format_png 20]: https://img-blog.csdnimg.cn/img_convert/369a70c40a89de0dafd3964fb8c269dd.webp?x-oss-process=image/format,png
[1656b89a1fc4cf1bd098d117b9bb3a24.jpeg]: https://img-blog.csdnimg.cn/img_convert/1656b89a1fc4cf1bd098d117b9bb3a24.jpeg
[25a078465b06df286d044f36884493c7.jpeg]: https://img-blog.csdnimg.cn/img_convert/25a078465b06df286d044f36884493c7.jpeg
[format_png 21]: https://img-blog.csdnimg.cn/img_convert/3866d0de7ec0f58dab58118fbb6db00b.webp?x-oss-process=image/format,png
[format_png 22]: https://img-blog.csdnimg.cn/img_convert/1701df8a5a09cc1fcdc9f43ad3bb6cbf.webp?x-oss-process=image/format,png
[7c41edb064e6222a694a7ba77d4515dc.jpeg]: https://img-blog.csdnimg.cn/img_convert/7c41edb064e6222a694a7ba77d4515dc.jpeg
[823688e22adb1c14441c3968e19a4b1c.jpeg]: https://img-blog.csdnimg.cn/img_convert/823688e22adb1c14441c3968e19a4b1c.jpeg
[c77528d7f5745a741592692728136615.jpeg]: https://img-blog.csdnimg.cn/img_convert/c77528d7f5745a741592692728136615.jpeg
[05df61cb65e24e790bd387968996d968.jpeg]: https://img-blog.csdnimg.cn/img_convert/05df61cb65e24e790bd387968996d968.jpeg
[format_png 23]: https://img-blog.csdnimg.cn/img_convert/c56606a302b82ffdc7a9a736a229c862.webp?x-oss-process=image/format,png
[db8b7b2d713a12f308309348969053dc.jpeg]: https://img-blog.csdnimg.cn/img_convert/db8b7b2d713a12f308309348969053dc.jpeg
[08490dd017a97a8c1fc87a9c13444d15.jpeg]: https://img-blog.csdnimg.cn/img_convert/08490dd017a97a8c1fc87a9c13444d15.jpeg
[format_png 24]: https://img-blog.csdnimg.cn/img_convert/1169aa6c2ef4da089ac59ca6bf307f86.webp?x-oss-process=image/format,png
[format_png 25]: https://img-blog.csdnimg.cn/img_convert/ffa6a92848ffe5e1febdd74cb52d0512.webp?x-oss-process=image/format,png
[format_png 26]: https://img-blog.csdnimg.cn/img_convert/b58a47a3ad6e65de33cbcd837d90e512.webp?x-oss-process=image/format,png
[920797f7c54620ac694e71f6ae9f8b55.jpeg]: https://img-blog.csdnimg.cn/img_convert/920797f7c54620ac694e71f6ae9f8b55.jpeg
[2e97a05c2057606f2dbfbcde36883c1f.jpeg]: https://img-blog.csdnimg.cn/img_convert/2e97a05c2057606f2dbfbcde36883c1f.jpeg
[format_png 27]: https://img-blog.csdnimg.cn/img_convert/858c37638bdbd7e900b484c2dd6190de.webp?x-oss-process=image/format,png
[format_png 28]: https://img-blog.csdnimg.cn/img_convert/1825749ce767dcb5f9456dd6627d1885.webp?x-oss-process=image/format,png
[37458606efb88d24f1329a7281a28c20.jpeg]: https://img-blog.csdnimg.cn/img_convert/37458606efb88d24f1329a7281a28c20.jpeg
[89767f643094f94a21f9dcc4f00ddcf9.jpeg]: https://img-blog.csdnimg.cn/img_convert/89767f643094f94a21f9dcc4f00ddcf9.jpeg
[925d35ec7cbab6144d8ab53b5f14784e.jpeg]: https://img-blog.csdnimg.cn/img_convert/925d35ec7cbab6144d8ab53b5f14784e.jpeg
[fee97218e8a65ce10bcfedb10146023d.jpeg]: https://img-blog.csdnimg.cn/img_convert/fee97218e8a65ce10bcfedb10146023d.jpeg
[format_png 29]: https://img-blog.csdnimg.cn/img_convert/f7d47289c12c937172f930c54ae14214.webp?x-oss-process=image/format,png
[ff61bff052d0ac5780ef9d4666dd96ce.jpeg]: https://img-blog.csdnimg.cn/img_convert/ff61bff052d0ac5780ef9d4666dd96ce.jpeg
[674e290a7246b463ddc33212250e21e2.jpeg]: https://img-blog.csdnimg.cn/img_convert/674e290a7246b463ddc33212250e21e2.jpeg
[d4feace6ccd53b517a82291f393fa669.jpeg]: https://img-blog.csdnimg.cn/img_convert/d4feace6ccd53b517a82291f393fa669.jpeg
[df0345999fcde60f642d625102bd3e92.jpeg]: https://img-blog.csdnimg.cn/img_convert/df0345999fcde60f642d625102bd3e92.jpeg
[4f4bde88ac763e135da43f871116a560.png]: https://img-blog.csdnimg.cn/img_convert/4f4bde88ac763e135da43f871116a560.png
[format_png 30]: https://img-blog.csdnimg.cn/img_convert/0f5772894f98158c7e18b9a9c3ec6ffb.webp?x-oss-process=image/format,png