Junit4与Mockito单元测试实战指南

1. Junit4与Mockito的单元测试基础

在Java开发领域，单元测试是保证代码质量的重要环节。Junit4作为经典的测试框架，配合Mockito这个强大的模拟库，能够有效解决测试中的依赖隔离问题。我经历过不少项目，发现很多团队虽然在使用这套组合，但往往只停留在基础用法层面。

Mockito的核心价值在于它能创建"替身对象"（mock objects）。想象一下，当你要测试一个订单服务，但这个服务依赖支付网关和库存系统。真实的支付网关每次调用都可能产生费用，而库存系统可能还没开发完成。这时Mockito就能派上用场——它可以创建这些依赖的模拟版本，让你能专注于测试订单服务本身的逻辑。

重要提示：Mockito 2.x版本开始要求Java 8+环境，如果你的项目还在用Java 7，需要使用Mockito 1.x的最后一个版本(1.10.19)

2. 环境搭建与基础配置

2.1 Maven依赖配置

对于使用Maven的项目，需要在pom.xml中添加以下依赖：

xml复制<dependencies>
    <!-- Junit4 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
    
    <!-- Mockito核心 -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>3.12.4</version>
        <scope>test</scope>
    </dependency>
    
    <!-- 可选：Mockito的Junit4运行器 -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-junit-runner</artifactId>
        <version>3.12.4</version>
        <scope>test</scope>
    </dependency>
</dependencies>

2.2 测试类的基本结构

一个典型的测试类结构如下：

java复制import static org.mockito.Mockito.*;
import static org.junit.Assert.*;

public class OrderServiceTest {
    // 测试目标对象
    private OrderService orderService;
    
    // 模拟对象
    private PaymentGateway mockPaymentGateway;
    private InventorySystem mockInventory;
    
    @Before
    public void setUp() {
        // 初始化模拟对象
        mockPaymentGateway = mock(PaymentGateway.class);
        mockInventory = mock(InventorySystem.class);
        
        // 注入依赖
        orderService = new OrderService(mockPaymentGateway, mockInventory);
    }
    
    @Test
    public void testPlaceOrder_Success() {
        // 测试逻辑将写在这里
    }
}

3. Mockito的核心功能详解

3.1 模拟对象行为

Mockito最常用的功能就是定义模拟对象的行为。假设我们要测试订单支付功能：

java复制@Test
public void testProcessPayment_Success() {
    // 准备测试数据
    Order order = new Order("order123", 100.0);
    String transactionId = "txn_123456";
    
    // 定义模拟行为
    when(mockPaymentGateway.processPayment(anyDouble(), anyString()))
        .thenReturn(new PaymentResult(true, transactionId));
    
    // 执行测试
    PaymentResult result = orderService.processPayment(order);
    
    // 验证结果
    assertTrue(result.isSuccess());
    assertEquals(transactionId, result.getTransactionId());
    
    // 验证交互
    verify(mockPaymentGateway).processPayment(100.0, "order123");
}

这里有几个关键点：

1. when(...).thenReturn(...) 定义了模拟方法的返回值
2. anyDouble() 和 anyString() 是参数匹配器
3. verify() 用于验证方法是否被调用

3.2 异常场景测试

测试异常情况同样重要：

java复制@Test(expected = PaymentFailedException.class)
public void testProcessPayment_Failure() {
    Order order = new Order("order123", 100.0);
    
    when(mockPaymentGateway.processPayment(anyDouble(), anyString()))
        .thenThrow(new PaymentGatewayException("Insufficient funds"));
    
    orderService.processPayment(order);
}

3.3 参数捕获与验证

有时我们需要检查传递给模拟对象的参数：

java复制@Test
public void testUpdateInventory() {
    Order order = new Order("order123", 100.0);
    order.addItem("prod1", 2);
    order.addItem("prod2", 1);
    
    orderService.placeOrder(order);
    
    // 捕获参数
    ArgumentCaptor<Map<String, Integer>> captor = 
        ArgumentCaptor.forClass(Map.class);
    
    verify(mockInventory).updateStock(captor.capture());
    
    Map<String, Integer> stockUpdates = captor.getValue();
    assertEquals(2, stockUpdates.get("prod1").intValue());
    assertEquals(1, stockUpdates.get("prod2").intValue());
}

4. 高级特性与实战技巧

4.1 部分模拟（Spy）

有时我们只需要模拟对象的某些方法，而其他方法保持真实行为：

java复制@Test
public void testPartialMocking() {
    // 创建真实对象
    EmailService realEmailService = new EmailService();
    
    // 创建spy（部分模拟）
    EmailService emailSpy = spy(realEmailService);
    
    // 模拟发送邮件方法
    doNothing().when(emailSpy).sendEmail(anyString());
    
    // 调用真实方法
    emailSpy.validateAddress("test@example.com");
    
    // 调用模拟方法
    emailSpy.sendEmail("test@example.com");
    
    verify(emailSpy).sendEmail("test@example.com");
}

4.2 验证调用顺序

在某些场景下，方法调用的顺序很重要：

java复制@Test
public void testMethodCallOrder() {
    orderService.processOrder("order123");
    
    InOrder inOrder = inOrder(mockInventory, mockPaymentGateway);
    
    inOrder.verify(mockInventory).checkStock("order123");
    inOrder.verify(mockPaymentGateway).authorizePayment(anyDouble());
    inOrder.verify(mockInventory).updateStock(anyMap());
}

4.3 自定义Answer实现

对于复杂的行为模拟，可以实现Answer接口：

java复制@Test
public void testWithCustomAnswer() {
    when(mockPaymentGateway.processPayment(anyDouble(), anyString()))
        .thenAnswer(new Answer<PaymentResult>() {
            @Override
            public PaymentResult answer(InvocationOnMock invocation) {
                Double amount = invocation.getArgument(0);
                String orderId = invocation.getArgument(1);
                
                if (amount > 1000) {
                    return new PaymentResult(false, "Amount too large");
                }
                return new PaymentResult(true, "txn_" + orderId);
            }
        });
    
    // 测试逻辑...
}

5. 常见问题与解决方案

5.1 静态方法模拟问题

Mockito默认不能模拟静态方法。如果需要模拟静态方法，可以考虑：

1. 重构代码，减少静态方法的使用
2. 使用PowerMock（但会增加测试复杂度）
3. 使用Mockito 3.4.0+的inline mock maker（实验性功能）

java复制// 使用Mockito的inline mock maker（需要特殊配置）
try (MockedStatic<UtilityClass> mocked = mockStatic(UtilityClass.class)) {
    mocked.when(UtilityClass::staticMethod).thenReturn("mocked");
    
    // 测试逻辑...
}

5.2 循环依赖问题

当测试类与被测类有循环依赖时，可能会遇到初始化问题。解决方案：

1. 使用setter注入代替构造器注入
2. 使用@InjectMocks注解

java复制@RunWith(MockitoJUnitRunner.class)
public class OrderServiceTest {
    @Mock
    private PaymentGateway paymentGateway;
    
    @Mock
    private InventorySystem inventorySystem;
    
    @InjectMocks
    private OrderService orderService;
    
    // 测试方法...
}

5.3 测试性能优化

当测试套件变得庞大时，执行速度可能变慢。可以考虑：

1. 避免在@Before中做耗时操作
2. 使用Mockito的RETURNS_DEEP_STUBS减少模拟层次
3. 对不需要验证的模拟方法使用doReturn().when()而不是when().thenReturn()

java复制@Test
public void testPerformanceOptimization() {
    // 创建深度模拟
    OrderService service = mock(OrderService.class, RETURNS_DEEP_STUBS);
    
    // 直接访问深层方法
    when(service.getOrder().getItems()).thenReturn(Arrays.asList(item1, item2));
    
    // 更高效的方法模拟
    doReturn(true).when(service).isValid(any());
}

6. 最佳实践与经验分享

在实际项目中应用Mockito多年，我总结了以下经验：

1. 命名规范：测试方法名应该清晰表达测试场景和预期结果，如placeOrder_ShouldReturnSuccess_WhenPaymentValid

2. 验证粒度：不要过度验证，只验证关键的交互和状态变化

3. 测试隔离：每个测试应该独立运行，不依赖其他测试的状态

4. 合理使用模拟：只模拟外部依赖，不要过度模拟使测试失去意义

5. 保持测试简洁：遵循"准备-执行-验证"的三段式结构

6. 及时清理：对于需要清理的资源，使用@After方法

java复制// 良好的测试示例
@Test
public void placeOrder_ShouldDeductInventory_WhenPaymentSucceeds() {
    // 准备
    Order order = createTestOrder();
    when(mockPaymentGateway.processPayment(anyDouble(), anyString()))
        .thenReturn(new PaymentResult(true, "txn_123"));
    
    // 执行
    OrderResult result = orderService.placeOrder(order);
    
    // 验证
    assertTrue(result.isSuccess());
    verify(mockInventory).updateStock(argThat(map -> map.get("prod1") == 2));
}

对于复杂的测试场景，可以考虑使用BDD（行为驱动开发）风格的测试：

java复制@Test
public void testOrderProcessing_BDDStyle() {
    // Given
    Order order = createTestOrder();
    given(mockPaymentGateway.processPayment(anyDouble(), anyString()))
        .willReturn(new PaymentResult(true, "txn_123"));
    
    // When
    OrderResult result = orderService.placeOrder(order);
    
    // Then
    then(result).should().beSuccessful();
    then(mockInventory).should().updateStock(anyMap());
}

Mockito与Junit4的结合为Java单元测试提供了强大而灵活的工具集。掌握这些技巧后，你会发现编写高质量、可维护的单元测试不再是一件困难的事。关键在于理解何时使用模拟、如何设计可测试的代码结构，以及如何在测试覆盖率和测试维护成本之间找到平衡点。