如何在 Spring Boot 4.0 预览版中整合 MyBatis-Plus。内容涵盖项目初始化、配置虚拟线程与响应式编程、实体类与 Mapper 编写、Service 层实现（含结构化并发）、Controller 层 REST API 设计、全局异常处理、AOT 原生镜像支持及 Docker 部署方案。通过示例代码展示了如何利用 Java 21 虚拟线程优化并发性能，结合 R2DBC 实现非阻塞数据访问，并提供了完整的构建工具配置与测试方法，旨在帮助开发者构建高性能的现代 Java 应用程序。
注：Spring Boot 4.0，本教程基于 Spring Boot 4.0 的预览版和新特性预期进行构建。实际发布时可能会有调整。
# 使用官方 Initializr
curl https://start.spring.io/starter.zip \
-d type=maven-project \
-d language=java \
-d bootVersion=4.0.0-M1 \
-d baseDir=spring-boot4-mybatisplus \
-d groupId=com.example \
-d artifactId=demo \
-d name=demo \
-d description=Demo+project+for+Spring+Boot+4.0+with+MyBatis-Plus \
-d packageName=com.example.demo \
-d packaging=jar \
-d javaVersion=21 \
-d dependencies=web,data-jpa \
-o demo.zip
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>4.0.0-M1</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>springboot4-mybatisplus</artifactId>
<version>1.0.0</version>
<name>springboot4-mybatisplus</name>
<description>Spring Boot 4.0 with MyBatis-Plus</description>
<properties>
<java.version>21</java.version>
<mybatis-plus.version>3.5.5</mybatis-plus.version>
<graalvm.version>23.0.0</graalvm.version>
</properties>
<dependencies>
<!-- Spring Boot 4.0 核心依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 响应式 Web 支持（新特性） -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<!-- MyBatis-Plus -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<!-- 数据库驱动 -->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<!-- 响应式 MySQL 驱动（新特性） -->
<dependency>
<groupId>io.asyncer</groupId>
<artifactId>r2dbc-mysql</artifactId>
<scope>runtime</scope>
</dependency>
<!-- 响应式 R2DBC -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-r2dbc</artifactId>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- GraalVM 原生镜像支持（新特性） -->
<dependency>
<groupId>org.graalvm.buildtools</groupId>
<artifactId>native-maven-plugin</artifactId>
</dependency>
<!-- 测试依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- 响应式测试支持 -->
<dependency>
<groupId>io.projectreactor</groupId>
<artifactId>reactor-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!-- Spring Boot Maven 插件，支持 AOT -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<image>
<builder>paketobuildpacks/builder-jammy-tiny:latest</builder>
<env>
<BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE>
</env>
</image>
</configuration>
</plugin>
<!-- GraalVM Native Image 插件 -->
<plugin>
<groupId>org.graalvm.buildtools</groupId>
<artifactId>native-maven-plugin</artifactId>
<version>${graalvm.version}</version>
<extensions>true</extensions>
<executions>
<execution>
<id>build-native</id>
<goals>
<goal>compile-no-fork</goal>
</goals>
<phase>package</phase>
</execution>
</executions>
</plugin>
</plugins>
</build>
<!-- Spring Milestone 仓库 -->
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
</project>
# Spring Boot 4.0 新配置格式
spring:
application:
name: springboot4-mybatisplus
# 数据源配置（虚拟线程优化）
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/mybatis_plus_demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
username: root
password: 123456
hikari:
# 虚拟线程池配置（Spring Boot 4.0 新特性）
thread-factory: org.springframework.boot.jdbc.VirtualThreadExecutor
# 响应式数据源（新特性）
r2dbc:
url: r2dbc:mysql://localhost:3306/mybatis_plus_demo
username: root
password: 123456
# AOT 编译配置
aot:
enabled: true
generate-code: true
# GraalVM 原生镜像配置
native:
mode: native
debug: true
# MyBatis-Plus 配置
mybatis-plus:
configuration:
# 自动映射行为
auto-mapping-behavior: full
# 驼峰命名转换
map-underscore-to-camel-case: true
# 日志实现
[]
package com.example.demo.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.BlockAttackInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.apache.ibatis.reflection.MetaObject;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import java.time.LocalDateTime;
/**
* MyBatis-Plus 配置类
* 使用 Spring Boot 4.0 新特性：虚拟线程兼容性配置
*/
@Configuration
@EnableTransactionManagement
@MapperScan("com.example.demo.mapper")
public class MyBatisPlusConfig {
/**
* MyBatis-Plus 拦截器配置
* 支持分页、乐观锁、防全表更新与删除
*/
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 分页插件
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
// 乐观锁插件
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
// 防止全表更新与删除
interceptor.addInnerInterceptor( ());
interceptor;
}
MetaObjectHandler {
() {
{
.strictInsertFill(metaObject, , LocalDateTime.class, LocalDateTime.now());
.strictInsertFill(metaObject, , LocalDateTime.class, LocalDateTime.now());
.strictInsertFill(metaObject, , Integer.class, );
}
{
.strictUpdateFill(metaObject, , LocalDateTime.class, LocalDateTime.now());
}
};
}
}
package com.example.demo.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 基础实体类
* 使用 Java 21 Record 模式（预览特性）
*/
@Data
@Accessors(chain = true)
public class BaseEntity implements Serializable {
/**
* 主键 ID - 使用虚拟线程安全的 ID 生成策略
*/
@TableId(type = IdType.ASSIGN_ID)
private Long id;
/**
* 创建时间
*/
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField(fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 创建人
*/
@TableField(fill = FieldFill.INSERT)
private String createBy;
/**
* 更新人
*/
@TableField(fill = FieldFill.INSERT_UPDATE)
private String updateBy;
/**
* 乐观锁版本号
*/
@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;
/**
* 逻辑删除标志
*/
@TableLogic
@TableField(fill = FieldFill.INSERT)
private Integer deleted;
}
package com.example.demo.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* 用户实体类
* 使用 Spring Boot 4.0 新特性：虚拟线程安全的序列化
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("sys_user")
public class User extends BaseEntity {
/**
* 用户名
*/
private String username;
/**
* 密码
*/
private String password;
/**
* 邮箱
*/
private String email;
/**
* 手机号
*/
private String phone;
/**
* 状态：0-禁用，1-启用
*/
private Integer status;
/**
* 虚拟线程安全的额外字段
* 使用 transient 避免序列化问题
*/
@TableField(exist = false)
private transient String virtualThreadInfo;
}
package com.example.demo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.data.repository.query.Param;
import org.springframework.r2dbc.core.DatabaseClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* 用户 Mapper
* 支持响应式查询（Spring Boot 4.0 新特性）
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
/**
* 传统阻塞式查询
*/
@Select("SELECT * FROM sys_user WHERE username = #{username}")
User selectByUsername(@Param("username") String username);
/**
* 响应式查询 - 返回单个结果
* 使用虚拟线程安全的方式
*/
@Select("SELECT * FROM sys_user WHERE id = #{id}")
default Mono<User> selectReactiveById(Long id, DatabaseClient databaseClient) {
return databaseClient.sql("SELECT * FROM sys_user WHERE id = :id")
.bind("id", id)
.map((row, metadata) -> {
User user = new User();
user.setId(row.get("id", Long.class));
user.setUsername(row.get("username", String.class));
user.setEmail(row.get("email", String.class));
user.setStatus(row.get("status", Integer.class));
return user;
})
.one();
}
Flux<User> {
databaseClient.sql()
.bind(, status)
.map((row, metadata) -> {
();
user.setId(row.get(, Long.class));
user.setUsername(row.get(, String.class));
user.setEmail(row.get(, String.class));
user.setStatus(row.get(, Integer.class));
user;
})
.all();
}
}
package com.example.demo.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.example.demo.entity.User;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.concurrent.CompletableFuture;
/**
* 用户服务接口
* 支持响应式和虚拟线程
*/
public interface UserService extends IService<User> {
/**
* 虚拟线程方式查询用户
* Spring Boot 4.0 新特性
*/
CompletableFuture<User> findUserByUsernameVirtualThread(String username);
/**
* 响应式查询用户
*/
Mono<User> findUserByIdReactive(Long id);
/**
* 响应式查询用户列表
*/
Flux<User> findUsersByStatusReactive(Integer status);
/**
* 使用结构化并发（Java 21 新特性）
*/
User findUserWithStructuredConcurrency(Long id);
}
package com.example.demo.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import com.example.demo.service.UserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.r2dbc.core.DatabaseClient;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.TimeUnit;
/**
* 用户服务实现
* 使用 Spring Boot 4.0 新特性：虚拟线程和响应式编程
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
private final UserMapper userMapper;
private final DatabaseClient databaseClient;
@Override
public CompletableFuture<User> findUserByUsernameVirtualThread(String username) {
return CompletableFuture.supplyAsync(() -> {
try {
// 模拟耗时操作
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
userMapper.selectOne( <User>().eq(User::getUsername, username));
}, Thread.ofVirtual().factory());
}
Mono<User> {
userMapper.selectReactiveById(id, databaseClient).doOnNext(user -> log.info(, user.getUsername()));
}
Flux<User> {
userMapper.selectReactiveByStatus(status, databaseClient).doOnNext(user -> log.info(, user.getUsername()));
}
User {
( .ShutdownOnFailure()) {
scope.fork(() -> userMapper.selectById(id));
scope.fork(() ->
+ id
);
scope.join();
scope.throwIfFailed();
userFuture.get();
(user != ) {
user.setVirtualThreadInfo(userDetailsFuture.get());
}
user;
} (InterruptedException e) {
Thread.currentThread().interrupt();
(, e);
} (Exception e) {
(, e);
}
}
{
( .ShutdownOnFailure()) {
List<StructuredTaskScope.Subtask<User>> tasks = users.stream()
.map(user -> scope.fork(() -> {
save(user);
user;
}))
.toList();
scope.join();
scope.throwIfFailed();
tasks.forEach(task -> log.info(, task.get().getUsername()));
} (InterruptedException e) {
Thread.currentThread().interrupt();
(, e);
} (Exception e) {
(, e);
}
}
}
package com.example.demo.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
/**
* 用户控制器
* 支持虚拟线程和传统阻塞模式
*/
@Slf4j
@RestController
@RequestMapping("/api/v1/users")
@RequiredArgsConstructor
public class UserController {
private final UserService userService;
/**
* 创建用户
*/
@PostMapping
public ResponseEntity<User> create(@RequestBody User user) {
boolean saved = userService.save(user);
return saved ? ResponseEntity.ok(user) : ResponseEntity.badRequest().build();
}
/**
* 分页查询用户
* 使用虚拟线程优化
*/
@GetMapping("/page")
public ResponseEntity<IPage<User>> page(
@RequestParam(defaultValue = "1") Integer current,
@RequestParam(defaultValue = "10") Integer size) {
Page<User> page = <>(current, size);
IPage<User> result = userService.page(page);
ResponseEntity.ok(result);
}
ResponseEntity<User>
ExecutionException, InterruptedException {
CompletableFuture<User> future = userService.findUserByUsernameVirtualThread(username);
ResponseEntity.ok(future.get());
}
ResponseEntity<User> {
userService.findUserWithStructuredConcurrency(id);
ResponseEntity.ok(user);
}
ResponseEntity<Void> {
Thread.ofVirtual().start(() -> {
userService.saveUsersWithVirtualThreads(users);
});
ResponseEntity.accepted().build();
}
}
package com.example.demo.controller;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;
/**
* 响应式用户控制器
* Spring Boot 4.0 响应式增强
*/
@Slf4j
@RestController
@RequestMapping("/api/v2/users")
@RequiredArgsConstructor
public class UserReactiveController {
private final UserService userService;
/**
* 响应式查询单个用户
*/
@GetMapping("/reactive/{id}")
public Mono<ResponseEntity<User>> findByIdReactive(@PathVariable Long id) {
return userService.findUserByIdReactive(id)
.map(ResponseEntity::ok)
.defaultIfEmpty(ResponseEntity.notFound().build());
}
/**
* 响应式查询用户列表
*/
@GetMapping(value = "/reactive/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<User> streamByStatus(@RequestParam Integer status) {
return userService.findUsersByStatusReactive(status)
.delayElements(Duration.ofMillis(100)) // 模拟流式处理
.doOnNext(user -> log.info("Streaming user: {}", user.getUsername()));
}
Flux<String> {
Flux.interval(Duration.ofSeconds())
.map(sequence -> String.format(, sequence, java.time.LocalTime.now()));
}
}
package com.example.demo.repository;
import com.example.demo.entity.User;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* 响应式用户仓库
* Spring Boot 4.0 响应式数据访问
*/
@Repository
public interface UserReactiveRepository extends R2dbcRepository<User, Long> {
/**
* 根据用户名查询
*/
@Query("SELECT * FROM sys_user WHERE username = :username")
Mono<User> findByUsername(String username);
/**
* 根据状态查询
*/
@Query("SELECT * FROM sys_user WHERE status = :status")
Flux<User> findByStatus(Integer status);
/**
* 分页查询
*/
@Query("SELECT * FROM sys_user ORDER BY create_time DESC LIMIT :limit OFFSET :offset")
Flux<User> findAllWithPagination(int limit, int offset);
}
package com.example.demo.handler;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.bind.support.WebExchangeBindException;
import reactor.core.publisher.Mono;
import java.util.HashMap;
import java.util.Map;
/**
* 全局异常处理器
* 支持响应式异常处理
*/
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
/**
* 处理 MyBatis-Plus 异常
*/
@ExceptionHandler(MybatisPlusException.class)
public ResponseEntity<Map<String, Object>> handleMybatisPlusException(MybatisPlusException e) {
log.error("MyBatis-Plus Exception: {}", e.getMessage(), e);
Map<String, Object> response = new HashMap<>();
response.put("code", HttpStatus.INTERNAL_SERVER_ERROR.value());
response.put("message", "数据库操作失败");
response.put("detail", e.getMessage());
response.put("timestamp", System.currentTimeMillis());
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
}
/**
* 处理虚拟线程中断异常
*/
@ExceptionHandler(InterruptedException.class)
public ResponseEntity<Map<String, Object>> handleInterruptedException(InterruptedException e) {
log.warn(, e.getMessage());
Map<String, Object> response = <>();
response.put(, HttpStatus.SERVICE_UNAVAILABLE.value());
response.put(, );
response.put(, System.currentTimeMillis());
Thread.currentThread().interrupt();
ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(response);
}
Mono<ResponseEntity<Map<String, Object>>> {
Mono.fromCallable(() -> {
Map<String, Object> response = <>();
response.put(, HttpStatus.BAD_REQUEST.value());
response.put(, );
Map<String, String> errors = <>();
e.getFieldErrors().forEach(error -> errors.put(error.getField(), error.getDefaultMessage()));
response.put(, errors);
response.put(, System.currentTimeMillis());
ResponseEntity.badRequest().body(response);
});
}
}
package com.example.demo.config;
import org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration;
import org.springframework.boot.web.embedded.tomcat.TomcatProtocolHandlerCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.core.task.support.TaskExecutorAdapter;
import org.springframework.scheduling.annotation.EnableAsync;
import java.util.concurrent.Executors;
/**
* 虚拟线程配置
* Spring Boot 4.0 核心新特性
*/
@Configuration
@EnableAsync
public class VirtualThreadConfig {
/**
* 配置 Tomcat 使用虚拟线程
*/
@Bean
public TomcatProtocolHandlerCustomizer<?> protocolHandlerVirtualThreadExecutorCustomizer() {
return protocolHandler -> protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
}
/**
* 配置 Spring 异步任务执行器使用虚拟线程
*/
@Bean(TaskExecutionAutoConfiguration.APPLICATION_TASK_EXECUTOR_BEAN_NAME)
public AsyncTaskExecutor asyncTaskExecutor() {
return new TaskExecutorAdapter(Executors.newVirtualThreadPerTaskExecutor());
}
/**
* 配置虚拟线程池用于数据库操作
*/
@Bean
public java.util.concurrent.ExecutorService databaseExecutor() {
return Executors.newThreadPerTaskExecutor(Thread.ofVirtual().name("db-virtual-thread-", 0).factory());
}
}
package com.example.demo.aot;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.RuntimeHintsRegistrar;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportRuntimeHints;
/**
* AOT 运行时提示注册
* Spring Boot 4.0 原生镜像支持
*/
@Configuration
@ImportRuntimeHints(AotRuntimeHints.MybatisPlusRuntimeHints.class)
public class AotRuntimeHints {
static class MybatisPlusRuntimeHints implements RuntimeHintsRegistrar {
@Override
public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
// 注册反射
hints.reflection().registerType(com.baomidou.mybatisplus.core.mapper.BaseMapper.class, hint ->
hint.withMembers(org.springframework.aot.hint.MemberCategory.INVOKE_PUBLIC_METHODS));
// 注册资源
hints.resources().registerPattern("mapper/*.xml");
hints.resources().registerPattern("mybatis-config.xml");
// 注册序列化
hints.serialization().registerType(com.example.demo.entity.User.class);
// 注册代理
hints.proxies().registerJdkProxy(org.apache.ibatis.binding.MapperProxy.class);
}
}
}
Args = --enable-url-protocols=http,https \
-H:+ReportExceptionStackTraces \
-H:+ReportUnsupportedElementsAtRuntime \
--initialize-at-build-time=com.mysql.cj \
--initialize-at-run-time=io.netty.handler.codec.http.HttpObjectEncoder \
-H:IncludeResourceBundles=com.mysql.cj.LocalizedErrorMessages
package com.example.demo;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 集成测试
* 测试虚拟线程和响应式功能
*/
@Slf4j
@SpringBootTest
class SpringBoot4MybatisPlusApplicationTests {
@Autowired
private UserService userService;
/**
* 测试虚拟线程查询
*/
@Test
void testVirtualThreadQuery() throws ExecutionException, InterruptedException, TimeoutException {
// 准备测试数据
User user = new User().setUsername("test_virtual").setEmail("[email protected]").setStatus(1);
userService.save(user);
// 使用虚拟线程查询
CompletableFuture<User> future = userService.findUserByUsernameVirtualThread("test_virtual");
future.get(, TimeUnit.SECONDS);
assertThat(result).isNotNull();
assertThat(result.getUsername()).isEqualTo();
log.info(, result.getId());
}
{
().setUsername().setEmail().setStatus();
userService.save(user);
Mono<User> userMono = userService.findUserByIdReactive(user.getId());
StepVerifier.create(userMono)
.assertNext(foundUser -> {
assertThat(foundUser).isNotNull();
assertThat(foundUser.getUsername()).isEqualTo();
})
.verifyComplete();
log.info();
}
{
().setUsername().setEmail().setStatus();
userService.save(user);
userService.findUserWithStructuredConcurrency(user.getId());
assertThat(result).isNotNull();
assertThat(result.getUsername()).isEqualTo();
assertThat(result.getVirtualThreadInfo()).contains();
log.info();
}
{
List<User> users = <>();
( ; i < ; i++) {
users.add( ().setUsername( + i).setEmail( + i + ).setStatus());
}
userService.saveUsersWithVirtualThreads(users);
List<User> savedUsers = userService.list( <User>().likeRight(User::getUsername, ));
assertThat(savedUsers).hasSize();
log.info(, savedUsers.size());
}
}
package com.example.demo.monitor;
import io.micrometer.core.instrument.MeterRegistry;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 虚拟线程性能监控
* Spring Boot 4.0 监控增强
*/
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class VirtualThreadMonitor {
private final MeterRegistry meterRegistry;
private final AtomicInteger activeVirtualThreads = new AtomicInteger(0);
/**
* 监控虚拟线程使用
*/
@Around("@annotation(com.example.demo.annotation.VirtualThreadMonitor)")
public Object monitorVirtualThread(ProceedingJoinPoint joinPoint) throws Throwable {
StopWatch stopWatch = new StopWatch();
int currentThreads = activeVirtualThreads.incrementAndGet();
try {
stopWatch.start();
Object result joinPoint.proceed();
stopWatch.stop();
meterRegistry.timer().record(stopWatch.getTotalTimeNanos(), java.util.concurrent.TimeUnit.NANOSECONDS);
meterRegistry.gauge(, activeVirtualThreads);
log.info(,
joinPoint.getSignature().getName(), stopWatch.getTotalTimeMillis(), currentThreads);
result;
} {
activeVirtualThreads.decrementAndGet();
}
}
}
package com.example.demo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
/**
* Spring Boot 4.0 Application
*/
@Slf4j
@SpringBootApplication
public class SpringBoot4MybatisPlusApplication {
public static void main(String[] args) {
// 启用 AOT 优化
System.setProperty("spring.aot.enabled", "true");
SpringApplication.run(SpringBoot4MybatisPlusApplication.class, args);
}
@EventListener(ApplicationReadyEvent.class)
public void onApplicationReady() {
log.info("=========================================");
log.info("Spring Boot 4.0 with MyBatis-Plus Started");
log.info("Java Version: {}", System.getProperty("java.version"));
log.info("Virtual Threads Available: {}", Thread.ofVirtual() != null ? "Yes" : "No");
log.info("Available Processors: {}", Runtime.getRuntime().availableProcessors());
log.info("=========================================");
}
}
# 构建阶段
FROM ghcr.io/graalvm/native-image:java21 AS builder
WORKDIR /app
COPY target/*.jar app.jar
RUN native-image -jar app.jar --no-fallback -H:Name=app-native
# 运行阶段
FROM alpine:latest
RUN apk add --no-cache libstdc++
WORKDIR /app
COPY --from=builder /app/app-native /app/app
EXPOSE 8080
ENTRYPOINT ["/app/app"]
version: '3.8'
services:
app:
build: .
ports:
- "8080:8080"
environment:
- SPRING_PROFILES_ACTIVE=prod
- JAVA_OPTS=-XX:+UseZGC -Xmx512m
depends_on:
- mysql
deploy:
resources:
limits:
memory: 512M
mysql:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: 123456
MYSQL_DATABASE: mybatis_plus_demo
ports:
- "3306:3306"
volumes:
- mysql_data:/var/lib/mysql
command:
- --default-authentication-plugin=mysql_native_password
- --character-set-server=utf8mb4
- --collation-server=utf8mb4_unicode_ci
volumes:
mysql_data:
Thread.ofVirtual() 和虚拟线程池优化并发性能本文展示了如何利用 Spring Boot 4.0 的新特性（虚拟线程、响应式编程、AOT 编译等）来整合 MyBatis-Plus，构建高性能的现代 Java 应用程序。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online