Mockito的方法调用多个服务的时候怎么办

如果你使用Mockito进行测试时，需要模拟多个服务的方法调用，可以使用Mockito的链式调用方式来实现。

首先，你需要使用Mockito.mock方法创建多个服务的mock对象：

ServiceA serviceA = Mockito.mock(ServiceA.class);
ServiceB serviceB = Mockito.mock(ServiceB.class);

接着，你可以使用Mockito.when方法来模拟服务的方法调用，并返回预设的结果：

Mockito.when(serviceA.methodA()).thenReturn("resultA");
Mockito.when(serviceB.methodB()).thenReturn("resultB");

最后，你可以在测试过程中按照你需要的顺序调用这些服务的方法，例如：

String resultA = serviceA.methodA();
String resultB = serviceB.methodB();

这样，你就可以在测试过程中模拟多个服务的方法调用，并验证你的代码在不同情况下的行为。

相关问题

Mockito.when一个多层调用的方法怎么写

您可以使用 Mockito 的链式调用来模拟多层调用的方法。例如，假设您有一个名为 `userService` 的服务，该服务中有一个名为 `getUserAddress` 的方法，该方法将调用另一个名为 `addressService` 的服务中的方法。您可以使用以下代码模拟这两个方法的调用：

// 创建 Mock 对象
UserService userService = Mockito.mock(UserService.class);
AddressService addressService = Mockito.mock(AddressService.class);

// 模拟 getUserAddress 方法
Mockito.when(userService.getUserAddress(Mockito.anyLong())).thenAnswer(invocation -> {
    Long userId = invocation.getArgument(0);
    Address address = addressService.getAddress(userId);
    return address;
});

// 模拟 getAddress 方法
Mockito.when(addressService.getAddress(Mockito.anyLong())).thenReturn(new Address("123 Main St."));

在上面的代码中，我们首先创建了 `UserService` 和 `AddressService` 的 Mock 对象。然后，我们使用 `when` 方法来模拟 `getUserAddress` 方法的调用。在模拟 `getUserAddress` 方法时，我们使用了 `thenAnswer` 方法来自定义方法的行为。在该方法中，我们获取了 `getUserAddress` 方法的参数，并使用 `addressService` 来获取用户的地址。最后，我们返回了模拟的地址对象。

接下来，我们使用 `when` 方法来模拟 `getAddress` 方法的调用。在模拟 `getAddress` 方法时，我们使用了 `thenReturn` 方法来指定方法的返回值。

通过这种方式，我们可以模拟多层调用的方法并指定它们的行为。

mockito 多线程

针对多线程编程的单元测试，可以使用Mockito的一些特性和技巧来完成。以下是一些常用的技巧：

1. 使用Mockito的异步调用技术，可以模拟多线程环境下的方法调用。例如，使用Mockito的when().thenAnswer()方法来模拟异步调用：

@Test
public void testAsyncMethod() throws Exception {
    CompletableFuture<String> future = new CompletableFuture<>();
    when(mock.asyncMethod()).thenAnswer(invocation -> {
        new Thread(() -> {
            future.complete("mock result");
        }).start();
        return future;
    });
    String result = mock.asyncMethod().get();
    assertEquals("mock result", result);
}

2. 使用CountDownLatch等多线程工具类来控制多线程的执行顺序。例如，使用CountDownLatch来等待所有线程执行完毕：

@Test
public void testMultiThread() throws Exception {
    CountDownLatch latch = new CountDownLatch(2);
    new Thread(() -> {
        // do something
        latch.countDown();
    }).start();
    new Thread(() -> {
        // do something
        latch.countDown();
    }).start();
    latch.await();
    // assert something
}

3. 使用Spy和ArgumentMatchers等技巧来模拟多线程环境下的方法调用和参数传递。例如，使用Spy来模拟一个多线程环境下的对象：

@Test
public void testMultiThreadWithSpy() throws Exception {
    MyClass myClass = new MyClass();
    MyClass spy = spy(myClass);
    CountDownLatch latch = new CountDownLatch(2);
    new Thread(() -> {
        doAnswer(invocation -> {
            // do something
            latch.countDown();
            return null;
        }).when(spy).myMethod(anyString());
    }).start();
    new Thread(() -> {
        doAnswer(invocation -> {
            // do something
            latch.countDown();
            return null;
        }).when(spy).myMethod(anyString());
    }).start();
    latch.await();
    verify(spy, times(2)).myMethod(anyString());
}