一、Spring Boot 分层测试策略
Spring Boot 应用采用经典的分层架构，不同层级的功能模块对应不同的测试策略，以确保代码质量和系统稳定性。
Spring Boot 分层架构：
bash
Spring Boot分层架构
A[客户端] -->|HTTP 请求| B[Controller 层]
B -->|调用| C[Service 层]
C -->|调用| D[Repository 层]
D -->|操作| E[数据库]
E -->|调用| F[外部服务接口]分层测试策略：
测试策略核心原则：
•单元测试 (UT)
隔离验证单模块逻辑（Controller、Service、Repository）。
价值：快速反馈，精准定位代码缺陷。
•集成测试 (IT)
垂直集成测试（应用内全链路）与水平集成测试（跨服务交互）
价值：保证生产环境行为一致性。
•契约测试 (CT)
保障跨服务接口一致性，与水平集成测试互补。
价值：防止接口"暗坑"，提升协作效率。
二、单元测试：逐层击破，精准验证
单元测试专注于验证单一模块的逻辑，通过模拟其依赖项，快速获取反馈。
2.1 Controller 层：HTTP接口的靶向验证
测试目标： REST API 接口的独立测试，隔离业务逻辑与外部依赖。
测试工具：
•@WebMvcTest：轻量级切片测试，仅加载 Controller 层相关 Bean。
•MockMvc：模拟 HTTP 请求与响应，支持链式断言。
•@MockBean：Mock 依赖的 Service 层组件，隔离Service层依赖。
实战示例：
java
@WebMvcTest(UserController.class) //只加载UserController进行测试。
public class UserControllerTest {
@Autowired
private MockMvc mockMvc;
//模拟UserService，用于提供预定义的行为。
@MockBean
private UserService userService;
@Test
void getUserById_Returns200() throws Exception {
// 模拟 Service 层返回
when(userService.findById(1L)).thenReturn(new User(1L, "Test"));
// 发起请求并断言
mockMvc.perform(get("/users/1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.name").value("Test"));
}
}1.代码解析
•1L - 代表Long类型的 ID，符合User实体类的定义。
•/users/1 -为 HTTP 请求中的路径参数，Spring 会自动将其转换为Long类型。
•测试逻辑 -通过模拟UserService返回固定的数据，验证 Controller 层的输入输出行为。
2.注解解析
@WebMvcTest
•专注于Web 层的单元测试。只加载 Web 层相关的 Bean，如MockMvc。
•@WebMvcTest(UserController.class)，表示只加载UserController进行测试。
@MockBean
•模拟服务层或其他依赖，避免与外部服务实际交互。
@Test
•标识一个单元测试方法。JUnit 会自动执行标记的方法，并报告结果。
MockMvc
•模拟 HTTP 请求并测试 Controller 行为及断言结果。
2.2 Service 层：业务逻辑深度验证
测试目标：验证业务规则的正确性、事务管理的行为符合预期。
测试工具：
@MockBean + @SpringBootTest（轻量模式）
@MockBean模拟数据库操作,结合@SpringBootTest提供的 Spring 应用上下文，进行Service层单元测试。
实战示例：
java
@SpringBootTest // 启动一个完整的 Spring 应用上下文
public class UserServiceTest {
// 自动注入 UserService 实例
@Autowired private UserService userService;
// 创建一个模拟的 UserRepository Bean，替代真实的数据库操作
@MockBean
private UserRepository userRepository;
@Test
void createUser_ValidInput_ReturnsUser() {
// 1. 准备测试数据
User user = new User("SpringBot");
when(userRepository.save(user)).thenReturn(user);
// 2. 调用业务方法
User result = userService.createUser(user);
// 3. 验证业务逻辑
assertThat(result.getName()).isEqualTo("SpringBot");
verify(userRepository).save(user); // 验证 Repository 方法被调用
}
@Test
void createUser_NullName_ThrowsException() {
// 验证业务规则：用户名为空时抛出异常
User user = new User(null);
assertThatThrownBy(() -> userService.createUser(user))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("用户名不能为空");
}
}代码解析：
•@SpringBootTest
启动 Spring Boot类似真实的测试环境，加载整个应用上下文。通常用于集成测试。
与其他注解结合使用时，可用于单元测试。如结合@Autowired自动注入 Bean，或者@MockBean模拟服务进行单元测试。
•@Autowired
自动注入userService，用于测试业务逻辑。
•@MockBean
创建一个模拟的userRepository，替代真实的数据库操作。
2.3 Repository 层：数据操作基础校验
测试目标：验证JPA实体映射、基础查询逻辑。
工具：@DataJpaTest 默认使用内存数据库H2。
实战示例：
java
@DataJpaTest // 启动 JPA 相关的测试环境，通常用于测试 Repository 层
public class UserRepositoryTest {
@Autowired private TestEntityManager entityManager; // 用于与数据库进行交互，执行持久化操作
@Autowired private UserRepository userRepository; // 自动注入 UserRepository，用于测试数据访问方法
@Test // 标记为测试方法
void findByEmail_ExistingEmail_ReturnsUser() {
// 创建一个用户对象并持久化到数据库
User user = new User("test@example.com");
entityManager.persist(user);
// 调用 UserRepository 方法，根据 email 查找用户
User found = userRepository.findByEmail("test@example.com");
// 断言返回的用户对象不为 null
assertThat(found).isNotNull();
}
}关键点：
•TestEntityManager 手动管理测试数据。
•默认隔离真实数据库，确保快速执行。
单元测试的优势：
•快速执行，约 50 毫秒/测试。
•精准定位问题。
三、集成测试：全链路一致性保证
3.1 垂直集成测试（应用内全链路）
测试目标：验证应用内各层的完整调用链。
工具组合：
•@SpringBootTest：启动 Spring Boot 应用测试环境，进行全链路集成测试。
•@Testcontainers：通过 Docker 启动真实数据库容器（如 PostgreSQL）。
•@AutoConfigureMockMvc：自动配置MockMvc，用于模拟 HTTP 请求。
•@Container：定义 Testcontainers 容器，启动真实数据库实例。
•OrderRepository：验证数据是否已保存至数据库。
代码示例：
java
@SpringBootTest
@AutoConfigureMockMvc
@Testcontainers
public class OrderIntegrationTest {
@Autowired
private MockMvc mockMvc; // 模拟 HTTP 请求
@Autowired
private OrderRepository orderRepository; // 注入 Repository 层以验证数据库
@Container
public static PostgreSQLContainer postgres = new PostgreSQLContainer("postgres:latest")
.withDatabaseName("testdb")
.withUsername("test")
.withPassword("password");
@Test
void createOrder_ValidRequest_OrderIsSaved() throws Exception {
// 发送请求创建订单
mockMvc.perform(post("/orders")
.contentType(MediaType.APPLICATION_JSON)
.content("{ \"productId\": 1 }"))
.andExpect(status().isCreated());
// 验证数据库中是否有保存的订单
Order order = orderRepository.findByProductId(1);
assertThat(order).isNotNull();
assertThat(order.getProductId()).isEqualTo(1);
}
}3.2 水平集成测试（跨服务交互）
测试目标：验证与外部服务的真实交互（如支付网关），确保跨服务的协议兼容性。
工具组合：
•@SpringBootTest
•@Testcontainers：启动模拟的外部服务容器（如 WireMock）。
•WireMockServer：模拟外部服务的响应，进行服务间的交互测试。
•@BeforeAll / @AfterAll：在测试执行前后配置和清理模拟服务。
代码示例：
java
@SpringBootTest
@Testcontainers
public class PaymentServiceIntegrationTest {
@Autowired
private PaymentService paymentService;
@Container
public static WireMockServer wireMockServer = new WireMockServer(options().port(8089)); // 设置外部服务模拟
@BeforeAll
static void setup() {
wireMockServer.start();
configureFor("localhost", 8089);
stubFor(post(urlEqualTo("/payment"))
.willReturn(aResponse()
.withStatus(200)
.withBody("{\"status\": \"success\"}")));
}
@AfterAll
static void teardown() {
wireMockServer.stop();
}
@Test
void processPayment_ValidRequest_ReturnsSuccess() {
// 模拟支付服务调用
PaymentRequest paymentRequest = new PaymentRequest(1, 100);
PaymentResponse response = paymentService.processPayment(paymentRequest);
// 验证支付处理是否成功
assertThat(response.getStatus()).isEqualTo("success");
}
}解析：
•WireMockServer：模拟外部支付服务。
•PaymentService：调用外部支付服务并验证支付结果。
3.3 持久层的集成测试
测试目标：验证应用与真实数据库、中间件的交互逻辑。
工具组合：
•Testcontainers：启动真实数据库（如MySQL、PostgreSQL）。
•@DynamicPropertySource：动态注入测试环境配置。
•@DataJpaTest：聚焦 JPA 层测试，自动配置 H2 或真实数据库。
实战示例：
java
@Testcontainers // 启动容器化的数据库实例（这里使用 PostgreSQL）
@DataJpaTest // 启动 JPA 测试环境,只加载与 JPA 相关的配置。
@AutoConfigureTestDatabase(replace = NONE) // 禁用 Spring Boot 默认的内存数据库配置，使用实际的 PostgreSQL 容器
public class UserRepositoryIntegrationTest {
@Container
static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15"); // 启动 PostgreSQL 容器，使用官方 15 版本
@DynamicPropertySource // 动态配置数据库连接属性
static void configure(DynamicPropertyRegistry registry) {
registry.add("spring.datasource.url", postgres::getJdbcUrl); // 配置数据库连接 URL
registry.add("spring.datasource.username", postgres::getUsername); // 配置数据库用户名
registry.add("spring.datasource.password", postgres::getPassword); // 配置数据库密码
}
@Test
void saveUser_PersistsToRealDatabase() {
// 创建用户并保存到数据库
User user = new User("IntegrationTest");
userRepository.save(user);
// 断言数据库中保存的用户数量为 1
assertThat(userRepository.findAll()).hasSize(1);
}
}1.注解解析：
@DataJpaTest
•专注于 JPA 层（JPA repository 或数据访问层操作）的测试，自动配置一个嵌入式数据库并扫描@Entity类。
@AutoConfigureTestDatabase(replace = NONE)
•禁用默认的嵌入式数据库（如 H2），使用外部数据库（如 PostgreSQL容器）进行测试。
@Container
•标记一个静态的、全局共享的容器实例，为测试提供服务。
@DynamicPropertySource
•动态配置 Spring 环境的属性，常用于设置容器生成的数据库连接信息。
优势：真实数据库行为模拟，避免H2与生产数据库的差异问题。
四、契约测试：消费者驱动的接口保卫者
契约测试（Consumer-Driven Contract,CDC）用于确保服务提供者与消费者对接口的理解一致，防止因接口变更引发故障。
4.1 核心流程
bash
participant Consumer as 消费者
participant PactBroker as Pact Broker
participant Provider as 提供者
Consumer->>PactBroker: 1. 定义并发布契约
PactBroker->>Provider: 2. 通知契约变更
Provider->>PactBroker: 3. 验证实现是否符合契约
PactBroker->>Consumer: 4. 反馈验证结果4.2 技术组合
•Pact：定义消费者期望的接口契约
•@PactTestFor：绑定契约与测试用例
•Pact Broker：集中管理契约版本
4.3 实战示例
1.消费者端定义契约
java
// OrderService（消费者端）定义契约
@Pact(consumer = "OrderService", provider = "PaymentService")
public RequestResponsePact paymentSuccessPact(PactDslWithProvider builder) {
return builder
// 提供者状态：订单已创建，待支付（需在提供者端实现数据准备）
.given("订单已创建，待支付")
// 消费者请求描述
.uponReceiving("支付订单的请求")
.method("POST")
.path("/payments")
.headers("Content-Type", "application/json") // 必须声明请求头
.body(new PactDslJsonBody()
.integerType("orderId", 1001) // 订单ID为整数类型
.decimalType("amount", 299.99) // 金额为小数类型
)
// 提供者预期响应
.willRespondWith()
.status(200)
.headers(Map.of("Content-Type", "application/json")) // 响应头校验
.body(new PactDslJsonBody()
.stringType("status", "SUCCESS") // 状态必须为字符串且值=SUCCESS
.stringType("transactionId", "TX123456") // 交易ID必须为字符串
)
.toPact(); // 生成Pact契约文件
}2.消费者端基于契约测试
java
@Test
@PactTestFor(
pactMethod = "paymentSuccessPact",
providerName = "PaymentService", // 指定提供者名称
pactVersion = PactSpecVersion.V3 // 使用Pact协议V3
)
void testPayment_WhenValidRequest_ReturnsSuccess(MockServer mockServer) {
// 1. 创建HTTP客户端，指向MockServer（模拟的PaymentService）
WebClient client = WebClient.create(mockServer.getUrl());
// 2. 构造请求并发送
PaymentRequest request = new PaymentRequest(1001, 299.99);
PaymentResponse response = client.post()
.uri("/payments")
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(request)
.retrieve()
.bodyToMono(PaymentResponse.class)
.block(); // 同步等待响应
// 3. 断言响应符合契约
assertThat(response).isNotNull();
assertThat(response.getStatus()).isEqualTo("SUCCESS");
assertThat(response.getTransactionId()).isEqualTo("TX123456");
}3.提供者端验证契约
目标：验证 PaymentService 的实现是否符合消费者定义的契约。
Step1. 提供者端代码实现
java
// PaymentService（提供者端）的Controller实现
@RestController
public class PaymentController {
@PostMapping("/payments")
public ResponseEntity<PaymentResponse> processPayment(
@RequestBody PaymentRequest request
) {
// 业务逻辑：处理支付请求
PaymentResponse response = new PaymentResponse();
response.setStatus("SUCCESS");
response.setTransactionId("TX" + UUID.randomUUID().toString().substring(0, 6));
return ResponseEntity.ok(response);
}
}Step2. 提供者端 Pact 验证配置（build.gradle）
// 添加Pact验证插件
bash
plugins {
id "au.com.dius.pact" version "4.6.8"
}
dependencies {
// Pact提供者端依赖
testImplementation 'au.com.dius.pact.provider:junit5:4.6.8'
}// 配置Pact验证任务
bash
pact {
serviceProviders {
PaymentService { // 提供者名称（需与契约中的provider一致）
protocol = 'http'
host = 'localhost'
port = 8080 // 本地服务端口
// 定义契约来源（本地文件或Pact Broker）
hasPactWith('OrderService') {
pactSource = file("path/to/OrderService-PaymentService.json")
}
}
}
}Step3: 提供者端状态准备（State Handler）
// 实现契约中的 given("订单已创建，待支付")
java
public class PaymentStateHandler {
@BeforeRequest("订单已创建，待支付")
public void setupOrderState(Map<String, Object> params) {
// 模拟订单已创建的数据库操作
Order order = new Order(1001, 299.99);
orderRepository.save(order);
}
}Step4: 提供者端测试类
java
@Provider("PaymentService") // 声明提供者名称
@PactFolder("pacts") // 契约文件路径
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
public class PaymentServiceContractTest {
@TestTemplate
@ExtendWith(PactVerificationSpringProvider.class)
void pactVerificationTestTemplate(PactVerificationContext context) {
context.verifyInteraction();
}
@BeforeEach
void before(PactVerificationContext context) {
// 设置服务状态处理器
context.setTarget(HttpTestTarget.fromUrl(new UrlParser().parse("http://localhost:8080")));
}
}Step5: 执行验证命令
bash
# 在提供者端执行验证（确保服务已启动）
./gradlew pactVerify -Dpact.provider.version=1.0.04.4.契约测试总结
通过上述步骤，契约测试完整覆盖了消费者与提供者的协作流程：
1.消费者定义契约：明确接口预期行为。
2.消费者本地验证：通过MockServer模拟提供者。
3.提供者实现接口：按契约开发功能。
4.提供者验证契约：确保实现与契约一致。
契约测试优势
•解耦团队协作，契约即文档。
•自动检测接口变更引发的破坏性修改。
五、总结：构建测试体系
5.1 测试策略全景图
bash
Spring Boot分层架构
A[客户端] -->|HTTP 请求| B[Controller 层]
B -->|调用| C[Service 层]
C -->|调用| D[Repository 层]
D -->|操作| E[数据库]
E -->|调用| F[外部服务接口]
测试策略全景
单元测试
B1[Controller 单元测试] -->|@WebMvcTest + MockMvc| B
C1[Service 单元测试] -->|@MockBean| C
D1[Repository 单元测试] -->|@DataJpaTest| D
集成测试
Int1[全链路调用] --> B --> C --> D --> |Testcontainers + 真实数据库| E
Int2[水平集成测试] --> F
契约测试
Contract1[消费者契约测试] -->|Pact 定义期望接口+本地验证| F
Contract2[提供者契约测试] -->|Pact 验证实现| F