1.快速入门
1.什么是mybatis-plus
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，它在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。以下是 MyBatis-Plus 的一些主要特性和功能：
- 无侵入：MyBatis-Plus 只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑。
- 效率至上：只需简单配置，即可快速进行单表 CRUD 操作，从而节省大量时间。
- 丰富功能：包括代码生成、自动分页、逻辑删除、自动填充、拦截器等功能。
- 广泛认可：连续 5 年获得开源中国年度最佳开源项目殊荣，Github 累计 16K Star。
- 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作。
- 支持 Lambda 形式调用：通过 Lambda 表达式，方便地编写各类查询条件，无需再担心字段写错。
- 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置。
- 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作。
- 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper、Model、Service、Controller 层代码。
- 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询。
- 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询。
- 内置全局拦截插件：提供全表 delete、update 操作智能分析阻断，也可自定义拦截规则，预防误操作。
MyBatis-Plus 的使用也非常简便。例如，你可以通过以下步骤快速开始使用 MyBatis-Plus：
- 添加依赖：在项目中添加 MyBatis-Plus 的依赖。
- 配置数据源：配置数据库连接信息。
- 编写实体类：定义与数据库表对应的实体类。
- 编写 Mapper 接口：继承 BaseMapper 接口。
- 使用：在服务层或控制器层调用 Mapper 接口中的方法进行 CRUD 操作。
以下是一个简单的示例代码：
public interface UserMapper extends BaseMapper<User> {
}
@SpringBootTest
public class SampleTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelect() {
System.out.println("----- selectAll method test ------");
List<User> userList = userMapper.selectList(null);
Assert.isTrue(5 == userList.size(), "");
userList.forEach(System.out::println);
}
}
控制台输出：
User(id=1, name=Jone, age=18, email=test1@baomidou.com)
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=3, name=Tom, age=28, email=test3@baomidou.com)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
User(id=5, name=Billie, age=24, email=test5@baomidou.com)
通过以上几个简单的步骤，就实现了 User 表的 CRUD 功能，甚至连 XML 文件都不用编写。
从上面可以看到，使用mybatis-plus主要有两步：
1.引入mybatis-plus起步依赖
2.自定义的mapper层接口继承BaseMapper
此时就可以使用很多已经封装好的单表查询方法
2.引入mybatis-plus起步依赖
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.3.1</version>
</dependency>
3.mybatis-plus常见注解
MyBatisPlusi通过扫描实体类，并基于反射获取实体类信息作为数据库表信息。以下是一些常见的 MyBatis-Plus 注解及其用途（主要用于实体类与数据库表映射）：
-
@TableName：
- 用于指定实体类对应的数据库表名。
- 常用于实体类名称与数据库表名不一致的情况。
@TableName("user") public class User { // ... } -
@TableId：
- 用于指定实体类中的主键字段。
- 可以指定主键类型，如自增、UUID等。
public class User { @TableId(type = IdType.AUTO) private Long id; // ... } -
@TableField：
- 用于指定实体类属性与数据库表字段的映射关系。
- 常用于属性名与字段名不一致的情况。
public class User { private String name; @TableField("email") private String email; // ... }
4.在 application.properties 或 application.yml 文件中的配置（配置项可选）
mybatis-plus:
type-aliases-package:com.itheima.mp.domain.po #别喀扫描包
mapper.-locations:"classpath*:/mapper/**/*.Xml" #Mapper.xml文件地址，默认值
configuration:
map-underscore-to-camel-case:true #是否开启下划线和驼峰的映射
cache-enabled:false#是否开启二级缓存
global-config:
db-config:
id-type:assign_id#id为雪花算法生成
update-strategy:not_null#更新策略：只更新非空字段
官方参考如下：mybatis-plus使用配置
2.核心功能
1.条件构造器
在 MyBatis-Plus 中，条件构造器（也称为 Wrapper）是一种非常强大的功能，它允许开发者以一种声明式的方式来构建 SQL 查询条件。这使得编写复杂的查询条件变得更加简单和直观。
主要条件构造器类：
-
AbstractWrapper：
- 基础条件构造器类，提供了基本的条件构造方法，如
eq（等于）、ne（不等于）、gt（大于）、lt（小于）等。
- 基础条件构造器类，提供了基本的条件构造方法，如
-
QueryWrapper：
- 用于查询操作的条件构造器，继承自
AbstractWrapper。它允许链式调用，构建查询条件。
- 用于查询操作的条件构造器，继承自
-
UpdateWrapper：
- 用于更新操作的条件构造器，同样继承自
AbstractWrapper。它也支持链式调用，构建更新条件。
- 用于更新操作的条件构造器，同样继承自
-
LambdaQueryWrapper 和 LambdaUpdateWrapper：
- 与
QueryWrapper和UpdateWrapper类似，但它们使用 Java 8 的 Lambda 表达式来指定条件字段，使得代码更加简洁，特别是在处理复杂对象属性时。
- 与
使用条件构造器的基本步骤：
-
创建条件构造器实例：
- 直接创建
QueryWrapper或UpdateWrapper的实例。
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); - 直接创建
-
链式调用添加条件：
- 使用条件构造器的方法链式添加查询条件。
queryWrapper.eq("name", "张三").lt("age", 30); -
使用条件构造器进行查询：
- 将条件构造器传递给 Mapper 接口的方法，执行查询。
List<User> users = userMapper.selectList(queryWrapper); -
使用 Lambda 条件构造器：
- 对于更复杂的查询条件，可以使用 Lambda 表达式指定字段。
LambdaQueryWrapper<User> lambdaQuery = new LambdaQueryWrapper<>(); lambdaQuery.eq(User::getName, "张三").ge(User::getAge, 18);
示例代码：
以下是使用条件构造器的一些示例：
// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 链式调用添加条件
queryWrapper.eq("name", "张三").lt("age", 30);
// 使用条件构造器进行查询
List<User> users = userMapper.selectList(queryWrapper);
// 使用 LambdaQueryWrapper
LambdaQueryWrapper<User> lambdaQuery = new LambdaQueryWrapper<>();
lambdaQuery.eq(User::getName, "张三").ge(User::getAge, 18);
// 执行查询
List<User> users = userMapper.selectList(lambdaQuery);
复杂查询示例：
// 创建 QueryWrapper 实例
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 添加多个条件
queryWrapper
.eq("name", "张三")
.lt("age", 30)
.and(w -> w.ge("age", 18).lt("age", 25))
.or()
.like("email", "example.com");
// 使用条件构造器进行查询
List<User> users = userMapper.selectList(queryWrapper);
在这个例子中，我们构建了一个查询条件，查询名字为“张三”，年龄小于30岁，或者年龄在18到25岁之间，并且电子邮件包含“example.com”的用户。
条件构造器使得在 MyBatis-Plus 中编写复杂查询变得非常简单和直观。
2.自定义SQL
我们可以利用MyBatisPlus的Wrapper来构建复杂的Vhere:条件，然后自己定义SQL语句中剩下的部分。
3.service接口
在 MyBatis-Plus 中，IService 接口是一个服务层的基础接口，它提供了一些基本的 CRUD 操作。通过继承 IService 接口，你可以为你的业务实体类生成相应的服务类，从而简化数据访问层的编码工作。
1. 定义 Service 接口
首先，你需要定义一个 Service 接口，并让它继承 IService<T>，其中 T 是你的实体类类型。
import com.baomidou.mybatisplus.extension.service.IService;
public interface UserService extends IService<User> {
// 可以在这里定义一些自定义的服务层方法
}
2. 实现 Service 接口
然后，创建一个 Service 实现类，继承 ServiceImpl，并传入你的 Mapper 接口和实体类类型。
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
// 实现自定义的服务层方法
}
3. 使用 Service 接口
在你的业务逻辑中，你可以通过 Spring 的依赖注入（DI）将 Service 接口注入到需要使用的地方。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class SomeBusinessService {
@Autowired
private UserService userService;
public void someBusinessMethod() {
// 使用 userService 进行数据操作
List<User> users = userService.list();
}
}
4. 自定义 Service 方法
在 Service 接口中，你可以定义一些自定义的方法，这些方法将在 Service 实现类中实现。这使得你可以封装一些复杂的业务逻辑。
public interface UserService extends IService<User> {
// 自定义方法
User findByUsername(String username);
}
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Override
public User findByUsername(String username) {
return this.lambdaQuery().eq(User::getUsername, username).one();
}
}
5. 使用 MyBatis-Plus 提供的 Service 方法
MyBatis-Plus 的 IService 接口提供了许多常用的 CRUD 方法，例如：
save(T entity): 保存一个实体。saveBatch(Collection<T> entityList): 批量保存实体。updateById(T entity): 根据 ID 更新实体。update(T entity, Wrapper<T> updateWrapper): 根据条件构造器更新实体。removeById(Serializable id): 根据 ID 删除实体。remove(Wrapper<T> queryWrapper): 根据条件构造器删除实体。list(Wrapper<T> queryWrapper): 根据条件构造器查询实体列表。
这些方法可以直接在 Service 接口的实现类中使用。
示例
以下是完整的示例，展示如何定义和使用 MyBatis-Plus 的 Service 接口：
// User 实体类
public class User {
private Long id;
private String name;
private Integer age;
// getters and setters
}
// User Mapper 接口
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
// User Service 接口
public interface UserService extends IService<User> {
User findByUsername(String username);
}
// User Service 实现类
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Override
public User findByUsername(String username) {
return this.lambdaQuery().eq(User::getUsername, username).one();
}
}
// 业务逻辑类
@Service
public class SomeBusinessService {
@Autowired
private UserService userService;
public void someBusinessMethod() {
User user = userService.findByUsername("example");
if (user != null) {
System.out.println("User found: " + user.getName());
}
}
}
3.扩展功能
1.代码生成
MyBatis-Plus 提供了一个强大的代码生成器，可以自动生成 Entity（实体类）、Mapper 接口、Mapper XML 文件、Service 接口和 Service 实现类等。这大大简化了项目的初始搭建和重复代码的编写。
如何使用 MyBatis-Plus 代码生成器：
-
添加依赖：
在项目的pom.xml文件中添加 MyBatis-Plus 代码生成器的依赖。<dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-generator</artifactId> <version>3.5.7</version> </dependency> -
配置代码生成器：
在项目中创建一个配置类，配置代码生成器的参数。@Configuration public class CodeGeneratorConfig { @Bean public MyMetaObjectHandler myMetaObjectHandler() { return new MyMetaObjectHandler(); } @Bean public CodeGenerator codeGenerator() { CodeGenerator codeGenerator = new CodeGenerator( new DataSourceConfig().setUrl("jdbc:mysql://localhost:3306/your_database") .setUsername("root") .setPassword("your_password"), "com.yourpackage" ); codeGenerator.setAuthor("Your Name"); codeGenerator.setServiceName("%sService"); return codeGenerator; } } -
编写启动类：
创建一个启动类，用于运行代码生成器。public class CodeGeneratorApplication { public static void main(String[] args) { CodeGenerator codeGenerator = SpringApplication.run(CodeGeneratorConfig.class, args) .getBean(CodeGenerator.class); codeGenerator.generateByTables("your_table_name"); } } -
生成代码：
运行CodeGeneratorApplication的main方法，代码生成器将自动生成相应的代码。 -
配置文件：
你也可以在application.yml或application.properties中配置数据库连接信息和代码生成器的其他参数。mybatis-plus: mapper-locations: classpath*:/mapper/*.xml global-config: db-config: id-type: auto logic-delete-value: 1 logic-not-delete-value: 0 configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl -
使用生成的代码：
生成的代码将包括 Entity 类、Mapper 接口、Service 接口和 Service 实现类。你可以直接在项目中使用这些生成的类。
示例：
以下是使用 MyBatis-Plus 代码生成器生成代码的示例：
// CodeGeneratorApplication.java
public class CodeGeneratorApplication {
public static void main(String[] args) {
CodeGenerator codeGenerator = SpringApplication.run(CodeGeneratorConfig.class, args)
.getBean(CodeGenerator.class);
codeGenerator.generateByTables("user");
}
}
// CodeGeneratorConfig.java
@Configuration
public class CodeGeneratorConfig {
@Bean
public MyMetaObjectHandler myMetaObjectHandler() {
return new MyMetaObjectHandler();
}
@Bean
public CodeGenerator codeGenerator() {
CodeGenerator codeGenerator = new CodeGenerator(
new DataSourceConfig().setUrl("jdbc:mysql://localhost:3306/your_database")
.setUsername("root")
.setPassword("your_password"),
"com.example"
);
codeGenerator.setAuthor("Your Name");
codeGenerator.setServiceName("%sService");
return codeGenerator;
}
}
运行 CodeGeneratorApplication 的 main 方法后，MyBatis-Plus 代码生成器将自动生成以下文件：
User.java（实体类）UserMapper.java（Mapper 接口）UserMapper.xml（Mapper XML 文件）UserService.java（Service 接口）UserServiceImpl.java（Service 实现类）
除此之外，idea中也有关于代码生成的plugin，自行选择即可
2.静态工具
MyBatis-Plus 提供了一些静态工具类，这些工具类可以帮助开发者更便捷地进行数据库操作。以下是一些常用的静态工具类及其使用方法：
-
AutoGenerator：
- 这是 MyBatis-Plus 的代码生成器，可以通过
AutoGenerator快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大地提升了开发效率。你可以在控制台输入模块表名，自动生成对应项目目录中的代码。
- 这是 MyBatis-Plus 的代码生成器，可以通过
-
Db：
Db是一个静态工具类，提供了与IService中方法签名基本一致的一些静态方法，可以帮助实现 CRUD 功能。例如：User user = Db.getById(1L, User.class); // 根据 ID 获取用户信息 List<User> list = Db.lambdaQuery(User.class) .like(User::getUsername, "o") .ge(User::getBalance, 1000).list(); // 查询用户名中带 "o" 并且 balance >= 1000 的用户信息 Db.lambdaUpdate(User.class) .set(User::getBalance, 2500) .eq(User::getUsername, "Rose").update(); // 设置用户名为 Rose 的用户的 balance 为 2500
-
Wrappers：
Wrappers是一个工具类，提供了快速创建查询条件构造器的方法。例如：QueryWrapper<User> queryWrapper = Wrappers.query(); queryWrapper.eq("name", "张三");
-
SqlHelper：
SqlHelper是一个工具类，提供了一些 SQL 操作的辅助方法。例如：int rows = Db.insert("INSERT INTO user (name, age) VALUES (?, ?)", "张三", 18); boolean success = SqlHelper.retBool(rows); // 判断插入操作是否成功
-
MyMetaObjectHandler：
MyMetaObjectHandler是一个元对象处理器，用于处理 MyBatis-Plus 的元数据。通常在配置类中使用，以自定义一些全局行为。
-
Configuration：
Configuration是 MyBatis-Plus 的全局配置类，可以通过它配置一些全局参数，如是否开启自动填充字段、是否开启逻辑删除等。
-
GlobalConfig：
GlobalConfig是 MyBatis-Plus 的全局配置类，用于设置代码生成器的全局配置，如输出目录、作者、是否打开目录等。
-
DataSourceConfig：
DataSourceConfig用于配置数据源信息，如数据库连接 URL、用户名、密码等。
-
PackageConfig：
PackageConfig用于配置代码生成的包路径信息，如父包名、模块名等。
3.逻辑删除
MyBatis-Plus 的逻辑删除功能是一种实现软删除的机制，它不会从数据库中真正删除记录，而是通过在记录中标记为“已删除”来实现删除的效果。这在需要保留数据以供历史分析或遵守某些数据保留政策的情况下非常有用。
如何实现逻辑删除：
-
添加逻辑删除字段：
在数据库表中添加一个字段，通常命名为is_deleted或deleted，类型为BIT或BOOLEAN。 -
配置逻辑删除字段：
在 MyBatis-Plus 的配置中，通过@TableLogic注解来指定逻辑删除的字段和值。 -
使用逻辑删除：
在查询、更新或删除操作时，MyBatis-Plus 会自动应用逻辑删除的规则。
具体步骤：
-
添加字段：
在数据库表中添加一个字段，例如is_deleted，类型为BIT或BOOLEAN。 -
配置 MyBatis-Plus：
在实体类中使用@TableLogic注解来指定逻辑删除的字段和值。例如：public class User { // 其他字段... @TableLogic(value = "0", delval = "1") private Integer isDeleted; }这里，
value是未删除的记录的值，delval是已删除的记录的值。 -
生成代码：
如果使用 MyBatis-Plus 的代码生成器，生成的实体类将包含逻辑删除字段。 -
查询操作：
当你执行查询操作时，MyBatis-Plus 会自动排除逻辑上已删除的记录。例如：List<User> users = userMapper.selectList(new QueryWrapper<User>().lambda() .eq(User::getIsDeleted, 0)); -
删除操作：
当需要删除记录时，实际上不是从数据库中删除，而是更新is_deleted字段的值为1：int rows = userMapper.delete(new QueryWrapper<User>().lambda() .eq(User::getIsDeleted, 0));这里，
delete方法实际上执行的是更新操作，将is_deleted字段设置为1。 -
实际删除：
如果需要彻底从数据库中删除记录，可以设置is_deleted为1然后执行删除操作：int rows = userMapper.delete(new QueryWrapper<User>().lambda() .eq(User::getIsDeleted, 1)); -
全局配置（可选）：
在全局配置中设置逻辑删除的值，这样所有实体类都会使用这些值：@Configuration public class MybatisPlusConfig { @Bean public MybatisPlusPropertiesCustomizer mybatisPlusPropertiesCustomizer() { return mybatisProperties -> { mybatisProperties.setLogicDeleteValue("1"); mybatisProperties.setLogicNotDeleteValue("0"); }; } }
4.枚举处理器
在 MyBatis-Plus 中，枚举处理器（Enum Handler）是一种自定义的处理器，用于处理枚举类型字段与数据库字段之间的转换。这在处理数据库中存储枚举值的场景中非常有用，尤其是当数据库中存储的是枚举的字符串或者整型值时。
枚举处理器的实现步骤：
-
定义枚举类型：首先定义你的枚举类型，确保每个枚举值都有一个对应的数据库值。
-
实现
IEnum接口：创建一个枚举处理器类，实现 MyBatis-Plus 的IEnum接口，该接口包含convert和getJavaType方法。 -
注册枚举处理器：在你的 MyBatis-Plus 配置中注册你的枚举处理器。
-
使用枚举处理器：在实体类中使用你的枚举类型字段，MyBatis-Plus 将自动使用注册的处理器进行转换。
示例：
假设我们有一个 Gender 枚举类型，它有两个值 MALE 和 FEMALE，分别对应数据库中的 1 和 2。
public enum Gender {
MALE(1, "Male"),
FEMALE(2, "Female");
private final int value;
private final String description;
Gender(int value, String description) {
this.value = value;
this.description = description;
}
public int getValue() {
return value;
}
public String getDescription() {
return description;
}
}
接下来，我们实现一个枚举处理器：
public class GenderTypeHandler implements IEnum<Gender> {
@Override
public Class<Gender> getJavaType() {
return Gender.class;
}
@Override
public Object convert(Gender gender) {
if (gender == null) {
return null;
}
return gender.getValue();
}
}
在 MyBatis-Plus 的配置中注册枚举处理器：
@Configuration
public class MyBatisPlusConfig {
@Bean
public MybatisPlusPropertiesCustomizer customizer() {
return mybatisProperties -> {
mybatisProperties.getTypeHandlers().add(new GenderTypeHandler());
};
}
}
最后，在实体类中使用枚举类型：
public class User {
// 其他字段...
private Gender gender; // 使用枚举类型
// getter 和 setter 方法...
}
这样，当你进行数据库操作时，MyBatis-Plus 将自动使用 GenderTypeHandler 来处理 Gender 类型的字段，将枚举值转换为数据库中的整型值，反之亦然。
使用枚举处理器的好处是，它提供了一种类型安全的方式来处理枚举和数据库值之间的转换，并且可以很容易地扩展以支持更复杂的转换逻辑。
5.JSON处理器
MyBatis-Plus 提供了多种 JSON 处理器，用于处理 JSON 字段与 Java 对象之间的转换。以下是一些关键点和示例：
-
内置 JSON 类型处理器：
MyBatis-Plus 内置了多种 JSON 类型处理器，包括AbstractJsonTypeHandler及其子类Fastjson2TypeHandler、FastjsonTypeHandler、GsonTypeHandler、JacksonTypeHandler等。这些处理器可以将 JSON 字符串与 Java 对象相互转换。 -
配置 JSON 处理器：
在实体类中，使用@TableField注解指定 JSON 处理器。例如：@Data @Accessors(chain = true) @TableName(autoResultMap = true) public class User { private Long id; ... @TableField(typeHandler = JacksonTypeHandler.class) private OtherInfo otherInfo; }确保存在对应的 JSON 解析依赖包。
-
XML 配置：
在 Mapper XML 文件中，可以为单个字段或多个字段中的某个字段配置类型处理器：<result column="other_info" jdbcType="VARCHAR" property="otherInfo" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler" /> <resultMap id="departmentResultMap" type="com.baomidou..."> <result property="director" column="director" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler" /> </resultMap> <select id="selectPageVO" resultMap="departmentResultMap"> select id,name,director from department ... </select> -
Wrapper 查询中的 TypeHandler 使用：
从 MyBatis-Plus 3.5.3.2 版本开始，可以在 Wrapper 查询中直接使用 TypeHandler：Wrappers.<H2User>lambdaQuery() .apply("name={0,typeHandler=" + H2userNameJsonTypeHandler.class.getCanonicalName() + "}", "{\"id\":101,\"name\":\"Tomcat\"}")) -
自定义类型处理器：
在 MyBatis-Plus 中，除了使用内置的类型处理器外，开发者还可以根据需要自定义类型处理器。例如，当使用 PostgreSQL 数据库时，可能会遇到 JSONB 类型的字段，这时可以创建一个自定义的类型处理器来处理 JSONB 数据。 -
使用 JSON 处理器的示例：
假设有一个User实体类，包含一个 JSON 字段additionalInfo：public class User { private Long id; private String name; @TableField(typeHandler = JacksonTypeHandler.class) private JsonNode additionalInfo; }在 Mapper 接口中，可以使用
@Update注解来更新 JSON 字段：public interface UserMapper extends BaseMapper<User> { @Update("UPDATE user SET additional_info = #{additionalInfo, typeHandler=com.yourpackage.JsonTypeHandler} WHERE id = #{id}") void updateAdditionalInfoById(@Param("additionalInfo") JsonNode additionalInfo, @Param("id") Long id); } -
考虑 JSON 字段的查询优化：
当在数据库中使用 JSON 字段时，查询性能可能成为一个问题。为了优化性能，可以使用数据库原生的 JSON 函数进行查询，例如在 PostgreSQL 中使用->>或#>>运算符。此外，为常用查询的 JSON 字段创建索引也是一个有效的策略。
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
