【Mybatis Plus】之 CRUD 实战

曾经终败给现在 2023-03-01 10:22 10阅读 0赞

# 一、MyBatis Plus 简介 #

--------------------

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

**MyBatista Plus 特性：**

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

快速开始参考：[http://mp.baomidou.com/guide/quick-start.html][http_mp.baomidou.com_guide_quick-start.html]

官网：[http://mp.baomidou.com/][http_mp.baomidou.com]

参考教程：[http://mp.baomidou.com/guide/][http_mp.baomidou.com_guide]

# 二、MyBatista Plus 环境搭建 #

--------------------

### 1、创建并初始化数据库 ###

**创建数据库：**

create database mybatis_plus;

**创建 User 表：**

# 建表
    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)
    );
    
    # 插入数据
    DELETE FROM user;
    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');

### 2、创建初始化工程 ###

使用 Spring Initializr 快速初始化一个 Spring Boot 工程

*  **Group：** *com.wang*
 *  **Artifact：** *mybatis-plus*
 *  **使用的版本：** *2.2.1.RELEASE*

### 3、添加依赖 ###

**配置 pom.xml 引入依赖**

<dependencies>
        
        <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>
    
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    
        
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
    
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    
        
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    
    </dependencies>

**注意：** 引入 MyBatis-Plus 之后请不要再次引入 MyBatis 以及 MyBatis-Spring ，以避免因版本差异导致的问  
题。

**IDEA 中安装 lombok插件**

在 Settings 下的 Plugins 中搜索 lombok，在搜索结果中安装第一个，即标题为 lombok 的插件选项，下载安装完成后重启 idea。

### 4、配置 ###

在 **application.properties** 配置文件中添加 MySQL 数据库的相关配置：

**mysql5**

#mysql数据库连接
    spring:
    	datasource:
    		driver-class-name: com.mysql.jdbc.Driver
    		url: jdbc:mysql://localhost:3306/mybatis_plus
    		username: root
    		password: 123456

mysql8 以上（spring boot 2.1），注意 driver 和 url 的变化：

spring:
    	datasource:
    		driver-class-name: com.mysql.cj.jdbc.Driver
    		url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8
    		username: root
    		password: 123456

**注意：**

1、这里的 **url** 使用了 **?serverTimezone=GMT%2B8** 后缀，因为 Spring Boot 2.1 以后集成了 8.0版本的jdbc驱动，这个版本的 jdbc 驱动需要添加这个后缀，否则运行测试用例报告如下错误：

java.sql.SQLException: The server time zone value 'ÖÐ¹ú±ê×¼Ê±¼ä' is unrecognized or represents

2、这里的 **driver-class-name** 使用了 c**om.mysql.cj.jdbc.Drive**r ，在 jdbc 8 中 建议使用这个驱动，之前的 **com.mysql.jdbc.Driver** 已经被废弃，否则运行测试用例的时候会有 WARN 信息

### 5、编写代码 ###

#### 1）主类 ####

在 Spring Boot 启动类中添加 **@MapperScan** 注解，扫描 Mapper 文件夹

**注意**：扫描的包名根据实际情况修改

import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    @MapperScan(value = "com.wang.mybatisplus.mapper")
    public class MybatisPlusApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(MybatisPlusApplication.class, args);
        }
    
    }

#### 2）实体 ####

创建包 **entity** 编写实体类 **User.java**（此处使用了 **Lombok** 简化代码）

import lombok.Data;
    
    // 使用 lombok 的 @Data 注解简化代码
    @Data
    public class User { 
        private Long id;
        private String name;
        private Integer age;
        private String email;
    }

加上 lombok 的 @Data 注解后，lombok 会为我们生成 getter/setter/toString 等方法，点击 idea 左下角的 Structure 可以看到编译结果已经有了 getter/setter/toString 等方法了。

更多 Lombok 的使用可以参考：[https://blog.csdn.net/motui/article/details/79012846][https_blog.csdn.net_motui_article_details_79012846]

#### 3）mapper 文件 ####

创建包 mapper 编写Mapper 接口： UserMapper.java

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.wang.mybatisplus.entity.User;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface UserMapper extends BaseMapper<User> { 
        
    }

### 6、搭建测试用例 ###

添加测试类，进行功能测试：

import com.wang.mybatisplus.entity.User;
    import com.wang.mybatisplus.mapper.UserMapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.List;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class MybatisPlusApplicationTests { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testSelectList() { 
            System.out.println(("----- selectAll method test ------"));
            
            // UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper
            // 所以不填写就是无任何条件
            List<User> userList = userMapper.selectList(null);
    
            userList.forEach(System.out::println);
        }
    
    }

**注意：**

如果 IDEA在 @Autowired 的 userMapper 处报错，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确的执行。

为了避免报错，可以在 dao 层的接口上添加 **@Repository** 注

### 7、配置日志 ###

为例更好地查看 MyBatis Plus 进行的 sql 语句操作，我们可以配置 mybatis 日志来查看 sql 输出日志，在 application.properties 中添加：

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

再次执行测试例子则会在控制台打印相关 sql 输出日志：

JDBC Connection [HikariProxyConnection@236858974 wrapping com.mysql.cj.jdbc.ConnectionImpl@661c46bc] will not be managed by Spring
    ==>  Preparing: SELECT id,name,age,email FROM user 
    ==> Parameters: 
    <==    Columns: id, name, age, email
    <==        Row: 1, Jone, 18, test1@baomidou.com
    <==        Row: 2, Jack, 20, test2@baomidou.com
    <==        Row: 3, Tom, 28, test3@baomidou.com
    <==        Row: 4, Sandy, 21, test4@baomidou.com
    <==        Row: 5, Billie, 24, test5@baomidou.com
    <==      Total: 5

## 三、CRUD 实战 ##

--------------------

### 一、Insert ###

#### 1、插入操作 ####

@Test
    public void testInsert() { 
        User user = new User();
        user.setName("Andy");
        user.setAge(18);
        user.setEmail("123456@163.com");
    
        int result = userMapper.insert(user);
        System.out.println("insert result : " + result);    // 影响的行数
        System.out.println("user : " + user);               // id自动回填
    }

我们查看一下控制台的 sql 输出日志：

==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? ) 
    ==> Parameters: 1286448461327196162(Long), Andy(String), 18(Integer), 123456@163.com(String)
    <==    Updates: 1

可以看到，数据库插入id值默认为：全局唯一 id

#### 2、主键策略 ####

**(1) ID\_WORKER**

MyBatis-Plus 默认的主键策略是： **ID\_WORKER** 全局唯一 ID

参考资料：分布式系统唯一ID生成方案汇总：[https://www.cnblogs.com/haoxinyue/p/5208136.html][https_www.cnblogs.com_haoxinyue_p_5208136.html]

**(2) 自增策略**

要想主键自增需要配置如下主键策略

*  需要在创建数据表的时候设置主键自增或者修改表结构为主键自增：

ALTER TABLE `user` MODIFY `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID';

*  实体字段中配置 @TableId(type = IdType.AUTO)：

@TableId(type = IdType.AUTO)
    private Long id;

要想影响所有实体的配置，可以设置全局主键配置:

# 全局设置主键生成策略
    mybatis-plus.global-config.db-config.id-type=auto

其它主键策略：分析 IdType 源码可知:

@Getter
    public enum IdType { 
        /** * 数据库ID自增 */
        AUTO(0),
        /** * 该类型为未设置主键类型 */
        NONE(1),
        /** * 用户输入ID * 该类型可以通过自己注册自动填充插件进行填充 */
        INPUT(2),
    
        /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
        /** * 全局唯一ID (idWorker) */
        ID_WORKER(3),
        /** * 全局唯一ID (UUID) */
        UUID(4),
        /** * 字符串全局唯一ID (idWorker 的字符串表示) */
        ID_WORKER_STR(5);
    
        private int key;
    
        IdType(int key) { 
            this.key = key;
        }
    }

### 二、Update ###

#### 1、根据Id更新操作 ####

注意：update时生成的sql自动是动态sql：UPDATE user SET age=? WHERE id=?

@Test
    public void testUpdateByid() { 
        User user = new User();
        user.setId(1286448461327196162L);
        user.setAge(24);
    
        int result = userMapper.updateById(user);
        System.out.println("update result : " + result);
    }

#### 2、自动填充 ####

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的**创建时间，更新时间**等。

我们可以使用 MyBatis Plus 的自动填充功能，完成这些字段的赋值工作：

**(1) 数据库表中添加自动填充字段**

在User表中添加 datetime 类型的新的字段 create\_time、update\_time：

ALTER TABLE `user` ADD `create_time` DATETIME;
    ALTER TABLE `user` ADD `update_time` DATETIME;

**(2) 实体上添加注解**

@Data
    public class User { 
    
        ......
    
        // 插入时自动填充字段值
        @TableField(fill = FieldFill.INSERT)
        private Date createTime;
    
        // 插入和更新时自动填充字段
        @TableField(fill = FieldFill.INSERT_UPDATE)
        private Date updateTime;
    }

**(3) 实现元对象处理器接口**

想要自动填充成效，我们必须实现 MetaObjectHandler 接口来自定义填充规则：

**注意：不要忘记添加 @Component 注解**

package com.wang.mybatisplus.handler;
    
    import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
    import org.apache.ibatis.reflection.MetaObject;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    
    @Component
    public class MyMetaObjectHandler implements MetaObjectHandler { 
    
        // 打印日志
        private static final Logger LOGGER = LoggerFactory.getLogger(MyMetaObjectHandler.class);
    
        // 自定义插入的填充规则
        @Override
        public void insertFill(MetaObject metaObject) { 
            LOGGER.info("start insert fill ....");
            this.setFieldValByName("createTime", new Date(), metaObject);
            this.setFieldValByName("updateTime", new Date(), metaObject);
        }
    
        // 自定义更新的填充规则
        @Override
        public void updateFill(MetaObject metaObject) { 
            LOGGER.info("start update fill ....");
            this.setFieldValByName("updateTime", new Date(), metaObject);
        }
    }

配置好后运行插入数据和更新数据测试用例就可以看到结果了。

#### 3、乐观锁 ####

**主要适用场景**：当要更新一条记录的时候，希望这条记录没有被别人更新，也就是说实现线程安全的数  
据更新。所以乐观锁是为了解决**丢失更新**的问题。

**乐观锁实现方式：**

*  取出记录时，获取当前 version
 *  更新时，带上这个 version
 *  执行更新时， set version = newVersion where version = oldVersion
 *  如果 version 不对，就更新失败

**代码实践：**

**（1）数据库中添加version字段**

ALTER TABLE `user` ADD COLUMN `version` INT DEFAULT 1;
    
    Field        Type         Collation        Null    Key     Default
    ----------- ----------- --------------- ------ ------ -------
    version      int(11)      (NULL)           YES             1

**（2）实体类添加version字段**

并添加 **@Version** 注解

// 版本号
    @Version
    @TableField(fill = FieldFill.INSERT)
    private Integer version;

**（3）元对象处理器接口添加version的insert默认值**

@Override
    public void insertFill(MetaObject metaObject) { 
        ......
        this.setFieldValByName("version", 1, metaObject);
    }

**特别说明:**

*  支持的数据类型只有 int, Integer, long, Long, Date, Timestamp, LocalDateTime
 *  整数类型下 newVersion = oldVersion + 1
 *  newVersion 会回写到 entity 中
 *  仅支持 updateById(id) 与 update(entity, wrapper) 方法
 *  在 update(entity, wrapper) 方法下, **wrapper 不能复用!!!**

**（4）在 MybatisPlusConfig 中注册 Bean**

创建配置类：

package com.wang.mybatisplus.config;
    
    import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    @EnableTransactionManagement
    @Configuration
    @MapperScan(value = "com.wang.mybatisplus.mapper")
    public class MybatisPlusConfig { 
    
        // 乐观锁插件
        @Bean
        public OptimisticLockerInterceptor optimisticLockerInterceptor() { 
            return new OptimisticLockerInterceptor();
        }
    }

从配置类中可以看到，我们加上了和主启动程序一样的 @Mapperscan 注解，一般情况下，我们都是把 @Mapperscan 注解放在配置类中，所以可以把主启动程序的 @Mapperscan 注解给移除掉。

**（5）测试**

模拟乐观锁修改成功：

/** * 测试乐观锁插件 */
    @Test
    public void testOptimisticLocker() { 
        // 查询
        User user = userMapper.selectById(1L);
    
        // 修改数据
        user.setName("wang");
        user.setAge(22);
    
        // 执行更新
        userMapper.updateById(user);
    }

查看 sql 控制台日志输出可以知道更新成功：

==>  Preparing: UPDATE user SET name=?, age=?, email=?, update_time=?, version=? WHERE id=? AND version=? 
    ==> Parameters: wang(String), 22(Integer), test1@baomidou.com(String), 2020-07-24 15:42:39.154(Timestamp), 2(Integer), 1(Long), 1(Integer)
    <==    Updates: 1

模拟乐观锁修改失败：

/** * 模拟乐观锁修改失败 */
    @Test
    public void testOptimisticLockFailed() { 
        // 查询
        User user = userMapper.selectById(1L);
    
        // 修改数据
        user.setName("zhang");
        user.setAge(24);
    
        // 模拟取出数据后，数据库中version实际数据比取出的值大，即已被其它线程修改并更新了 version
        user.setVersion(user.getVersion() - 1);
    
        // 执行更新
        userMapper.updateById(user);
    }

查看 sql 控制台日志输出可以知道更新失败：

==>  Preparing: UPDATE user SET name=?, age=?, email=?, update_time=?, version=? WHERE id=? AND version=? 
    ==> Parameters: zhang(String), 24(Integer), test1@baomidou.com(String), 2020-07-24 15:43:56.842(Timestamp), 2(Integer), 1(Long), 1(Integer)
    <==    Updates: 0

### 三、Select ###

#### 1、根据id查询记录 ####

// 根据ID查询
    @Test
    public void testSelectById() { 
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }

#### 2、通过多个id批量查询 ####

// 通过多个ID批量查询
    @Test
    public void testSelectBatchIds() { 
        List<User> userList = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        userList.forEach(System.out::println);
    }

#### 3、简单的条件查询 ####

通过 map 封装查询条件

// 简单的条件查询
    @Test
    public void testSelectByMap() { 
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "wang");
        map.put("age", 22);
    
        List<User> userList = userMapper.selectByMap(map);
        userList.forEach(System.out::println);
    }

\*\*注意：\*\*map 中的 key 对应的是数据库中的列名。例如数据库 user\_id，实体类是 userId，这时 map 的 key 需  
要填写 user\_id

#### 4、分页查询 ####

MyBatis Plus 自带分页插件，只要简单的配置即可实现分页功能

**（1）创建配置类**

// 分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() { 
        return new PaginationInterceptor();
    }

**（2）测试 selectPage 分页**

\*\*测试：\*\*最终通过page对象获取相关数据

// 测试 selectPage 分页
    @Test
    public void testSelectPage() { 
        Page<User> page = new Page<>(1, 5);
        userMapper.selectPage(page, null);
    
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getCurrent());
        System.out.println(page.getPages());
        System.out.println(page.getSize());
        System.out.println(page.getTotal());
        System.out.println(page.hasNext());
        System.out.println(page.hasPrevious());
    }

查看控制台 sql 语句打印：

JsqlParserCountOptimize sql=SELECT  id,name,age,email,create_time,update_time,version  FROM user
    ==>  Preparing: SELECT COUNT(1) FROM user 
    ==> Parameters: 
    <==    Columns: COUNT(1)
    <==        Row: 7
    ==>  Preparing: SELECT id,name,age,email,create_time,update_time,version FROM user LIMIT 0,5 
    ==> Parameters: 
    <==    Columns: id, name, age, email, create_time, update_time, version
    <==        Row: 1, wang, 22, test1@baomidou.com, null, 2020-07-24 15:42:39, 2
    <==        Row: 2, Jack, 20, test2@baomidou.com, null, null, 1
    <==        Row: 3, Tom, 28, test3@baomidou.com, null, null, 1
    <==        Row: 4, Sandy, 21, test4@baomidou.com, null, null, 1
    <==        Row: 5, Billie, 24, test5@baomidou.com, null, null, 1
    <==      Total: 5

**（3）测试selectMapsPage分页：结果集是 Map**

// 测试 selectMapsPage 分页
    @Test
    public void testSelectMapsPage() { 
        Page<User> page = new Page<>(1, 5);
        IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(page, null);
    
        // 注意：此行必须使用 mapIPage 获取记录列表，否则会有数据类型转换错误
        mapIPage.getRecords().forEach(System.out::println);
    
        System.out.println(page.getCurrent());
        System.out.println(page.getPages());
        System.out.println(page.getSize());
        System.out.println(page.getTotal());
        System.out.println(page.hasNext());
        System.out.println(page.hasPrevious());
    }

### 四、Delete ###

#### 1、根据id删除记录 ####

// 根据ID删除记录
    @Test
    public void testDeleteById() { 
        int result = userMapper.deleteById(7L);
        System.out.println(result);
    }

#### 2、批量删除 ####

// 批量删除
    @Test
    public void testDeleteBatchIds() { 
        int result = userMapper.deleteBatchIds(Arrays.asList(4, 5, 6));
        System.out.println(result);
    }

#### 3、简单的条件查询删除 ####

// 根据简单条件查询删除
    @Test
    public void testDeleteByMap() { 
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "Tom");
        map.put("age", 28);
    
        int result = userMapper.deleteByMap(map);
        System.out.println(result);
    }

#### 4、逻辑删除 ####

*  **物理删除：真实删除**，将对应数据从数据库中删除，之后查询不到此条被删除数据
 *  **逻辑删除：假删除**，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中仍  
    旧能看到此条数据记录

**1）数据库中添加 deleted字段**

ALTER TABLE `user` ADD COLUMN `deleted` TINYINT DEFAULT 0;

**2）实体类添加deleted 字段**

并加上 **@TableLogic** 注解 和 **@TableField(fill = FieldFill.INSERT)** 注解

// 代表逻辑删除字段
    @TableLogic(value = "0", delval = "1")
    @TableField(fill = FieldFill.INSERT)
    private Integer deleted;

@TableLogic 注解有两个参数，value 表示未删除时的值，delval 表示删除后的值。当然也可以不在注解上提供这两个参数值，因为 MP 默认的全局配置值就是 0 和 1。

我们也可以在 application.properties 添加默认值：

# 配置逻辑删除值
    mybatis-plus.global-config.db-config.logic-delete-value=1
    mybatis-plus.global-config.db-config.logic-not-delete-value=0

**3）元对象处理器接口添加 deleted 的 insert 默认值**

@Override
    public void insertFill(MetaObject metaObject) { 
        ......
        this.setFieldValByName("deleted", 0, metaObject);
    }

**4）在 MybatisPlusConfig 中注册 Bean**

// 逻辑删除插件
    @Bean
    public ISqlInjector sqlInjector() { 
        return new LogicSqlInjector();
    }

**5）测试逻辑删除**

// 测试逻辑删除
    @Test
    public void testLogicDelete() { 
        int result = userMapper.deleteById(1L);
        System.out.println(result);
    }

查询数据可以发现，数据并没有被删除，只是 deleted 字段的值由0变成了1

id  name       age  email               deleted  
    ------------------- ------ ------ ------------------ ---------
                      1  Jone        18  test1@baomidou.com          1
                      2  Jack        20  test2@baomidou.com          0
                      3  Tom         28  test3@baomidou.com          0

分析打印的sql语句，发现逻辑删除是一条update语句

JDBC Connection [HikariProxyConnection@1462928549 wrapping com.mysql.cj.jdbc.ConnectionImpl@3fbfbf84] will not be managed by Spring
    ==>  Preparing: UPDATE user SET deleted=1 WHERE id=? AND deleted=0 
    ==> Parameters: 1(Long)
    <==    Updates: 1

接下来测试一下查询逻辑删除后的数据以及对应的SQL语句：

// 测试逻辑删除后的查询：不包括被逻辑删除的记录
    @Test
    public void testLogicDeleteSelect() { 
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }

==>  Preparing: SELECT id,name,age,email,create_time,update_time,version,deleted FROM user WHERE deleted=0 
    ==> Parameters: 
    <==    Columns: id, name, age, email, create_time, update_time, version, deleted
    <==        Row: 2, Jack, 20, test2@baomidou.com, null, null, 1, 0
    <==        Row: 3, Tom, 28, test3@baomidou.com, null, null, 1, 0
    <==        Row: 4, Sandy, 21, test4@baomidou.com, null, null, 1, 0
    <==        Row: 5, Billie, 24, test5@baomidou.com, null, null, 1, 0
    <==        Row: 1286448461327196162, Andy, 24, 123456@163.com, null, null, 1, 0
    <==      Total: 5

从打印的 sql 语句中可以看出，查询语句包含了一个条件：**WHERE deleted=0**，所以只查询出了 deleted 字段值不等于1的数据。

## 性能分析 ##

--------------------

性能分析拦截器，用于输出每条 SQL 语句及其执行时间  
SQL 性能执行分析，开发环境使用，超过指定时间，停止运行，有助于发现问题

### 1、配置插件 ###

#### 在 MybatisPlusConfig 中配置 ####

// SQL 执行性能分析插件:开发环境使用，线上不推荐
    @Bean
    @Profile({ "dev", "test"})   // 设置 dev test 环境开启
    public PerformanceInterceptor performanceInterceptor() { 
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100); // sql 最大执行时长，超过此处设置的ms则sql不执行
        performanceInterceptor.setFormat(true); // sql 是否格式化
        return performanceInterceptor;
    }

#### 参数说明： ####

*  **maxTime**： SQL 执行最大时长，超过自动停止运行，有助于发现问题。
 *  **format**： SQL是否格式化，默认false。

#### SpringBoot 配置文件中设置dev环境 ####

# 环境设置：dev、test、prod
    spring.profiles.active=dev

可以针对各环境新建不同的配置文件 **application-dev.properties、application-test.properties、application-**  
**prod.properties**

### 2、测试 ###

#### 1）常规测试 ####

// 测试性能插件
    @Test
    public void testPerformance() { 
        User user = new User();
        user.setName("Andy");
        user.setAge(24);
        user.setEmail("andy@google.com");
        userMapper.insert(user);
    }

查看 SQL 语句输出：

==>  Preparing: INSERT INTO user ( name, age, email, create_time, update_time, version, deleted ) VALUES ( ?, ?, ?, ?, ?, ?, ? ) 
    ==> Parameters: Andy(String), 24(Integer), andy@google.com(String), 2020-07-25 10:07:10.482(Timestamp), 2020-07-25 10:07:10.482(Timestamp), 1(Integer), 0(Integer)
    <==    Updates: 1
     Time：47 ms - ID：com.wang.mybatisplus.mapper.UserMapper.insert
    Execute SQL：
        INSERT 
        INTO
            user
            ( name, age, email, create_time, update_time, version, deleted ) 
        VALUES
            ( 'Andy', 24, 'andy@google.com', '2020-07-25 10:07:10.482', '2020-07-25 10:07:10.482', 1, 0 )

#### 2）将maxTime 改小之后再次进行测试 ####

performanceInterceptor.setMaxTime(30)

如果执行时间过长，则抛出异常：The SQL execution time is too large：

org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.PersistenceException: 
    ### Error updating database. Cause: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException: The SQL execution time is too large, please optimize ! 
    ### The error may involve com.wang.mybatisplus.mapper.UserMapper.insert-Inline

[http_mp.baomidou.com_guide_quick-start.html]: http://mp.baomidou.com/guide/quick-start.html
[http_mp.baomidou.com]: http://mp.baomidou.com/
[http_mp.baomidou.com_guide]: http://mp.baomidou.com/guide/
[https_blog.csdn.net_motui_article_details_79012846]: https://blog.csdn.net/motui/article/details/79012846
[https_www.cnblogs.com_haoxinyue_p_5208136.html]: https://www.cnblogs.com/haoxinyue/p/5208136.html