快速入门
MyBatis-Plus（简称 MP）是 MyBatis 的增强工具，它在 MyBatis 的基础上只做增强不做改变，简化了开发，提高了效率。以下是 MyBatis-Plus 的快速入门指南，帮助您快速上手使用。
1. 环境准备
- JDK：1.8 或以上版本。
- Maven：用于依赖管理。
- 数据库：MySQL、PostgreSQL 等（以 MySQL 为例）。
2. 创建 Maven 项目
在 IDE 中创建一个 Maven 项目，并在 pom.xml 中添加 MyBatis-Plus 和相关依赖。
pom.xml 配置
<dependencies><!-- MyBatis-Plus 核心依赖 --><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.5.3.1</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><version>1.18.26</version><scope>provided</scope></dependency><!-- Spring Boot Web（可选，用于测试） --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><version>2.7.12</version></dependency>
</dependencies>
3. 配置数据库连接
在 application.yml 或 application.properties 中配置数据库连接信息。
application.yml 配置
spring:datasource:url: jdbc:mysql://localhost:3306/mybatis_plus_demo?useSSL=false&serverTimezone=UTCusername: rootpassword: 123456driver-class-name: com.mysql.cj.jdbc.Driver
4. 创建实体类
使用 MyBatis-Plus 时，实体类需要与数据库表对应。可以使用 @TableName 注解指定表名，@TableId 注解指定主键。
示例：User 实体类
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;@Data
@TableName("user") // 指定表名
public class User {@TableId // 指定主键private Long id;private String name;private Integer age;private String email;
}
5. 创建 Mapper 接口
MyBatis-Plus 提供了 BaseMapper 接口，直接继承即可获得常用的 CRUD 方法。
示例：UserMapper 接口
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;@Mapper
public interface UserMapper extends BaseMapper<User> {// 无需编写方法，BaseMapper 已提供常用方法
}
6. 测试 CRUD 操作
在测试类中测试 MyBatis-Plus 的 CRUD 功能。
示例：测试类
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.util.List;@SpringBootTest
public class MyBatisPlusTest {@Autowiredprivate UserMapper userMapper;@Testpublic void testInsert() {User user = new User();user.setName("张三");user.setAge(25);user.setEmail("zhangsan@example.com");int result = userMapper.insert(user);System.out.println("插入结果：" + result);}@Testpublic void testSelect() {User user = userMapper.selectById(1L);System.out.println("查询结果：" + user);}@Testpublic void testUpdate() {User user = new User();user.setId(1L);user.setName("李四");int result = userMapper.updateById(user);System.out.println("更新结果：" + result);}@Testpublic void testDelete() {int result = userMapper.deleteById(1L);System.out.println("删除结果：" + result);}@Testpublic void testSelectList() {QueryWrapper<User> queryWrapper = new QueryWrapper<>();queryWrapper.ge("age", 20); // 查询年龄 >= 20 的用户List<User> userList = userMapper.selectList(queryWrapper);userList.forEach(System.out::println);}
}
7. 常用功能
（1）分页查询
MyBatis-Plus 提供了分页插件，只需简单配置即可实现分页查询。
配置分页插件
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class MyBatisPlusConfig {@Beanpublic PaginationInterceptor paginationInterceptor() {return new PaginationInterceptor();}
}
分页查询示例
@Test
public void testSelectPage() {Page<User> page = new Page<>(1, 5); // 第 1 页，每页 5 条QueryWrapper<User> queryWrapper = new QueryWrapper<>();queryWrapper.ge("age", 20);IPage<User> userPage = userMapper.selectPage(page, queryWrapper);userPage.getRecords().forEach(System.out::println);
}
（2）条件构造器
MyBatis-Plus 提供了 QueryWrapper 和 LambdaQueryWrapper，用于构建复杂的查询条件。
示例：LambdaQueryWrapper
@Test
public void testLambdaQueryWrapper() {LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();lambdaQueryWrapper.ge(User::getAge, 20); // 查询年龄 >= 20 的用户List<User> userList = userMapper.selectList(lambdaQueryWrapper);userList.forEach(System.out::println);
}
8. 总结
MyBatis-Plus 的核心优势在于：
- 简化开发：通过继承
BaseMapper，无需编写 SQL 即可实现 CRUD 操作。 - 功能强大：支持分页、条件构造器、代码生成器等高级功能。
- 易于集成：与 Spring Boot 无缝集成，配置简单。
通过以上步骤，您可以快速入门 MyBatis-Plus，并在实际项目中应用。更多高级功能可参考 MyBatis-Plus 官方文档。
常见注解
以下是 MyBatis-Plus 常见注解 的表格整理，方便快速查阅和使用：
| 注解 | 作用 | 示例 |
|---|---|---|
@TableName | 指定实体类对应的数据库表名。 | @TableName("user") |
@TableId | 指定实体类的主键字段。 | @TableId(type = IdType.AUTO) |
@TableField | 指定实体类字段与数据库列的映射关系。 | @TableField("user_name") |
@Version | 标识乐观锁字段。 | @Version |
@EnumValue | 指定枚举类型字段的值与数据库存储值的映射。 | @EnumValue |
@TableLogic | 标识逻辑删除字段。 | @TableLogic |
@MapperScan | 指定 MyBatis Mapper 接口的扫描路径。 | @MapperScan("com.example.mapper") |
@DS | 指定数据源（多数据源场景）。 | @DS("slave") |
@InterceptorIgnore | 忽略某些拦截器（如分页拦截器）。 | @InterceptorIgnore(tenantLine = "true") |
@SqlParser | 指定 SQL 解析器（如多租户场景）。 | @SqlParser(filter = true) |
@KeySequence | 指定主键生成策略（如序列）。 | @KeySequence(value = "SEQ_USER", clazz = Long.class) |
@OrderBy | 指定查询结果的排序规则。 | @OrderBy("age DESC") |
@Param | 指定方法参数的名称（用于 XML 或注解中的 SQL）。 | @Param("userId") Long userId |
@Insert | 标识插入操作的 SQL 注解。 | @Insert("INSERT INTO user (name, age) VALUES (#{name}, #{age})") |
@Update | 标识更新操作的 SQL 注解。 | @Update("UPDATE user SET name = #{name} WHERE id = #{id}") |
@Delete | 标识删除操作的 SQL 注解。 | @Delete("DELETE FROM user WHERE id = #{id}") |
@Select | 标识查询操作的 SQL 注解。 | @Select("SELECT * FROM user WHERE id = #{id}") |
@Results | 标识查询结果的映射关系。 | @Results({ @Result(column = "user_name", property = "name") }) |
@ResultMap | 引用已定义的 @Results 映射。 | @ResultMap("userResultMap") |
@Mapper | 标识 MyBatis Mapper 接口。 | @Mapper |
@Repository | 标识 DAO 层组件（Spring 注解）。 | @Repository |
常用注解详解
1. @TableName
用于指定实体类对应的数据库表名。如果表名与实体类名不一致，可以使用该注解。
示例：
@TableName("user")
public class User {// 字段定义
}
2. @TableId
用于指定实体类的主键字段。支持多种主键生成策略（如自增、UUID 等）。
示例：
@TableId(type = IdType.AUTO)
private Long id;
3. @TableField
用于指定实体类字段与数据库列的映射关系。如果字段名与列名不一致，可以使用该注解。
示例：
@TableField("user_name")
private String name;
4. @Version
用于标识乐观锁字段。MyBatis-Plus 会自动在更新时检查该字段的值。
示例：
@Version
private Integer version;
5. @TableLogic
用于标识逻辑删除字段。MyBatis-Plus 会在删除操作时自动更新该字段的值。
示例：
@TableLogic
private Integer deleted;
6. @DS
用于指定数据源（多数据源场景）。可以标注在方法或类上。
示例：
@DS("slave")
public List<User> selectAll() {return userMapper.selectList(null);
}
7. @MapperScan
用于指定 MyBatis Mapper 接口的扫描路径。通常标注在 Spring Boot 启动类上。
示例：
@SpringBootApplication
@MapperScan("com.example.mapper")
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}
8. @Param
用于指定方法参数的名称，适用于 XML 或注解中的 SQL。
示例：
@Select("SELECT * FROM user WHERE id = #{userId}")
User selectById(@Param("userId") Long userId);
总结
MyBatis-Plus 提供了丰富的注解，用于简化开发、增强功能。通过合理使用这些注解，可以显著提高开发效率。更多注解和详细用法可参考 MyBatis-Plus 官方文档。
MyBatis约定
在 MyBatis 和 MyBatis-Plus 中，“约定大于配置”（Convention Over Configuration）是一种设计理念，旨在通过默认约定减少开发者的配置工作量，同时保持灵活性。以下是这一理念的详细介绍：
1. 什么是约定大于配置？
“约定大于配置” 是一种软件开发原则，强调通过默认约定来减少显式配置的需求。开发者只需遵循框架的默认规则，就可以快速实现功能，而不需要编写大量的配置文件。
在 MyBatis-Plus 中，这一理念得到了充分体现。例如：
- 默认情况下，实体类的类名与数据库表名一致，字段名与列名一致。
- 默认的主键生成策略是自增（
IdType.AUTO）。 - 默认的逻辑删除字段是
deleted，默认值为0（未删除）。
2. MyBatis-Plus 中的约定大于配置
（1）表名与类名的映射
- 默认约定：实体类的类名与数据库表名一致（驼峰转下划线）。
- 例如：
User类默认映射到user表。
- 例如：
- 自定义配置：如果需要自定义表名，可以使用
@TableName注解。
示例：
@TableName("t_user") // 自定义表名
public class User {// 字段定义
}
（2）字段名与列名的映射
- 默认约定：实体类的字段名与数据库列名一致（驼峰转下划线）。
- 例如：
userName字段默认映射到user_name列。
- 例如：
- 自定义配置：如果需要自定义列名，可以使用
@TableField注解。
示例：
@TableField("user_name") // 自定义列名
private String userName;
（3）主键生成策略
- 默认约定：主键生成策略为自增（
IdType.AUTO）。 - 自定义配置：如果需要自定义主键生成策略，可以使用
@TableId注解。
示例：
@TableId(type = IdType.ASSIGN_ID) // 使用雪花算法生成主键
private Long id;
（4）逻辑删除
- 默认约定：逻辑删除字段为
deleted，默认值为0（未删除），删除时更新为1。 - 自定义配置：如果需要自定义逻辑删除字段，可以使用
@TableLogic注解。
示例：
@TableLogic
private Integer isDeleted; // 自定义逻辑删除字段
（5）自动填充字段
- 默认约定：支持自动填充创建时间和更新时间字段。
- 自定义配置：可以使用
@TableField注解的fill属性指定填充策略。
示例：
@TableField(fill = FieldFill.INSERT) // 插入时自动填充
private LocalDateTime createTime;@TableField(fill = FieldFill.INSERT_UPDATE) // 插入和更新时自动填充
private LocalDateTime updateTime;
（6）分页查询
- 默认约定：MyBatis-Plus 提供了分页插件，默认支持分页查询。
- 自定义配置：可以通过配置
PaginationInterceptor自定义分页行为。
示例：
@Bean
public PaginationInterceptor paginationInterceptor() {return new PaginationInterceptor();
}
3. 约定大于配置的优势
- 减少配置：通过默认约定，开发者无需编写大量配置文件，减少了开发工作量。
- 提高效率：遵循约定可以快速实现功能，提升开发效率。
- 保持灵活：在需要时，可以通过注解或配置覆盖默认约定，满足个性化需求。
4. 示例：完整实体类
以下是一个遵循 “约定大于配置” 的实体类示例：
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.time.LocalDateTime;@Data
@TableName("user") // 自定义表名
public class User {@TableId(type = IdType.AUTO) // 主键自增private Long id;private String name; // 默认映射到 name 列@TableField("user_age") // 自定义列名private Integer age;@TableLogic // 逻辑删除字段private Integer deleted;@TableField(fill = FieldFill.INSERT) // 自动填充创建时间private LocalDateTime createTime;@TableField(fill = FieldFill.INSERT_UPDATE) // 自动填充更新时间private LocalDateTime updateTime;
}
总结
MyBatis-Plus 通过 “约定大于配置” 的理念，提供了默认的规则和约定，减少了开发者的配置工作量。同时，通过注解和配置，开发者可以灵活地覆盖默认约定，满足个性化需求。这种设计既提高了开发效率，又保持了灵活性，是 MyBatis-Plus 的核心优势之一。
核心功能
条件构造器
MyBatis-Plus 提供了强大的 条件构造器（QueryWrapper 和 LambdaQueryWrapper），用于动态构建复杂的 SQL 查询条件。以下是条件构造器的详细介绍和使用示例。
以下是 MyBatis-Plus 中四种条件构造器 的详细介绍，包括 常用方法 和 使用示例，帮助您全面掌握它们的使用。
1. QueryWrapper
QueryWrapper 是用于 查询操作 的条件构造器，支持字符串形式的字段名。
常用方法：
| 方法 | 说明 |
|---|---|
eq | 等于 = |
ne | 不等于 <> |
gt | 大于 > |
ge | 大于等于 >= |
lt | 小于 < |
le | 小于等于 <= |
between | 介于 BETWEEN |
notBetween | 不介于 NOT BETWEEN |
like | 模糊查询 LIKE |
notLike | 不模糊查询 NOT LIKE |
in | 包含 IN |
notIn | 不包含 NOT IN |
isNull | 为空 IS NULL |
isNotNull | 不为空 IS NOT NULL |
orderByAsc | 按字段升序排序 ORDER BY ASC |
orderByDesc | 按字段降序排序 ORDER BY DESC |
groupBy | 按字段分组 GROUP BY |
select | 指定查询字段 |
last | 在 SQL 语句末尾追加内容 |
示例：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "张三").ge("age", 20).like("email", "example.com").orderByDesc("create_time");List<User> userList = userMapper.selectList(queryWrapper);
2. LambdaQueryWrapper
LambdaQueryWrapper 是用于 查询操作 的条件构造器，基于 Lambda 表达式，支持类型安全的字段引用。
常用方法：
与 QueryWrapper 相同，但使用 Lambda 表达式指定字段名。
示例：
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName, "张三").ge(User::getAge, 20).like(User::getEmail, "example.com").orderByDesc(User::getCreateTime);List<User> userList = userMapper.selectList(lambdaQueryWrapper);
3. UpdateWrapper
UpdateWrapper 是用于 更新操作 的条件构造器，支持字符串形式的字段名。
常用方法：
| 方法 | 说明 |
|---|---|
eq | 等于 = |
ne | 不等于 <> |
gt | 大于 > |
ge | 大于等于 >= |
lt | 小于 < |
le | 小于等于 <= |
between | 介于 BETWEEN |
notBetween | 不介于 NOT BETWEEN |
like | 模糊查询 LIKE |
notLike | 不模糊查询 NOT LIKE |
in | 包含 IN |
notIn | 不包含 NOT IN |
isNull | 为空 IS NULL |
isNotNull | 不为空 IS NOT NULL |
set | 设置更新字段的值 |
setSql | 设置更新字段的 SQL 表达式 |
示例：
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("name", "张三").set("age", 30).set("email", "zhangsan@example.com");int result = userMapper.update(null, updateWrapper);
4. LambdaUpdateWrapper
LambdaUpdateWrapper 是用于 更新操作 的条件构造器，基于 Lambda 表达式，支持类型安全的字段引用。
常用方法：
与 UpdateWrapper 相同，但使用 Lambda 表达式指定字段名。
示例：
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.eq(User::getName, "张三").set(User::getAge, 30).set(User::getEmail, "zhangsan@example.com");int result = userMapper.update(null, lambdaUpdateWrapper);
5. 四种条件构造器的对比
| 条件构造器 | 用途 | 字段名形式 | 类型安全 | 适用场景 |
|---|---|---|---|---|
QueryWrapper | 查询 | 字符串 | 不支持 | 简单的查询场景 |
LambdaQueryWrapper | 查询 | Lambda 表达式 | 支持 | 需要类型安全的查询场景 |
UpdateWrapper | 更新 | 字符串 | 不支持 | 简单的更新场景 |
LambdaUpdateWrapper | 更新 | Lambda 表达式 | 支持 | 需要类型安全的更新场景 |
6. 使用建议
- 查询操作：
- 如果字段名固定且简单，可以使用
QueryWrapper。 - 如果需要类型安全或字段名可能变化，推荐使用
LambdaQueryWrapper。
- 如果字段名固定且简单，可以使用
- 更新操作：
- 如果字段名固定且简单，可以使用
UpdateWrapper。 - 如果需要类型安全或字段名可能变化，推荐使用
LambdaUpdateWrapper。
- 如果字段名固定且简单，可以使用
7. 示例：完整对比
查询操作
// 使用 QueryWrapper
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "张三").ge("age", 20).like("email", "example.com");// 使用 LambdaQueryWrapper
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName, "张三").ge(User::getAge, 20).like(User::getEmail, "example.com");
更新操作
// 使用 UpdateWrapper
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("name", "张三").set("age", 30).set("email", "zhangsan@example.com");// 使用 LambdaUpdateWrapper
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.eq(User::getName, "张三").set(User::getAge, 30).set(User::getEmail, "zhangsan@example.com");
总结
MyBatis-Plus 提供了四种条件构造器，分别用于查询和更新操作，并支持字符串字段名和 Lambda 表达式两种形式。通过合理选择条件构造器，可以显著提高代码的可读性、安全性和开发效率。以下是它们的核心优势：
- 类型安全：
LambdaQueryWrapper和LambdaUpdateWrapper支持类型安全的字段引用。 - 链式调用：支持链式调用，方便组合多个条件。
- 灵活嵌套：支持嵌套条件，满足复杂查询和更新需求。
更多高级用法可参考 MyBatis-Plus 官方文档。
扩展功能
静态工具
在 MyBatis-Plus 中，静态工具类 提供了一些便捷的方法，可以在不依赖 Spring 容器的情况下使用 MyBatis-Plus 的功能。以下是常用的静态工具类及其应用场景的详细介绍。
1. Db 工具类
Db 是 MyBatis-Plus 提供的数据库操作工具类，支持直接执行 SQL 语句。
常用方法：
| 方法 | 说明 |
|---|---|
list | 查询列表 |
query | 查询单条记录 |
update | 更新操作 |
delete | 删除操作 |
execute | 执行任意 SQL 语句 |
应用场景：
- 在不依赖 Mapper 接口的情况下执行 SQL 语句。
- 快速执行简单的查询、更新、删除操作。
示例：
// 查询列表
List<User> userList = Db.list("SELECT * FROM user WHERE age > ?", 20);// 更新操作
int result = Db.update("UPDATE user SET age = ? WHERE id = ?", 30, 1);// 删除操作
int result = Db.delete("DELETE FROM user WHERE id = ?", 1);
2. SqlHelper 工具类
SqlHelper 是 MyBatis-Plus 提供的 SQL 辅助工具类，用于生成 SQL 语句或处理 SQL 相关逻辑。
常用方法：
| 方法 | 说明 |
|---|---|
getTableInfo | 获取表信息 |
getSqlStatement | 获取 SQL 语句 |
getSqlWhere | 获取 SQL WHERE 条件 |
应用场景：
- 动态生成 SQL 语句。
- 获取表信息或 SQL 相关元数据。
示例：
// 获取表信息
TableInfo tableInfo = SqlHelper.table(User.class);// 获取 SQL 语句
String sql = SqlHelper.getSqlStatement(UserMapper.class, "selectById");
3. StringUtils 工具类
StringUtils 是 MyBatis-Plus 提供的字符串工具类，用于处理字符串相关操作。
常用方法：
| 方法 | 说明 |
|---|---|
isBlank | 判断字符串是否为空 |
isNotBlank | 判断字符串是否非空 |
join | 拼接字符串 |
toCamelCase | 将字符串转换为驼峰命名 |
应用场景：
- 处理字符串相关逻辑。
- 动态生成 SQL 语句或条件。
示例：
// 判断字符串是否为空
boolean isBlank = StringUtils.isBlank("");// 拼接字符串
String result = StringUtils.join("a", "b", "c"); // 输出 "abc"
4. ReflectionKit 工具类
ReflectionKit 是 MyBatis-Plus 提供的反射工具类，用于处理 Java 反射相关操作。
常用方法：
| 方法 | 说明 |
|---|---|
getFieldValue | 获取字段值 |
setFieldValue | 设置字段值 |
getMethod | 获取方法 |
invokeMethod | 调用方法 |
应用场景：
- 动态获取或设置对象的字段值。
- 动态调用对象的方法。
示例：
User user = new User();
ReflectionKit.setFieldValue(user, "name", "张三");String name = ReflectionKit.getFieldValue(user, "name");
5. LambdaUtils 工具类
LambdaUtils 是 MyBatis-Plus 提供的 Lambda 表达式工具类，用于处理 Lambda 表达式相关操作。
常用方法：
| 方法 | 说明 |
|---|---|
getFieldName | 获取 Lambda 表达式对应的字段名 |
getMethodName | 获取 Lambda 表达式对应的方法名 |
应用场景：
- 动态获取 Lambda 表达式对应的字段名或方法名。
- 在
LambdaQueryWrapper或LambdaUpdateWrapper中使用。
示例：
String fieldName = LambdaUtils.getFieldName(User::getName); // 输出 "name"
6. IdWorker 工具类
IdWorker 是 MyBatis-Plus 提供的 ID 生成工具类，用于生成分布式唯一 ID。
常用方法：
| 方法 | 说明 |
|---|---|
getId | 生成唯一 ID |
get32UUID | 生成 32 位 UUID |
应用场景：
- 生成分布式唯一 ID。
- 生成 UUID。
示例：
long id = IdWorker.getId(); // 生成唯一 ID
String uuid = IdWorker.get32UUID(); // 生成 32 位 UUID
7. 应用场景总结
| 工具类 | 应用场景 |
|---|---|
Db | 直接执行 SQL 语句，无需依赖 Mapper 接口。避免循环依赖 |
SqlHelper | 动态生成 SQL 语句或处理 SQL 相关逻辑。 |
StringUtils | 处理字符串相关逻辑，动态生成 SQL 语句或条件。 |
ReflectionKit | 动态获取或设置对象的字段值，动态调用对象的方法。 |
LambdaUtils | 动态获取 Lambda 表达式对应的字段名或方法名。 |
IdWorker | 生成分布式唯一 ID 或 UUID。 |
总结
MyBatis-Plus 提供的静态工具类可以显著简化开发，尤其是在不依赖 Spring 容器的情况下执行数据库操作、处理字符串、反射或生成唯一 ID 等场景。通过合理使用这些工具类，可以提高代码的简洁性和开发效率。更多高级用法可参考 MyBatis-Plus 官方文档。
插件功能
MyBatis-Plus 提供了丰富的 插件 功能，用于扩展和增强 MyBatis 的核心功能。以下是 MyBatis-Plus 中常用插件的介绍及其使用实例。
1. 分页插件
分页插件用于实现数据库查询的分页功能。
配置分页插件
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class MyBatisPlusConfig {@Beanpublic PaginationInterceptor paginationInterceptor() {return new PaginationInterceptor();}
}
使用示例
Page<User> page = new Page<>(1, 10); // 第 1 页，每页 10 条
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ge("age", 20);IPage<User> userPage = userMapper.selectPage(page, queryWrapper);
userPage.getRecords().forEach(System.out::println);
2. 乐观锁插件
乐观锁插件用于实现乐观锁机制，防止并发更新冲突。
配置乐观锁插件
import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class MyBatisPlusConfig {@Beanpublic OptimisticLockerInterceptor optimisticLockerInterceptor() {return new OptimisticLockerInterceptor();}
}
使用示例
// 实体类中添加乐观锁字段
public class User {@Versionprivate Integer version;// 其他字段
}// 更新操作
User user = userMapper.selectById(1L);
user.setName("李四");
int result = userMapper.updateById(user);
3. SQL 性能分析插件
SQL 性能分析插件用于监控 SQL 执行时间，帮助优化 SQL 性能。
配置 SQL 性能分析插件
import com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class MyBatisPlusConfig {@Beanpublic PerformanceInterceptor performanceInterceptor() {PerformanceInterceptor interceptor = new PerformanceInterceptor();interceptor.setMaxTime(1000); // 设置 SQL 执行的最大时间（单位：ms）interceptor.setFormat(true); // 格式化 SQL 语句return interceptor;}
}
使用示例
启用插件后，SQL 执行时间超过 maxTime 时会输出警告日志。
4. 动态表名插件
动态表名插件用于动态切换表名，适用于分表场景。
配置动态表名插件
import com.baomidou.mybatisplus.extension.plugins.DynamicTableNameInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class MyBatisPlusConfig {@Beanpublic DynamicTableNameInnerInterceptor dynamicTableNameInnerInterceptor() {DynamicTableNameInnerInterceptor interceptor = new DynamicTableNameInnerInterceptor();interceptor.setTableNameHandler((sql, tableName) -> {// 根据业务逻辑动态返回表名return "user_" + LocalDate.now().getYear();});return interceptor;}
}
使用示例
启用插件后，执行 SQL 时会根据配置动态切换表名。
5. 防止全表更新与删除插件
防止全表更新与删除插件用于拦截没有 WHERE 条件的更新和删除操作，避免误操作。
配置防止全表更新与删除插件
import com.baomidou.mybatisplus.extension.plugins.BlockAttackInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class MyBatisPlusConfig {@Beanpublic BlockAttackInnerInterceptor blockAttackInnerInterceptor() {return new BlockAttackInnerInterceptor();}
}
使用示例
启用插件后，执行没有 WHERE 条件的更新或删除操作时会抛出异常。
6. 自定义插件
如果需要自定义插件，可以实现 MyBatis 的 Interceptor 接口。
自定义插件示例
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;import java.sql.Connection;
import java.util.Properties;@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
public class MyPlugin implements Interceptor {@Overridepublic Object intercept(Invocation invocation) throws Throwable {System.out.println("自定义插件：拦截 SQL 执行");return invocation.proceed();}@Overridepublic Object plugin(Object target) {return Plugin.wrap(target, this);}@Overridepublic void setProperties(Properties properties) {}
}
配置自定义插件
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class MyBatisPlusConfig {@Beanpublic MyPlugin myPlugin() {return new MyPlugin();}
}
7. 插件配置总结
| 插件 | 作用 |
|---|---|
| 分页插件 | 实现数据库查询的分页功能。 |
| 乐观锁插件 | 实现乐观锁机制，防止并发更新冲突。 |
| SQL 性能分析插件 | 监控 SQL 执行时间，帮助优化 SQL 性能。 |
| 动态表名插件 | 动态切换表名，适用于分表场景。 |
| 防止全表更新与删除插件 | 拦截没有 WHERE 条件的更新和删除操作，避免误操作。 |
| 自定义插件 | 自定义拦截器，扩展 MyBatis 功能。 |
总结
MyBatis-Plus 提供了丰富的插件功能，可以显著增强 MyBatis 的核心功能。通过合理配置和使用这些插件，可以提高开发效率、优化性能并避免误操作。更多插件和高级用法可参考 MyBatis-Plus 官方文档。
--linux下的打包命令 -- tar 和gzip)
)
![[ C语言 ] | 从0到1？](http://pic.xiahunao.cn/[ C语言 ] | 从0到1？)
技术实现详解)
 自动配置原理)
)
