Spring Boot 最佳实践

3.7 spring-boot-flyway — 数据库版本迁移

模块定位：使用 Flyway 进行数据库版本管理，在应用启动时自动执行 SQL 迁移脚本，确保数据库结构与代码一致。

文件结构

迁移脚本示例

// V1__create_user_table.sql
CREATE TABLE t_user (
    id          BIGINT PRIMARY KEY AUTO_INCREMENT,
    username    VARCHAR(50) NOT NULL,
    password    VARCHAR(100) NOT NULL,
    email       VARCHAR(100),
    create_time DATETIME
);

// V2__add_user_fields.sql
ALTER TABLE t_user
    ADD COLUMN phone VARCHAR(20),
    ADD COLUMN status INT DEFAULT 1;

配置要点

spring:
  flyway:
    enabled: true              # 启用 Flyway（默认即启用）
    locations: classpath:db/migration  # 迁移脚本位置
    baseline-on-migrate: true  # 对已存在的库，自动基线化
    validate-on-migrate: true  # 执行前校验

四、缓存与会话 — Spring Cache

四、1 spring-boot-cache — 缓存抽象

模块定位：使用 Spring Cache 抽象层，统一多种缓存实现（Redis、ConcurrentHashMap 等），通过注解即可实现缓存功能。

核心代码：缓存配置

// 启用缓存注解
@SpringBootApplication
@EnableCaching  // 关键：开启缓存支持
public class Application { }

// CacheConfiguration.java — 缓存管理器配置
@Configuration
public class CacheConfiguration {

    @Bean
    public CacheManager cacheManager() {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))      // 默认过期时间
            .serializeKeysWith(SerializationPair.fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        return RedisCacheManager.builder(RedisConnectionFactory)
            .cacheDefaults(config)
            .build();
    }
}

核心代码：缓存注解使用

@Service
public class CacheService {

    @Autowired
    private UserRepository userRepository;

    // 缓存方法返回值，key 为 "user:" + 参数 username
    @Cacheable(value = "users", key = "#username")
    public UserDO getUser(String username) {
        return userRepository.findByUsername(username).orElse(null);
    }

    // 更新缓存
    @CachePut(value = "users", key = "#user.username")
    public UserDO updateUser(UserDO user) {
        return userRepository.save(user);
    }

    // 清除缓存
    @CacheEvict(value = "users", key = "#username")
    public void deleteUser(String username) {
        userRepository.findByUsername(username)
            .ifPresent(u -> userRepository.delete(u));
    }
}

四、2 spring-boot-redis — Redis 集成

模块定位：使用 Spring Data Redis 操作 Redis 数据库，支持字符串、哈希、列表、集合、有序集合五种数据结构，以及分布式锁功能。

文件结构

核心代码：RedisTemplate 配置

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // Key 使用 String 序列化
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // Value 使用 JSON 序列化（Jackson）
        Jackson2JsonRedisSerializer<Object> serializer =
            new Jackson2JsonRedisSerializer<>(Object.class);
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}

核心代码：完整 Redis 操作封装

@Service
public class RedisOptService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // === String 类型操作 ===
    public void set(String key, Object value, long seconds) {
        redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
    }

    // === Hash 类型操作 ===
    public void hashSet(String key, String field, Object value) {
        redisTemplate.opsForHash().put(key, field, value);
    }

    // === List 类型操作 ===
    public void listPush(String key, Object value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    // === Set 类型操作 ===
    public void setAdd(String key, Object... values) {
        redisTemplate.opsForSet().add(key, values);
    }

    // === ZSet 类型操作（有序集合）===
    public void zSetAdd(String key, Object value, double score) {
        redisTemplate.opsForZSet().add(key, value, score);
    }
}

核心代码：分布式锁

@Service
public class RedisLockService {

    @Autowired
    private RedisLockRegistry redisLockRegistry;

    // 获取分布式锁
    public void lock(String lockKey) {
        Lock lock = redisLockRegistry.obtain(lockKey);
        lock.lock();
    }

    // 释放锁
    public void unlock(String lockKey) {
        Lock lock = redisLockRegistry.obtain(lockKey);
        lock.unlock();
    }

    // 尝试获取锁（带超时）
    public boolean tryLock(String lockKey, long waitTime, long leaseTime) {
        Lock lock = redisLockRegistry.obtain(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            return false;
        }
    }
}

四、3 spring-boot-session — 分布式会话

模块定位：使用 Spring Session 将 Session 存储到 Redis，实现多实例/集群环境下的会话共享。

核心代码：Session 认证拦截器

// LoginInterceptor.java — Session 认证拦截器
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        UserDO user = (UserDO) session.getAttribute("user");
        if (user == null) {
            response.setStatus(401);
            return false;  // 未登录，拒绝访问
        }
        return true;  // 已登录，放行
    }
}

核心代码：注册拦截器

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor)
            .addPathPatterns("/api/**")       // 拦截所有 API
            .excludePathPatterns("/api/login");  // 排除登录接口
    }
}

配置要点

spring:
  data:
    redis:
      host: localhost
      port: 6379
  session:
    store-type: redis      # 指定 Session 存储类型为 Redis
    timeout: 30m             # Session 过期时间

五、消息与邮件 — 消息队列

五、1 spring-boot-activemq — ActiveMQ (JMS)

模块定位：使用 Apache ActiveMQ 实现消息队列，基于 JMS (Java Message Service) API。

核心代码：消息监听器

// MsgController.java — 消息接收
@RestController
public class MsgController {

    // 监听队列消息
    @JmsListener(destination = "test.queue")
    public void receiveQueue(String message) {
        System.out.println("收到队列消息: " + message);
    }

    // 监听主题（发布/订阅）
    @JmsListener(destination = "test.topic")
    public void receiveTopic(String message) {
        System.out.println("收到主题消息: " + message);
    }
}

核心代码：消息发送

@Service
public class MsgService {

    @Autowired
    private JmsTemplate jmsTemplate;

    // 发送消息到队列
    public void sendQueue(String queueName, String message) {
        jmsTemplate.convertAndSend(queueName, message);
    }

    // 发送消息到主题
    public void sendTopic(String topicName, String message) {
        jmsTemplate.convertAndSend(topicName, message);
    }
}

配置要点

spring:
  jms:
    url: tcp://localhost:61616
    username: admin
    password: admin
  activemq:
    in-memory: true    # 内存模式（测试用）

五、2 spring-boot-rabbitmq — RabbitMQ (AMQP)

模块定位：使用 RabbitMQ 消息中间件，基于 AMQP 协议，支持直接交换、主题交换、扇出交换等多种路由模式。

核心代码：RabbitMQ 配置

@Configuration
public class RabbitMQConfig {

    public static final String QUEUE = "test.queue";
    public static final String EXCHANGE = "test.exchange";

    @Bean
    public Queue queue() {
        return new Queue(QUEUE, true);  // durable=true 持久化
    }

    @Bean
    public DirectExchange exchange() {
        return new DirectExchange(EXCHANGE, true, false);
    }

    @Bean
    public Binding binding(Queue queue, DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("test.routingKey");
    }
}

核心代码：消息发送与接收

// 消息发送
@Service
public class MsgService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String message) {
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE,
            "test.routingKey", message);
    }
}

// 消息接收
@RabbitListener(queues = RabbitMQConfig.QUEUE)
public void receive(String message) {
    System.out.println("收到消息: " + message);
}

配置要点

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        concurrency: 3           # 最小消费者数
        max-concurrency: 10      # 最大消费者数
        prefetch: 1              # 每次只处理一条消息
        acknowledge-mode: manual  # 手动确认

五、3 spring-boot-kafka — Kafka 集成

模块定位：使用 Apache Kafka 分布式消息平台，适用于高吞吐、大数据量场景。

核心代码：Kafka 配置

@Configuration
public class KafkaConfig {

    // 定义 Topic（应用启动时自动创建）
    @Bean
    public NewTopic topic() {
        return new NewTopic("test-topic", 3, (short) 1);
        // 参数：topic名, 分区数, 副本因子
    }
}

核心代码：消息发送与接收

// 消息发送
@Service
public class KafkaService {
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void send(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }
}

// 消息接收
@Service
public class KafkaListenerService {

    @KafkaListener(topics = "test-topic",
                    groupId = "test-group")
    public void listen(String message) {
        System.out.println("收到 Kafka 消息: " + message);
    }
}

配置要点

spring:
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: test-group
      auto-offset-restore: earliest  # 从最早的消息开始消费
      enable-auto-commit: false     # 关闭自动提交

五、4 spring-boot-mail — Java Mail

模块定位：使用 Spring Mail 发送邮件，支持纯文本和 HTML 格式邮件。

核心代码：邮件控制器

@RestController
@RequestMapping("/api/email")
public class EmailController {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private MailProperties mailProperties;

    // 发送简单文本邮件
    @PostMapping("/simple")
    public void sendSimple(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(mailProperties.getFrom());
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        mailSender.send(message);
    }

    // 发送 HTML 邮件（带附件）
    @PostMapping("/html")
    public void sendHtml(MultipartFile attachment) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        helper.setFrom(mailProperties.getFrom());
        helper.setTo("user@example.com");
        helper.setSubject("测试邮件");
        helper.setText(<h1>Hello</h1><p>这是一封 HTML 邮件</p>, true);

        // 添加附件
        if (attachment != null) {
            helper.addAttachment(attachment.getOriginalFilename(), attachment.getResource());
        }
        mailSender.send(message);
    }
}

配置要点

spring:
  mail:
    host: smtp.gmail.com
    port: 587
    username: your-email@gmail.com
    password: your-app-password  # 应用专用密码（非邮箱密码）
    properties:
      mail.smtp.auth: true
      mail.smtp.starttls.enable: true
      mail.smtp.starttls.required: true

六、安全与监控 — Actuator

六、1 spring-boot-actuator — 应用监控

模块定位：使用 Spring Boot Actuator 提供生产级应用监控端点，支持健康检查、指标收集、自定义端点等功能。

核心代码：自定义监控端点

@Configuration
public class MetricsConfig {

    @Bean
    public MeterRegistryCustomizer<Counter> customCounter() {
        return counter -> counter.tag("app", "my-application");
    }
}

// 自定义端点
@WebEndpoint(id = "custom")
public class TestEndpoint {

    @ReadOperation  // GET 请求
    public Map<String, Object> info() {
        Map<String, Object>> result = new HashMap<>();
        result.put("version", "1.0.0");
        result.put("status", "running");
        return result;
    }
}

配置要点

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,custom  # 暴露的端点
  endpoint:
    health:
      show-details: always    # 显示详细健康信息

安全配置（Spring Security 集成）

// SecurityConfig.java — Actuator 安全配置
@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authz -> authz
                .requestMatchers("/actuator/**").hasRole("ADMIN")  # Actuator 需要 ADMIN 角色
                .anyRequest().authenticated()
            )
            .httpBasic(Customizer.withDefaults());
        return http.build();
    }
}

六、2 spring-boot-aop — AOP 面向切面编程

模块定位：使用 Spring AOP 实现横切关注点（日志、事务、权限校验等）与业务逻辑分离。

核心代码：日志切面

@Aspect
@Component
public class CalcAspect {

    // 前置通知：方法执行前
    @Before("execution(* cn.javastack.springboot.aop.service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        System.out.println("方法: " + joinPoint.getSignature().getName() + " 开始");
    }

    // 后置通知：方法执行后（无论是否异常）
    @After("execution(* cn.javastack.springboot.aop.service.*.*(..))")
    public void after(JoinPoint joinPoint) {
        System.out.println("方法: " + joinPoint.getSignature().getName() + " 结束");
    }

    // 返回后通知：获取返回值
    @AfterReturning(value = "execution(* cn.javastack.springboot.aop.service.*.*(..))",
                     returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("方法: " + joinPoint.getSignature().getName()
            + " 返回值: " + result);
    }

    // 环绕通知：最强大的通知类型
    @Around("execution(* cn.javastack.springboot.aop.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();  // 执行目标方法
        long elapsed = System.currentTimeMillis() - start;
        System.out.println("方法: " + pjp.getSignature().getName()
            + " 耗时: " + elapsed + "ms");
        return result;
    }

    // 异常通知：方法抛出异常时
    @AfterThrowing(value = "execution(* cn.javastack.springboot.aop.service.*.*(..))",
                    throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e) {
        System.out.println("方法: " + joinPoint.getSignature().getName()
            + " 异常: " + e.getMessage());
    }
}

六、3 spring-boot-admin-server — 监控服务端

六、4 spring-boot-admin-client — 监控客户端

模块定位：Spring Boot Admin 是基于 Actuator 的可视化监控平台，提供 UI 界面展示应用健康状态、日志级别、JVM 指标等。

服务端核心代码

@SpringBootApplication
@EnableAdminServer  // 关键注解：启用 Admin Server
public class Application { }

// application.yml — 服务端配置
server:
  port: 9090
spring.boot.admin:
  ui:
    title: "Spring Boot Admin"

客户端核心代码

// 客户端 application.yml
spring.boot.admin.client:
  url: http://localhost:9090    # Admin Server 地址
  instance:
    metadata:
      user.name: "${spring.security.user.name}"
      user.password: "${spring.security.user.password}"

六、5 spring-boot-jasypt — 配置加密

模块定位：使用 Jasypt 对配置文件中的敏感信息（数据库密码、API Key 等）进行加密存储。

配置示例

// application.yml — 加密后的配置
spring:
  datasource:
    password: ENC(aB3xK9mP2vR7wQ5tL8nY4jF6hD1gS0cE)  # 加密密码

使用方式：

1. 添加依赖：com.github.ulisesbocchio:jasypt-spring-boot-starter
2. 使用 DefaultTextEncryptor 生成加密值：

// JasyptTest.java — 生成加密密码
@Test
public void encrypt() {
    DefaultTextEncryptor encryptor = new DefaultTextEncryptor();
    encryptor.setPassword("myMasterPassword");  # 加密密钥
    String encrypted = encryptor.encrypt("db_password_123");
    System.out.println(encrypted);  # 输出: aB3xK9mP2vR7wQ5tL8nY4jF6hD1gS0cE
}

# 启动时指定
java -Djasypt.encryptor.password="myMasterPassword" -jar app.jar

七、日志 — Logback

七、1 spring-boot-logging — 默认日志框架

模块定位：Spring Boot 默认使用 Logback 作为日志框架，通过 logback-spring.xml 或 application.yml 配置日志行为。

配置要点：application.yml

logging:
  level:
    root: INFO                          # 根日志级别
    cn.javastack: DEBUG                   # 项目包下 DEBUG 级别
    org.springframework: WARN             # Spring 框架 WARN 级别
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
  file:
    name: logs/application.log            # 日志文件路径
    max-size: 10MB                        # 单个日志文件最大大小
    max-history: 30                       # 保留 30 天日志

七、2 spring-boot-tinylog — 轻量级日志框架

模块定位：TinyLog 是一个轻量级 Java 日志框架，配置简单、性能优秀，适合对启动速度敏感的场景。

配置文件：tinylog.properties

# 日志级别
level = INFO

# 控制台输出
writer1 = console
writer1.format = {date: HH:mm:ss.SSS} {class}:{method} - {message}

# 文件输出（滚动策略）
writer2 = rolling-file
writer2.file = logs/app-{date: yyyy-MM-dd}.log
writer2.max-files = 30          # 最多保留 30 个文件
writer2.size = 10 MB            # 单个文件最大 10MB
writer2.format = {date: HH:mm:ss.SSS} {level}: {class}:{method} - {message}

八、高级特性 — 定时任务与打包

八、1 spring-boot-schedule — 定时任务

模块定位：使用 Spring @Scheduled 实现定时任务调度，支持 Cron 表达式、固定间隔、固定延迟等模式。

核心代码：简单任务

// 启用定时任务
@SpringBootApplication
@EnableScheduling  // 关键注解
public class Application { }

// SimpleTask.java — 简单定时任务
@Component
public class SimpleTask {

    // 固定间隔执行（每隔 5 秒）
    @Scheduled(fixedRate = 5000)
    public void fixedRateTask() {
        System.out.println("fixedRate: " + LocalDateTime.now());
    }

    // 固定延迟执行（上次完成后等待 5 秒再开始）
    @Scheduled(fixedDelay = 5000)
    public void fixedDelayTask() {
        System.out.println("fixedDelay: " + LocalDateTime.now());
    }

    // Cron 表达式（复杂调度）
    @Scheduled(cron = "0 0 12 * * ?")  # 每天中午 12:00
    public void cronTask() {
        System.out.println("cron: " + LocalDateTime.now());
    }
}

核心代码：自定义调度器

// TaskConfig.java — 自定义线程池调度器
@Configuration
public class TaskConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(TaskScheduler scheduler) {
        scheduler.scheduleAtFixedRate(() -> {
            System.out.println("定时任务: " + LocalDateTime.now());
        }, 0, 5000);
    }
}

八、2 spring-boot-quartz — Quartz 调度器

模块定位：使用 Quartz 企业级任务调度框架，支持持久化、集群、动态增删改任务等功能。

核心代码：Quartz 配置

// 自定义 Job（继承 QuartzJobBean）
public class SimpleTask extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Quartz 任务执行: " + LocalDateTime.now());
    }
}

// TaskConfig.java — Quartz 配置
@Configuration
public class TaskConfig {

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        try {
            // 创建 JobDetail
            JobDetail job = JobBuilder.newJob(SimpleTask.class)
                .withIdentity("myJob", "myGroup")
                .storeDurably()
                .build();

            // 创建 Trigger（Cron 触发器）
            Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "myGroup")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0/5 * * * ?"))  # 每 5 分钟
                .build();

            SchedulerFactoryBean factory = new SchedulerFactoryBean();
            factory.setJobDetails(job);
            factory.setTriggers(trigger);
            return factory;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

八、3 spring-boot-graalvm — GraalVM 原生镜像

模块定位：使用 GraalVM 将 Spring Boot 应用编译为原生可执行文件，大幅减少启动时间和内存占用。

构建命令

# 使用 native-maven-plugin 构建
mvn package -Pnative -Dnative.image.skipBuildImage=false

# 或使用 Docker 构建
docker build -f src/main/docker/Dockerfile.native .

八、4 spring-boot-war — WAR 打包

模块定位：将 Spring Boot 应用打包为 WAR 文件，部署到外部 Tomcat/Jetty 等 Servlet 容器。

核心代码

// pom.xml — 修改打包方式
<packaging>war</packaging>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>  # 关键：provided 作用域
</dependency>

// Application.java — 继承 SpringBootServletInitializer
@SpringBootApplication
public class Application extends SpringBootServletInitializer {

    @Override
    protected SpringBootServletInitializer configure(SpringApplicationBuilder builder) {
        return builder.sources(Application.class).build();
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

八、5 javastack-spring-boot-starter — 自定义 Starter

模块定位：学习如何编写 Spring Boot 自动配置的 Starter，实现可复用的组件封装。

文件结构

核心代码：配置属性类

@ConfigurationProperties(prefix = "javastack.test")
@Data
public class TestServiceProperties {
    private String name = "default";
    private Integer timeout = 5000;
    private Boolean enabled = true;
}

核心代码：自动配置类

@Configuration
@ConditionalOnProperties(prefix = "javastack.test", name = "enabled", havingValue = "true")
@EnableConfigurationProperties(TestServiceProperties.class)  // 启用配置属性绑定
public class TestServiceAutoConfiguration {

    @Autowired
    private TestServiceProperties properties;

    @Bean
    public TestService testService() {
        return new TestService(properties.getName(), properties.getTimeout());
    }
}

自动注册（Spring Boot 2.x）

# META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  cn.javastack.springboot.starter.config.TestServiceAutoConfiguration

Spring Boot 3.x 变更： 改用 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件：

cn.javastack.springboot.starter.config.TestServiceAutoConfiguration

九、测试 — Spring Boot 测试

九、1 spring-boot-test — 完整测试方案

模块定位：Spring Boot 提供完整的测试支持，包括 MockMvc（Web 层）、@MockBean（依赖模拟）、JsonTest（JSON 序列化）等。

文件结构

核心代码：MockMvc 测试

// 启用 Spring Boot 测试环境
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc  // 自动配置 MockMvc
public class MockMvcTests {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetUser() throws Exception {
        mockMvc.perform(get("/api/users/1"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.username").value("testuser"));
    }

    @Test
    public void testCreateUser() throws Exception {
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"username\":\"newuser\"}"))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").exists());
    }
}

核心代码：@MockBean 测试

@SpringBootTest
public class MockBeanTests {

    @MockBean  // 模拟 UserRepository 依赖
    private UserRepository userRepository;

    @Autowired
    private UserController userController;

    @Test
    public void testGetUser() {
        // 模拟依赖返回
        BDDMockito.given(userRepository.findById(1L))
            .willReturn(Optional.of(new UserDO(1L, "test")));

        // 调用控制器
        UserDO user = userController.getUser(1L);
        assertThat(user.getUsername()).isEqualTo("test");

        // 验证交互
        BDDMockito.then(userRepository).verify().findById(1L);
    }
}

核心代码：JSON 序列化测试

@JsonTest  // 仅加载 Jackson 相关配置
public class JsonTests {

    @Autowired
    private JacksonTester<UserDO> jsonTester;

    @Test
    public void testSerialize() throws IOException {
        UserDO user = new UserDO(1L, "test", "test@example.com");

        // 断言 JSON 序列化结果
        assertThat(jsonTester.write(user).getJson())
            .hasPathField("id", 1)
            .hasPathField("username", "test");
    }
}

核心代码：TestRestTemplate 测试

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MvcTests {

    @Autowired
    private TestRestTemplate testRestTemplate;

    @Test
    public void getUserTest() {
        Result result = testRestTemplate.getForObject(
            "/user/get?username={username}", Result.class,
            Map.of("username", "Java技术栈"));
        assertThat(result.getCode()).isEqualTo(0);
        assertThat(result.getMsg()).isEqualTo("ok");
    }
}

spring:
  datasource:
    url: jdbc:h2:mem:testdb     # 测试用内存数据库
    username: sa
    password:
  jpa:
    hibernate:
      ddl-auto: create-drop     # 测试结束后自动删除