20K Java+AI 岗位高频考点 — 测试能力是区分初级和高级工程师的标志。覆盖测试金字塔、JUnit5、Mockito、TestContainers、Spring Boot测试、契约测试、测试策略设计等。
/ E2E测试 \ ← 少量(慢、脆弱)
/ 集成测试 \ ← 适量
/ 单元测试 \ ← 大量(快、稳定)
比例建议:单元测试70% : 集成测试20% : E2E测试10%
原则:
| 维度 | 单元测试 | 集成测试 | E2E测试 |
|---|---|---|---|
| 范围 | 单个方法/类 | 多个组件 | 完整流程 |
| 依赖 | Mock | 真实/容器 | 真实环境 |
| 速度 | 毫秒 | 秒级 | 分钟级 |
| 稳定性 | 高 | 中 | 低 |
| 目的 | 逻辑正确性 | 组件交互 | 业务流程 |
工具:JaCoCo(Java标准)
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<configuration>
<rules>
<rule>
<element>BUNDLE</element>
<limits>
<limit><counter>LINE</counter><value>COVEREDRATIO</value><minimum>0.70</minimum></limit>
<limit><counter>BRANCH</counter><value>COVEREDRATIO</value><minimum>0.80</minimum></limit>
</limits>
</rule>
</rules>
</configuration>
</plugin>
@Test // 测试方法
@DisplayName("用户注册-正常流程")
@ParameterizedTest // 参数化测试
@RepeatedTest(3) // 重复测试
@Tag("slow") // 标签过滤
@Nested // 嵌套测试类
@Disabled // 跳过测试
// 生命周期
@BeforeAll // 所有测试前执行一次(static方法)
@BeforeEach // 每个测试前执行
@AfterEach // 每个测试后执行
@AfterAll // 所有测试后执行一次(static方法)
@ParameterizedTest
@CsvSource({
"100, 10, 90", // amount, discount, expected
"200, 50, 150",
"50, 0, 50"
})
@DisplayName("折扣计算")
void calculateDiscount(BigDecimal amount, BigDecimal discount, BigDecimal expected) {
assertEquals(expected, priceService.calculate(amount, discount));
}
@ParameterizedTest
@EnumSource(value = OrderStatus.class, names = {"CREATED", "PAID"})
@DisplayName("可取消的订单状态")
void testCancellableStatus(OrderStatus status) {
assertTrue(status.isCancellable());
}
@ParameterizedTest
@MethodSource("invalidEmails")
@DisplayName("无效邮箱验证")
void testInvalidEmail(String email) {
assertThrows(ValidationException.class, () -> validator.validateEmail(email));
}
static Stream<String> invalidEmails() {
return Stream.of("", "abc", "@qq.com", "a@b@c.com");
}
// 标准断言
assertEquals(expected, actual);
assertTrue(condition);
assertNull(object);
assertThrows(Exception.class, () -> riskyOperation());
assertTimeout(Duration.ofSeconds(1), () -> slowMethod());
// 分组断言
assertAll("user",
() -> assertEquals("张三", user.getName()),
() -> assertEquals(25, user.getAge()),
() -> assertTrue(user.isActive())
);
// 自定义扩展 - 测试方法耗时统计
public class TimingExtension implements BeforeTestExecutionCallback, AfterTestExecutionCallback {
@Override
public void beforeTestExecution(ExtensionContext context) {
context.getStore(ExtensionContext.Namespace.GLOBAL)
.put("start", System.currentTimeMillis());
}
@Override
public void afterTestExecution(ExtensionContext context) {
long start = context.getStore(ExtensionContext.Namespace.GLOBAL).get("start", Long.class);
long duration = System.currentTimeMillis() - start;
if (duration > 1000) {
System.out.println(context.getDisplayName() + " took " + duration + "ms (SLOW)");
}
}
}
@ExtendWith(TimingExtension.class)
class OrderServiceTest { ... }
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
@Mock OrderRepository orderRepository;
@Mock PaymentService paymentService;
@InjectMocks OrderService orderService;
@Test
@DisplayName("创建订单-正常流程")
void createOrder_success() {
// Given
OrderRequest request = new OrderRequest(1L, List.of(new Item(100L, 2)));
when(orderRepository.save(any())).thenReturn(new Order(1L, request));
// When
Order order = orderService.create(request);
// Then
assertNotNull(order);
verify(orderRepository).save(argThat(o -> o.getStatus() == CREATED));
verify(paymentService, never()).process(any()); // 未调用支付
}
}
// Mock:完全模拟,方法默认返回null/0
List<String> mockList = mock(List.class);
mockList.add("a");
verify(mockList).add("a"); // 通过(验证了交互)
assertEquals(0, mockList.size()); // 0(不是真实行为)
// Spy:部分模拟,保留真实行为
List<String> spyList = spy(new ArrayList<>());
spyList.add("a");
assertEquals(1, spyList.size()); // 1(真实行为)
doReturn(100).when(spyList).size(); // 覆盖特定方法
assertEquals(100, spyList.size());
@Test
void verifyOrderSaved() {
orderService.create(request);
// 捕获参数
ArgumentCaptor<Order> captor = ArgumentCaptor.forClass(Order.class);
verify(orderRepository).save(captor.capture());
Order saved = captor.getValue();
assertEquals(CREATED, saved.getStatus());
assertEquals(new BigDecimal("99.00"), saved.getTotalAmount());
}
@Test
@DisplayName("取消订单-已支付订单不可取消")
void cancelOrder_alreadyPaid() {
Order order = new Order(1L, PAID);
when(orderRepository.findById(1L)).thenReturn(Optional.of(order));
BusinessException ex = assertThrows(BusinessException.class,
() -> orderService.cancel(1L));
assertEquals("已支付订单不可取消", ex.getMessage());
}
@Test
@DisplayName("支付-余额不足")
void pay_insufficientBalance() {
Order order = new Order(1L, new BigDecimal("100"));
when(orderRepository.findById(1L)).thenReturn(Optional.of(order));
when(paymentService.getBalance(1L)).thenReturn(new BigDecimal("50"));
assertThrows(InsufficientBalanceException.class,
() -> orderService.pay(1L));
}
| 注解 | 加载范围 | 适用场景 |
|---|---|---|
@SpringBootTest | 完整ApplicationContext | 集成测试 |
@WebMvcTest | Controller层 + Mock Bean | Controller测试 |
@DataJpaTest | JPA + 内嵌H2 | Repository测试 |
@WebFluxTest | WebFlux Controller | 响应式测试 |
@RestClientTest | RestTemplate | 外部API调用测试 |
@JsonTest | JSON序列化/反序列化 | DTO测试 |
@WebMvcTest(OrderController.class)
class OrderControllerTest {
@Autowired MockMvc mockMvc;
@MockBean OrderService orderService;
@Autowired ObjectMapper objectMapper;
@Test
@DisplayName("创建订单-201")
void createOrder_201() throws Exception {
CreateOrderRequest request = new CreateOrderRequest(1L, List.of(new ItemRequest(100L, 2)));
when(orderService.create(any())).thenReturn(new OrderDTO(1L, "CREATED", new BigDecimal("199")));
mockMvc.perform(post("/api/orders")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(request)))
.andExpect(status().isCreated())
.andExpect(jsonPath("$.id").value(1L))
.andExpect(jsonPath("$.status").value("CREATED"));
}
@Test
@DisplayName("参数校验-400")
void createOrder_invalidRequest_400() throws Exception {
CreateOrderRequest request = new CreateOrderRequest(null, Collections.emptyList());
mockMvc.perform(post("/api/orders")
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(request)))
.andExpect(status().isBadRequest());
}
}
@DataJpaTest
class OrderRepositoryTest {
@Autowired TestEntityManager entityManager;
@Autowired OrderRepository orderRepository;
@Test
@DisplayName("按用户ID查询订单")
void findByUserId() {
entityManager.persist(new Order(1L, new BigDecimal("100")));
entityManager.persist(new Order(1L, new BigDecimal("200")));
entityManager.persist(new Order(2L, new BigDecimal("300")));
List<Order> orders = orderRepository.findByUserId(1L);
assertEquals(2, orders.size());
}
}
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class OrderIntegrationTest {
@Autowired TestRestTemplate restTemplate;
@Test
@DisplayName("完整订单流程")
void fullOrderFlow() {
// 1. 创建订单
ResponseEntity<OrderDTO> createResp = restTemplate.postForEntity(
"/api/orders", new CreateOrderRequest(1L, List.of(new ItemRequest(100L, 2))), OrderDTO.class);
assertEquals(HttpStatus.CREATED, createResp.getStatusCode());
Long orderId = createResp.getBody().getId();
// 2. 查询订单
ResponseEntity<OrderDTO> getResp = restTemplate.getForEntity(
"/api/orders/" + orderId, OrderDTO.class);
assertEquals(HttpStatus.OK, getResp.getStatusCode());
assertEquals("CREATED", getResp.getBody().getStatus());
// 3. 支付
restTemplate.postForEntity("/api/orders/" + orderId + "/pay",
new PayRequest(new BigDecimal("199")), Void.class);
}
}
TestContainers用Docker容器提供真实的测试环境(数据库、消息队列等),解决H2与MySQL行为不一致的问题。
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>testcontainers</artifactId>
<version>1.20.x</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>mysql</artifactId>
<scope>test</scope>
</dependency>
@SpringBootTest
@Testcontainers
class OrderRepositoryIT {
@Container
static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
.withDatabaseName("testdb")
.withUsername("test")
.withPassword("test");
@DynamicPropertySource
static void configureProperties(DynamicPropertyRegistry registry) {
registry.add("spring.datasource.url", mysql::getJdbcUrl);
registry.add("spring.datasource.username", mysql::getUsername);
registry.add("spring.datasource.password", mysql::getPassword);
}
@Autowired OrderRepository orderRepository;
@Test
void testRealMySQL() {
Order order = new Order(1L, new BigDecimal("100"));
orderRepository.save(order);
Order found = orderRepository.findById(order.getId()).orElseThrow();
assertEquals(new BigDecimal("100.00"), found.getAmount());
}
}
@Container
static KafkaContainer kafka = new KafkaContainer(
DockerImageName.parse("confluentinc/cp-kafka:7.5.0"));
@DynamicPropertySource
static void kafkaProperties(DynamicPropertyRegistry registry) {
registry.add("spring.kafka.bootstrap-servers", kafka::getBootstrapServers);
}
@Autowired KafkaTemplate<String, String> kafkaTemplate;
@Autowired KafkaConsumer<String, String> consumer;
@Test
void testKafkaProduceAndConsume() {
kafkaTemplate.send("test-topic", "hello world");
ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(10));
assertEquals(1, records.count());
assertEquals("hello world", records.iterator().next().value());
}
@Test
void testConcurrentOrderCreation() throws InterruptedException {
int threads = 100;
ExecutorService executor = Executors.newFixedThreadPool(threads);
CountDownLatch latch = new CountDownLatch(threads);
AtomicInteger successCount = new AtomicInteger();
for (int i = 0; i < threads; i++) {
executor.submit(() -> {
try {
orderService.create(request);
successCount.incrementAndGet();
} finally {
latch.countDown();
}
});
}
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertEquals(100, successCount.get());
executor.shutdown();
}
@WebMvcTest(OrderController.class)
@Import(SecurityConfig.class)
class SecuredControllerTest {
@Autowired MockMvc mockMvc;
@Test
@WithMockUser(roles = "ADMIN")
@DisplayName("管理员可访问所有订单")
void adminCanAccessAll() throws Exception {
mockMvc.perform(get("/api/orders"))
.andExpect(status().isOk());
}
@Test
@WithMockUser(roles = "USER")
@DisplayName("普通用户不能删除订单")
void userCannotDelete() throws Exception {
mockMvc.perform(delete("/api/orders/1"))
.andExpect(status().isForbidden());
}
@Test
@DisplayName("未认证返回401")
void unauthenticated() throws Exception {
mockMvc.perform(get("/api/orders"))
.andExpect(status().isUnauthorized());
}
}
// Spring Cloud Contract Producer
@Test
void validateOrderContract() {
// given:
MockMvcRequestSpecification request = given();
// when:
ResponseOptions<?> response = given().spec(request)
.get("/api/orders/1");
// then:
assertThat(response.statusCode()).isEqualTo(200);
assertThat(response.body().jsonPath().getString("status")).isEqualTo("CREATED");
}
@Test
void testScheduledTask() {
// 方式一:直接调用方法
scheduledTask.dailyCleanup();
verify(cleanupRepository).deleteOldRecords(any());
// 方式二:使用Awaitility等待
await().atMost(5, SECONDS)
.untilAsserted(() -> verify(notificationService).sendDailyReport());
}
// 方式一:Builder模式
Order order = OrderBuilder.anOrder()
.withUserId(1L)
.withAmount(new BigDecimal("100"))
.withStatus(PAID)
.build();
// 方式二:Test Fixture
@BeforeEach
void setUp() {
testOrder = new Order(1L, new BigDecimal("100"), PAID);
testUser = new User(1L, "张三", Role.ADMIN);
orderRepository.save(testOrder);
userRepository.save(testUser);
}
// 方式三:SQL脚本
@Sql("/test-data/orders.sql")
@Test
void testWithSqlData() { ... }
# GitHub Actions
- name: Run Tests
run: ./mvnw verify # 包含 unit + integration + contract tests
- name: Test Report
uses: dorny/test-reporter@v1
with:
name: Test Results
path: target/surefire-reports/*.xml
reporter: java-junit
1. 单元测试(70%):Service层逻辑、工具类
2. 集成测试(20%):Repository + 真实DB(TestContainers)
3. API测试(8%):MockMvc测试Controller
4. E2E测试(2%):关键业务流程
分层策略:
src/test/:单元测试src/test/java/.../it/:集成测试(*IT.java)src/test/java/.../e2e/:端到端滥用:所有依赖都Mock → 测试的是Mock而不是真实代码。
正确:
@SpringBootTest
class ChatServiceTest {
@MockBean ChatClient chatClient;
@Autowired ChatService chatService;
@Test
void testRAGAnswer() {
when(chatClient.prompt().user(anyString()).call().content())
.thenReturn("Java是一种面向对象的编程语言");
String answer = chatService.ask("什么是Java?");
assertNotNull(answer);
assertTrue(answer.contains("Java"));
}
}
1. 测试依赖执行顺序:每个测试应该独立
2. 测试中有if/else:测试不应该有分支逻辑
3. 测试睡Sleep:用Awaitility代替Thread.sleep
4. 测试关注实现细节:应该测行为不是实现
5. 一个测试测多个场景:一个测试一个场景
优点:代码设计更好、测试覆盖率高、重构有信心
缺点:初期开发速度慢、需要自律
实用建议:
测试金字塔:70%单元 / 20%集成 / 10%E2E
>
JUnit5三件套:@ParameterizedTest参数化、@Nested嵌套、assertAll分组断言
>
Mockito三原则:Mock外部、Spy内部、验证交互用verify
>
TestContainers:告别H2,用真实MySQL/Redis/Kafka做集成测试