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, '[e-mail]', NULL, '2023-06-28 09:20:20'),
(1088248166370832385, 'Tony', 25, '[e-mail]', 1087982257332887553, '2023-06-28 11:12:22'),
(1088250446457389058, 'Jack', 28, '[e-mail]', 1088248166370832385, '2023-06-28 08:31:16'),
(1094590409767661570, 'Rose', 31, '[e-mail]', 1088248166370832385, '2023-06-27 09:15:15'),
(1094592041087729666, 'Lemon', 32, '[e-mail]', 1088248166370832385, '2023-06-28 09:48:16');

项目添加依赖

<properties><java.version>1.8</java.version><mybatis-plus.version>3.3.2</mybatis-plus.version>
</properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><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=UTCdriver-class-name: com.mysql.cj.jdbc.Driverusername: rootpassword: root# 配置日志
logging:level:root: warncom.xkw.mp.crud.mapper: tracepattern: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;// 乐观锁注解@Versionprivate  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 {@AutowiredUserMapper userMapper;@AutowiredIUserService userService;@Testpublic 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功能* <p>这个 Mapper 支持 id 泛型</p>** @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 条件，查询全部记录* <p>注意： 只返回第一个字段的值</p>** @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 {/*** 乐观锁注解*/@Versionprivate  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
*/