Java使用Mockito进行模拟和测试桩实践过程

做Ja va开发，尤其是写单元测试的时候，Mockito几乎是绕不开的一个工具。它本质上是一个模拟框架，可以用来在测试代码中模拟对象的行为，让开发者摆脱对真实依赖的强绑定。简单来说，就是用“替身”来代替真实对象，把控测试环境，验证代码逻辑是否正确。

有了Mockito，我们可以轻松为一个对象指定预期行为，而不用真正去构造那个真实的对象。这种技术最常见的用武之地，是在那些不方便搭建完整集成测试环境，但又需要对代码逻辑进行充分验证的场景下。可以说，从单元测试到集成测试，再到行为驱动开发（BDD），Mockito都能派上大用场。

一、Mockito基础知识

1、Mockito的优点

• 使用简单：API设计得很直观，花不了多少功夫就能上手。
• 支持多种场景：不管是基础的单元测试，还是复杂的集成测试，甚至BDD，都有一套完整的应对方案。
• 文档与生态成熟：官方文档和社区的资源相当丰富，遇到问题很容易找到参考。

2、Mockito的局限性

• 不支持对静态方法和final方法进行模拟——这是个硬伤，遇到这种情况通常得找PowerMock来帮忙。
• 如果过度使用模拟，反而会让测试代码变得难以维护，这一点需要警惕。

3、Mockito的常见概念

• Mock：一个对象的虚拟实现，它有和真实对象一样的方法和属性，但不会真正执行这些方法里的逻辑。
• Stub：为某个方法调用预先设定好返回值，用来控制测试代码的执行路径。
• Verify：说白了就是“校验”，验证模拟对象是否按预期发生了交互——比如某个方法有没有被调用，被调用了几次，传入的参数对不对。

4、Mockito的常见用法

• 创建Mock对象

List mockList = mock(List.class);

• Stub方法调用

when(mockList.get(0)).thenReturn("first");

• 验证方法调用

verify(mockList).add("one");

• 模拟方法抛出异常

when(mockList.get(anyInt())).thenThrow(new RuntimeException());

除此之外，Mockito还提供了ArgumentMatchers来做参数匹配、用注解来简化Mock对象的创建、以及使用Spy来监视真实对象等高级功能。把这些用法吃透，写单元测试和集成测试的效率会明显上一个台阶。

二、使用Mockito进行模拟

1、使用Mockito进行模拟的步骤和示例

模拟对象的核心逻辑其实不复杂，关键步骤可以梳理成下面几步：

首先，在pom.xml里引入Mockito依赖：

org.mockito
mockito-core
3.12.4
test

接着，准备好要测试的类和接口——比如下面这个经典的UserService和UserDao：

public class UserService {
private UserDao userDao;
public UserService(UserDao userDao) {
this.userDao = userDao;
}
public User getUserById(int id) {
return userDao.getUserById(id);
}
}
public interface UserDao {
User getUserById(int id);
}

然后，创建Mock对象并设置其行为：

UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));

最后，跑一下测试：

@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}

2、使用when()

when()方法是Mockito里最常用的桩方法手段，基本格式如下：

when(mockObject.someMethod()).thenReturn(someValue);

还是UserService的例子：

@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}

3、使用doReturn()

doReturn()和when()功能类似，但写法上稍有不同：

doReturn(someValue).when(mockObject).someMethod();

@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
doReturn(new User(1, "John")).when(userDao).getUserById(1);
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}

4、使用mock()方法创建模拟对象

SomeClass mockObject = mock(SomeClass.class);

@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}

5、使用@Mock注解创建模拟对象

用代码手动mock()是一种方式，但更常见的做法是通过@Mock注解来声明。不过，前提是测试类上要加上@RunWith(MockitoJUnitRunner.class)：

@Mock
private UserDao userDao;

@Test
public void testGetUserById() {
UserService userService = new UserService(userDao);
// ...
}

这里有几个细节需要注意：

• 被@Mock修饰的变量在初始化时不能为null。
• 默认情况下，它的Answer是RETURNS_DEFAULTS。
• 如果希望它返回智能空值，可以显式指定@Mock(answer = Answers.RETURNS_SMART_NULLS)。
• 用注解创建的Mock对象会自动注入测试类，但如果不用或不声明，可能会抛出UnnecessaryStubbingException异常。

6、使用@Spy注解进行模拟对象的部分模拟

有时候，我们不希望完全模拟一个对象，而是想“保留一部分真实行为”。这时候@Spy就派上用场了。它可以创建一个部分模拟的对象，让真实方法继续执行，同时又能对另外一些方法进行模拟。

public class ExampleServiceTest {
@Spy
private ExampleServiceImpl exampleServiceSpy;

@Test
public void testSomeMethod() {
Mockito.doCallRealMethod().when(exampleServiceSpy).someMethod();
Mockito.when(exampleServiceSpy.someOtherMethod()).thenReturn("mocked result");

exampleServiceSpy.someMethod();

Mockito.verify(exampleServiceSpy).someOtherMethod();
}
}

在这个例子里，someMethod的行为是真实的，但someOtherMethod被模拟了。最后还可以用verify来验证真实行为调用了哪些模拟方法。

三、使用Mockito进行测试桩

1、测试桩的作用和场景

所谓测试桩，就是在单元测试里预先给方法设定好返回值或异常，以此来模拟各种业务场景。下面是一些典型的应用场景：

• 测试异常处理逻辑：通过桩方法让方法抛出异常，看被测代码能不能正确应对。
• 测试特定输入下的行为：比如输入为null时，代码能否正常处理。
• 模拟外部依赖交互：那些数据库、接口之类的外部依赖，用桩来假返回或抛出异常，可以“隔离”出被测代码。
• 测试边界条件：比如输入是最大值或最小值时的情况。

一句话，测试桩能帮开发人员快速构造各种测试场景，保证代码在多种情况下都不掉链子。

2、使用Mockito进行测试桩的步骤和示例

过程大致分三步：准备接口、设置桩值、执行断言。先看一个接口定义：

public interface UserService {
User getUserById(int userId);
}

然后模拟返回值的测试：

@Test
public void testGetUserById() {
UserService userService = Mockito.mock(UserService.class);
User expectedUser = new User("Alice", 20);
Mockito.when(userService.getUserById(Mockito.anyInt())).thenReturn(expectedUser);

User actualUser = userService.getUserById(1);
Assert.assertEquals(expectedUser, actualUser);
}

再来看模拟抛出异常的写法：

@Test(expected = UserNotFoundException.class)
public void testGetUserByIdWhenUserNotFound() {
UserService userService = Mockito.mock(UserService.class);
Mockito.when(userService.getUserById(Mockito.anyInt())).thenThrow(UserNotFoundException.class);
userService.getUserById(1);
}

3、使用thenReturn()方法设置桩值

这是最常见的一种桩方法，直接指定返回值。比如：

@Test
public void testGetPerson() {
PersonDao personDao = mock(PersonDao.class);
when(personDao.getPerson(1)).thenReturn(new Person("Alice", 20));

PersonService personService = new PersonService(personDao);
Person person = personService.getPerson(1);
assertEquals("Alice", person.getName());
assertEquals(20, person.getAge());
}

4、使用thenThrow()方法抛出异常

想模拟异常场景，就靠thenThrow()了。用法也很直接：

@Test
public void testDoSomething() throws Exception {
SomeObject mockObject = mock(SomeObject.class);
when(mockObject.doSomething()).thenThrow(new RuntimeException("test exception"));

assertThrows(RuntimeException.class, () -> {
mockObject.doSomething();
});
}

5、使用doAnswer()方法自定义桩方法

当简单的返回值无法满足需求时，doAnswer()可以让我们自定义方法的行为。例如，模拟List.get()方法，让它返回的字符串后面自动加上“Mockito”：

List list = mock(List.class);
doAnswer(invocation -> {
Object[] args = invocation.getArguments();
String result = (String) args[0] + "Mockito";
return result;
}).when(list).get(anyInt());

6、使用@Captor注解进行参数捕获

有时候我们不光要验证方法有没有被调用，还想知道传入的参数到底是什么。这时候@Captor就派上用场了：

@Captor
private ArgumentCaptor captor;

在测试中：

mockObject.doSomething("test");
verify(mockObject).doSomething(captor.capture());
assertEquals("test", captor.getValue());

四、Mockito进阶用法

1、使用Mockito进行异步测试

异步逻辑的测试向来是个难点。Mockito在这块提供了两种思路：模拟异步回调和等待异步结果。

模拟异步回调

利用Answer接口，可以在异步回调发生时手动执行回调逻辑：

@Test
public void testAsyncCallback() {
MyAsyncService service = mock(MyAsyncService.class);
when(service.doSomethingAsync(anyString(), any(Consumer.class))).thenAnswer(invocation -> {
Object[] args = invocation.getArguments();
String arg1 = (String) args[0];
Consumer callback = (Consumer) args[1];
callback.accept(arg1 + " is done");
return null;
});

MyAsyncClient client = new MyAsyncClient(service);
String result = client.doSomething("test");
assertEquals("test is done", result);
}

等待异步结果

利用CompletableFuture，可以模拟异步方法的返回过程，并在测试中手动触发完成：

@Test
public void testAsyncResult() throws Exception {
MyAsyncService service = mock(MyAsyncService.class);
CompletableFuture future = new CompletableFuture<>();
when(service.doSomethingAsync(anyString())).thenReturn(future);

MyAsyncClient client = new MyAsyncClient(service);
CompletableFuture result = client.doSomethingAsync("test");
assertFalse(result.isDone());

future.complete("test is done");
assertTrue(result.isDone());
assertEquals("test is done", result.get());
}

2、使用Mockito进行参数匹配

Mockito提供的参数匹配器很丰富，常见的有：any()、eq()、isA()以及各种anyXxx()（如anyInt()）。示例：

@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
@Mock
private UserDao userDao;
@InjectMocks
private UserService userService;

@Test
public void testGetUserByName() {
when(userDao.getUserByName(any(String.class)))
.thenReturn(new User("Tom"));
User user = userService.getUserByName("Tom");
assertEquals("Tom", user.getName());
}
}

3、使用Mockito进行void方法的桩方法和验证

对于没有返回值的void方法，可以用doNothing()和doThrow()来做桩：

List mockList = mock(List.class);
doNothing().when(mockList).add(anyString());
doThrow(new RuntimeException()).when(mockList).clear();

验证void方法也很简单：

mockList.clear();
verify(mockList).clear();

4、使用Mockito进行mock静态方法和final方法

Mockito本身不支持静态方法和final方法的模拟。不过，可以结合PowerMock来搞定。核心步骤包括：引入PowerMock依赖、使用@RunWith(PowerMockRunner.class)和@PrepareForTest注解、调用PowerMockito.mockStatic()等。这里不再逐一贴代码，但也需要提醒一句：能别用就别用，过度依赖PowerMock会让测试代码的可读性和可维护性打折扣。

五、总结

Mockito作为Ja va生态中主流的模拟框架，它的简单易用和功能全面，让它成为了单元测试场景下的首选工具之一。从模拟对象、测试桩，到参数匹配和异步测试，每一步都在帮助开发者把测试代码写得更干净、更高效。

当然，它也有自己的短板——比如不能直接处理静态方法和final方法，所以有时候得配合PowerMock来弥补。但总体来说，掌握Mockito绝对是一个值得投入的技能，它不仅能提升代码质量，也能显著降低后期的维护成本。