MyBatis-Plus为简化开发而生
简介
MyBatis-Plus 简称 MP是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
他们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。
特性
-
无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
-
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
-
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
-
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
-
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
-
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
-
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
-
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
支持数据库
任何能使用
MyBatis进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下，如果不在下列表查看分页部分教程 PR 您的支持。
-
MySQL，Oracle，DB2，H2，HSQL，SQLite，PostgreSQL，SQLServer，Phoenix，Gauss ，ClickHouse，Sybase，OceanBase，Firebird，Cubrid，Goldilocks，csiidb，informix，TDengine，redshift
-
达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据库，瀚高数据库，优炫数据库。
框架结构
SSM传统编程模式
快速开始
现有一张User表
-- 用户表：user
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` BIGINT(20) PRIMARY KEY AUTO_INCREMENT COMMENT '主键',
`name` VARCHAR(30) DEFAULT NULL COMMENT '姓名',
`age` INT(11) DEFAULT NULL COMMENT '年龄',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
`manager_id` BIGINT(20) DEFAULT NULL COMMENT '直属上级id',
`create_time` DATETIME(0) DEFAULT NULL COMMENT '创建时间',
`update_time` DATETIME DEFAULT NULL COMMENT '修改时间',
`version` INT(11) DEFAULT '1' COMMENT '版本',
`deleted` INT(1) DEFAULT '0' COMMENT '逻辑删除标识(0.未删除,1.已删除)'
) ENGINE=INNODB CHARSET=UTF8;
INSERT INTO `user`(`id`,`name`,`age`,`email`,`manager_id`,`create_time`) VALUES
(1087982257332887553, '徐源', 28, '[email protected]', NULL, '2023-06-28 09:20:20'),
(1088248166370832385, 'Tony', 25, '[email protected]', 1087982257332887553, '2023-06-28 11:12:22'),
(1088250446457389058, 'Jack', 28, '[email protected]', 1088248166370832385, '2023-06-28 08:31:16'),
(1094590409767661570, 'Rose', 31, '[email protected]', 1088248166370832385, '2023-06-27 09:15:15'),
(1094592041087729666, 'Lemon', 32, '[email protected]', 1088248166370832385, '2023-06-28 09:48:16');
项目添加依赖
<properties>
<java.version>1.8java.version>
<mybatis-plus.version>3.3.2mybatis-plus.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starterartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<scope>runtimescope>
dependency>
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
<version>${mybatis-plus.version}version>
dependency>
dependencies>
配置
在 application.yml 配置文件中添加数据库的相关配置：
# 配置数据源
spring:
datasource:
url: jdbc:mysql://121.89.226.84:3306/mybatis-plus?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: root
# 配置日志
logging:
level:
root: warn
com.xkw.mp.crud.mapper: trace
pattern:
console: '%p%m%n'
mybatis-plus:
mapper-locations: ['classpath:/mapper/*Mapper.xml']
在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹：
@SpringBootApplication
@MapperScan("com.xkw.mp.crud.mapper")
public class CrudApp {
public static void main(String[] args) {
SpringApplication.run(ServiceApp.class, args);
}
}
编码
编写实体类 User.java（此处使用了 Lombok简化代码）
@Data
public class User {
private Long id;
private String name;
private Integer age;
private String email;
private Long managerId;
private LocalDateTime createTime;
private LocalDateTime updateTime;
// 乐观锁注解
@Version
private Integer version = 1;
// 逻辑删除标识(0.未删除,1.已删除)
@TableLogic
@TableField(select = false)
private Integer deleted = 0;
}
编写 Mapper 包下的 UserMapper接口
public interface UserMapper extends BaseMapper<User> {
}
编写 Service 包下的 IUserService接口（非必须）
public interface IUserService extends IService<User> {
}
@Service
public class UserService extends ServiceImpl<UserMapper, User> implements IUserService {
}
测试
@RunWith(SpringRunner.class)
@SpringBootTest(classes = CrudApp.class)
@Slf4j
public class SampleTest {
@Autowired
UserMapper userMapper;
@Autowired
IUserService userService;
@Test
public void testSelect() {
List<User> users01 = userMapper.selectList(null);
Assert.assertEquals(8, users01.size());
users01.forEach(user -> log.info(user.getName()));
List<User> users02 = userService.list();
Assert.assertEquals(8, users02.size());
users02.forEach(user -> log.info(user.getName()));
}
}
以上代码可以通过代码生成器快速生成，并且可以定制化生成：
AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
CRUD
通用Mapper
通用 CRUD 封装BaseMapper 接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器；
泛型 T 为任意实体对象；
参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键；
对象 Wrapper 为 条件构造器。
/**
* Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
* 这个 Mapper 支持 id 泛型
*
* @author hubin
* @since 2016-01-23
*/
public interface BaseMapper<T> extends Mapper<T> {
/**
* 插入一条记录
*
* @param entity 实体对象
*/
int insert(T entity);
/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);
/**
* 根据 columnMap 条件，删除记录
*
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
/**
* 删除（根据ID 批量删除）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
/**
* 根据 ID 修改
*
* @param entity 实体对象
*/
int updateById(@Param(Constants.ENTITY) T entity);
/**
* 根据 whereEntity 条件，更新记录
*
* @param entity 实体对象 (set 条件值,可以为 null)
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
/**
* 根据 ID 查询
*
* @param id 主键ID
*/
T selectById(Serializable id);
/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
/**
* 查询（根据 columnMap 条件）
*
* @param columnMap 表字段 map 对象
*/
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
/**
* 根据 entity 条件，查询一条记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询总记录数
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录
* 注意： 只返回第一个字段的值
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
<E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件
* @param queryWrapper 实体对象封装操作类
*/
<E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}
通用Service
通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆；
泛型 T 为任意实体对象；
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类；
对象 Wrapper 为 条件构造器。
Save
// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);
通用 insertBatch 为什么放在 service 层处理
-
SQL 长度有限制海量数据量单条 SQL 无法执行，就算可执行也容易引起内存泄露 JDBC 连接超时等
-
不同数据库对于单条 SQL 批量语法不一样不利于通用
-
目前的解决方案：循环预处理批量提交，虽然性能比单 SQL 慢但是可以解决以上问题。
SaveOrUpdate
// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
Remove
// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);
Update
// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);
Get
// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
List
// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
Page
// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);
Chain
query
// 链式查询 普通
QueryChainWrapper<T> query();
// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper<T> lambdaQuery();
// 示例：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();
update
/ 链式更改 普通
UpdateChainWrapper<T> update();
// 链式更改 lambda 式。注意：不支持 Kotlin
LambdaUpdateChainWrapper<T> lambdaUpdate();
// 示例：
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);
条件构造器
MyBatis-Plus条件构造器（MyBatis-Plus Condition Wrapper）是 MyBatis-Plus 框架提供的一个强大的查询条件构建工具，用于在 SQL 查询中添加多个动态条件；
通过使用条件构造器，您可以方便地根据不同的情况动态构建查询条件，并且避免了手动编写复杂的 SQL 语句。它提供了一套简单直观的 API，使得构建和管理查询条件变得更加灵活和高效。
使用条件构造器，您可以轻松实现以下常见操作：
等值判断 eq(column, value) 示例：
QueryWrapper<User> query = new QueryWrapper<>();
query.eq("name", "Tony");
不等值判断 ne(column, value) 示例：
QueryWrapper<User> query = new QueryWrapper<>();
query.ne("age", 28);
大于判断 gt(column, value)示例：gt(“salary”, 5000)
小于判断 lt(column, value)示例：lt(“create_time”, LocalDateTime.now())
范围判断 between(column, value1, value2)示例：between(“price”, 100, 200)
模糊查询 like(column, value)示例：like(“title”, “%keyword%”)
除此之外，条件构造器还支持排序、分页、子查询等功能，以及各种逻辑运算符（与、或、非）、函数计算等高级操作。
Lambda条件构造器
在 MyBatis-Plus 中，除了常规的条件构造器外，还提供了一种更为简洁、方便的 Lambda 条件构造器（Lambda Query Wrapper）；
使用 Lambda 条件构造器，您可以通过 Java 8 中引入的 Lambda 表达式来编写查询条件；
使用 Lambda 条件构造器，能够让代码更加精炼，并且具有语法高亮和类型安全性，防误写；
下面是几个示例：
等值判断 eq(column, value) 示例：
LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
lambdaQuery.eq(User::getName, "Tony");
不等值判断 ne(column, value) 示例：
LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
lambdaQuery.ne(User::getAge, 28);
大于判断：wrapper.gt(User::getSalary, 5000)
小于判断：wrapper.lt(User::getCreateTime, LocalDateTime.now())
范围判断：wrapper.between(User::getPrice, 100, 200)
模糊查询：wrapper.like(User::getTitle, "%keyword%")
Lambda 条件构造器还支持排序、分页、子查询等功能，以及各种逻辑运算符（与、或、非）、函数计算等高级操作，使得条件拼接变得更加灵活和简单。
通过使用 MyBatis-Plus 的 Lambda 条件构造器，您可以轻松实现复杂查询，减少手动编写 SQL 的工作量，并且更容易维护和理解代码。它大大简化了查询条件的构建过程，提升了开发效率和代码质量。
Case
查询，徐姓或者年龄大于等于25，按照年龄降序排列，年龄相同则按照id升序排列
SQL：name like ‘徐%’ or age>=25 order by age desc,id asc
QueryWrapper<User> query = new QueryWrapper<>();
query.likeRight("name", "徐")
.or().ge("age", 25)
.orderByDesc("age")
.orderByAsc("id");
List<User> list = userMapper.selectList(query);
list.forEach(System.out::println);
LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
lambdaQuery.likeRight(User::getName, "徐")
.or().ge(User::getAge, 25)
.orderByDesc(User::getAge)
.orderByAsc(User::getId);
List<User> list02 = userMapper.selectList(lambdaQuery);
list02.forEach(System.out::println);
List<User> list03 = userService.lambdaQuery()
.likeRight(User::getName, "涂")
.or().ge(User::getAge, 25)
.orderByDesc(User::getAge)
.orderByAsc(User::getId)
.list();
list03.forEach(System.out::println);
/**
* DEBUG==> Preparing: SELECT id,name,age,email,manager_id,create_time FROM user WHERE (name LIKE ? OR age >= ?) ORDER BY age DESC,id ASC
* DEBUG==> Parameters: 徐%(String), 20(Integer)
*/
查询，徐姓或者（龄小于40并且年龄大于28并且邮箱不为空）
SQL：name like ‘徐%’ or (age < 40 and age > 28 and email is not null)
QueryWrapper<User> query = new QueryWrapper<>();
query.likeRight("name", "徐")
.or(q -> q.between("age", 28, 40)
.isNotNull("email"));
List<User> list01 = userMapper.selectList(query);
list01.forEach(System.out::println);
LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
lambdaQuery.likeRight(User::getName, "徐")
.or(q -> q.between(User::getAge, 28, 40)
.isNotNull(User::getName));
List<User> list02 = userMapper.selectList(lambdaQuery);
list02.forEach(System.out::println);
/**
* DEBUG==> Preparing: SELECT id,name,age,email,manager_id,create_time FROM user WHERE (name LIKE ? OR (age BETWEEN ? AND ? AND name IS NOT NULL))
* DEBUG==> Parameters: 徐%(String), 28(Integer), 40(Integer)
*/
查询指定字段，名字中包含雨并且年龄小于40
QueryWrapper<User> query = new QueryWrapper<>();
query.select("name", "age")
.like("name", "雨")
.lt("age", 40);
List<User> list01 = userMapper.selectList(query);
list01.forEach(System.out::println);
LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
lambdaQuery.select(User::getName, User::getAge)
.like(User::getName, "雨")
.lt(User::getAge, 40);
List<User> list02 = userMapper.selectList(lambdaQuery);
list02.forEach(System.out::println);
/**
* DEBUG==> Preparing: SELECT name,age FROM user WHERE (name LIKE ? AND age < ?)
* DEBUG==> Parameters: %雨%(String), 40(Integer)
*/
查询，创建日期为2023年06月28日并且直属上级为徐姓
SQL：date_format(create_time, ‘%Y-%m-%d’)=‘2023-06-28’ and manager_id in (select id from user where name like ‘徐%’)
QueryWrapper<User> query = new QueryWrapper<>();
query.apply("DATE_FORMAT(create_time,'%Y-%m-%d')={0}", "2023-06-28")
.inSql("manager_id", "SELECT id FROM `user` WHERE `name` LIKE '徐%'");
List<User> list01 = userMapper.selectList(query);
list01.forEach(System.out::println);
LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
lambdaQuery.apply("DATE_FORMAT(create_time,'%Y-%m-%d')={0}", "2023-06-28")
.inSql(User::getManagerId, "SELECT id FROM `user` WHERE `name` LIKE '徐%'");
List<User> list02 = userMapper.selectList(lambdaQuery);
list02.forEach(System.out::println);
/**
* DEBUG==> Preparing: SELECT id,name,age,email,manager_id,create_time FROM user WHERE (DATE_FORMAT(create_time,'%Y-%m-%d')=? AND manager_id IN (SELECT id FROM `user` WHERE `name` LIKE '徐%'))
* DEBUG==> Parameters: 2023-06-28(String)
*/
主键策略
MyBatis-Plus 提供了一种灵活且开发友好的主键策略，可以方便地生成和管理实体类的主键。以下是 MyBatis-Plus 主要支持的几种主键策略：
-
自增主键（AUTO_INCREMENT）：这是最常见的主键策略之一，数据库会自动为每条记录分配一个唯一的递增值作为主键；
-
UUID 主键：使用 Universally Unique Identifier (UUID) 作为唯一标识符，在插入数据时会自动生成一个长度为 32 的唯一字符串，并将其作为主键；
-
分布式 ID：提供了多种分布式 ID 策略，如雪花算法 Snowflake、Leaf、Ulid 等。这些策略通过在不同节点之间进行协调来产生全局唯一的 ID；
-
自定义主键生成器：允许开发者根据具体业务需求自定义主键生成逻辑，只需要实现 KeyGenerator 接口并配置到相应的实体上即可。
对于自增主键，MyBatis-Plus 在默认情况下会假设数据库会返回自动生成的主键，并自动将其设置回实体对象中。
若您使用的数据库无法自动生成主键或想手动控制主键生成过程，可以设置 @TableId注解的 type 属性为 IdType.INPUT，然后通过编码方式设置主键值。
对于 UUID 主键或分布式 ID，只需使用 @TableId注解指定主键生成策略为IdType.UUID 或 IdType.ID_WORKER 等即可。MyBatis-Plus 将会在插入数据时自动生成相应的主键。
若想自定义主键生成逻辑，可以实现 KeyGenerator 接口，并将该自定义主键生成器注入到 IOC 容器中。然后在实体类的 @TableId 注解中设置 generator 属性为自定义主键生成器的名字。
总而言之，MyBatis-Plus 提供了多种灵活且易用的主键策略，能够满足不同项目和业务场景下的需求。开发者可以根据具体情况选择合适的主键生成方式，并通过简单的配置即可轻松管理实体对象的主键。
插件
分页插件
分页插件（PaginationInterceptor）：分页是在大部分应用中都需要处理的需求之一；MyBatis-Plus 的分页插件可以帮助我们方便地进行数据库查询结果的分页操作。通过使用该插件，我们可以很容易地实现分页查询并获取分页结果。
@Bean
@ConditionalOnMissingBean
public PaginationInterceptor paginationInterceptor() {
PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
// 单页限制 500 条，小于 0 如 -1 不受限制
paginationInterceptor.setLimit(-1);
// 溢出总页数后是否进行处理(默认不处理)
paginationInterceptor.setOverflow(true);
return paginationInterceptor;
}
LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
query.ge(User::getAge, 26)
.orderByDesc(User::getCreateTime);
Page<User> page = new Page<>(1, 2);
IPage<Map<String, Object>> iPage = userMapper.selectMapsPage(page, query);
System.out.println("总页数：" + page.getPages());
System.out.println("总记录数：" + iPage.getTotal());
List<Map<String, Object>> list = iPage.getRecords();
list.forEach(System.out::println);
乐观锁插件
数据库乐观锁插件（OptimisticLockerInterceptor）：乐观锁是一种并发控制机制，通过在数据表中添加一个版本号字段实现。MyBatis-Plus 的乐观锁插件可以自动处理带有乐观锁的更新操作，确保并发情况下不会出现数据被覆盖或丢失的问题。
/**
* 引入乐观锁插件
*/
@Bean
@ConditionalOnMissingBean
public OptimisticLockerInterceptor optimisticLockerInterceptor(){
return new OptimisticLockerInterceptor();
}
@Data
public class User {
/**
* 乐观锁注解
*/
@Version
private Integer version;
}
User user = userMapper.selectById(1673973063479255042L);
user.setAge(30);
System.out.println("开始休息，在修改的过程中，有其他用户对数据进行了更新...");
Thread.sleep(10000);
System.out.println("去数据库修改该条数据，并将version增加一个版本");
int rows = userMapper.updateById(user);
System.out.println("影响行数："+rows);
/**
* DEBUG==> Preparing: SELECT id,name,age,email,manager_id,create_time,update_time,version,deleted FROM user WHERE id=?
* DEBUG==> Parameters: 1673973063479255042(Long)
* TRACE<== Columns: id, name, age, email, manager_id, create_time, update_time, version, deleted
* TRACE<== Row: 1673973063479255042, 王二狗, 30, null, 1088248166370832385, 2023-06-28 00:34:14, null, 5, 0
* DEBUG<== Total: 1
* 开始休息，在修改的过程中，有其他用户对数据进行了更新...
* 去数据库修改该条数据，并将version增加一个版本
* DEBUG==> Preparing: UPDATE user SET name=?, age=?, manager_id=?, create_time=?, version=?, deleted=? WHERE id=? AND version=?
* DEBUG==> Parameters: 王二狗(String), 30(Integer), 1088248166370832385(Long), 2023-06-28T00:34:14(LocalDateTime), 6(Integer), 0(Integer), 1673973063479255042(Long), 5(Integer)
* DEBUG<== Updates: 0
* 影响行数：0
*/
