一、前言 🌟
🧩 MyBatis & MyBatis-Plus 是啥关系？
MyBatis 是一个优秀的 ORM 框架（Object Relational Mapping，面向对象关系映射），它让我们可以通过编写 SQL 来操作数据库，同时又能保持代码结构清晰、可维护。但它有个小“毛病”：太需要自己写了！ 🥲
比如最基本的增删改查，都要你手动写 SQL 或 XML，非常容易陷入“重复劳动”。
这时，MyBatis-Plus（简称 MP） 横空出世！🚀
它是对 MyBatis 的增强工具包，不改变原有用法的前提下，自动帮你生成大量常用操作，极大地提高了开发效率，让你把精力放在“业务逻辑”而不是“CRUD”。
💡 为什么选择 MyBatis-Plus？
开箱即用，零配置 🛠️
只要引入依赖、稍微配置一下，基本功能就能立刻使用！内置强大功能 ✨
通用 CRUD、分页、条件构造器、乐观锁、代码生成器……这些以前得写很多代码，现在只要几行，轻轻松松搞定！兼容原生 MyBatis 🔁
你可以边用 MP，边用你原来的 MyBatis 代码，两者不冲突！社区活跃、文档清晰 📚
这是一个“不求人也能搞懂”的工具，适合入门和快速开发。
👶 适合人群与使用场景
✅ 初学者 / 编程小白：不想一开始就写一堆 SQL 和 XML，MP 让你更快进入开发状态。
✅ 开发时间紧张的项目：快速搭建后端接口，节省大量开发时间。
✅ 偏前端的全栈开发者：不太想深入数据库细节，只想“快速搞定数据库功能”。
✅ 中小型项目 / 快速原型设计：CRUD 轻松写，代码清爽不乱套。
🎉 简单一句话总结：MyBatis 是打基础的砖，MyBatis-Plus 是帮你搬砖的机器！
上车不亏，轻松起飞！🚀
二、MyBatis-Plus 简介 🎯
🧐 什么是 MyBatis-Plus？
MyBatis-Plus（简称 MP） 是基于 MyBatis 的增强工具包，它的目标很明确：
👉 简化开发，提升效率，让你从“繁琐重复的 SQL 编写”中解放出来！
它就像是给 MyBatis 装上了“外挂”🔧，在不改变原有用法的基础上，为你带来很多 开箱即用的强大功能，比如不用写 SQL 也能增删改查、自动分页、代码生成等等。
📦 类比一下：
MyBatis 是一个优秀的电钻（好用但需要自己操作）
MyBatis-Plus 是自动电钻（点一下按钮，它自己转 😆）
💡 核心理念：简化开发 & 零侵入
MP 最核心的两个关键词就是：
简化开发 🚀
几行代码就能搞定数据库操作，大大提升开发效率，尤其在 CURD 密集型业务中如鱼得水🐟。零侵入设计 ✋
不破坏原来的 MyBatis 用法，兼容性强。你可以一边用 MP 的快捷操作，一边写自己的 SQL，两不耽误！
🌟 MyBatis-Plus 的主要特性一览
| 特性 | 描述 | 适合谁 |
|---|---|---|
| ✅ 无需编写 XML | 基本 CRUD 操作不用再写繁琐的 mapper.xml 了，直接调用接口方法即可 | 小白福音！ |
| ✅ 内置通用 CRUD | 提供丰富的通用 Mapper 方法，如 insert、deleteById、selectById 等 |
快速开发首选 |
| ✅ 条件构造器 | 不再手写 SQL，链式调用实现查询条件，如 eq、like、between 等 |
写代码像写诗 ✍️ |
| ✅ 分页插件 | 超轻松实现分页查询，只需配置一次，随处可用 | 做列表页神器 📄 |
| ✅ 自动填充字段 | 创建时间 / 更新时间自动维护，减少重复代码 | 对懒人超友好 😎 |
| ✅ 乐观锁机制 | 并发操作数据时防止互相覆盖，适合多用户修改场景 | 数据安全保障盾🛡️ |
| ✅ 代码生成器 | 自动生成 Entity、Mapper、Service、Controller，大大节省重复工作 | “我不想写模板代码”星人 ❤️ |
🧠 总结一句话：
MyBatis-Plus = 更聪明的 MyBatis，更快乐的开发体验！
接下来，我们就要开始实操啦！动手写代码，带你快速上手 MP 🚀
三、快速入门 🛠️
接下来，我们将真正动手，带你从 0 配置项目环境，到写出第一个 CRUD 接口！不用怕，这部分超简单，按步骤来就行啦！
✅ 环境准备
开发环境我们建议用这个组合：
| 工具 | 推荐版本 |
|---|---|
| JDK | 1.8 或以上 ☕ |
| Spring Boot | 2.5.x ~ 3.x ✅ |
| MyBatis-Plus | 最新稳定版本 |
| 数据库 | MySQL 5.7+ / 8.0 |
| 开发工具 | IntelliJ IDEA / VS Code 👨💻 |
📦 项目依赖（Maven 示例）
在 pom.xml 中添加如下依赖👇
<dependencies>
<!-- MyBatis-Plus 核心依赖 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.5</version> <!-- 版本可根据官网调整 -->
</dependency>
<!-- MySQL 驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
<!-- Lombok（简化实体类编写） -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
🗃️ 数据库准备（以 MySQL 为例）
创建一个简单的表，比如用户表：
CREATE TABLE user (
id BIGINT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(50),
age INT,
email VARCHAR(100)
);
⚙️ 基本配置
1. application.yml 配置示例：
spring:
datasource:
url: jdbc:mysql://localhost:3306/demo_db?useSSL=false&serverTimezone=UTC
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 控制台输出 SQL
2. Mapper 扫描配置
在你的启动类或配置类上加上👇：
@MapperScan("com.example.mapper")
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
💻 第一个 CRUD 示例！
1. 创建实体类（使用 Lombok 简化）
@Data
@TableName("user") // 表名对应
public class User {
private Long id;
private String name;
private Integer age;
private String email;
}
2. 编写 Mapper 接口
public interface UserMapper extends BaseMapper<User> {
// BaseMapper 已经提供了常用方法，不用自己写啦！
}
3. 简单的增删改查示例
可以在测试类或 Controller 中写如下代码来测试👇
@Autowired
private UserMapper userMapper;
// 插入数据
User user = new User();
user.setName("小明");
user.setAge(22);
user.setEmail("xiaoming@example.com");
userMapper.insert(user);
// 查询
User u = userMapper.selectById(1L);
System.out.println(u);
// 更新
u.setAge(25);
userMapper.updateById(u);
// 删除
userMapper.deleteById(1L);
🎉 恭喜你，第一个 MP 项目成功运行！
是不是比想象中还简单？
下一步我们可以进入功能加强环节，比如：条件查询、分页、自动填充字段等，都是 MP 的看家本领！
四、核心功能详解 🔍
4.1 通用 CRUD 接口（BaseMapper 的魔法 ✨）
在 MP 中，只要你的 Mapper 接口继承了 BaseMapper<T>，就拥有了一整套通用的 CRUD 方法，不用再写任何 SQL 或 XML，直接用就行！👌
🌱 使用准备
public interface UserMapper extends BaseMapper<User> {
// 什么都不用写，BaseMapper 已经帮你写好了！
}
📚 常用方法一览表（超实用🔥）
| 方法名 | 作用 | 示例 |
|---|---|---|
insert(T entity) |
插入数据 | userMapper.insert(user); |
deleteById(id) |
根据 ID 删除 | userMapper.deleteById(1L); |
updateById(entity) |
根据 ID 修改 | user.setAge(30); userMapper.updateById(user); |
selectById(id) |
根据 ID 查询 | userMapper.selectById(1L); |
selectList(wrapper) |
条件查询列表 | userMapper.selectList(null); 查询全部 |
selectCount(wrapper) |
条件统计数量 | userMapper.selectCount(null); |
🧪 示例代码演示
// 新增
User user = new User();
user.setName("张三");
user.setAge(28);
user.setEmail("zhangsan@example.com");
userMapper.insert(user);
// 查询
User found = userMapper.selectById(user.getId());
System.out.println("查到的用户：" + found);
// 修改
found.setAge(30);
userMapper.updateById(found);
// 删除
userMapper.deleteById(found.getId());
🧠 小贴士：
BaseMapper提供的是最基础的操作，它适用于单表、简单业务逻辑。如果有复杂 SQL 需求（多表联查、动态条件），就配合
QueryWrapper或自己写 SQL。
4.2 条件构造器 Wrapper 使用 🧱
MyBatis-Plus 提供了多种条件构造器，帮你构建查询、更新等 SQL 语句，再也不用写 if else 拼 SQL 了！🎉
🎯 常见构造器简介
| 构造器 | 简介 |
|---|---|
QueryWrapper<T> |
通用查询构造器，字段名使用字符串 |
LambdaQueryWrapper<T> |
Lambda 查询构造器，字段使用方法引用，更安全不易错 |
UpdateWrapper<T> |
用于构建更新条件 |
LambdaUpdateWrapper<T> |
Lambda 风格更新构造器 |
🔍 QueryWrapper 示例（字符串字段版）
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("age", 25)
.like("name", "张")
.orderByDesc("id");
List<User> users = userMapper.selectList(wrapper);
📖 输出 SQL：
SELECT * FROM user WHERE age = 25 AND name LIKE '%张%' ORDER BY id DESC;
✅ LambdaQueryWrapper 示例（推荐，更安全）
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getAge, 25)
.like(User::getName, "张")
.orderByDesc(User::getId);
List<User> users = userMapper.selectList(wrapper);
🧠 好处：
不怕拼错字段名，字段名改了 IDEA 会提示你
更适合大型项目、重构场景
🧰 常见条件方法大全
| 方法 | 含义 |
|---|---|
eq("col", val) |
等于 |
ne("col", val) |
不等于 |
gt("col", val) |
大于 |
lt("col", val) |
小于 |
like("col", val) |
模糊匹配 |
in("col", list) |
IN 查询 |
between("col", val1, val2) |
BETWEEN 查询 |
isNull("col") / isNotNull("col") |
判断字段是否为空 |
🧩 动态拼接条件（比如：某些字段不为空才查询）
String name = "张三";
Integer age = null;
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.like(StringUtils.isNotBlank(name), "name", name)
.eq(age != null, "age", age);
💡 小技巧：条件方法的第一个参数是 boolean，控制这个条件是否加入 SQL。
4.3 分页功能 📄
分页查询在实际开发中太常见了（比如：用户列表、文章列表、商品列表等等），MyBatis-Plus 提供了极其简单优雅的分页方案！
✅ 第一步：配置分页插件（必须配置一次）
在 Spring Boot 项目中创建一个配置类 👇
@Configuration
public class MyBatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 添加分页插件
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return interceptor;
}
}
⚠️ 如果你用的是 MyBatis-Plus 3.4 以前的版本，分页插件写法不同，推荐升级到最新版更方便！
🚀 第二步：使用分页查询
分页查询只需要两个参数：Page 对象 + QueryWrapper（可选）
// 查询第 1 页，每页 5 条记录
Page<User> page = new Page<>(1, 5);
// 执行分页查询（可以带查询条件）
IPage<User> result = userMapper.selectPage(page, new QueryWrapper<User>().like("name", "张"));
// 获取分页结果
List<User> records = result.getRecords(); // 当前页数据
long total = result.getTotal(); // 总记录数
long pages = result.getPages(); // 总页数
🎯 分页结果对象 IPage 解读
| 方法 | 含义 |
|---|---|
getRecords() |
当前页数据列表 |
getTotal() |
总记录数 |
getCurrent() |
当前页码 |
getPages() |
总页数 |
getSize() |
每页条数 |
💡 Lambda + 分页 + 条件示例（推荐组合）
Page<User> page = new Page<>(1, 10);
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.ge(User::getAge, 18);
IPage<User> result = userMapper.selectPage(page, wrapper);
你就能优雅地实现 👇
SELECT * FROM user WHERE age >= 18 LIMIT 0, 10;
是不是超丝滑~ ✨
🎉 小结：分页功能 = 插件配置 + 一行代码，效率杠杠的！
4.4 自动填充字段 & 乐观锁 🔄🛡️
🕐 自动填充字段（比如：创建时间、更新时间）
开发时常常会有这样的字段：
create_time：记录创建时间update_time：每次修改都会更新这个字段
自己手动填？太麻烦，容易忘！MP 帮你自动填上！
✅ 第一步：数据库字段设置默认值（非必须）
create_time DATETIME,
update_time DATETIME
✅ 第二步：实体类上加注解
@Data
public class User {
private Long id;
private String name;
private Integer age;
private String email;
@TableField(fill = FieldFill.INSERT) // 插入时自动填充
private LocalDateTime createTime;
@TableField(fill = FieldFill.INSERT_UPDATE) // 插入和更新时都填
private LocalDateTime updateTime;
}
✅ 第三步：实现元数据处理器（核心）
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
this.strictInsertFill(metaObject, "createTime", LocalDateTime::now, LocalDateTime.class);
this.strictInsertFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class);
}
@Override
public void updateFill(MetaObject metaObject) {
this.strictUpdateFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class);
}
}
就这样，插入或更新数据的时候，MP 自动帮你维护时间字段，不用你手动 set 啦！ 🎉
🛡️ 乐观锁机制（防止并发写入冲突）
在高并发系统中，可能会出现两个用户同时修改同一条数据，造成覆盖问题。
乐观锁的策略是：
👉 更新前判断“版本号”是否一致，不一致就不让更新！
✅ 第一步：数据库增加 version 字段
ALTER TABLE user ADD version INT DEFAULT 1;
✅ 第二步：实体类增加注解
@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;
✅ 第三步：配置乐观锁插件
在之前的分页插件配置类中加入这一行👇
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
✅ 最后：用 updateById 就自动生效！
User user = userMapper.selectById(1L);
user.setAge(40);
userMapper.updateById(user); // 会自动带上 version 判断
⚠️ 如果更新时发现 version 不一致，会直接更新失败，不抛异常，但返回值为 0（更新失败），你可以据此进行重试逻辑。
✅ 工作原理小图示（简化）：
1. 查询时拿到 version = 1
2. 修改数据，准备更新 version = 2
3. SQL 更新时会判断 version 是否还是 1
4. 是：更新成功；否则：失败，说明别人改过了！
✅ 总结一句话：
自动填充 ➜ 让你更专注业务逻辑，不管时间字段
乐观锁 ➜ 让你数据更安全，不担心“最后一次覆盖”
4.5 代码生成器 🧙♂️ 自动化开发神器！
手写一堆实体类、Mapper、Service……烦不烦？
MP 的代码生成器就是为了解放双手而生的！
✅ 步骤概览：
添加依赖
编写生成代码（单独建一个类跑）
执行后直接生成一整套代码 ✨
☕ 1. 添加依赖（Maven）
<!-- 代码生成器 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.5.5</version>
</dependency>
<!-- 模板引擎（默认用的是 Velocity） -->
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity-engine-core</artifactId>
<version>2.3</version>
</dependency>
⚙️ 2. 编写代码生成器类
public class CodeGenerator {
public static void main(String[] args) {
// 数据源配置
DataSourceConfig.Builder dataSourceConfig = new DataSourceConfig
.Builder("jdbc:mysql://localhost:3306/demo_db", "root", "root");
// 策略配置
StrategyConfig strategy = new StrategyConfig.Builder()
.addInclude("user") // 要生成的表名，可以多个
.entityBuilder().enableLombok() // 开启 Lombok
.controllerBuilder().enableRestStyle() // REST 风格
.build();
// 全局配置
GlobalConfig globalConfig = new GlobalConfig.Builder()
.author("你的名字") // 作者名
.outputDir(System.getProperty("user.dir") + "/src/main/java") // 输出路径
.build();
// 包配置
PackageConfig packageConfig = new PackageConfig.Builder()
.parent("com.example") // 包名根路径
.moduleName("demo") // 子模块名
.build();
// 执行生成
AutoGenerator generator = new AutoGenerator(dataSourceConfig.build());
generator.global(globalConfig);
generator.packageInfo(packageConfig);
generator.strategy(strategy);
generator.execute();
}
}
📂 3. 执行效果（生成结构）
src/main/java
├── com/example/demo/entity/User.java
├── com/example/demo/mapper/UserMapper.java
├── com/example/demo/service/UserService.java
├── com/example/demo/service/impl/UserServiceImpl.java
├── com/example/demo/controller/UserController.java
XML 文件也会自动生成到 resources/mapper/ 文件夹下！
🧠 小贴士：
支持多表生成：
addInclude("user", "product", "order")支持配置逻辑删除字段、版本字段、自动填充字段等
模板引擎也可以替换成 Freemarker、Beetl 等（看你口味 😋）
🎉 结语一句话： 代码生成器 ≠ 代码屎山，而是让你从繁琐重复中解放出来，优雅开启高效开发！
五、进阶使用技巧 💡
5.1 多数据源支持（动态切库，轻松搞定！）
在复杂系统中，我们经常会遇到一个项目要操作多个数据库的情况。MyBatis-Plus 本身不提供多数据源管理，但可以配合 Spring Boot + dynamic-datasource-spring-boot-starter 快速搞定！
✅ 一、引入依赖（动态数据源）
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>3.6.1</version>
</dependency>
✅ 二、application.yml 配置多个数据源
spring:
datasource:
dynamic:
primary: master
strict: false
datasource:
master:
url: jdbc:mysql://localhost:3306/db1
username: root
password: root
slave:
url: jdbc:mysql://localhost:3306/db2
username: root
password: root
✅ 三、使用注解动态切库
@Service
public class UserService {
@DS("master") // 指定使用 master 库
public List<User> getFromMaster() {
return userMapper.selectList(null);
}
@DS("slave") // 指定使用 slave 库
public List<User> getFromSlave() {
return userMapper.selectList(null);
}
}
💬 默认不加 @DS 时使用的是 primary 指定的库。
✅ 四、小结 🧠
| 功能 | 工具 |
|---|---|
| 多数据源管理 | dynamic-datasource |
| 数据源切换方式 | @DS 注解、AOP方式等 |
| 适合场景 | 读写分离、多模块库、历史库 |
5.2 逻辑删除（数据不会真的被删除，安全又可靠）
✅ 一、配置逻辑删除字段
为了实现逻辑删除，我们需要在数据库表中添加一个标志字段。常见的做法是新增一个 deleted 字段，它用于表示数据是否已被删除。通常，0 表示未删除，1 表示已删除。
1.1 修改数据库表，添加 deleted 字段
ALTER TABLE user ADD deleted TINYINT DEFAULT 0; -- 0: 未删除，1: 已删除
1.2 在实体类中加入 deleted 字段，并标注 @TableLogic 注解
@Data
public class User {
private Long id;
private String name;
private Integer age;
private String email;
@TableLogic
private Integer deleted; // 逻辑删除字段
}
这里的 @TableLogic 注解告诉 MyBatis-Plus 这个字段是用来标记逻辑删除的，MP 会根据它的值自动处理删除操作。
✅ 二、使用逻辑删除查询
2.1 默认查询会自动排除已删除数据
当我们通过 MyBatis-Plus 查询数据时，默认会自动排除已删除的数据。也就是说，不需要手动加过滤条件。
// 查询所有未删除的用户
List<User> users = userMapper.selectList(null); // 自动排除已删除的用户
2.2 如果需要查询已删除的数据
如果你想查询包括已删除的数据，可以通过 QueryWrapper 的 eq 方法手动设置过滤条件：
// 查询已删除的数据
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("deleted", 1); // 1 表示已删除
List<User> deletedUsers = userMapper.selectList(wrapper);
2.3 手动执行逻辑删除
如果你想手动删除某条数据（即标记为已删除），你可以通过更新操作来实现：
User user = new User();
user.setId(1L);
user.setDeleted(1); // 设置为已删除
userMapper.updateById(user);
这样，数据并不会被从数据库中删除，而是将 deleted 字段设置为 1。
✅ 三、自动删除操作
MyBatis-Plus 也提供了内置的逻辑删除方法，例如 deleteById，但需要开启逻辑删除功能。这些方法会自动将 deleted 字段置为 1，而不是从数据库中物理删除。
// 逻辑删除（实际并未删除记录，只是将 deleted 字段更新为 1）
userMapper.deleteById(1L);
如果你用的是 delete 之类的操作，它会被转为更新 deleted = 1。
✅ 四、逻辑删除的自动过滤
MyBatis-Plus 会自动在所有查询中加上 deleted = 0 的过滤条件，无需手动编写。但你也可以自定义某些查询不受 deleted 字段影响。
4.1 自定义查询（不受 deleted 影响）
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("age", 20);
List<User> users = userMapper.selectList(wrapper); // 不受 deleted 字段影响
4.2 忽略删除字段的查询
如果你在查询时想不受 deleted 字段影响，可以使用 QueryWrapper 的 eq 来明确指定查询条件。
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.isNull("deleted"); // 查询 deleted 字段为 null 的数据
✅ 小结：
逻辑删除字段配置：在数据库和实体类中增加
deleted字段，并在实体类上使用@TableLogic注解。自动过滤：MyBatis-Plus 查询时，默认会自动排除已删除的数据（
deleted = 0）。手动删除：通过更新
deleted字段来实现逻辑删除。自定义查询：通过
QueryWrapper手动控制查询条件，避免deleted字段影响查询。
好的，接下来我们深入探讨 5.3 性能分析插件，它能帮助我们高效优化数据库性能，让SQL执行更加高效！🚀
5.3 性能分析插件（SQL 执行分析与慢 SQL 提醒）
MyBatis-Plus 提供的 性能分析插件，可以用来 分析 SQL 执行时间，并及时 提醒慢 SQL。它对于开发过程中进行 SQL 性能调优，以及提前发现潜在的 性能瓶颈 很有帮助。
✅ 一、配置性能分析插件
在 Spring Boot 中，配置性能分析插件非常简单。你只需要在项目的配置类中定义一个 PerformanceInterceptor bean，就可以启用性能分析。
1.1 添加 Maven 依赖
首先，确保你的 pom.xml 中包含了 MyBatis-Plus 依赖，通常这些依赖在初始化项目时就已经添加好了。如果没有，可以手动添加：
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.5</version>
</dependency>
1.2 配置 PerformanceInterceptor
你可以通过 PerformanceInterceptor 来配置 SQL 执行时间分析。接下来，在你的配置类中进行设置：
@Configuration
public class MyBatisPlusConfig {
@Bean
public PerformanceInterceptor performanceInterceptor() {
PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
performanceInterceptor.setMaxTime(3000); // 设置最大执行时间，单位毫秒
performanceInterceptor.setFormat(true); // 格式化 SQL，输出更友好
return performanceInterceptor;
}
}
setMaxTime(3000)：表示如果 SQL 执行时间超过 3000 毫秒（即 3 秒），会触发警告提醒。setFormat(true)：表示 SQL 输出时会进行格式化，使得 SQL 更加易读。
✅ 二、慢 SQL 提醒
慢 SQL 提醒 功能可以帮助我们发现执行时间过长的 SQL，提前优化它们，避免性能瓶颈。
2.1 慢 SQL 输出
当某条 SQL 执行时间超过你设定的最大执行时间时，会在控制台输出警告，并且显示 SQL 执行的详细信息。
[WARN] 3000ms exceeded: SELECT * FROM user WHERE age > 20;
这里的 3000ms 就是执行时间，意味着这条查询已经超过了设定的 3 秒，可能需要进一步优化。
2.2 配置日志输出
为了方便查看慢 SQL，可以配置日志输出，便于后续分析。你可以通过配置 logback 或 log4j2 输出 SQL 执行日志。
示例如下：
<logger name="com.baomidou.mybatisplus" level="DEBUG">
<appender-ref ref="Console" />
</logger>
这样，所有的 SQL 执行日志都会被打印出来，帮助你跟踪慢 SQL。
✅ 三、常见慢 SQL 排查建议
当你发现某些 SQL 执行时间过长时，可以通过以下几个方面进行排查和优化：
3.1 查看索引
没有索引：如果查询没有使用索引，数据库会全表扫描，导致查询速度变慢。可以在常用查询字段上添加索引。
3.2 优化查询逻辑
复杂查询：避免在查询时进行复杂的多表联查或子查询，可以考虑将查询拆解，减少不必要的数据处理。
3.3 数据量过大
分页查询：对于数据量较大的查询，尽量使用分页查询，避免一次性查询过多数据。
✅ 小结：
| 功能 | 配置说明 |
|---|---|
| 性能分析插件 | 通过 PerformanceInterceptor 来启用 |
| 设置最大执行时间 | setMaxTime(3000)，超过 3000 毫秒提醒 |
| 格式化 SQL | setFormat(true)，输出更易读的 SQL |
| 慢 SQL 提醒 | 输出执行时间超过最大值的 SQL，并给出警告 |
| SQL 执行日志输出 | 配置日志框架（如 logback）输出 SQL 执行信息 |
4. 使用性能分析插件的优势
及时发现性能瓶颈：慢 SQL 提醒帮助开发者及时发现执行时间过长的 SQL，进行优化，避免在生产环境中出现性能问题。
提高开发效率：通过 SQL 执行时间分析，开发人员可以更加高效地找到需要优化的部分，而不需要手动去调试和分析。
自动化优化：性能分析插件自动化地给出执行时间警告，降低了开发人员在性能优化上的工作量。
5.4 自定义 SQL（让你更自由，查询不受限）
MyBatis-Plus 提供了非常强大的查询功能，但在某些复杂的业务场景中，通用的 CRUD 方法可能无法满足需求。此时，你可以通过自定义 SQL 来实现更灵活的查询。
✅ 一、使用 @Select 注解执行自定义 SQL
MyBatis-Plus 允许你通过 @Select 注解来执行自定义的 SQL 查询。你可以在 Mapper 接口中直接写 SQL 语句，非常方便。
1.1 使用 @Select 注解执行查询
在 Mapper 接口中的方法上使用 @Select 注解，直接编写 SQL 语句：
@Mapper
public interface UserMapper extends BaseMapper<User> {
@Select("SELECT * FROM user WHERE age > #{age}")
List<User> selectByAge(@Param("age") int age);
}
@Select注解表示这个方法执行一个查询操作。#{age}是参数占位符，表示方法中的参数age会被传入到 SQL 中。
调用示例：
List<User> users = userMapper.selectByAge(20); // 查询年龄大于 20 的用户
1.2 使用其他 SQL 注解
除了 @Select，你还可以使用其他注解（如 @Insert、@Update 和 @Delete）来执行自定义的 SQL。
@Mapper
public interface UserMapper extends BaseMapper<User> {
@Insert("INSERT INTO user(name, age, email) VALUES(#{name}, #{age}, #{email})")
void insertUser(User user);
@Update("UPDATE user SET name=#{name} WHERE id=#{id}")
void updateUser(User user);
@Delete("DELETE FROM user WHERE id=#{id}")
void deleteUser(Long id);
}
这里的
@Insert、@Update和@Delete注解分别对应插入、更新和删除操作，SQL 语句直接写在注解中。
✅ 二、XML 自定义 SQL
虽然注解方式方便，但在面对复杂的查询时，SQL 可能变得难以维护，尤其是在多个查询语句时，XML 配置方式更加灵活。你可以将 SQL 放在 XML 文件中，保持代码的整洁性。
2.1 配置 XML 文件中的自定义 SQL
在 resources/mapper 目录下创建一个 UserMapper.xml 文件，定义自定义的 SQL 语句：
<mapper namespace="com.example.mapper.UserMapper">
<!-- 自定义查询，查询年龄大于指定值的用户 -->
<select id="selectByAge" resultType="com.example.model.User">
SELECT * FROM user WHERE age > #{age}
</select>
<!-- 自定义插入 -->
<insert id="insertUser">
INSERT INTO user(name, age, email) VALUES(#{name}, #{age}, #{email})
</insert>
<!-- 自定义更新 -->
<update id="updateUser">
UPDATE user SET name=#{name} WHERE id=#{id}
</update>
<!-- 自定义删除 -->
<delete id="deleteUser">
DELETE FROM user WHERE id=#{id}
</delete>
</mapper>
2.2 在 Mapper 接口中调用 XML 中的 SQL
@Mapper
public interface UserMapper extends BaseMapper<User> {
List<User> selectByAge(@Param("age") int age);
void insertUser(User user);
void updateUser(User user);
void deleteUser(Long id);
}
在接口方法中，不需要再次编写 SQL，只需要调用 XML 文件中对应的
id。
✅ 三、动态 SQL
在某些场景下，我们需要根据不同的条件动态构建 SQL，比如查询条件根据用户输入的不同而变化。MyBatis 提供了 XML 文件中的动态 SQL 标签来实现这一需求。
3.1 使用 <if> 标签构建动态 SQL
<mapper namespace="com.example.mapper.UserMapper">
<select id="selectByDynamicConditions" resultType="User">
SELECT * FROM user
<where>
<if test="name != null">AND name = #{name}</if>
<if test="age != null">AND age = #{age}</if>
</where>
</select>
</mapper>
<where>标签会自动为 SQL 语句加上WHERE关键字，并且自动处理多余的AND。<if>标签会根据条件判断来动态生成 SQL 语句。
3.2 使用 <choose> 标签处理复杂的逻辑
<select id="selectByDynamicConditions" resultType="User">
SELECT * FROM user
<where>
<choose>
<when test="name != null">AND name = #{name}</when>
<when test="age != null">AND age = #{age}</when>
<otherwise>AND deleted = 0</otherwise>
</choose>
</where>
</select>
<choose>标签类似于 Java 的switch语句，用来在多个条件中选择一个。
✅ 小结：
| 操作 | 说明 |
|---|---|
@Select 注解 |
用于执行自定义的查询 SQL |
@Insert 注解 |
用于执行自定义的插入 SQL |
@Update 注解 |
用于执行自定义的更新 SQL |
@Delete 注解 |
用于执行自定义的删除 SQL |
| XML 自定义 SQL | 将 SQL 放在 XML 文件中进行配置 |
| 动态 SQL | 使用 <if>, <choose> 等标签来构建动态 SQL |
| 自定义 SQL 优势 | 提高灵活性，满足复杂查询需求 |
六、常见问题与优化建议
✅ 一、与 MyBatis 的兼容性问题
MyBatis-Plus 是基于 MyBatis 的封装和扩展，因此它是与 MyBatis 兼容的。但由于 MyBatis-Plus 提供了大量的自动化功能，某些情况下可能会与原生 MyBatis 的配置或行为有所冲突。以下是几个常见的兼容性问题和解决方案：
1.1 兼容性问题：自定义插件与 MyBatis-Plus 的冲突
问题描述：如果你已经使用了 MyBatis 的某些自定义插件（比如分页插件、性能分析插件等），可能会和 MyBatis-Plus 的默认插件发生冲突。
解决方案：确保自定义插件与 MyBatis-Plus 插件的顺序和优先级正确，或者在 MyBatis 配置中明确排除 MyBatis-Plus 插件。
1.2 MyBatis 配置文件的冲突
问题描述：在 MyBatis 配置文件中手动配置的某些设置可能与 MyBatis-Plus 的自动配置产生冲突，比如缓存策略、驼峰命名规则等。
解决方案：如果你手动设置了 MyBatis 的配置，可以通过
@MapperScan指定扫描的包路径，或者明确禁用 MyBatis-Plus 的某些功能。
@MapperScan("com.example.mapper")
@Configuration
public class MyBatisConfig {
// 手动配置 MyBatis 和 MyBatis-Plus 的兼容设置
}
✅ 二、大批量插入的性能优化
在处理大批量数据插入时，性能是一个非常重要的问题。虽然 MyBatis-Plus 提供了基本的 insertBatch 功能，但对于大批量数据插入，仍然有很多优化空间。
2.1 使用批量插入代替逐条插入
问题描述：逐条插入数据会导致大量的数据库连接和 I/O 操作，极大影响性能。
解决方案：使用批量插入来减少数据库操作的次数。MyBatis-Plus 提供了
saveBatch方法来进行批量插入。
List<User> users = // 一些用户数据;
userService.saveBatch(users); // 批量插入数据
2.2 批量插入大小的控制
问题描述：批量插入时，一次插入的数量过大可能会导致内存溢出或数据库压力过大。
解决方案：建议将批量插入的数量控制在合理范围内（例如，每次 500-1000 条数据），根据实际情况调整批次大小。
int batchSize = 1000; // 每次插入 1000 条数据
for (int i = 0; i < users.size(); i += batchSize) {
int end = Math.min(i + batchSize, users.size());
userService.saveBatch(users.subList(i, end));
}
2.3 开启数据库的批量操作支持
问题描述：有些数据库的默认配置可能不会启用批量插入的优化。
解决方案：根据使用的数据库类型，确保开启批量操作支持。例如，使用 MySQL 时可以通过设置
auto-commit为false来提高批量插入的性能。
✅ 三、枚举类型处理
在实际开发中，我们经常会使用枚举类型来表示某些状态、类型等。MyBatis-Plus 对枚举类型提供了很好的支持，但在某些情况下，处理不当可能会导致问题。
3.1 枚举类型存储为数字或字符串
问题描述：枚举类型在数据库中通常以数字或字符串形式存储，但 MyBatis-Plus 默认会将枚举类型转换为其
ordinal（数字值）进行存储，这可能与数据库中的存储格式不一致。解决方案：通过
@EnumValue注解指定枚举值存储的方式（例如存储为字符串）。
public enum UserStatus {
ACTIVE(1, "Active"),
INACTIVE(0, "Inactive");
@EnumValue
private final int code;
private final String description;
UserStatus(int code, String description) {
this.code = code;
this.description = description;
}
}
使用
@EnumValue注解可以指定枚举类型的存储值（如存储为数字或字符串）。
3.2 枚举字段的映射处理
问题描述：如果枚举类型的值需要特殊映射处理，可能会出现转换问题。
解决方案：可以通过 MyBatis-Plus 提供的
@TableField注解配合自定义类型处理器（TypeHandler）来处理枚举类型的转换。
@TableField(typeHandler = EnumTypeHandler.class)
private UserStatus status;
✅ 四、字段自动映射策略优化
MyBatis-Plus 默认会按照驼峰命名规则进行字段映射，但有时我们希望字段名的映射更加灵活。以下是一些优化建议：
4.1 全局驼峰命名规则的优化
问题描述：默认情况下，MyBatis-Plus 会根据驼峰命名规则自动进行字段映射，但在某些场景下，表字段名与实体类字段名不完全一致。
解决方案：可以通过配置全局策略，关闭或修改驼峰命名规则的自动映射策略。
@Configuration
public class MyBatisPlusConfig {
@Bean
public GlobalConfig globalConfig() {
GlobalConfig globalConfig = new GlobalConfig();
globalConfig.setDbColumnUnderline(true); // 开启数据库字段与实体类字段的自动映射
return globalConfig;
}
}
4.2 自定义字段映射策略
问题描述：如果你需要某些字段采用不同的映射规则，默认的全局配置可能无法满足需求。
解决方案：通过
@TableField注解手动配置字段的映射策略。例如，使用value设置数据库列名，使用exist设置字段是否映射到数据库：
@TableField(value = "user_name", exist = true) // 映射为 "user_name" 字段
private String username;
4.3 避免不必要的字段映射
问题描述：如果数据库中存在很多字段，而你只需要部分字段，加载不需要的字段会浪费性能。
解决方案：可以通过
@TableField(exist = false)来标记某些字段不参与数据库映射。
@TableField(exist = false)
private String tempField; // 不参与数据库字段映射
✅ 小结
| 问题类别 | 解决方案 |
|---|---|
| 兼容性问题 | 调整插件顺序，避免与 MyBatis 配置冲突，明确禁用 MyBatis-Plus 功能 |
| 大批量插入优化 | 使用 saveBatch 进行批量插入，控制批量大小，开启数据库批量支持 |
| 枚举类型处理 | 使用 @EnumValue 控制枚举值存储方式，使用自定义 TypeHandler |
| 字段自动映射优化 | 配置全局策略，手动映射字段名，避免不必要的字段映射 |
七、项目实战案例：整合 Spring Boot + MyBatis-Plus 实现一个简单的用户管理系统
✅ 一、项目需求分析
我们要实现一个简单的 用户管理系统，用户能够进行如下操作：
分页查询：查询用户信息，支持分页功能。
用户查询：支持按用户姓名或年龄查询用户。
用户新增：用户信息的新增操作。
自动填充：在新增或更新用户时，自动填充某些字段（例如创建时间、更新时间等）。
✅ 二、项目搭建与配置
2.1 创建 Spring Boot 项目
使用 Spring Initializr 创建一个新的 Spring Boot 项目。
Group: com.example
Artifact: user-management
Dependencies: Spring Web, Spring Data JPA, MyBatis-Plus, MySQL Driver, Lombok
将创建好的项目导入到 IDE 中。
2.2 配置 MyBatis-Plus 和数据库连接
在 application.yml 文件中配置数据库连接和 MyBatis-Plus 设置：
spring:
datasource:
url: jdbc:mysql://localhost:3306/my_database?serverTimezone=UTC
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
mapper-locations: classpath:/mapper/*Mapper.xml
typeAliasesPackage: com.example.model
configuration:
map-underscore-to-camel-case: true # 驼峰命名
配置了 MySQL 数据库的连接。
启用了 驼峰命名转换，将数据库的下划线命名转换为 Java 中的驼峰命名。
✅ 三、创建实体类（User）
在 com.example.model 包下创建 User 实体类：
package com.example.model;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@Data
@TableName("user")
public class User implements Serializable {
@TableId(type = IdType.AUTO)
private Long id;
private String name;
private Integer age;
private String email;
@TableField(fill = FieldFill.INSERT)
private Date createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
@TableLogic // 逻辑删除字段
private Integer deleted;
}
@TableName("user"): 表示该实体类对应的数据库表是user。@TableId(type = IdType.AUTO): 表示id字段为自增长。@TableField(fill = FieldFill.INSERT): 表示createTime字段在插入时自动填充。@TableLogic: 表示启用逻辑删除功能。
✅ 四、创建 Mapper 接口
在 com.example.mapper 包下创建 UserMapper 接口：
package com.example.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.model.User;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
继承
BaseMapper<User>，自动获得常见的 CRUD 操作。
✅ 五、创建 Service 层
在 com.example.service 包下创建 UserService 接口和实现类 UserServiceImpl：
5.1 创建 UserService 接口
package com.example.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.example.model.User;
public interface UserService extends IService<User> {
// 可以扩展自定义的方法
}
5.2 创建 UserServiceImpl 实现类
package com.example.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.mapper.UserMapper;
import com.example.model.User;
import com.example.service.UserService;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
// 实现自定义的方法
}
ServiceImpl是 MyBatis-Plus 提供的实现类，它已经实现了常见的 CRUD 方法。
✅ 六、创建 Controller 层
在 com.example.controller 包下创建 UserController 控制器，提供分页查询和用户操作接口：
package com.example.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.model.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
// 分页查询
@GetMapping("/page")
public Page<User> getUsers(@RequestParam int page, @RequestParam int size) {
Page<User> userPage = new Page<>(page, size);
return userService.page(userPage);
}
// 根据条件查询用户
@GetMapping("/search")
public List<User> searchUsers(@RequestParam(required = false) String name, @RequestParam(required = false) Integer age) {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
if (name != null) {
queryWrapper.like("name", name);
}
if (age != null) {
queryWrapper.eq("age", age);
}
return userService.list(queryWrapper);
}
// 添加用户
@PostMapping("/add")
public boolean addUser(@RequestBody User user) {
return userService.save(user);
}
// 删除用户（逻辑删除）
@DeleteMapping("/delete/{id}")
public boolean deleteUser(@PathVariable Long id) {
return userService.removeById(id);
}
}
分页查询：使用 MyBatis-Plus 提供的
Page对象进行分页。查询用户：通过
QueryWrapper实现动态查询，支持按姓名和年龄查询。添加用户：通过
save方法新增用户，自动填充字段。删除用户：通过
removeById实现逻辑删除。
✅ 七、分页查询插件配置
为了支持分页查询，我们需要启用 MyBatis-Plus 的分页插件。创建分页插件配置类：
package com.example.config;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MyBatisPlusConfig {
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
}
PaginationInterceptor是 MyBatis-Plus 提供的分页插件，可以自动处理分页查询。
✅ 八、项目运行与测试
启动 Spring Boot 项目。
使用 Postman 或其他工具测试接口：
分页查询：GET
/user/page?page=1&size=10按条件查询：GET
/user/search?name=John添加用户：POST
/user/add删除用户：DELETE
/user/delete/{id}
✅ 九、功能总结
在这个简单的用户管理系统中，我们实现了以下常用功能：
分页查询：通过 MyBatis-Plus 提供的分页插件，支持高效的分页查询。
查询功能：支持根据用户姓名和年龄查询用户。
用户新增与自动填充：在新增用户时，使用了 MyBatis-Plus 提供的字段自动填充功能。
逻辑删除：通过
@TableLogic注解实现了用户的逻辑删除。
八、总结
在本篇博客中，我们详细介绍了 MyBatis-Plus 的基本概念、快速入门、进阶使用技巧以及常见问题的优化建议，并通过一个简单的 用户管理系统 实战案例展示了 MyBatis-Plus 的应用。接下来，我们回顾一下 MyBatis-Plus 的优势，并分享一些实际项目中的应用注意事项以及学习路线建议。
✅ 一、回顾 MyBatis-Plus 的优势
MyBatis-Plus 作为 MyBatis 的增强工具，提供了很多优秀的特性，使得开发者可以在使用 MyBatis 的同时，享受更高效、更简洁的开发体验。
1.1 简化开发，减少重复代码
MyBatis-Plus 提供了许多自动化功能，特别是通用 CRUD 操作、分页插件和条件构造器，极大减少了开发者手动编写 SQL 的工作量。这些功能帮助开发者专注于业务逻辑，而不需要重复地写大量的增删改查操作代码。
1.2 零侵入设计
MyBatis-Plus 保持与 MyBatis 的兼容性，且不会影响原有的 MyBatis 功能。你可以在 MyBatis 的基础上，灵活地使用 MyBatis-Plus 提供的增强功能，进行快速开发，保证了极高的灵活性和可扩展性。
1.3 丰富的插件支持
MyBatis-Plus 内置了很多插件，如分页插件、性能分析插件、自动填充插件等，极大提高了开发效率，尤其是在处理复杂查询、分页和批量操作时。这些插件可以帮助开发者提升性能，同时减少编码错误。
1.4 开箱即用
MyBatis-Plus 提供了开箱即用的特性，你几乎不需要额外的配置和代码就能实现常见的功能，比如自动填充、乐观锁、逻辑删除等。这些功能开箱即用，帮助开发者省去配置和实现的麻烦。
✅ 二、实际项目中应用注意事项
尽管 MyBatis-Plus 提供了很多便捷的功能，在实际项目中应用时，仍需注意以下几个方面：
2.1 合理使用自动生成的代码
虽然 MyBatis-Plus 提供了代码生成器来快速生成实体类、Mapper 接口、Service 类等，但在实际开发中，还是需要对这些生成的代码进行一些手动优化和调整。例如，生成的字段可能没有考虑到业务上的特殊需求，或者有些字段需要手动添加注解来调整映射规则。
2.2 注意 SQL 性能优化
MyBatis-Plus 简化了 SQL 的编写，但在使用分页查询和复杂条件查询时，需要特别关注 SQL 性能，避免因不恰当的查询条件、未加索引的字段等原因导致查询性能问题。可以通过性能分析插件（如 SQL 执行分析、慢 SQL 提醒等）来及时发现和优化性能瓶颈。
2.3 自定义 SQL 与 MyBatis-Plus 的冲突
如果你在项目中需要使用自定义的复杂 SQL，可能会与 MyBatis-Plus 自动生成的 SQL 产生冲突。在这种情况下，应该灵活使用 MyBatis 原生的 @Select 注解或 XML 配置来编写自定义 SQL，避免自动生成的 SQL 影响你的查询。
2.4 数据库表与实体类的映射
MyBatis-Plus 会根据驼峰命名规则自动映射数据库表字段和实体类的属性，但在某些情况下，数据库表的字段和实体类的属性命名规则不一致，可能会导致映射问题。在这种情况下，需要手动通过 @TableField 和 @TableName 注解来指定映射规则。
2.5 正确使用分页插件
分页插件虽然非常方便，但需要注意其使用方式。尤其在多个查询同时进行时，分页插件可能会影响查询的准确性。需要确保分页查询的参数正确，并且分页逻辑不影响其他查询条件。
✅ 三、学习路线建议
对于想深入学习 MyBatis-Plus 和提升开发效率的开发者，以下是一个推荐的学习路线：
3.1 了解 MyBatis 基础
MyBatis-Plus 是基于 MyBatis 的增强工具，因此了解 MyBatis 的基本使用和原理是非常重要的。你需要掌握以下内容：
MyBatis 的基本配置
SQL 映射与映射文件的使用
基本的增删改查操作
3.2 深入学习 MyBatis-Plus 功能
了解 MyBatis-Plus 的核心功能并进行实践：
通用 CRUD 操作：掌握 MyBatis-Plus 提供的
BaseMapper和常用的 CRUD 方法。分页插件：深入学习 MyBatis-Plus 的分页查询和如何优化分页性能。
条件构造器：掌握
QueryWrapper和UpdateWrapper，学习如何通过条件构造器进行动态查询。自动填充与乐观锁：掌握如何配置自动填充字段和乐观锁机制。
逻辑删除与性能分析插件：了解如何使用逻辑删除功能以及如何启用性能分析插件。
3.3 实战项目开发
通过实战项目来加深理解，以下是一些推荐的项目实践：
用户管理系统：实现分页查询、动态查询、自动填充、逻辑删除等功能。
订单管理系统：处理复杂的查询条件、批量插入、优化数据库性能。
博客系统：实现文章的增删改查、评论功能、分页显示等。
3.4 性能优化与高级功能
在掌握基本功能后，可以深入学习 MyBatis-Plus 提供的高级功能：
自定义 SQL 的编写与优化
性能调优，尤其是处理大批量数据插入时的优化方法
动态数据源切换与多数据源支持
事务管理和分布式事务
3.5 社区与资源
参与 MyBatis-Plus 的社区和论坛，学习别人分享的经验和最佳实践，及时了解最新的版本和功能更新。同时，也可以参考官方文档和博客来获取更多资料。
✅ 小结
通过这篇文章，我们全面了解了 MyBatis-Plus 的优势、使用技巧以及实际应用中的一些注意事项。MyBatis-Plus 作为一个强大的 MyBatis 增强工具，能够大大简化开发工作，提升开发效率。在实际项目中合理使用 MyBatis-Plus，并根据项目需求进行优化，将使你能够更高效地开发和维护应用。
希望你能够通过不断的学习与实践，掌握 MyBatis-Plus，并在项目中充分利用它的强大功能。祝你在 MyBatis-Plus 的使用中取得更多的成功！🎉
九、参考资料
在深入学习和使用 MyBatis-Plus 的过程中，以下是一些有用的参考资料，可以帮助你更好地理解和掌握 MyBatis-Plus：
1. 官方文档
MyBatis-Plus 的官方文档详细介绍了 MyBatis-Plus 的所有功能，包括基本用法、进阶特性、插件使用、配置项等。通过官方文档，你可以快速找到你需要的功能和配置信息。
2. GitHub 地址
MyBatis-Plus 的源码和最新版本可以在 GitHub 上找到。如果你对 MyBatis-Plus 的源码感兴趣，或者想了解最新的功能和改进，GitHub 是一个非常好的资源。
3. 其他资源
除了官方文档和 GitHub，网络上有很多关于 MyBatis-Plus 的教程和博客。可以参考社区的文章和讨论，了解如何解决开发过程中遇到的问题。
结语：
在这篇文章中，我们从 MyBatis-Plus 的基本概念和优势开始，逐步深入介绍了其核心特性、进阶使用技巧、实际项目应用等内容。通过这篇详解，你不仅能快速上手 MyBatis-Plus，还能理解它在实际开发中的强大能力和灵活性。
🔑 MyBatis-Plus 的核心优势
零侵入设计：MyBatis-Plus 兼容 MyBatis，可以平滑过渡至现有项目，无需大规模重构。
简化开发：自动化的 CRUD 操作、分页插件、条件构造器等功能让开发者能够快速开发高效、简洁的应用。
插件支持：性能分析插件、逻辑删除、自动填充等插件提供了更高效的开发体验。
🚀 如何应用到实际项目中
通过一个简单的用户管理系统，我们展示了如何在实际项目中集成 MyBatis-Plus。无论是 分页查询、自动填充，还是 逻辑删除，MyBatis-Plus 都能帮助我们轻松实现这些常见功能，从而提高开发效率和代码质量。
🧑💻 学习 MyBatis-Plus 的持续进阶
对于初学者，建议先从 基础配置 和 简单的增删改查 操作入手，逐步掌握 MyBatis-Plus 提供的各种功能。
随着对 MyBatis-Plus 使用的深入，可以尝试 性能优化、复杂查询、自定义 SQL 等进阶应用，提升开发技能。
通过参与开源社区和参考官方文档，可以及时了解 MyBatis-Plus 的更新和优化。
🌟 MyBatis-Plus 的未来
随着 MyBatis-Plus 不断更新和优化，它将为开发者提供更多的便捷功能。在未来的开发工作中，MyBatis-Plus 将帮助我们更高效、更智能地构建应用。它不仅是一个工具，更是一个增强 MyBatis 开发效率的最佳伙伴。
最后，感谢你跟随本文一起深入学习 MyBatis-Plus。希望你能够在实践中不断积累经验，掌握 MyBatis-Plus 的高效开发技巧，提升开发效率，成为一个更加高效的 Java 开发者！🚀
祝你学习愉快，编码顺利！ 😊