Spring Boot单元测试实战：JUnit5与Mockito高级技巧

1. Spring Boot单元测试基础概念

1.1 单元测试的本质与价值

单元测试是软件开发过程中验证代码最小可测试单元（通常是方法或函数）是否按预期工作的测试方法。在Spring Boot应用中，单元测试主要关注四个核心层面：

• 业务逻辑层：验证核心业务规则的正确性
• 数据访问层：确保数据库操作的可靠性
• 服务层：检查服务组件的功能完整性
• 控制器层：测试HTTP请求处理能力

实际开发中，我们经常遇到这样的场景：一个简单的订单计算逻辑，如果没有单元测试保障，很容易在后续迭代中出现问题：

java复制@Service
public class OrderService {
    public BigDecimal calculateTotal(Order order) {
        // 这个计算逻辑看似简单，但缺少测试时容易出错
        return order.getItems().stream()
            .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add)
            .multiply(order.getDiscountRate()) // 后续添加的折扣计算
            .add(order.getShippingFee());     // 后续添加的运费计算
    }
}

1.2 单元测试的核心价值体现

1. 早期缺陷发现：在代码提交前捕获逻辑错误，相比集成测试能更早发现问题
2. 代码质量提升：迫使开发者编写可测试的代码，自然提高代码质量
3. 重构安全保障：修改代码时，单元测试作为安全网确保不破坏现有功能
4. 活文档作用：测试用例本身就是最好的API使用示例
5. 开发效率提升：长期来看，减少手动测试时间，加速持续集成流程

经验之谈：在实际项目中，良好的单元测试套件可以将生产环境缺陷减少60-80%。特别是对于核心业务逻辑，单元测试的投入产出比非常高。

2. Spring Boot测试环境配置

2.1 依赖管理最佳实践

Maven配置中，测试依赖应该放在<dependencies>的特定位置，并明确scope：

xml复制<dependencies>
    <!-- 主要依赖... -->
    
    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    
    <!-- 按需添加的测试依赖 -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-inline</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2.2 测试目录结构规范

合理的测试目录结构应该与主代码保持对称：

code复制src/test/java/
└── com/example/
    ├── ApplicationTests.java        # 基础测试类
    ├── config/
    │   ├── TestSecurityConfig.java  # 测试安全配置
    │   └── TestDatabaseConfig.java  # 测试数据库配置
    ├── service/
    │   ├── UserServiceTest.java     # 服务层测试
    │   └── OrderServiceTest.java
    ├── repository/
    │   ├── UserRepositoryTest.java  # 仓库层测试
    │   └── OrderRepositoryTest.java
    ├── web/
    │   ├── UserControllerTest.java  # 控制器测试
    │   └── OrderControllerTest.java
    └── util/
        ├── JsonTestUtils.java       # 测试工具类
        └── TestDataFactory.java     # 测试数据工厂

3. JUnit 5深度应用

3.1 生命周期注解实战

JUnit 5的注解体系比JUnit 4更加丰富和灵活：

java复制class LifecycleTest {
    private static int classCounter = 0;
    private int testCounter = 0;

    @BeforeAll
    static void initAll() {
        classCounter++;
        System.out.println("@BeforeAll - 初始化共享资源");
    }

    @BeforeEach
    void init() {
        testCounter++;
        System.out.println("@BeforeEach - 初始化测试数据");
    }

    @Test
    void firstTest() {
        System.out.println("执行第一个测试");
        assertTrue(testCounter > 0);
    }

    @Test
    void secondTest() {
        System.out.println("执行第二个测试");
        assertEquals(1, classCounter);
    }

    @AfterEach
    void tearDown() {
        System.out.println("@AfterEach - 清理测试数据");
    }

    @AfterAll
    static void tearDownAll() {
        System.out.println("@AfterAll - 清理共享资源");
    }
}

3.2 断言方法的进阶用法

JUnit 5提供了丰富的断言方法，可以满足各种测试场景：

java复制@Test
void advancedAssertions() {
    // 集合断言
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    assertIterableEquals(Arrays.asList("Alice", "Bob", "Charlie"), names);
    
    // 异常断言
    IllegalArgumentException exception = assertThrows(
        IllegalArgumentException.class,
        () -> { throw new IllegalArgumentException("非法参数"); }
    );
    assertEquals("非法参数", exception.getMessage());
    
    // 超时断言
    assertTimeoutPreemptively(Duration.ofMillis(100), () -> {
        Thread.sleep(50);
    });
    
    // 组合断言
    User user = new User("test@example.com");
    assertAll("用户属性验证",
        () -> assertNotNull(user.getId()),
        () -> assertEquals("test@example.com", user.getEmail()),
        () -> assertTrue(user.getCreatedAt().isBefore(LocalDateTime.now()))
    );
}

4. Spring Boot测试注解解析

4.1 测试切片注解对比

Spring Boot提供了多种测试切片注解，适用于不同层次的测试：

4.2 @SpringBootTest深度配置

java复制@SpringBootTest(
    classes = {Application.class, TestConfig.class}, // 指定配置类
    webEnvironment = WebEnvironment.RANDOM_PORT,    // 随机端口
    properties = {
        "spring.datasource.url=jdbc:h2:mem:testdb",
        "logging.level.root=ERROR"
    }
)
@ActiveProfiles("test")
@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
class FullIntegrationTest {
    
    @LocalServerPort
    private int port;
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void contextLoads() {
        assertNotNull(restTemplate);
    }
    
    @Test
    void apiEndpointTest() {
        ResponseEntity<String> response = restTemplate.getForEntity(
            "http://localhost:" + port + "/api/status", String.class);
        assertEquals(HttpStatus.OK, response.getStatusCode());
    }
}

5. Mockito高级技巧

5.1 Mock对象的行为配置

java复制@ExtendWith(MockitoExtension.class)
class MockitoAdvancedTest {
    
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    void testMockBehavior() {
        // 基本Stubbing
        when(userRepository.findById(1L))
            .thenReturn(Optional.of(new User(1L, "admin")));
        
        // 异常Stubbing
        when(userRepository.findById(999L))
            .thenThrow(new EntityNotFoundException("用户不存在"));
        
        // 参数匹配器
        when(userRepository.findByEmail(anyString()))
            .thenAnswer(invocation -> {
                String email = invocation.getArgument(0);
                return Optional.of(new User(email));
            });
        
        // 连续响应
        when(userRepository.count())
            .thenReturn(1L, 2L, 3L); // 第一次返回1，第二次2，第三次3
        
        // 验证
        User user = userService.getUserById(1L);
        verify(userRepository, times(1)).findById(1L);
        verify(userRepository, never()).delete(any());
    }
}

5.2 参数捕获技术

java复制@Test
void testArgumentCaptor() {
    User user = new User("test@example.com");
    userService.register(user);
    
    ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClass(User.class);
    verify(userRepository).save(userCaptor.capture());
    
    User savedUser = userCaptor.getValue();
    assertEquals("test@example.com", savedUser.getEmail());
    assertNotNull(savedUser.getCreatedAt());
    
    // 验证密码加密
    ArgumentCaptor<String> passwordCaptor = ArgumentCaptor.forClass(String.class);
    verify(passwordEncoder).encode(passwordCaptor.capture());
    assertEquals(user.getPassword(), passwordCaptor.getValue());
}

6. 数据库测试策略

6.1 测试数据库配置

application-test.properties配置示例：

properties复制# H2内存数据库配置
spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;MODE=MySQL
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# JPA配置
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

# 测试专用配置
spring.test.database.replace=ANY
spring.test.jpa.properties.hibernate.globally_quoted_identifiers=true

6.2 测试数据准备策略

java复制@DataJpaTest
@AutoConfigureTestDatabase(replace = Replace.NONE)
@Transactional
class RepositoryTest {
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Autowired
    private UserRepository userRepository;
    
    @BeforeEach
    void setUp() {
        // 方法1：使用EntityManager直接插入
        User user1 = new User("user1@example.com");
        entityManager.persist(user1);
        
        // 方法2：使用SQL脚本
        entityManager.getEntityManager()
            .createNativeQuery("INSERT INTO users(email) VALUES('user2@example.com')")
            .executeUpdate();
    }
    
    @Test
    @Sql("/test-data.sql") // 方法3：使用外部SQL脚本
    @Sql(scripts = "/clean-data.sql", 
         executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
    void testWithExternalData() {
        List<User> users = userRepository.findAll();
        assertFalse(users.isEmpty());
    }
    
    @Test
    void testWithDynamicData() {
        // 方法4：动态生成测试数据
        User newUser = User.builder()
            .email("new@example.com")
            .password("password")
            .build();
        
        User saved = userRepository.save(newUser);
        assertNotNull(saved.getId());
    }
}

7. Web层测试全攻略

7.1 MockMvc高级特性

java复制@WebMvcTest(UserController.class)
@Import(SecurityConfig.class)
@AutoConfigureMockMvc(addFilters = false)
class ControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Test
    void testGetUser() throws Exception {
        when(userService.getUser(1L))
            .thenReturn(new User(1L, "test@example.com"));
        
        mockMvc.perform(get("/api/users/{id}", 1L)
                .header("Authorization", "Bearer token")
                .contentType(MediaType.APPLICATION_JSON))
            .andExpect(status().isOk())
            .andExpect(content().contentType(MediaType.APPLICATION_JSON))
            .andExpect(jsonPath("$.id").value(1))
            .andExpect(jsonPath("$.email").value("test@example.com"))
            .andDo(print());
    }
    
    @Test
    void testCreateUser() throws Exception {
        when(userService.createUser(any()))
            .thenReturn(new User(1L, "new@example.com"));
        
        mockMvc.perform(post("/api/users")
                .content("{\"email\":\"new@example.com\",\"password\":\"123456\"}")
                .contentType(MediaType.APPLICATION_JSON))
            .andExpect(status().isCreated())
            .andExpect(header().exists("Location"))
            .andExpect(jsonPath("$.id").exists());
    }
    
    @Test
    @WithMockUser(username = "admin", roles = {"ADMIN"})
    void testSecuredEndpoint() throws Exception {
        mockMvc.perform(get("/api/admin/users"))
            .andExpect(status().isOk());
    }
}

7.2 自定义MockMvc配置

对于复杂的测试场景，可以自定义MockMvc配置：

java复制@WebMvcTest
class CustomMockMvcTest {
    
    @Autowired
    private WebApplicationContext context;
    
    private MockMvc mockMvc;
    
    @BeforeEach
    void setup() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(this.context)
            .addFilter(new CustomFilter()) // 添加自定义过滤器
            .alwaysDo(print())            // 总是打印请求/响应
            .defaultRequest(get("/").accept(MediaType.APPLICATION_JSON))
            .apply(documentationConfiguration(restDocumentation)) // Spring REST Docs
            .build();
    }
    
    @Test
    void testCustomConfig() throws Exception {
        mockMvc.perform(get("/api/test"))
            .andExpect(status().isOk());
    }
}

8. 集成测试策略

8.1 分层测试金字塔

Spring Boot应用的测试应该遵循测试金字塔原则：

code复制        /\
       /  \
      / UI \
     /______\
    /        \
   /  API     \
  /  测试      \
 /______________\
/                \
|   单元测试     |
|   (70-80%)    |
|_______________|

8.2 测试配置管理

使用@TestConfiguration管理测试专用Bean：

java复制@TestConfiguration
public class TestConfig {
    
    @Bean
    @Primary
    public UserService testUserService() {
        return new TestUserService();
    }
    
    @Bean
    public PasswordEncoder testPasswordEncoder() {
        return NoOpPasswordEncoder.getInstance(); // 测试专用
    }
}

@SpringBootTest
@Import(TestConfig.class)
class IntegrationTestWithCustomConfig {
    
    @Autowired
    private UserService userService;
    
    @Test
    void testWithCustomBean() {
        User user = userService.createUser("test@example.com", "password");
        assertNotNull(user);
        assertEquals("test@example.com", user.getEmail());
    }
}

9. 测试最佳实践

9.1 测试命名规范

采用BDD风格命名，提高测试可读性：

java复制class UserServiceTest {
    
    @Nested
    @DisplayName("当创建用户时")
    class WhenCreatingUser {
        
        @Test
        @DisplayName("给定有效邮箱和密码 - 应该成功创建用户")
        void givenValidEmailAndPassword_shouldCreateUser() {
            // 测试逻辑
        }
        
        @Test
        @DisplayName("给定无效邮箱格式 - 应该抛出验证异常")
        void givenInvalidEmailFormat_shouldThrowValidationException() {
            // 测试逻辑
        }
    }
    
    @Nested
    @DisplayName("当查找用户时")
    class WhenFindingUser {
        
        @Test
        @DisplayName("给定存在的用户ID - 应该返回用户对象")
        void givenExistingUserId_shouldReturnUser() {
            // 测试逻辑
        }
    }
}

9.2 测试数据构建模式

使用构建器模式创建测试数据：

java复制class UserTestDataBuilder {
    private Long id;
    private String email = "default@example.com";
    private String password = "password";
    private UserStatus status = UserStatus.ACTIVE;
    
    public static UserTestDataBuilder aUser() {
        return new UserTestDataBuilder();
    }
    
    public UserTestDataBuilder withEmail(String email) {
        this.email = email;
        return this;
    }
    
    public UserTestDataBuilder withStatus(UserStatus status) {
        this.status = status;
        return this;
    }
    
    public User build() {
        return new User(id, email, password, status);
    }
}

// 使用示例
@Test
void testWithBuilder() {
    User user = UserTestDataBuilder.aUser()
        .withEmail("test@example.com")
        .withStatus(UserStatus.INACTIVE)
        .build();
    
    assertNotNull(user);
    assertEquals("test@example.com", user.getEmail());
    assertEquals(UserStatus.INACTIVE, user.getStatus());
}

10. 高级测试技巧

10.1 参数化测试

JUnit 5的参数化测试非常强大：

java复制@ParameterizedTest
@ValueSource(strings = {"test@example.com", "user@domain.com"})
void isValidEmail_withValidEmails_shouldReturnTrue(String email) {
    assertTrue(validator.isValidEmail(email));
}

@ParameterizedTest
@CsvSource({
    "1, 'John', 'john@example.com'",
    "2, 'Alice', 'alice@example.com'"
})
void getUser_withExistingIds_shouldReturnUser(Long id, String name, String email) {
    when(repo.findById(id)).thenReturn(Optional.of(new User(id, name, email)));
    User user = service.getUser(id);
    assertEquals(email, user.getEmail());
}

@ParameterizedTest
@MethodSource("provideInvalidEmails")
void isValidEmail_withInvalidEmails_shouldReturnFalse(String email) {
    assertFalse(validator.isValidEmail(email));
}

private static Stream<Arguments> provideInvalidEmails() {
    return Stream.of(
        Arguments.of("invalid"),
        Arguments.of("user@"),
        Arguments.of("@domain.com")
    );
}

10.2 动态测试

对于需要动态生成测试用例的场景：

java复制@TestFactory
Stream<DynamicTest> generateDynamicTests() {
    return IntStream.range(1, 6)
        .mapToObj(i -> DynamicTest.dynamicTest(
            "测试用户#" + i,
            () -> {
                User user = new User(i, "user" + i + "@example.com");
                User saved = repository.save(user);
                assertEquals(i, saved.getId().longValue());
            }
        ));
}

@TestFactory
Stream<DynamicNode> dynamicTestsWithContainers() {
    return Stream.of(
        DynamicContainer.dynamicContainer("用户创建测试",
            Stream.of(
                DynamicTest.dynamicTest("有效用户", () -> {
                    User user = new User("valid@example.com");
                    assertDoesNotThrow(() -> service.createUser(user));
                }),
                DynamicTest.dynamicTest("无效邮箱", () -> {
                    User user = new User("invalid");
                    assertThrows(ValidationException.class, 
                        () -> service.createUser(user));
                })
            )
        )
    );
}

11. 测试覆盖率与质量

11.1 JaCoCo配置与使用

Maven配置示例：

xml复制<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.7</version>
    <executions>
        <execution>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
        </execution>
        <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
                <goal>report</goal>
            </goals>
        </execution>
        <execution>
            <id>check</id>
            <goals>
                <goal>check</goal>
            </goals>
            <configuration>
                <rules>
                    <rule>
                        <element>BUNDLE</element>
                        <limits>
                            <limit>
                                <counter>LINE</counter>
                                <value>COVEREDRATIO</value>
                                <minimum>0.80</minimum>
                            </limit>
                            <limit>
                                <counter>BRANCH</counter>
                                <value>COVEREDRATIO</value>
                                <minimum>0.70</minimum>
                            </limit>
                        </limits>
                    </rule>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>

11.2 测试质量检查清单

1. 测试独立性：每个测试应该独立运行，不依赖其他测试的状态
2. 可重复性：测试在任何环境、任何时间运行都应该得到相同结果
3. 快速反馈：单元测试应该快速执行（整个套件在几分钟内完成）
4. 明确断言：每个测试应该有明确的断言，验证特定行为
5. 测试行为而非实现：关注方法做什么，而不是怎么做
6. 适当覆盖率：关键业务逻辑应该达到高覆盖率（80%+）
7. 可读性：测试名称和结构应该清晰表达测试意图
8. 资源清理：测试应该清理它创建的任何资源

12. 常见问题解决方案

12.1 事务管理问题

java复制@SpringBootTest
@Transactional
class TransactionProblemTest {
    
    @Autowired
    private PlatformTransactionManager transactionManager;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    void testWithoutTransaction() {
        // 这个测试不在事务中运行
        User user = new User("test@example.com");
        userRepository.save(user);
        
        // 数据会持久化到数据库
        assertTrue(userRepository.findByEmail("test@example.com").isPresent());
    }
    
    @Test
    void testWithManualTransaction() {
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        
        transactionTemplate.execute(status -> {
            User user = new User("tx@example.com");
            userRepository.save(user);
            return null;
        });
        
        // 事务已提交，数据持久化
        assertTrue(userRepository.findByEmail("tx@example.com").isPresent());
    }
    
    @Test
    void testWithRollback() {
        User user = new User("rollback@example.com");
        userRepository.save(user);
        
        // 默认会回滚
        assertTrue(userRepository.findByEmail("rollback@example.com").isPresent());
    }
    
    @Test
    @Commit
    void testWithCommit() {
        User user = new User("commit@example.com");
        userRepository.save(user);
        
        // 数据会持久化
        assertTrue(userRepository.findByEmail("commit@example.com").isPresent());
    }
}

12.2 时间相关测试

处理时间敏感逻辑的测试策略：

java复制class TimeSensitiveTest {
    
    @Test
    void testWithFixedClock() {
        // 固定时间点
        Instant fixedInstant = Instant.parse("2023-01-01T00:00:00Z");
        Clock fixedClock = Clock.fixed(fixedInstant, ZoneId.systemDefault());
        
        TimeService timeService = new TimeService(fixedClock);
        
        assertEquals(LocalDate.of(2023, 1, 1), timeService.getCurrentDate());
    }
    
    @Test
    void testTimeout() {
        assertTimeoutPreemptively(Duration.ofMillis(100), () -> {
            // 执行耗时操作
            Thread.sleep(50);
        });
    }
    
    @Test
    void testExpiryLogic() {
        // 使用可变的测试时钟
        TestClock clock = TestClock.fixed(Instant.now(), ZoneId.systemDefault());
        ExpiryService service = new ExpiryService(clock);
        
        Instant expiryTime = service.calculateExpiry(30, ChronoUnit.DAYS);
        
        // 快进时间
        clock.instant = clock.instant().plus(29, ChronoUnit.DAYS);
        assertFalse(service.isExpired(expiryTime));
        
        clock.instant = clock.instant().plus(2, ChronoUnit.DAYS);
        assertTrue(service.isExpired(expiryTime));
    }
    
    static class TestClock extends Clock {
        private Instant instant;
        private final ZoneId zone;
        
        TestClock(Instant instant, ZoneId zone) {
            this.instant = instant;
            this.zone = zone;
        }
        
        static TestClock fixed(Instant instant, ZoneId zone) {
            return new TestClock(instant, zone);
        }
        
        @Override public ZoneId getZone() { return zone; }
        @Override public Clock withZone(ZoneId zone) { return fixed(instant, zone); }
        @Override public Instant instant() { return instant; }
    }
}

在实际项目中，单元测试不是银弹，但却是保证代码质量最有效的手段之一。我个人的经验是：对于核心业务逻辑，测试覆盖率应该尽可能高；对于简单的getter/setter或样板代码，可以适当放宽要求。最重要的是建立适合自己团队的测试文化，让单元测试成为开发流程中自然的一部分。