springboot整合mybatis-plus看这篇文章就足够了
目录
什么是mybatis-plus
特点
框架结构
引入依赖
代码生成器
使用mybatis自带的方法进行增删改查
条件构造
分页插件
逻辑删除
通用枚举类
自动填充功能
乐观锁
总结
什么是mybatis-plus
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
特点
- 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
- 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
- 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
- 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
- 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
- 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
- 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
- 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
- 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
- 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
- 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
- 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
框架结构
引入依赖
springboot
maven：
com.baomidou
mybatis-plus-boot-starter
3.3.1.tmp
gradle：
compile group: 'com.baomidou', name: 'mybatis-plus-boot-starter', version: '3.3.1.tmp'springmvc
maven：
com.baomidou
mybatis-plus
3.3.1.tmp
gradle：
compile group: 'com.baomidou', name: 'mybatis-plus', version: '3.3.1.tmp'
代码生成器
代码生成器可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
还没有试用代码生成器之前的项目结构：
数据库设置
1.新建数据库：test
2.新建数据表：users，数据表结构如下：
代码开发
引入依赖，这里我一maven为例，gradle可以搜索相关依赖：
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.2.5.RELEASE
com.ymy
springboot-mybatis-plus
0.0.1-SNAPSHOT
springboot-mybatis-plus
Demo project for Spring Boot
1.8
org.springframework.boot
spring-boot-starter-web
mysql
mysql-connector-java
runtime
com.baomidou
mybatis-plus-boot-starter
3.3.1.tmp
org.projectlombok
lombok
true
com.baomidou
mybatis-plus-boot-starter
3.3.1.tmp
com.baomidou
mybatis-plus-generator
3.3.1.tmp
org.apache.velocity
velocity-engine-core
2.2
org.freemarker
freemarker
2.3.30
org.springframework.boot
spring-boot-starter-test
test
org.junit.vintage
junit-vintage-engine
org.springframework.boot
spring-boot-maven-plugin
CodeGenerator代码生成器类：
package com.ymy.config;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import java.util.ArrayList;
import java.util.List;
public class CodeGenerator {
public static void main(String[] args) {
// 代码生成器
AutoGenerator mpg = new AutoGenerator();
// 全局配置
GlobalConfig gc = new GlobalConfig();
String projectPath = System.getProperty("user.dir");
gc.setOutputDir("F:\\demo\\springboot-mybatis-plus\\src\\main\\java");
gc.setAuthor("yaomaoyang");
gc.setOpen(false);
// gc.setSwagger2(true); 实体属性 Swagger2 注解
mpg.setGlobalConfig(gc);
// 数据源配置
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:mysql://127.0.0.1:33306/test?useUnicode=true&useSSL=false&characterEncoding=utf8");
// dsc.setSchemaName("public");
dsc.setDriverName("com.mysql.cj.jdbc.Driver");
dsc.setUsername("root");
dsc.setPassword("root");
mpg.setDataSource(dsc);
// 包配置
PackageConfig pc = new PackageConfig();
//pc.setModuleName(scanner("模块名"));
pc.setParent("com.ymy");
mpg.setPackageInfo(pc);
// 自定义配置
// InjectionConfig cfg = new InjectionConfig() {
// @Override
// public void initMap() {
// Map map = new HashMap<>();
// map.put("abc", this.getConfig().getGlobalConfig().getAuthor() + "-mp");
// this.setMap(map);
// }
// };
// 如果模板引擎是 freemarker
String templatePath = "/templates/mapper.xml.ftl";
// 如果模板引擎是 velocity
// String templatePath = "/templates/mapper.xml.vm";
// 自定义输出配置
List focList = new ArrayList<>();
// 自定义配置会被优先输出
focList.add(new FileOutConfig(templatePath) {
@Override
public String outputFile(TableInfo tableInfo) {
// 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
+ "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
}
});
// cfg.setFileCreate(new IFileCreate() {
// @Override
// public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
// // 判断自定义文件夹是否需要创建
// checkDir("调用默认方法创建的目录");
// return false;
// }
// });
// cfg.setFileOutConfigList(focList);
// mpg.setCfg(cfg);
// 配置模板
TemplateConfig templateConfig = new TemplateConfig();
// 配置自定义输出模板
//指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
// templateConfig.setEntity("templates/entity2.java");
// templateConfig.setService();
// templateConfig.setController();
templateConfig.setXml(null);
mpg.setTemplate(templateConfig);
// 策略配置
StrategyConfig strategy = new StrategyConfig();
strategy.setNaming(NamingStrategy.underline_to_camel);
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
//strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
strategy.setEntityLombokModel(true);
strategy.setRestControllerStyle(true);
// 公共父类
// strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
// 写于父类中的公共字段
//strategy.setSuperEntityColumns("id");
strategy.setInclude("users");//表名
strategy.setControllerMappingHyphenStyle(true);
strategy.setTablePrefix(pc.getModuleName() + "_");
mpg.setStrategy(strategy);
mpg.setTemplateEngine(new FreemarkerTemplateEngine());
mpg.execute();
}
}
运行main方法：
10:01:54.232 [main] DEBUG com.baomidou.mybatisplus.generator.AutoGenerator - ==========================准备生成文件...==========================
10:01:54.719 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 创建目录： [F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\entity]
10:01:54.719 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 创建目录： [F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\controller]
10:01:54.720 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 创建目录： [F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\service]
10:01:54.721 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 创建目录： [F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\mapper]
10:01:54.721 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 创建目录： [F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\service\impl]
10:01:54.992 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 模板:/templates/entity.java.ftl; 文件:F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\entity\Users.java
10:01:55.010 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 模板:/templates/mapper.java.ftl; 文件:F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\mapper\UsersMapper.java
10:01:55.016 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 模板:/templates/service.java.ftl; 文件:F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\service\IUsersService.java
10:01:55.026 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 模板:/templates/serviceImpl.java.ftl; 文件:F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\service\impl\UsersServiceImpl.java
10:01:55.034 [main] DEBUG com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine - 模板:/templates/controller.java.ftl; 文件:F:\demo\springboot-mybatis-plus\src\main\java\com\ymy\controller\UsersController.java
10:01:55.034 [main] DEBUG com.baomidou.mybatisplus.generator.AutoGenerator - ==========================文件生成完成！！！==========================
Process finished with exit code 0看到上面的标志表示代码已经生成完毕，项目目录结构如下：
由于后续的开发我都将采用注解的形式，所以我这里并没有生成xml文件，如果你想生成xml文件，可以设置这个文件：
templateConfig.setXml(null);使用mybatis自带的方法进行增删改查
数据源配置
打开application.yml配置文件
spring:
datasource:
url: jdbc:mysql://127.0.0.1:33306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true&allowMultiQueries=true
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: root注意： driver-class-name 这个参数值回会根据mysql驱动的版本变动而变动。
mysql
mysql-connector-java
runtime
如果mysql-connector-java版本大于6.0，那么使用：com.mysql.cj.jdbc.Driver，否则：com.mysql.jdbc.Driver，这点需要特别注意。
1.新增
由于新增操作时针对对象操作，所以我对Users，请看代码：
如果你引入了@Builder这种建造者模式，那么Users对象将不能使用new进行实例化，如果想支持建造者和new两种创建实例的方式，那么需要引入两个注解：@NoArgsConstructor（无参构造）、@AllArgsConstructor（有参构造，这个看情况）。
这里还需要注意一点，u_sex、deleted两个字段类型为tinyint(1)，使用代码生成器生成的实体类Users中与他们对应的类型是：boolean，所以这里最好将他们修改为Integer。
新增测试类：MybatisPlusTest.java
package com.ymy;
import com.ymy.entity.Users;
import com.ymy.service.IUsersService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.time.LocalDateTime;
@SpringBootTest
@Slf4j
public class MybatisPlusTest {
@Autowired
private IUsersService usersService;
/**
* 插入操作（使用mybatis-plus自带方法）
*/
@Test
public void add(){
//初始化实例并赋值
Users user = Users.builder().uName("张三").uMail("[email protected]")
.uPassword("123456").uPhone("15000000000")
.createTime(LocalDateTime.now()).uSex(1).deleted(0).build();
//插入
boolean save = usersService.save(user);
log.info("保存返回的结果：{}",save);
}
}
运行add方法：
数据库：
查询
由于查询会涉及到列表，刚刚直插入了一条，这里我在数据库手动添加了3条数据：
查询代码：
/**
* 查询操作（使用mybatis-plus自带方法）
*/
@Test
public void select(){
//查询整张表
List list = usersService.list();
log.info("查询整张表的数据结果：{}",list);
//通过用户id查询用户
Users user = usersService.getById(1);
log.info("通过用户id查询数据结果：{}",user);
} 查询结果：
2020-03-10 10:54:39.790 INFO 56092 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2020-03-10 10:54:40.011 INFO 56092 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2020-03-10 10:54:40.059 INFO 56092 --- [ main] com.ymy.MybatisPlusTest : 查询整张表的数据结果：[Users(id=1, uName=张三, uPassword=123456, [email protected], uPhone=15000000000, uSex=1, createTime=2020-03-10T02:44:15, deleted=0), Users(id=2, uName=李四, uPassword=123456, [email protected], uPhone=15111111111, uSex=1, createTime=2020-03-10T02:44:15, deleted=0), Users(id=3, uName=王五, uPassword=123456, [email protected], uPhone=15222222222, uSex=1, createTime=2020-03-10T10:48:07, deleted=0), Users(id=4, uName=赵六, uPassword=123456, [email protected], uPhone=15333333333, uSex=1, createTime=2020-03-10T10:48:34, deleted=0)]
2020-03-10 10:54:40.067 INFO 56092 --- [ main] com.ymy.MybatisPlusTest : 通过用户id查询数据结果：Users(id=1, uName=张三, uPassword=123456, [email protected], uPhone=15000000000, uSex=1, createTime=2020-03-10T02:44:15, deleted=0)修改操作
/**
* 修改操作（使用mybatis-plus自带方法）
*/
@Test
public void update(){
Users user = Users.builder().id(1).uName("张三").uMail("[email protected]")
.uPassword("123123").uPhone("15000000000")
.createTime(LocalDateTime.now()).uSex(1).deleted(0).build();
//通过id修改数据
boolean flag = usersService.updateById(user);
log.info("根据id修改数据返回的结果：{}",flag);
}
删除操作
/**
* 删除操作（使用mybatis-plus自带方法）
*/
@Test
public void remove(){
//通过id删除记录
boolean flag = usersService.removeById(4);
log.info("根据id修改数据返回的结果：{}",flag);
}
条件构造
条件构造可以让sql变得更加的灵活，不用写代码也可以操作多条件的sql语句，下面我们一起来看看条件构造的使用方式：
AbstractWrapper
QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件注意: entity 生成的 where 条件与 使用各个 api 生成的 where 条件没有任何关联行为
请看代码实例：
/**
* 条件构造
*/
@Test
public void conditionalConstruct(){
//通过用户名和性别查询用户信息
QueryWrapper usersQueryWrapper = new QueryWrapper()
.eq("u_name","张三")//姓名
.eq("u_sex",1);//性别
List users = usersService.list(usersQueryWrapper);
log.info("根据用户名和性别查询的结果：{}",users);
//将用户名为张三并且性别为男的用户的密码设置为999999
UpdateWrapper updateWrapper = new UpdateWrapper()
.eq("u_name","张三")//姓名
.eq("u_sex",1)
.set("u_password","999999");//将密码设置为999999
boolean update = usersService.update(updateWrapper);
log.info("将用户名为张三并且性别为男的用户的密码设置为999999的返回结果：{}",update);
//通过对象类的实行修改
UpdateWrapper updateEntity = new UpdateWrapper()
.eq("u_name","张三")//姓名
.eq("u_sex",1);
Users users1 = new Users();
users1.setUPassword("999999");
boolean update1 = usersService.update(users1, updateEntity);
log.info("通过对象类的实行修改返回的结果：{}",update1);
//删除用户名为王五并且性别为1的用户
UpdateWrapper deleteUser = new UpdateWrapper()
.eq("u_name","王五")//姓名
.eq("u_sex",1);
boolean remove = usersService.remove(deleteUser);
log.info("删除用户名为王五并且性别为1的用户返回结果：{}",remove);
//lambda表达式查询 查询用户名为zhangsan的用户
LambdaQueryWrapper lambdaWrapper = new QueryWrapper().lambda().eq(Users::getUName, "张三");
List lambdaUsers = usersService.list(lambdaWrapper);
log.info("lambda表达式查询 查询用户名为zhangsan的用户返回结果：{}",lambdaUsers);
} 2020-03-10 11:25:36.666 INFO 78972 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2020-03-10 11:25:36.901 INFO 78972 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2020-03-10 11:25:36.945 INFO 78972 --- [ main] com.ymy.MybatisPlusTest : 根据用户名和性别查询的结果：[Users(id=1, uName=张三, uPassword=123123, [email protected], uPhone=15000000000, uSex=1, createTime=2020-03-10T02:58:19, deleted=0)]
2020-03-10 11:25:36.966 INFO 78972 --- [ main] com.ymy.MybatisPlusTest : 将用户名为张三并且性别为男的用户的密码设置为999999的返回结果：true
2020-03-10 11:25:36.982 INFO 78972 --- [ main] com.ymy.MybatisPlusTest : 通过对象类的实行修改返回的结果：true
2020-03-10 11:25:36.998 INFO 78972 --- [ main] com.ymy.MybatisPlusTest : 删除用户名为王五并且性别为1的用户返回结果：true
2020-03-10 11:25:37.019 INFO 78972 --- [ main] com.ymy.MybatisPlusTest : lambda表达式查询 查询用户名为zhangsan的用户返回结果：[Users(id=1, uName=张三, uPassword=999999, [email protected], uPhone=15000000000, uSex=1, createTime=2020-03-10T03:25:39, deleted=0)]以上我只写了一个和条件构造一起使用的条件：eq，还有很多，详情请参https://mp.baomidou.com/guide/wrapper.html#abstractwrapper
分页插件
mybatis-plus使用分页不需要像mybatis一样添加依赖，因为mybatis-plus已经提供了分页插件，直接拿来使用即可。
1.引入依赖：
package com.ymy.config;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@EnableTransactionManagement
@Configuration
public class MybatisPlusConfig {
@Bean
public PaginationInterceptor paginationInterceptor() {
PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
// 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求 默认false
// paginationInterceptor.setOverflow(false);
// 设置最大单页限制数量，默认 500 条，-1 不受限制
// paginationInterceptor.setLimit(500);
// 开启 count 的 join 优化,只针对部分 left join
paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
return paginationInterceptor;
}
}
打工告成，接下来就可以使用分页了。
/**
* 分页测试
*/
@Test
public void paginationTest(){
//分页查询
Page page = new Page(1,5);// 1:当前页 5：每页展示多少行
IPage usersPage = usersService.page(page);
log.info("总数：{} 条",usersPage.getTotal());
log.info("通过分页查询返回的结果条数：{}",usersPage.getRecords().size());
log.info("通过分页查询返回数据：{}",usersPage);
for(Users user: usersPage.getRecords()){
log.info("记录：{}",user);
}
} 2020-03-10 11:54:23.113 INFO 83360 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2020-03-10 11:54:23.356 INFO 83360 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2020-03-10 11:54:23.463 INFO 83360 --- [ main] com.ymy.MybatisPlusTest : 总数：6 条
2020-03-10 11:54:23.463 INFO 83360 --- [ main] com.ymy.MybatisPlusTest : 通过分页查询返回的结果条数：5
2020-03-10 11:54:23.463 INFO 83360 --- [ main] com.ymy.MybatisPlusTest : 通过分页查询返回数据：com.baomidou.mybatisplus.extension.plugins.pagination.Page@7da34b26
2020-03-10 11:54:23.463 INFO 83360 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=1, uName=张三, uPassword=999999, [email protected], uPhone=15000000000, uSex=1, createTime=2020-03-10T03:25:39, deleted=0)
2020-03-10 11:54:23.463 INFO 83360 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=2, uName=李四, uPassword=123456, [email protected], uPhone=15111111111, uSex=1, createTime=2020-03-10T02:44:15, deleted=0)
2020-03-10 11:54:23.463 INFO 83360 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=5, uName=王五, uPassword=123456, [email protected], uPhone=15111111111, uSex=1, createTime=2020-03-10T03:41:12, deleted=0)
2020-03-10 11:54:23.464 INFO 83360 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=6, uName=赵六, uPassword=123456, [email protected], uPhone=15111111111, uSex=0, createTime=2020-03-10T03:41:13, deleted=0)
2020-03-10 11:54:23.464 INFO 83360 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=7, uName=王麻子, uPassword=123123, [email protected], uPhone=15111111111, uSex=0, createTime=2020-03-10T03:41:31, deleted=0)将当前页换成2
2020-03-10 12:01:24.239 INFO 82440 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2020-03-10 12:01:24.467 INFO 82440 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2020-03-10 12:01:24.571 INFO 82440 --- [ main] com.ymy.MybatisPlusTest : 总数：6 条
2020-03-10 12:01:24.572 INFO 82440 --- [ main] com.ymy.MybatisPlusTest : 通过分页查询返回的结果条数：1
2020-03-10 12:01:24.572 INFO 82440 --- [ main] com.ymy.MybatisPlusTest : 通过分页查询返回数据：com.baomidou.mybatisplus.extension.plugins.pagination.Page@55fee662
2020-03-10 12:01:24.572 INFO 82440 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=8, uName=令狐冲, uPassword=110110, [email protected], uPhone=15888888888, uSex=0, createTime=2020-03-10T03:41:52, deleted=0)
上面的查询没有嵌套条件，我们也可以结合查询条件一起使用，mybatis-plus也给出了对应的方法，请看源码：
/**
* 翻页查询
*
* @param page 翻页对象
* @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
*/
default > E page(E page, Wrapper queryWrapper) {
return getBaseMapper().selectPage(page, queryWrapper);
} 分页结合条件构造一起使用，由于前面已经讲解过条件构造了，这里就不做代码展示了，你可能还有疑问，那就是使用mybatis-plus自带的方法可以使用这个分页插件，如果是我们自己手动写的sql，也能支持分页吗？，当然可以，请看代码：
/**
* 分页测试（手动编写sql）
*/
@Test
public void paginationSqlTest(){
//分页查询
Page page = new Page(1,5);// 1:当前页 5：每页展示多少行
IPage usersPage = usersService.selectList(page);
log.info("总数：{} 条",usersPage.getTotal());
log.info("通过分页查询返回的结果条数：{}",usersPage.getRecords().size());
log.info("通过分页查询返回数据：{}",usersPage);
for(Users user: usersPage.getRecords()){
log.info("记录：{}",user);
}
}
public interface IUsersService extends IService {
/**
* 通过手动编写sql查询分页
* @param page
* @return
*/
IPage selectList(Page page);
}
@Service
public class UsersServiceImpl extends ServiceImpl implements IUsersService {
@Autowired
private UsersMapper usersMapper;
@Override
public IPage selectList(Page page) {
return usersMapper.selectListBySql(page);
}
}
@Mapper
public interface UsersMapper extends BaseMapper {
@Select("select * from users ")
IPage selectListBySql(Page page);
}
2020-03-10 12:08:23.945 INFO 85452 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2020-03-10 12:08:24.173 INFO 85452 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2020-03-10 12:08:24.282 INFO 85452 --- [ main] com.ymy.MybatisPlusTest : 总数：6 条
2020-03-10 12:08:24.282 INFO 85452 --- [ main] com.ymy.MybatisPlusTest : 通过分页查询返回的结果条数：5
2020-03-10 12:08:24.283 INFO 85452 --- [ main] com.ymy.MybatisPlusTest : 通过分页查询返回数据：com.baomidou.mybatisplus.extension.plugins.pagination.Page@73a8e994
2020-03-10 12:08:24.283 INFO 85452 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=1, uName=张三, uPassword=999999, [email protected], uPhone=15000000000, uSex=1, createTime=2020-03-10T03:25:39, deleted=0)
2020-03-10 12:08:24.283 INFO 85452 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=2, uName=李四, uPassword=123456, [email protected], uPhone=15111111111, uSex=1, createTime=2020-03-10T02:44:15, deleted=0)
2020-03-10 12:08:24.283 INFO 85452 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=5, uName=王五, uPassword=123456, [email protected], uPhone=15111111111, uSex=1, createTime=2020-03-10T03:41:12, deleted=0)
2020-03-10 12:08:24.283 INFO 85452 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=6, uName=赵六, uPassword=123456, [email protected], uPhone=15111111111, uSex=0, createTime=2020-03-10T03:41:13, deleted=0)
2020-03-10 12:08:24.283 INFO 85452 --- [ main] com.ymy.MybatisPlusTest : 记录：Users(id=7, uName=王麻子, uPassword=123123, [email protected], uPhone=15111111111, uSex=0, createTime=2020-03-10T03:41:31, deleted=0)
可以看出，手动编写的sql，同样是支持分页的，查询也很简单，只需要将Page对象传递到Mapper即可，我们一起来看看返回的对象IPage到底是一个什么东西。
public interface IPage extends Serializable {
/**
* 降序字段数组
*
* @return order by desc 的字段数组
* @see #orders()
*/
@Deprecated
default String[] descs() {
return null;
}
/**
* 升序字段数组
*
* @return order by asc 的字段数组
* @see #orders()
*/
@Deprecated
default String[] ascs() {
return null;
}
/**
* 获取排序信息，排序的字段和正反序
*
* @return 排序信息
*/
List orders();
/**
* KEY/VALUE 条件
*
* @return ignore
*/
default Map condition() {
return null;
}
/**
* 自动优化 COUNT SQL【 默认：true 】
*
* @return true 是 / false 否
*/
default boolean optimizeCountSql() {
return true;
}
/**
* 进行 count 查询 【 默认: true 】
*
* @return true 是 / false 否
*/
default boolean isSearchCount() {
return true;
}
/**
* 计算当前分页偏移量
*/
default long offset() {
return getCurrent() > 0 ? (getCurrent() - 1) * getSize() : 0;
}
/**
* 当前分页总页数
*/
default long getPages() {
if (getSize() == 0) {
return 0L;
}
long pages = getTotal() / getSize();
if (getTotal() % getSize() != 0) {
pages++;
}
return pages;
}
/**
* 内部什么也不干
* 只是为了 json 反序列化时不报错
*/
default IPage setPages(long pages) {
// to do nothing
return this;
}
/**
* 设置是否命中count缓存
*
* @param hit 是否命中
* @since 3.3.1
*/
default void hitCount(boolean hit) {
}
/**
* 是否命中count缓存
*
* @return 是否命中count缓存
* @since 3.3.1
*/
default boolean isHitCount() {
return false;
}
/**
* 分页记录列表
*
* @return 分页对象记录列表
*/
List getRecords();
/**
* 设置分页记录列表
*/
IPage setRecords(List records);
/**
* 当前满足条件总行数
*
* @return 总条数
*/
long getTotal();
/**
* 设置当前满足条件总行数
*/
IPage setTotal(long total);
/**
* 获取每页显示条数
*
* @return 每页显示条数
*/
long getSize();
/**
* 设置每页显示条数
*/
IPage setSize(long size);
/**
* 当前页，默认 1
*
* @return 当前页
*/
long getCurrent();
/**
* 设置当前页
*/
IPage setCurrent(long current);
/**
* IPage 的泛型转换
*
* @param mapper 转换函数
* @param 转换后的泛型
* @return 转换泛型后的 IPage
*/
@SuppressWarnings("unchecked")
default IPage convert(Function mapper) {
List collect = this.getRecords().stream().map(mapper).collect(toList());
return ((IPage) this).setRecords(collect);
}
}
逻辑删除
什么是逻辑删除？在删除中，分物理删除和逻辑删除，物理删除：将数据从数据表中删除；逻辑删除：使用一个字段标识，未被删除是一个状态，删除以后是一个状态，说直白一点，逻辑删除就是一个更新操作。
准备工作
在用户表新建一个字段用来标识用户的状态：deleted（是否删除 0：正常 1：删除），由于之前新建users表中已经添加了此字段，所以我们直接开始写代码。
编辑配置文件application.yml
# 逻辑删除
mybatis-plus:
global-config:
db-config:
logic-delete-field: deleted #全局逻辑删除字段值 3.3.0开始支持，详情看下面。
logic-delete-value: 1 # 逻辑已删除值(默认为 1)
logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)在实体类Users中设置状态的字段
/**
* 是否删除 0：正常 1：删除
*/
@TableLogic
private Integer deleted;新建测试代码
/**
* 逻辑删除
*/
@Test
public void logicRemove(){
//删除用户名为令狐冲的用户信息
boolean remove = usersService.remove(new UpdateWrapper().lambda().eq(Users::getUName, "令狐冲"));
log.info("删除返回的结果：{}",remove);
} 
可以发现，令狐冲的deleted状态被设置为了1，不知道有没有细心的靓仔发现了一个问题，那就是我已经在配置文件中设置了logic-delete-field: deleted：全局逻辑删除字段值，为什么还要在实体类中加入 @TableLogic注解呢？
logic-delete-field代表全局配置，如果你设置了这个属性，那么系统会自动在所有实体类中匹配你设置的字段，如果没有找到，执行物理删除，@TableLogic可以在不同的实体类设置在不同的字段上，如果全局配置和注解都没有，那么将会执行物理删除，注解的形式会相对来说比较灵活，但是代码侵入较强，全局配置比较死板，但是代码侵入较弱，项目使用中可以根据自己数据表的结构做出相应的选择。
注意：逻辑删除默认只会在MP自带的方法中生效，比如查询：list()方法他会自动加上deleted=0的条件，如果sql时自己编写的时候Mp不会加上deleted=0的条件，所以在使用自定义sql的时候别忘了加上deleted条件。
通用枚举类
通用枚举解决了字段转换的问题，如：性别，数据库存放的是数字，但是在界面上却要展示字符串，我们还需要在程序中做一次转换，使用MP的通用枚举类之后，就无需我们自己做转换了。
测试方法
/**
* 枚举
*/
@Test
public void enumTest(){
//删除用户名为令狐冲的用户信息
Users users = usersService.getOne(new UpdateWrapper().lambda().eq(Users::getUName, "令狐冲"));
log.info("查询返回的结果：{}",users);
} 这只是一个简单的查询列表语句，还没有设置通用枚举，我们先看一下没有设置通用枚举的结果：
2020-03-10 17:04:04.831 INFO 94084 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2020-03-10 17:04:05.091 INFO 94084 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2020-03-10 17:04:05.158 INFO 94084 --- [ main] com.ymy.MybatisPlusTest : 查询返回的结果：Users(id=1, uName=张三, uPassword=999999, [email protected], uPhone=15000000000, uSex=1, createTime=2020-03-10T06:21:05, deleted=0)
你会发现这时候我们返回的uSex并不是我们需要的结果，我们需要的是男性或者女性，但是程序给我们返回了 1/2，我们需要自己处理，现在我们使用MP的通用枚举，代码改造开始。
1.新建性别枚举类
package com.ymy.entity.enums;
import com.baomidou.mybatisplus.annotation.EnumValue;
import com.baomidou.mybatisplus.core.enums.IEnum;
/**
* 性别枚举类
*/
public enum SexEnum implements IEnum {
MAN(1,"男"),
WOMAN(2,"女");
@EnumValue
private final int code;
private final String descp;
SexEnum(int code, String descp) {
this.code = code;
this.descp = descp;
}
@Override
public String toString() {
return this.descp;
}
@Override
public Integer getValue() {
return code;
}
}
2.改造实体类中的性别字段
@JSONField(serialzeFeatures= SerializerFeature.WriteEnumUsingToString)
private SexEnum uSex;@JSONField需要FastJson的依赖。
3.引入FastJson
com.alibaba
fastjson
1.2.62
4.编辑配置文件：application.yml
# 逻辑删除
mybatis-plus:
global-config:
db-config:
logic-delete-field: deleted #全局逻辑删除字段值 3.3.0开始支持，详情看下面。
logic-delete-value: 1 # 逻辑已删除值(默认为 1)
logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)
type-enums-package: com.ymy.entity.enums #扫描MP的通用枚举类所在的package运行测试案例，查看结果
这里我们需要注意一点，如果我们数据库给定字段的类型如果是tinyint(1)，那么执行上面得到的性别将会时null，原因时MP会将 tinyint(1)映射为boolean类型，也就是说我们需要将枚举类中的1，2，改为true、false，但0一般标识true，非0标识false，true、false无法满足我们的需求，纳入和处理呢？其实很简单，我们只需要将数据库的字段类型修改为int即可。
自动填充功能
自动填充：指定字段在没有给定具体值时，系统将自动的填充设置好的数据，常见的例子比如数据添加的创建时间，数据修改的修改时间，这些都可以设置为自动填充。
这个时候我们需要在在数据表增加两个一个字段，update_time,不能给定默认值，并且不会虽数据修改发生变化。
1.自定义实现通用填充类MyMetaObjectHandler
package com.ymy.config;
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.time.LocalDateTime;
@Component
@Slf4j
public class MyMetaObjectHandler implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
log.info("start insert fill ....");
this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
// this.fillStrategy(metaObject, "createTime", LocalDateTime.now()); // 也可以使用(3.3.0 该方法有bug请升级到之后的版本如`3.3.1.8-SNAPSHOT`)
/* 上面选其一使用,下面的已过时(注意 strictInsertFill 有多个方法,详细查看源码) */
//this.setFieldValByName("operator", "Jerry", metaObject);
//this.setInsertFieldValByName("operator", "Jerry", metaObject);
}
@Override
public void updateFill(MetaObject metaObject) {
log.info("start update fill ....");
this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
//this.fillStrategy(metaObject, "updateTime", LocalDateTime.now()); // 也可以使用(3.3.0 该方法有bug请升级到之后的版本如`3.3.1.8-SNAPSHOT`)
/* 上面选其一使用,下面的已过时(注意 strictUpdateFill 有多个方法,详细查看源码) */
//this.setFieldValByName("operator", "Tom", metaObject);
//this.setUpdateFieldValByName("operator", "Tom", metaObject);
}
}
2.在实体类中将需要填充的字段添加注解标识
/**
* 创建时间
*/
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 修改时间
*/
@TableField(fill = FieldFill.UPDATE)
private LocalDateTime updateTime;
public enum FieldFill {
/**
* 默认不处理
*/
DEFAULT,
/**
* 插入填充字段
*/
INSERT,
/**
* 更新填充字段
*/
UPDATE,
/**
* 插入和更新填充字段
*/
INSERT_UPDATE
}3.测试案例
/**
* 通用字段测试（插入）
*/
@Test
public void GeneralFieldInsertTest(){
Users user = Users.builder().uName("东方不败").uMail("[email protected]")
.uPassword("123456").uPhone("15000000000")
.uSex(SexEnum.MAN).deleted(0)
.build();
//插入
boolean save = usersService.save(user);
log.info("保存返回的结果：{}",save);
}
/**
* 通用字段测试（修改）
*/
@Test
public void GeneralFieldUpdateTest(){
Users user = new Users();
user.setUPassword("qoqoqoqoqoqoqo");
//插入
boolean save = usersService.update(user,new UpdateWrapper().lambda().eq(Users::getUName,"东方不败"));
log.info("保存返回的结果：{}",save);
} 4.测试结果
添加：
修改
这样就实现了代码的自动填充，但是这里需要注意一个问题，只有使用Mp自带方法的时候才会生效，并且使用还是有条件的：必须是update(实体类，Wapper条件)，否者自动填充将无效。
乐观锁
主要适用场景
意图：
当要更新一条记录的时候，希望这条记录没有被别人更新
乐观锁实现方式：
取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败
1.数据库增加version字段
2.注册乐观锁bean
/**
* 注册乐观锁
* @return
*/
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
return new OptimisticLockerInterceptor();
}3.在Users实体类中添加version，字段，并加上@version注解，标识使用此字段实现乐观锁。
/**
* 版本号
*/
@Version
private Long version;乐观锁配置完成，接下来我们将用乐观锁两个事例，一个成功、一个失败，为了更好的看到MP所做的操作，我先将sql日志打印在控制台中，我们修改配置文件
mybatis-plus:
global-config:
db-config:
logic-delete-field: deleted #全局逻辑删除字段值 3.3.0开始支持，详情看下面。
logic-delete-value: 1 # 逻辑已删除值(默认为 1)
logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)
type-enums-package: com.ymy.entity.enums #扫描MP的通用枚举类所在的package
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #控制台输出sql现在我们开始写测试案例，我们需要将张三的密码修改为"yyyyyyyy"。
/**
* 乐观锁测试
*/
@Test
public void versionTest() {
Users users = usersService.getOne(new QueryWrapper().lambda().eq(Users::getUName, "张三"));
users.setUPassword("yyyyyyyy");
boolean update = usersService.updateById(users);
log.info("修改了用户信息，状态：{}", update);
} 由于数据库中version字段是刚刚新增的，并且默认0，我们一起来执行一下测试代码会发生什么
我们会发现，MP在条件中自动给我们加上了version字段和deleted，deleted是我们之前配置的逻辑删除，version是我们刚刚配置的乐观锁，可能你现在有疑问了，配置这个version字段的用意到底是什么呢？我举个例子，假如你的账户有100元，这个时候你想给你的朋友转50元感谢他帮你抢了一个N95口罩，但是这个时候你的妈妈担心你没有钱生活了，他往你的账户上转了1000元，按照我们的预期，现在你的账户的余额应该是：1050元，这是我们预期的，但并不代表这是程序执行后的结果，为什么呢？因为有cpu缓存以及多线程的存在，导致你的账户余额可能是1100，也有可能是1050，也有可能是50；这种结果是不是很可怕，这里我就不演示这种案例，你只要明白就行，而乐观锁就是用来保证你给你朋友转账/你妈妈给你转账只能成功一个，这样就保证了你资金的安全，现在我们来模拟一个修改用户信息失败的案例，请看代码：
/**
* 乐观锁测试
*/
@Test
public void versionTest() throws InterruptedException {
//线程1
Thread t1 = new Thread(() -> {
updatePwd1();
});
//线程2
Thread t2 = new Thread(() -> {
updatePwd2();
});
t1.start();
t2.start();
t1.join();
t2.join();
log.info("执行完毕");
}
/**
* 将张三的密码修改为：pppppppppppp
*
* @return
*/
private void updatePwd1() {
String threadName = Thread.currentThread().getName();
Users users = usersService.getOne(new QueryWrapper().lambda().eq(Users::getUName, "张三"));
log.info("线程：{} 获取到的用户信息：{}", threadName, users);
try {
//为了能让两个查询都执行完毕之后在执行修改操作，所以在这里休眠了1秒中
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
users.setUPassword("pppppppppppp");
boolean update = usersService.updateById(users);
log.info("线程：{} 修改了用户信息，状态：{}", threadName, update);
}
/**
* 将张三的密码修改为：ooooooooooo
*
* @return
*/
private void updatePwd2() {
String threadName = Thread.currentThread().getName();
Users users = usersService.getOne(new QueryWrapper().lambda().eq(Users::getUName, "张三"));
log.info("线程：{} 获取到的用户信息：{}", threadName, users);
try {
//为了能让两个查询都执行完毕之后在执行修改操作，所以在这里休眠了1秒中
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
users.setUPassword("ooooooooooo");
boolean update = usersService.updateById(users);
log.info("线程：{} 修改了用户信息，状态：{}", threadName, update);
} 第一个线程需要将张三的密码修改为：pppppppppppp，第二个线程需要将密码修改为：ooooooooooo，两个线程同时执行，我这里为了保证两个线程同时执行查询，并且都还没执行修改操作，我这里就是模拟一下同时修改，你们项目开发的时候千万别这么写代码，由于我们之前已经执行了一次更新操作，我们的数据库中version字段的值也应该+1
这时候我们再来运行多线程的测试代码：
Creating a new SqlSession
Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@709bb28d] was not registered for synchronization because synchronization is not active
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@21152fe7] was not registered for synchronization because synchronization is not active
2020-03-11 10:41:53.870 INFO 115848 --- [ Thread-3] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2020-03-11 10:41:54.128 INFO 115848 --- [ Thread-3] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
JDBC Connection [HikariProxyConnection@1688741162 wrapping com.mysql.cj.jdbc.ConnectionImpl@3d6da8bf] will not be managed by Spring
==> Preparing: SELECT id,u_name,u_password,u_mail,u_phone,u_sex,version,create_time,update_time,deleted FROM users WHERE deleted=0 AND (u_name = ?)
==> Parameters: 张三(String)
<== Columns: id, u_name, u_password, u_mail, u_phone, u_sex, version, create_time, update_time, deleted
<== Row: 1, 张三, yyyyyyyy, [email protected], 15000000000, 1, 1, 2020-03-08 06:21:05, 2020-03-09 09:21:10, 0
<== Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@21152fe7]
JDBC Connection [HikariProxyConnection@1306964427 wrapping com.mysql.cj.jdbc.ConnectionImpl@3d6da8bf] will not be managed by Spring
2020-03-11 10:41:54.209 INFO 115848 --- [ Thread-3] com.ymy.MybatisPlusTest : 线程：Thread-3 获取到的用户信息：Users(id=1, uName=张三, uPassword=yyyyyyyy, [email protected], uPhone=15000000000, uSex=男, version=1, createTime=2020-03-08T06:21:05, updateTime=2020-03-09T09:21:10, deleted=0)
==> Preparing: SELECT id,u_name,u_password,u_mail,u_phone,u_sex,version,create_time,update_time,deleted FROM users WHERE deleted=0 AND (u_name = ?)
==> Parameters: 张三(String)
<== Columns: id, u_name, u_password, u_mail, u_phone, u_sex, version, create_time, update_time, deleted
<== Row: 1, 张三, yyyyyyyy, [email protected], 15000000000, 1, 1, 2020-03-08 06:21:05, 2020-03-09 09:21:10, 0
<== Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@709bb28d]
2020-03-11 10:41:54.221 INFO 115848 --- [ Thread-2] com.ymy.MybatisPlusTest : 线程：Thread-2 获取到的用户信息：Users(id=1, uName=张三, uPassword=yyyyyyyy, [email protected], uPhone=15000000000, uSex=男, version=1, createTime=2020-03-08T06:21:05, updateTime=2020-03-09T09:21:10, deleted=0)
Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@28c0761b] was not registered for synchronization because synchronization is not active
2020-03-11 10:41:55.214 INFO 115848 --- [ Thread-3] com.ymy.config.MyMetaObjectHandler : start update fill ....
Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@420ba4aa] was not registered for synchronization because synchronization is not active
2020-03-11 10:41:55.223 INFO 115848 --- [ Thread-2] com.ymy.config.MyMetaObjectHandler : start update fill ....
JDBC Connection [HikariProxyConnection@1719623840 wrapping com.mysql.cj.jdbc.ConnectionImpl@3d6da8bf] will not be managed by Spring
==> Preparing: UPDATE users SET u_name=?, u_password=?, u_mail=?, u_phone=?, u_sex=?, version=?, create_time=?, update_time=? WHERE id=? AND version=? AND deleted=0
JDBC Connection [HikariProxyConnection@2004050803 wrapping com.mysql.cj.jdbc.ConnectionImpl@35e1ffd5] will not be managed by Spring
==> Preparing: UPDATE users SET u_name=?, u_password=?, u_mail=?, u_phone=?, u_sex=?, version=?, create_time=?, update_time=? WHERE id=? AND version=? AND deleted=0
==> Parameters: 张三(String), ooooooooooo(String), [email protected](String), 15000000000(String), 1(Integer), 2(Long), 2020-03-08T06:21:05(LocalDateTime), 2020-03-09T09:21:10(LocalDateTime), 1(Integer), 1(Long)
==> Parameters: 张三(String), pppppppppppp(String), [email protected](String), 15000000000(String), 1(Integer), 2(Long), 2020-03-08T06:21:05(LocalDateTime), 2020-03-09T09:21:10(LocalDateTime), 1(Integer), 1(Long)
<== Updates: 0
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@420ba4aa]
<== Updates: 1
2020-03-11 10:41:55.257 INFO 115848 --- [ Thread-2] com.ymy.MybatisPlusTest : 线程：Thread-2 修改了用户信息，状态：false
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@28c0761b]
2020-03-11 10:41:55.258 INFO 115848 --- [ Thread-3] com.ymy.MybatisPlusTest : 线程：Thread-3 修改了用户信息，状态：true
2020-03-11 10:41:55.258 INFO 115848 --- [ main] com.ymy.MybatisPlusTest : 执行完毕
这时候你们会发现，线程名：Thread-2修改密码成功了，Thread-3修改密码失败了，符合我们的要求，两个线程同时执行修改操作的时候，只能成功一个，我们再来看看数据库的结果：
总结
mybatis-plus的介绍及使用就写到这里了，其实还有一些特性我没有写到，比如：多租户 SQL 解析器、动态数据源、自定义ID生成器等等，这篇已经写的很多了，如果有需要可以评论，我可以继续加。