【Mybatis Plus】之 CRUD 实战
燕博文
一、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/
二、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>
<!-- starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- test -->
<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>
<!-- lombok用来简化实体类 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- mybatis-plus -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.0.5</version>
</dependency>
<!-- mysql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- junit -->
<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 使用了 com.mysql.cj.jdbc.Driver ，在 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
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
(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
类似资料：