编辑“︁Java Mockito框架”︁

= Java Mockito框架 =

Mockito 是一个流行的 Java 单元测试框架，专门用于模拟（Mocking）对象的行为。它允许开发者在测试过程中创建和管理模拟对象，从而隔离被测代码的依赖项，使单元测试更加专注、高效。

== 介绍 ==
Mockito 主要用于解决单元测试中的依赖问题。在测试某个类时，如果它依赖于其他复杂的类或外部服务（如数据库、API 等），直接测试可能会变得困难。Mockito 通过创建这些依赖的模拟对象，使开发者可以控制它们的行为，从而专注于测试目标类的逻辑。

Mockito 的主要特点包括：
* 简单易用的 API
* 支持模拟对象的行为（方法返回值、异常抛出等）
* 支持验证方法调用（次数、参数等）
* 与 JUnit 和 TestNG 等测试框架无缝集成

== 基本用法 ==
以下是一个简单的 Mockito 示例，展示如何创建模拟对象并定义其行为：

<syntaxhighlight lang="java">
import static org.mockito.Mockito.*;
import org.junit.Test;

public class MockitoBasicTest {
    
    @Test
    public void testMocking() {
        // 创建模拟对象
        List<String> mockedList = mock(List.class);
        
        // 定义模拟行为
        when(mockedList.get(0)).thenReturn("first");
        
        // 使用模拟对象
        assertEquals("first", mockedList.get(0));
        
        // 验证交互
        verify(mockedList).get(0);
    }
}
</syntaxhighlight>

'''代码解释：'''
1. 使用 <code>mock()</code> 方法创建了一个 List 接口的模拟对象
2. 使用 <code>when().thenReturn()</code> 定义了当调用 <code>get(0)</code> 方法时的返回值
3. 使用模拟对象并验证其行为
4. 使用 <code>verify()</code> 验证方法是否被调用

== 高级特性 ==

=== 参数匹配器 ===
Mockito 提供了参数匹配器，可以更灵活地定义方法行为：

<syntaxhighlight lang="java">
@Test
public void testArgumentMatchers() {
    List<String> mockedList = mock(List.class);
    
    // 使用anyInt()匹配任何整数参数
    when(mockedList.get(anyInt())).thenReturn("element");
    
    assertEquals("element", mockedList.get(0));
    assertEquals("element", mockedList.get(999));
}
</syntaxhighlight>

=== 验证调用次数 ===
可以验证方法被调用的次数：

<syntaxhighlight lang="java">
@Test
public void testVerification() {
    List<String> mockedList = mock(List.class);
    
    mockedList.add("once");
    mockedList.add("twice");
    mockedList.add("twice");
    
    // 验证方法调用次数
    verify(mockedList).add("once");
    verify(mockedList, times(2)).add("twice");
    verify(mockedList, never()).add("never happened");
}
</syntaxhighlight>

=== 抛出异常 ===
可以模拟方法抛出异常：

<syntaxhighlight lang="java">
@Test(expected = RuntimeException.class)
public void testException() {
    List<String> mockedList = mock(List.class);
    
    when(mockedList.get(anyInt())).thenThrow(new RuntimeException());
    
    mockedList.get(0); // 抛出RuntimeException
}
</syntaxhighlight>

== 实际应用案例 ==
考虑一个用户服务，它依赖于用户仓库（UserRepository）来获取用户数据：

<syntaxhighlight lang="java">
public class UserService {
    private UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUserById(long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("User not found"));
    }
    
    public void updateUserEmail(long id, String newEmail) {
        User user = getUserById(id);
        user.setEmail(newEmail);
        userRepository.save(user);
    }
}
</syntaxhighlight>

使用 Mockito 测试这个服务：

<syntaxhighlight lang="java">
public class UserServiceTest {
    
    @Test
    public void testGetUserById() {
        // 创建模拟仓库
        UserRepository mockRepo = mock(UserRepository.class);
        
        // 创建测试用户
        User testUser = new User(1L, "test@example.com");
        
        // 定义模拟行为
        when(mockRepo.findById(1L)).thenReturn(Optional.of(testUser));
        when(mockRepo.findById(2L)).thenReturn(Optional.empty());
        
        // 创建被测试服务
        UserService userService = new UserService(mockRepo);
        
        // 测试正常情况
        User result = userService.getUserById(1L);
        assertEquals("test@example.com", result.getEmail());
        
        // 测试用户不存在情况
        assertThrows(UserNotFoundException.class, () -> {
            userService.getUserById(2L);
        });
    }
    
    @Test
    public void testUpdateUserEmail() {
        UserRepository mockRepo = mock(UserRepository.class);
        UserService userService = new UserService(mockRepo);
        
        User testUser = new User(1L, "old@example.com");
        when(mockRepo.findById(1L)).thenReturn(Optional.of(testUser));
        
        userService.updateUserEmail(1L, "new@example.com");
        
        assertEquals("new@example.com", testUser.getEmail());
        verify(mockRepo).save(testUser);
    }
}
</syntaxhighlight>

== Mockito 最佳实践 ==
1. '''只模拟必要的依赖'''：不要过度使用模拟，只模拟那些使测试复杂化的外部依赖
2. '''保持测试简单'''：每个测试应该只关注一个行为
3. '''使用明确的验证'''：明确验证预期的交互，但避免过度验证
4. '''考虑使用@Mock注解'''：在大型测试类中，可以使用 <code>@Mock</code> 注解和 <code>MockitoAnnotations.openMocks(this)</code> 来初始化模拟对象

== Mockito 与依赖注入 ==
Mockito 与依赖注入框架（如 Spring）可以很好地配合使用。以下是结合 Spring 和 Mockito 的测试示例：

<syntaxhighlight lang="java">
@ExtendWith(MockitoExtension.class)
public class SpringIntegrationTest {
    
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    public void testWithSpringIntegration() {
        User testUser = new User(1L, "test@example.com");
        when(userRepository.findById(1L)).thenReturn(Optional.of(testUser));
        
        User result = userService.getUserById(1L);
        assertEquals("test@example.com", result.getEmail());
    }
}
</syntaxhighlight>

== 常见问题 ==
'''Q: Mockito 和 PowerMock 有什么区别？'''
A: Mockito 主要用于模拟接口和类的方法行为，而 PowerMock 可以模拟静态方法、构造函数等更复杂的情况。通常建议优先使用 Mockito，只有在必要时才使用 PowerMock。

'''Q: 如何模拟 void 方法？'''
A: 可以使用 <code>doNothing()</code>, <code>doThrow()</code> 或 <code>doAnswer()</code> 来模拟 void 方法：

<syntaxhighlight lang="java">
@Test
public void testVoidMethod() {
    List<String> mockedList = mock(List.class);
    
    // 模拟void方法抛出异常
    doThrow(new RuntimeException()).when(mockedList).clear();
    
    assertThrows(RuntimeException.class, () -> {
        mockedList.clear();
    });
}
</syntaxhighlight>

== 总结 ==
Mockito 是 Java 单元测试中不可或缺的工具，它通过模拟对象帮助开发者编写更专注、更可靠的单元测试。从简单的行为模拟到复杂的交互验证，Mockito 提供了丰富的功能来满足各种测试需求。掌握 Mockito 可以显著提高代码质量和开发效率。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java单元测试]]