快速上手MyBatisPlus~（基友搭配，效率翻倍）

太过爱你忘了你带给我的痛 2022-12-17 14:55 128阅读 0赞

### 目录 ###

*  一、简介
 *  二、快速入门
 *   *  1. 创建数据库及数据表
     *  2. 新建项目，导入依赖
     *  3. 编写数据库配置文件&连接
     *  4. 创建pojo实体类
     *  5. 编写mapper&扫描
     *  6. 测试类简单测试
     *  7. 小结
 *  三、配置日志
 *  四、CRUD及其拓展
 *   *  1. 插入insert & 主键生成策略
     *   *  1. 测试插入
         *  2. 主键生成策略
         *   *  更改策略：主键自增AUTO
             *  更改策略：手动输入INPUT
     *  2. 更新update & 自动填充功能
     *   *  1. 测试更新
         *  2. 自动填充
         *   *  方式一：数据库级别
             *  方式二：代码级别
     *  3. 查询select & 分页查询插件
     *   *  1. 测试查询
         *  2. 分页查询
     *  4. 删除delete & 逻辑删除
     *   *  1. 测试删除
         *  2. 逻辑删除
 *  五、乐观锁插件
 *   *  1. 实现方式
     *  2. 测试乐观锁插件
     *   *  1、添加version字段
         *  2、同步实体类
         *  3、注册乐观锁组件
         *  4、测试
 *  六、性能分析插件
 *   *  1. 导入插件
     *  2. 配置开发环境
     *  3. 配置插件
     *  4. 测试
 *  七、条件构造器
 *   *  1. 条件查询
     *  2. 子查询
     *  3. 分组查询
     *  4. 排序查询
 *  八、代码自动生成器

# 一、简介 #

**官网**：[https://mybatis.plus/][https_mybatis.plus]

> `MyBatis-Plus`（简称 `MP`）是一个 `MyBatis` 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生
> 
> 本文`MyBatis-Plus`版本基于3.0.5，最新的新版本会有些许改变  
> ![image-20201022181852363][]

**特性**

*  **无侵入**：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
 *  **损耗小**：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

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

# 二、快速入门 #

## 1. 创建数据库及数据表 ##

> 首先创建一个数据库`mybatis_plus`，再新建一个`user`表  
> ![image-20201018174550363][]

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');
    -- 真实开发中，version（乐观锁）、deleted（逻辑删除）、gmt_create、gmt_modified

最后得到`user`表  
![image-20201018174952281][]

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

## 2. 新建项目，导入依赖 ##

> 首先新建一个springboot项目，勾选组件时勾选`Spring Web`，然后导入以下依赖
> 
> 本文的`mybatis-plus`版本基于3.0.5

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
    
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.0.5</version>
    </dependency>

**加粗样式**说明：尽量不要同时导入 mybatis 和 mybatisplus，会存在依赖问题和版本的差异！

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

## 3. 编写数据库配置文件&连接 ##

> 在springboot配置文件`application.properties`中配置数据库连接

spring.datasource.username=root
    spring.datasource.password=200024
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC

注意：`mysql 5`和`mysql 8`版本的驱动不同，8版本需要增加时区设置

然后连接数据库，打开我们创建的`mybatis_plus`数据库  
![image-20201018181216802][]

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

## 4. 创建pojo实体类 ##

> 在主程序同级目录下新建`pojo`包，其中创建`User`表对应的实体类

package com.zsr.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User { 
        private Long id;
        private String name;
        private int age;
        private String email;
    }

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

## 5. 编写mapper&扫描 ##

> 在主程序同级目录下新建`mapper`包，其中新建mapper接口`UserMapper`，继承`BaseMapper`接口
> 
>  *  到此，所有的crud方法即编写完成，来源于父接口；不再需要像以前一样编写很多配置
>  *  注意使用`@Repository`注解声明为mapper（dao）层的bean，或者使用`@Mapper`注解标注
>     
>     `@Mapper`和`@Repository`的区别：https://www.cnblogs.com/yanghj/archive/2019/09/24/11580830.html
>     
>     `@Mapper`注解爆红问题：https://www.cnblogs.com/del88/p/12516969.html、
>     
>     这里建议两个注解一起使用

package com.zsr.mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.zsr.pojo.User;
    import org.apache.ibatis.annotations.Mapper;
    import org.springframework.stereotype.Repository;
    
    @Mapper
    @Repository
    public interface UserMapper extends BaseMapper<User> { 
    
    }

然后为了使我们的mapper生效，我们需要到主程序增加一个注解进行相应的扫描并识别

（其实使用了`@Repository`可以忽略这一步，为了规范，尽量写上）

//扫描mapper目录
    @MapperScan("com.zsr.mapper")

![image-20201018225723399][]

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

## 6. 测试类简单测试 ##

> 我们在springboot提供的测试类进行查询全部用户测试
> 
>  *  首先需要注入`UserMapper`对象，然后便可调用MyBatis已经封装好的的crud方法

package com.zsr;
    
    import com.zsr.mapper.UserMapper;
    import com.zsr.pojo.User;
    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 MybatisPlusApplicationTests { 
        @Autowired
        private UserMapper userMapper;
    
        //查询全部用户
        @Test
        void QueryAllUsers() { 
            //参数是一个wrapper条件构造器,这里先不用,写null
            List<User> userList = userMapper.selectList(null);
            userList.forEach(System.out::println);
        }
    }

测试运行，成功查到所有的信息  
![image-20201018232743225][]

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

## 7. 小结 ##

> 通过上述简单的几步，就可以实现 User 表的 CRUD 功能，以往的 XML 文件不再需要

*  集成`MyBatis-Plus`非常的简单，只需要引入对应的依赖，并配置 mapper 扫描路径即可
 *  `MyBatis-Plus` 的强大远不止如此，我们继续深入学习学习

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

# 三、配置日志 #

> 虽然我们已经实现了基本的CRUD功能，但是相应的sql语句是不可见的，为了看每条sql是怎么执行的，我们必须查看日志；
> 
> `MyBatis Plus`本身集成了log日志功能，我们打开即可

接下来在`application.properties`中启动`MyBatis plus`本身日志；我们也可以使用第三方的日志，但是需要导入相应的依赖

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

我们再次运行上述的查询全部用户方法，即可查看到所执行sql的相关日志信息  
![image-20201019171819660][]

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

# 四、CRUD及其拓展 #

## 1. 插入insert & 主键生成策略 ##

### 1. 测试插入 ###

> 首先在测试类添加一个方法`InsertUser`测试插入用户的功能，这里省略主键`id`的赋值

//插入用户
    @Test
    public void InsertUser() { 
        val user = new User();
        user.setName("zsr");
        user.setAge(20);
        user.setEmail("1241@qq.com");
        userMapper.insert(user);
    }

测试一下，查看日志信息，成功插入数据，且可以看到为我们自动生成了一个ID  
![image-20201019174228049][]  
刷新我们的数据表查看，可以看到新插入的数据  
![image-20201019174239431][]  
我们并没有设置主键`id`的值，但是`MyBatis Plus`自动为我们生成了一个id，这个id是如何生成的？

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

### 2. 主键生成策略 ###

> 系统唯一ID（主键）是我们在设计一个系统的时候常常会遇见的问题，生成ID的方法有很多，适应不同的场景、需求以及性能要求；有些比较复杂的系统甚至会有多个ID生成的策略
> 
> **分布式系统唯一ID生成方案汇总**：https://www.cnblogs.com/haoxinyue/p/5208136.html

在`MyBatis Plus`中，生成主键`id`的方法是 **雪花算法**，我们也可以通过`@TableId`注解设置修改使用其他的生成策略，我们看看该注解的源码

![image-20201019155035694][]  
可以看到有一个参数`type`，我们就是通过设置该参数的值`IdType`来指定ID的生成策略，查看参数值`IdType`的源码

![image-20201019155241478][]

可以发现这是一个枚举类，其中有五种方式，默认生成ID的方式是`ID_WORKER`，底层也就是通过`雪花算法`实现的  
![img][]

*  `AUTO`：数据库ID自增
 *  `NONE`：未设置主键类型（注解里等于跟随全局,全局里约等于 INPUT）
 *  `INPUT`：插入前自己设置主键的值
 *  `ID_WORKER`：分布式全局唯一ID（长整型类型）
 *  `UUID`：32位UUID字符串
 *  `ID_WORKER_STR`：分布式全局唯一ID（字符串类型）

> 接下来我们通过`@TableID`注解指定其他策略试试

#### 更改策略：主键自增AUTO ####

我们在我们实体类的主键上可以指定所需的方式，这里配置为`主键自增`方式

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User { 
        @TableId(type = IdType.AUTO)
        private Long id;
        private String name;
        private int age;
        private String email;
    }

同时要在数据库中设置主键`id`自增，然后保存。否则会报错  
![image-20201019172347538][]  
再次测试一下上述插入方法，成功插入，且新插入user的id实现了自增  
![image-20201019174414360][]  
我们可以多测试几次，可以发现每次id都+1，成功实现了主键自增功能  
![image-20201019174608111][]

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

#### 更改策略：手动输入INPUT ####

将主键id上的注解更改为

@TableId(type = IdType.INPUT)

再次测试一下插入  
![image-20201019175057199][]  
这里之所以id自增的方式插入了一个用户，是因为我们的数据表设置了主键自增

查看日志信息，发现id为null，因此我们需要手动设置id

//插入用户
    @Test
    public void InsertUser() { 
        val user = new User();
        user.setName("zsr");
        user.setAge(20);
        user.setEmail("1241@qq.com");
        user.setId(6L);
        userMapper.insert(user);
    }

再次测试，成功插入指定id用户  
![image-20201019175332712][]

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

## 2. 更新update & 自动填充功能 ##

### 1. 测试更新 ###

> 在测试类中新建一个方法，注意`updateById()`方法传入的参数为User对象

更新`id`为6的用户信息

//更新用户
    @Test
    public void updateUser() { 
        User user = new User();
        user.setId(6L);
        user.setName("gcc");
        user.setAge(18);
        userMapper.updateById(user);//传入的参数是一个对象
    }

运行该测试方法，成功更新指定用户的信息  
![image-20201019191044649][]  
总结：在`MyBatisPlus`中，所有的sql都是自动动态配置的（动态sql）

### 2. 自动填充 ###

> 数据库写入一些东西时，比如创建时间、修改时间！更新这些字段时，一般都是自动化完成的，不希望自己手动更新
> 
> 在阿里巴巴开发手册中，所有的数据库表几乎都有两个字段：`gmt_create`、`gmt_modified`；这两个字段都是自动化更新的
> 
> 接下来我们来实现一下这两个字段的自动填充

#### 方式一：数据库级别 ####

**1. 首先在数据库表`user`中新增两个字段`crate_time`、`update_time`；**

默认值都设置为`CURRENT_TIMESTAMP`，`updata_time`字段勾选**根据当前时间戳更新**，然后保存

![image-20201019192006380][]  
然后在IDEA中刷新数据表查看，添加成功  
![image-20201019192149850][]  
**2. 同步实体类，新增两个字段**

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User { 
        @TableId(type = IdType.INPUT)
        private Long id;
        private String name;
        private int age;
        private String email;
        private Date createTime;
        private Date updateTime;
    }

**3. 运行测试**

修改一下`updateUser`方法后运行测试

//更新用户
    @Test
    public void updateUser() { 
        User user = new User();
        user.setId(6L);
        user.setName("gcc");
        user.setAge(19);
        userMapper.updateById(user);//传入的参数是一个对象
    }

![image-20201019192757405][]  
可以发现出了我们更新的6号用户的`update_time`更新了，其他的用户都没有更新，这就是自动填充的实现，我们在代码中并没有设置其更新的值，而是通过修改数据表的设置在数据库级别实现自动更新

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

#### 方式二：代码级别 ####

**1. 首先删除数据表中上述两个字段的默认值以及`update_time`的更新操作**

![image-20201019193603782][]  
**2. 我们可以在实体类字段属性上添加注解`@TableField`实现自动填充，来看看该注解的源码**  
![image-20201019225011393][]  
**其中有个`fill`属性用于设置字段自动填充策略`FieldFill`，我们在看看可以设置的策略**  
![image-20201019225116241][]  
可以看到，`FiledFill`同样是个枚举类，有四种填充策略，默认是`DEFAULT`不处理

接下来我们使用该注解在字段上进行设置

*  在`createTime`时填充策略为`INSERT`：插入填充字段
 *  在`updateTime`时填充策略位`INSER_UPDATE`：插入和更新时填充字段

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User { 
        @TableId(type = IdType.AUTO)//更改为自增
        private Long id;
        private String name;
        private int age;
        private String email;
        //字段添加填充内容
        @TableField(fill = FieldFill.INSERT)
        private Date createTime;
        @TableField(fill = FieldFill.INSERT_UPDATE)
        private Date updateTime;
    }

**3. 编写自动填充处理器处理这个注解**

> 在主程序同级目录下新建`handler`包，其中创建自己的处理器`MyMetaObjectHandler`类，继承`MetaObjectHandler`接口，重写其方法

package com.zsr.handler;
    
    import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.ibatis.reflection.MetaObject;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    
    @Slf4j
    @Component//放置IOC容器中
    public class MyMetaObjectHandler implements MetaObjectHandler { 
        //插入时的填充策略
        @Override
        public void insertFill(MetaObject metaObject) { 
            log.info("开始插入填充...");
            //在插入时填充`crateTime`和`updateTime`字段
            this.setFieldValByName("createTime", new Date(), metaObject);
            this.setFieldValByName("updateTime", new Date(), metaObject);
        }
    
        //更新时的填充策略
        @Override
        public void updateFill(MetaObject metaObject) { 
            //在更新时填充`updateTime`字段
            this.setFieldValByName("updateTime", new Date(), metaObject);
        }
    }

**4. 运行测试**

首选运行插入方法`InsertUser`

//插入用户
    @Test
    public void InsertUser() { 
        User user = new User();
        user.setName("zsr");
        user.setAge(20);
        user.setEmail("1241@qq.com");
        userMapper.insert(user);
    }

运行后可以发现新插入的用户两个时间与其他不同，实现了自动填充更新  
![image-20201024084505316][]  
然后我们update一下新插入的用户试试

//更新用户
    @Test
    public void updateUser() { 
        User user = new User();
        user.setId(1318125068800643078l);
        user.setName("gcc");
        user.setAge(19);
        userMapper.updateById(user);//传入的参数是一个对象
    }

运行完可以看到`update_time`成功更新  
![image-20201019231523032][]

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

## 3. 查询select & 分页查询插件 ##

### 1. 测试查询 ###

1、通过id查询用户

//查询指定用户
    @Test
    public void selectUserByID() { 
        User user = userMapper.selectById(3l);
        System.out.println(user);
    }

![image-20201021183611857][]

2、查询批量用户

//批量查询用户
    @Test
    public void selectUserByBatchID() { 
        List<User> users = userMapper.selectBatchIds(Arrays.asList(4, 5, 6, 7, 8));//参数为列表集合
        System.out.println(users);
    }

![image-20201021183946220][]

3、条件查询

//条件查询
    @Test
    public void selectUserWithCondition() { 
        HashMap<String, Object> map = new HashMap<>();
        //自定义查询条件
        map.put("name", "gcc");
        List<User> users = userMapper.selectByMap(map);
        System.out.println(users);
    }

![image-20201021184507544][]

### 2. 分页查询 ###

> **在MyBatisPlus内部内置了分页插件，我们稍加配置即可使用**

**1、配置拦截器组件**

> 在主程序同级目录下新建`config`包，其中新建`MyBatisConfig`，其中配置分页插件
> 
> 同时将扫描包注解`@MapperScan("com.zsr.mapper")`从我们主程序转移到该配置类，更加规范

package com.zsr.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;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    @MapperScan("com.zsr.mapper")//扫描mapper目录
    @EnableTransactionManagement//自动管理事务
    @Configuration//配置类
    public class MyBatisConfig { 
        //分页插件
        @Bean
        public PaginationInterceptor paginationInterceptor() { 
            return new PaginationInterceptor();
        }
    
    }

**2、直接使用page对象进行分页操作**

> 在测试类中测试分页查询

//测试分页查询
    @Test
    public void queryByPage() { 
        Page<User> userPage = new Page<>(1, 5);//第一个参数为当前页,第二个参数为页面大小
        userMapper.selectPage(userPage, null);//需要传入page对象和wrapper(这里设置为null)
        userPage.getRecords().forEach(System.out::println);
    }

![image-20201021201643432][]  
成功查出1~5号用户，同时可以发现本质还是使用`limit`进行分页

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

## 4. 删除delete & 逻辑删除 ##

### 1. 测试删除 ###

1、删除指定id用户

//删除指定用户
    @Test
    public void deleteByID() { 
        userMapper.deleteById(1318125068800643078l);
    }

运行测试成功删除  
![image-20201021202452534][]

2、批量删除

//批量删除
    @Test
    public void deleteByBatchID() { 
        userMapper.deleteBatchIds(Arrays.asList(1318125068800643077l,1318125068800643076l));
    }

运行后结果：  
![image-20201021202555748][]  
3、条件删除

//条件删除
    @Test
    public void deleteByCondition() { 
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "zsr");//自定义条件:删除所有name为zsr的
        userMapper.deleteByMap(map);
    }

运行后结果：  
![image-20201021203120567][]

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

### 2. 逻辑删除 ###

> `物理删除`：从数据库中直接移除
> 
> `逻辑删除`：数据库中没有移除，而是通过一个变量来让其失效（delete=0 —> delete=1）

**1、在数据表中增加一个`deleted`字段**  
![image-20201021233040471][]  
**2、同步pojo实体类**

> 用`@TableLogic`注解标名这是逻辑删除子u按

@TableLogic//逻辑删除
    private int deleted;

**3、配置逻辑删除组件**

> 首先在`MyBatisConfig`中配置组件，然后再`application.properties`添加相应的配置

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

在springboot配置文件中配置：

*  已删除`deleted`=1
 *  未删除`deleted`=0

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

**4、测试**

//删除1号用户
    @Test
    public void deleteByID() { 
        userMapper.deleteById(1l);
    }

运行该删除方法，查看日志信息  
![image-20201021233839855][]  
可以看到，我们执行的删除方法本质上是更新操作，更新了`deleted`的值，刷新user表看看  
![image-20201021233946382][]  
可以看到1号用户并没有删除，记录仍在数据库，只是`deleted`变为1，代表已删除

我们查询所有用户试试

//查询全部用户
    @Test
    public void QueryAllUsers() { 
        //参数是一个wrapper条件构造器,这里先不用,写null
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }

运行查看日志信息  
![image-20201021234329800][]  
可以看到，查询的时候带了条件`deleted`=0，即未删除的用户才能被查询到；自动过滤被逻辑删除的字段，所以我们查询不到用户1，因为已经逻辑删除

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

# 五、乐观锁插件 #

> `乐观锁`：故名思意十分乐观，它总是认为不会出现问题，无论干什么不去上锁！如果出现了问题，再次更新值测试
> 
> `悲观锁`：故名思意十分悲观，它总是认为总是出现问题，无论干什么都会上锁！再去操作！  
> ![image-20201022214435765][]

## 1. 实现方式 ##

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

-- A 先查询，获得版本号 version = 1 
    update user set name = "zsr", version = version + 1 
    where id = 2 and version = 1
    
    -- B 如果此时B线程抢先完成，这个时候 version = 2，会导致 A 修改失败！ 
    update user set name = "zsr", version = version + 1 
    where id = 2 and version = 1

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

## 2. 测试乐观锁插件 ##

### 1、添加version字段 ###

首先给数据库表添加一个`version`字段，设置默认值为1  
![image-20201020232631141][]  
查看是否添加成功  
![image-20201020233231809][]

### 2、同步实体类 ###

> 添加`version`字段，注意添加`@version`注解

@Version//代表这是一个乐观锁
    private int version;

### 3、注册乐观锁组件 ###

> 再`MyBatisConfig`中注册乐观锁插件

//注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() { 
        return new OptimisticLockerInterceptor();
    }

### 4、测试 ###

> 我们去测试类测试一下，分别测试乐观锁成功和失败的两种情况

**1、首先测试单线程对用户进行修改的情况**

//测试单线程修改
    @Test
    public void TestOptimisticLocker_success() { 
        //获取用户
        User user = userMapper.selectById(1L);
        //修改用户信息
        user.setName("new zsr");
        user.setEmail("1234@qq.com");
        //执行更新操作
        userMapper.updateById(user);
    }

运行测试一下，修改成功信息，查看打印的日志  
![image-20201021181635523][]  
可以看到，第一次的查询和第二次的更新操作的sql语句都附加了`version`信息，第一次查出来version为1，更新操作时，version+1更改为2，这就是乐观锁的作用，修改成功  
![image-20201021182019363][]  
**2、再测试两个线程都对用户进行修改的情况**

//测试多线程修改
    @Test
    public void TestOptimisticLocker_fail() { 
        //线程1,设置了值但未修改
        User user1 = userMapper.selectById(1L);
        user1.setName("zsr1");
        user1.setEmail("1234@qq.com");
    
        //线程2,设置了值且更新
        User user2 = userMapper.selectById(1L);
        user2.setName("zsr2");
        user2.setEmail("4567@qq.com");
        userMapper.updateById(user2);
    
        //线程1进行更新:如果没有乐观锁就会覆盖线程2设置的值
        userMapper.updateById(user1);
    }

运行测试一下，查看日志信息，可以看到线程2的更新操作成功了，线程1并未成功，这是因为线程2更新前，`version`的值为2，更新后变为3，但是线程1最后的更新操作的附加条件`version`仍未2，与当下`version`不同，所以更新失败  
![image-20201021182652191][]  
同时可以查看user表，最终结果是线程2修改的结果  
![image-20201021182856717][]

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

# 六、性能分析插件 #

> 开发过程中，会遇到一些慢sql，**我们通常需要将其提取出来并进行相应的优化，优化查询效率；**
> 
> MyBatisPlus就提供了一个性能分析插件：性能分析拦截器
> 
>  *  作用：用于输出每条SQL语句执行的时间，如果sql语句的时间超过我们指定的时间，就可以停止运行

## 1. 导入插件 ##

> 在`MyBatisConfig`中添加组件

//性能分析插件
    @Bean
    @Profile({ "dev","test"})// 设置 dev test 环境开启
    public PerformanceInterceptor performanceInterceptor() { 
        return new PerformanceInterceptor();
    }

## 2. 配置开发环境 ##

> 在springboot配置文件中设置开发环境

#设置开发环境
    spring.profiles.active=dev

## 3. 配置插件 ##

> 在上述组件方法`performanceInterceptor()`中添加自己的配置

//性能分析插件
    @Bean
    @Profile({ "dev", "test"})// 设置 dev test 环境开启
    public PerformanceInterceptor performanceInterceptor() { 
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(1);//设置sql执行的最大时间,如果超过了该时间则不执行,以ms为单位
        performanceInterceptor.setFormat(true);//设置sql格式化
        return performanceInterceptor;
    }

## 4. 测试 ##

> 测试一下查询全部用户

运行测试，可以看到sql语句格式化的效果  
![image-20201022001009902][]  
发现报错了，我们可以看到sql执行的时间为**63ms**，超过我们设定的时间**1ms**，所以报错  
![image-20201022001230532][]  
我们修改一下，将sql执行的最大时间更改为**100ms**，在进行测试  
![image-20201022001404031][]  
即可成功运行  
![image-20201022001459649][]

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

# 七、条件构造器 #

![image-20201022002058305][]

## 1. 条件查询 ##

> 一、简单条件运算符
> 
>  *  `eq`：等于 =
>  *  `ne`：不等于 <>
>  *  `gt`：大于 >
>  *  `ge`：大于等于 >=
>  *  `lt`：小于 <
>  *  `le`：小于等于 <=
> 
> 二、逻辑运算符
> 
>  *  `or`：拼接or
>  *  `and`：
>  *  `nest`
> 
> 三、模糊查询
> 
>  *  `between`：between 值1 and 值2
>  *  `notbetween`：notbetween 值1 and 值2
>  *  `like`：like ‘%值%’
>  *  `not like`：notlike ‘%值%’
>  *  `likeLeft`：like ‘%值’
>  *  `likeRight`：like ‘值%’
>  *  `isNull`：字段为空
>  *  `isNotNull`：字段不为空
>  *  `in`：字段 in（value1，value2 …）
>  *  `notIn`：字段 notIn（value1，value2 …）

**1、查询name不为空,邮箱不为空且年龄>=20的用户**

//查询name不为空,邮箱不为空且年龄>=20的用户
    @Test
    public void test1() { 
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //链式编程
        wrapper.isNotNull("name").isNotNull("email").ge("age", 20);
        userMapper.selectList(wrapper).forEach(System.out::println);
    }

运行测试，查看输入信息，可以发现附加了我们所需的条件语句  
![image-20201022003151367][]

**2、查询年龄小于20或大于25的用户**

//查询年龄小于20或大于25的用户
    @Test
    public void test2() { 
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //链式编程
        wrapper.lt("age", 20).or().gt("age", 25);
        userMapper.selectObjs(wrapper);
    }

![image-20201022225552068][]  
**3、查询年龄介于20~30之间的用户**

//查询年龄介于20~30之间的用户
    @Test
    public void test3() { 
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //链式编程
        wrapper.between("age", 20, 30);
        userMapper.selectCount(wrapper);//返回结果数
    }

![image-20201022170829617][]

**4、查询名字中不包含e的,且邮箱以t开头的**

//查询名字中不包含e的,且邮箱以t开头的
    @Test
    public void test4() { 
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //链式编程
        wrapper
                .notLike("name", "e")
                .likeRight("email", "t");//相当于右边加一个百分号:t%
        userMapper.selectMaps(wrapper);
    }

![image-20201022171438794][]

## 2. 子查询 ##

>  *  `inSql`：字段 in（sql语句）
>  *  `notInSql`：字段 notIn（sql语句）

//子查询
    @Test
    public void test5() { 
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //链式编程
        wrapper.inSql("id", "select id from user where id<3");
        userMapper.selectObjs(wrapper);
    }

![image-20201022172012747][]

## 3. 分组查询 ##

>  *  `groupBy`：group by 字段,…
>  *  `having`：having（sql语句）

**1、根据不同的更新时间进行分组**

//根据update_time分组查询
    @Test
    public void test9() { 
        QueryWrapper<User> wra pper = new QueryWrapper<>();
        //链式编程
        wrapper.select("count(*)","update_time").groupBy("update_time");
        userMapper.selectObjs(wrapper);
    }

![image-20201022232412124][]

## 4. 排序查询 ##

>  *  `orderByAsc`：order by 字段,… asc
>  *  `orderByDesc`：order by 字段,… desc

**1、按id降序排序查询**

//按id降序排序查询
    @Test
    public void test6() { 
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //链式编程
        wrapper.orderByDesc("id");//id降序排序
        userMapper.selectObjs(wrapper);
    }

![image-20201022172330795][]  
**2、按id降序升序查询**

//按id降序排序查询
    @Test
    public void test7() { 
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //链式编程
        wrapper.orderByAsc("id");//id降序排序
        userMapper.selectObjs(wrapper);
    }

![image-20201022222331127][]

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

# 八、代码自动生成器 #

> `AutoGenerator` 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、 Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
> 
> **代码生成器配置文档**：[https://mybatis.plus/config/generator-config.html\#%E5%9F%BA%E6%9C%AC%E9%85%8D%E7%BD%AE][https_mybatis.plus_config_generator-config.html_E5_9F_BA_E6_9C_AC_E9_85_8D_E7_BD_AE]

**模板配置**：其余的可以根据[官方配置文档][https_mybatis.plus_config_generator-config.html_E5_9F_BA_E6_9C_AC_E9_85_8D_E7_BD_AE]自定配置

package com.zsr;
    
    import com.baomidou.mybatisplus.annotation.DbType;
    import com.baomidou.mybatisplus.annotation.FieldFill;
    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.po.TableFill;
    import com.baomidou.mybatisplus.generator.config.rules.DateType;
    import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
    
    import java.util.ArrayList;
    
    // 代码自动生成器
    public class CodeAutoGenerate { 
        public static void main(String[] args) { 
            //需要构建一个代码自动生成器对象
            AutoGenerator generator = new AutoGenerator();
    
            //配置策略
    
            //1.全局配置
            GlobalConfig gc = new GlobalConfig();
            String projectPath = System.getProperty("user.dir");//获取当前项目路径
            gc.setOutputDir(projectPath + "/src/main/java");//设置代码的生成目录
            gc.setAuthor("zsr");//设置作者名
            gc.setOpen(false);//设置是否打开资源管理器
            gc.setFileOverride(false); //是否覆盖原来生成的代码
            gc.setServiceName("%sService"); //去Service的I前缀
            gc.setIdType(IdType.ID_WORKER);//设置主键生成策略
            gc.setDateType(DateType.ONLY_DATE);//设置日期类型
            gc.setSwagger2(true);//设置自动配置swagger文档
            //将全局配置装入自动代码生成器
            generator.setGlobalConfig(gc);
    
            //2.数据源配置
            DataSourceConfig dsc = new DataSourceConfig();
            dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC");
            dsc.setDriverName("com.mysql.cj.jdbc.Driver");
            dsc.setUsername("root");
            dsc.setPassword("200024");
            dsc.setDbType(DbType.MYSQL);
            //将数据源配置装入自动代码生成器
            generator.setDataSource(dsc);
    
            //3.包的配置
            PackageConfig pc = new PackageConfig();
            pc.setModuleName("blog");//设置模块名
            pc.setParent("com.zsr");//设置放置的包名
            pc.setEntity("pojo");//pojo层包名
            pc.setMapper("mapper");//mapper层包名
            pc.setService("service");//service层包名
            pc.setController("controller");//controller层包名
            //将包配置装入自动代码生成器
            generator.setPackageInfo(pc);
    
            //4.策略配置
            StrategyConfig strategy = new StrategyConfig();
            strategy.setInclude("user"); //设置要映射的数据表名
            strategy.setNaming(NamingStrategy.underline_to_camel);//设置包命名的规则:下划线转驼峰命名
            strategy.setColumnNaming(NamingStrategy.underline_to_camel);//设置数据库字段命名规则
            strategy.setEntityLombokModel(true); //开启自动生成lombok
            strategy.setLogicDeleteFieldName("deleted");//设置逻辑删除字段名
            //自动填充配置
            TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);//创建时间
            TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT_UPDATE);//修改时间
            ArrayList<TableFill> tableFills = new ArrayList<>();//自动填充策略集
            tableFills.add(gmtCreate);
            tableFills.add(gmtModified);
            strategy.setTableFillList(tableFills);//设置自动填充策略
    
            //乐观锁
            strategy.setVersionFieldName("version");
            strategy.setRestControllerStyle(true);//开启restful驼峰命名格式
            strategy.setControllerMappingHyphenStyle(true);//设置请求链接格式,例如localhost:8080/hello_id_2
            generator.setStrategy(strategy);//设置乐观锁策略
    
            //执行代码构造器
            generator.execute();
        }
    }

[https_mybatis.plus]: https://mybatis.plus/
[image-20201022181852363]: /images/20221122/e2fcb26acf904473b633c0e904e74aa9.png
[image-20201018174550363]: /images/20221122/06e411769d29417f9a2223d897e62325.png
[image-20201018174952281]: https://gitee.com/zhong_siru/images/raw/master//img/image-20201018174952281.png
[image-20201018181216802]: /images/20221122/12ea0e1321194df688ccf730f37d4561.png
[image-20201018225723399]: https://gitee.com/zhong_siru/images/raw/master//img/image-20201018225723399.png
[image-20201018232743225]: /images/20221122/52e85683f55347239f5ab2c4557b539f.png
[image-20201019171819660]: /images/20221122/628d90cc39904205bb83c243e9bd352a.png
[image-20201019174228049]: /images/20221122/294307981f504dcabe139d203491c650.png
[image-20201019174239431]: /images/20221122/804a1f8d4a01497eb4b612d4f10a84f7.png
[image-20201019155035694]: /images/20221122/8c4e3beb1ffa4957be5b0c2a348369a9.png
[image-20201019155241478]: https://gitee.com/zhong_siru/images/raw/master//img/image-20201019155241478.png
[img]: /images/20221122/8a95cbc6978c49e4832176928c388f63.png
[image-20201019172347538]: /images/20221122/a48ee03e298e4ceeacbf6c283271cc67.png
[image-20201019174414360]: /images/20221122/1974bfc224184cd487cdea106a6edb15.png
[image-20201019174608111]: /images/20221122/01a2496b29de44529a162fb7eb8955aa.png
[image-20201019175057199]: /images/20221122/139dc377e55c4b58808c5615814ea0fd.png
[image-20201019175332712]: /images/20221122/0533d9ce000b41e5b0095924a5641b2a.png
[image-20201019191044649]: /images/20221122/17eb57a6cf9c470186153d1bfcc5789a.png
[image-20201019192006380]: /images/20221122/5166778b3267405a8da4b334d450006b.png
[image-20201019192149850]: /images/20221122/94bba434e0d243389e08df2d4f6bfb0b.png
[image-20201019192757405]: /images/20221122/22b8fd961e8e4016bfdcf41873998b37.png
[image-20201019193603782]: /images/20221122/5597ba9750854461b235395a95449479.png
[image-20201019225011393]: /images/20221122/8d6f19ee7a724525bdecb9d3080d8d1b.png
[image-20201019225116241]: https://gitee.com/zhong_siru/images/raw/master//img/image-20201019225116241.png
[image-20201024084505316]: /images/20221122/1d7e55619b784e2ab2aad8db784c4bbd.png
[image-20201019231523032]: /images/20221122/fdccfa1fe3ec4102aa70205d8adb8177.png
[image-20201021183611857]: /images/20221122/a2f3608010d44d048b8548fd31b3d479.png
[image-20201021183946220]: /images/20221122/eac9a16fb7a7473dabd06b01adaa6b0f.png
[image-20201021184507544]: /images/20221122/d28ebe8f1c764e27ab96f1285dafb9ef.png
[image-20201021201643432]: /images/20221122/dbb66bc8cccb4cdc8de2a7b620fc966a.png
[image-20201021202452534]: /images/20221122/fc6fa7aad6484faf9ad9bdd2dde912dd.png
[image-20201021202555748]: /images/20221122/aa9aea21a3e9440c80ca01ff7c5aa153.png
[image-20201021203120567]: /images/20221122/35371204906f48998922d5072380683f.png
[image-20201021233040471]: /images/20221122/56de0f5a5920475b9e40f555cd717333.png
[image-20201021233839855]: /images/20221122/b6b915b1df9245478e331ceb5bc9e55b.png
[image-20201021233946382]: /images/20221122/a907641b5f464cefa21e8072aca28ebe.png
[image-20201021234329800]: /images/20221122/60314886988b41889e0543b22f792a58.png
[image-20201022214435765]: /images/20221122/f50bd1f47b3f49139fc76c730c0da340.png
[image-20201020232631141]: /images/20221122/a720646b31a44ac5b4367c7b08708f0d.png
[image-20201020233231809]: /images/20221122/2307462071364c1d95b6114a4c35e8cb.png
[image-20201021181635523]: /images/20221122/fbc4c9f8a7e347f093d316b07c487172.png
[image-20201021182019363]: /images/20221122/0f93199e6bec430d9ec4fcea4f9ef9f2.png
[image-20201021182652191]: /images/20221122/4438595d7bb84ab19b2b8655718fc1c9.png
[image-20201021182856717]: /images/20221122/e8386c600594415280888bbba89f9191.png
[image-20201022001009902]: /images/20221122/b9541618ef08489eb802295d2fe933cc.png
[image-20201022001230532]: /images/20221122/46e3b26d6ab147f8a7882498f13633d9.png
[image-20201022001404031]: /images/20221122/1e69979971da4203a935ed0c314ff35d.png
[image-20201022001459649]: /images/20221122/9fd0e785b1f847789e4d841737684f5a.png
[image-20201022002058305]: /images/20221122/fae61a2d200f49258dac7ba2009da933.png
[image-20201022003151367]: /images/20221122/f853f4b2c2f14a11a7ab4c9dd6d9bed8.png
[image-20201022225552068]: /images/20221122/20c57485d70b4c01bf0cd7ce26dba853.png
[image-20201022170829617]: https://gitee.com/zhong_siru/images/raw/master//img/image-20201022170829617.png
[image-20201022171438794]: /images/20221122/c84c284373d04443ba18d31d3e6cc011.png
[image-20201022172012747]: /images/20221122/17142c82d7ce42de943999257780594a.png
[image-20201022232412124]: /images/20221122/75fc754f7921435492a2e7294613f4b0.png
[image-20201022172330795]: /images/20221122/adaf03b7993f45b69c91e098c703c6c2.png
[image-20201022222331127]: /images/20221122/8b79a575faed4ef18efd9cd012fdf524.png
[https_mybatis.plus_config_generator-config.html_E5_9F_BA_E6_9C_AC_E9_85_8D_E7_BD_AE]: https://mybatis.plus/config/generator-config.html#%E5%9F%BA%E6%9C%AC%E9%85%8D%E7%BD%AE