一、单元测试的困境与Mockito的救赎

1.1 传统单元测试的痛点

在真实项目中进行单元测试时，开发者常面临三大挑战：

• 外部依赖：数据库连接、网络服务、文件系统等难以隔离
• 测试复杂度：需要构造复杂对象状态才能触发特定逻辑
• 执行速度：集成测试耗时过长（如等待远程API响应）

// 传统测试的典型问题示例
public class PaymentServiceTest {
    
    
    @Test
    public void testProcessPayment() {
    
    
        // 需要真实的支付网关连接
        PaymentGateway gateway = new PayPalGateway();
        PaymentService service = new PaymentService(gateway);
        
        // 测试可能因网络问题失败
        assertTrue(service.processPayment(100.0));
    }
}

1.2 Mockito的核心价值

Mockito通过模拟对象（Mock）技术提供四大利器：

• 依赖隔离：模拟外部服务的行为
• 行为验证：确认方法调用符合预期
• 状态预设：精确控制测试条件
• 异常测试：轻松模拟错误场景

// 使用Mockito的测试示例
@ExtendWith(MockitoExtension.class)
class PaymentServiceTest {
    
    
    @Mock
    PaymentGateway mockGateway;
    
    @InjectMocks
    PaymentService service;
    
    @Test
    void testProcessPayment() {
    
    
        when(mockGateway.charge(anyDouble())).thenReturn(true);
        
        assertTrue(service.processPayment(100.0));
        verify(mockGateway).charge(100.0);
    }
}

二、Mockito核心功能深度解析

2.1 基础模拟操作

2.1.1 创建Mock对象

// 方式1：静态方法
List<String> mockList = mock(List.class);

// 方式2：注解驱动
@Mock
UserRepository userRepo;

@BeforeEach
void setup() {
    
    
    MockitoAnnotations.openMocks(this);
}

2.1.2 设置方法行为

方法	功能描述	示例
when().thenReturn()	设置返回值	when(mock.size()).thenReturn(10)
doReturn().when()	替代语法	doReturn(10).when(mock).size()
when().thenThrow()	抛出异常	when(mock.get(0)).thenThrow(new RuntimeException())
doNothing().when()	空方法	doNothing().when(mock).clear()
when().thenAnswer()	动态响应	when(mock.get(anyInt())).thenAnswer(inv -> inv.getArgument(0))

2.2 验证方法调用

// 基本验证
verify(mockList).add("test");

// 验证调用次数
verify(mockList, times(2)).clear();

// 验证调用顺序
InOrder inOrder = inOrder(mockA, mockB);
inOrder.verify(mockA).prepare();
inOrder.verify(mockB).execute();

// 验证无调用
verifyNoInteractions(mockService);

2.3 参数匹配器

// 内置匹配器
verify(mock).process(argThat(arg -> arg.length() > 5));

// 自定义匹配器
class ValidUserMatcher implements ArgumentMatcher<User> {
    
    
    public boolean matches(User user) {
    
    
        return user.getId() != null && user.getEmail().contains("@");
    }
}

verify(userService).save(argThat(new ValidUserMatcher()));

三、高级功能与最佳实践

3.1 Spy对象：部分模拟

List<String> realList = new ArrayList<>();
List<String> spyList = spy(realList);

// 真实方法调用
doReturn(100).when(spyList).size();

spyList.add("item");
assertEquals(1, spyList.size());  // 真实方法
assertEquals(100, spyList.size()); // 模拟方法

3.2 注解驱动开发

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    
    
    @Mock
    InventoryService inventory;
    
    @Spy
    AuditLog auditLog = new FileAuditLog();
    
    @InjectMocks
    OrderService service;
    
    @Test
    void testPlaceOrder() {
    
    
        when(inventory.checkStock("A001")).thenReturn(10);
        
        service.placeOrder("A001", 5);
        
        verify(auditLog).log("Order placed: A001 x5");
    }
}

3.3 复杂场景处理

3.3.1 连续调用模拟

when(mock.randomInt())
    .thenReturn(1)
    .thenReturn(2)
    .thenThrow(new RuntimeException());

assertEquals(1, mock.randomInt());
assertEquals(2, mock.randomInt());
assertThrows(RuntimeException.class, () -> mock.randomInt());

3.3.2 参数捕获

ArgumentCaptor<Order> orderCaptor = ArgumentCaptor.forClass(Order.class);
verify(orderService).submit(orderCaptor.capture());

Order submitted = orderCaptor.getValue();
assertEquals("Pending", submitted.getStatus());

四、企业级应用实践

4.1 Spring集成测试

@SpringBootTest
@ExtendWith(MockitoExtension.class)
class UserServiceIntegrationTest {
    
    
    @MockBean
    UserRepository userRepo;
    
    @Autowired
    UserService userService;
    
    @Test
    void testFindActiveUsers() {
    
    
        when(userRepo.findByStatus("active"))
            .thenReturn(List.of(new User("Alice"), new User("Bob")));
            
        assertEquals(2, userService.getActiveUsers().size());
    }
}

4.2 异步方法测试

@Test
void testAsyncOperation() {
    
    
    CompletableFuture<Result> future = new CompletableFuture<>();
    when(mockService.asyncCall()).thenReturn(future);
    
    TestThread testThread = new TestThread(() -> {
    
    
        Result result = target.processAsync();
        assertNotNull(result);
    });
    
    testThread.start();
    future.complete(new Result());
    testThread.join();
}

4.3 数据库访问层测试

@Test
void testUserRepository() {
    
    
    User mockUser = mock(User.class);
    when(mockUser.getId()).thenReturn(100L);
    
    EntityManager em = mock(EntityManager.class);
    UserRepository repo = new UserRepository(em);
    
    repo.save(mockUser);
    
    verify(em).persist(mockUser);
    verify(mockUser).setCreatedDate(any());
}

五、最佳实践与反模式

5.1 黄金准则

1. 验证行为而非实现：关注方法做了什么，而不是怎么做
2. 保持测试简洁：每个测试用例验证单个场景
3. 合理使用验证：避免过度验证内部实现细节
4. 组合使用匹配器：增强测试的灵活性和可读性

5.2 常见反模式

反模式	症状	改进方案
过度模拟	Mock对象层级超过3层	重构代码结构
脆弱测试	测试因实现细节改变而失败	验证结果而非中间过程
魔法数字	测试数据缺乏业务含义	使用具名常量
忽略异常路径	只测试happy path	覆盖边界条件和异常情况

六、Mockito生态扩展

6.1 与JUnit 5深度集成

@MockitoSettings
class ModernTest {
    
    
    @Mock
    Calculator calc;
    
    @Test
    void testAdd() {
    
    
        when(calc.add(2, 3)).thenReturn(5);
        assertEquals(5, calc.add(2, 3));
    }
}

6.2 PowerMock整合

@RunWith(PowerMockRunner.class)
@PrepareForTest(StaticUtils.class)
public class StaticTest {
    
    
    @Test
    public void testStaticMethod() {
    
    
        PowerMockito.mockStatic(StaticUtils.class);
        when(StaticUtils.getConfig()).thenReturn("test");
        
        assertEquals("test", StaticUtils.getConfig());
    }
}

6.3 自定义扩展

public class LoggingAnswer implements Answer<Object> {
    
    
    public Object answer(InvocationOnMock invocation) {
    
    
        System.out.println("Called: " + invocation);
        return null;
    }
}

@Test
void testLogging() {
    
    
    List<String> mock = mock(List.class, new LoggingAnswer());
    mock.add("test");
}

结语：编写可靠的单元测试

Mockito作为Java单元测试的事实标准工具，其价值不仅在于简化测试编写，更在于推动良好的代码设计。通过遵循"测试驱动开发"的理念，开发者可以创建出更模块化、更可维护的代码库。正如软件大师Martin Fowler所说：“好的测试应该像显微镜，帮助开发者看清代码的内部运作。” 掌握Mockito，就是获得了一台强大的代码显微镜。

附：文中图表内容描述

图1：Mockito核心架构图

[架构层次]
1. 核心引擎：
   ├─ 代理生成（ByteBuddy/CGLIB）
   ├─ 调用记录器（InvocationTracker）
   └─ 验证系统（VerificationMode）

2. 扩展模块：
   ├─ JUnit5集成
   ├─ Spring支持
   └─ 自定义匹配器

3. 开发者接口：
   ├─ 流式API（when/then）
   ├─ 注解驱动（@Mock/@InjectMocks）
   └─ BDD风格（given/will）

图2：Mock对象生命周期

[阶段流程]
1. 初始化阶段：
   - 创建Mock对象
   - 设置默认行为

2. 记录阶段：
   - 方法调用被记录
   - 参数被存储

3. 验证阶段：
   - 检查调用次数
   - 验证参数匹配
   - 确认调用顺序

4. 重置阶段：
   - 清除调用记录
   - 恢复默认行为

图3：企业级测试金字塔

[分层结构]
顶层：E2E测试（5%）
中层：集成测试（15%）
底层：单元测试（80%）

Mockito定位：
- 单元测试层核心工具
- 集成测试层辅助工具
- E2E测试层不推荐使用