1. Future异常处理测试挑战
在Java并发编程中，Future接口的get()方法会声明抛出InterruptedException和ExecutionException。在编写单元测试时，我们经常需要覆盖这些异常捕获块，以确保程序在异步操作失败时能正确响应。然而，直接模拟Future对象并使其get()方法抛出异常，并验证捕获块是否执行，常常会遇到挑战。
常见的错误尝试是使用when(futureMock.get()).thenThrow(CompletableFuture.completedFuture(interruptedException))。这种写法是错误的，因为thenThrow()期望的是一个Throwable对象（即异常实例），而不是一个Future对象。正确的做法是直接传递异常实例，例如thenThrow(interruptedException)。
更深层次的问题在于，即使成功模拟了异常抛出，如何验证一个仅包含异常处理逻辑（如一个空的catch块）的捕获块是否被执行？单元测试需要可观察的副作用来验证行为。
2. 解决方案核心：可验证的副作用与Mockito Spy
要有效测试Future的异常捕获块，关键在于两点：
立即学习“Java免费学习笔记（深入）”；
- 正确模拟Future.get()抛出异常。
- 在异常捕获块中引入可验证的副作用。 这通常意味着调用一个外部服务或记录日志。然后，我们可以使用Mockito的spy功能来监视这个副作用是否被触发。
2.1 生产代码设计
为了使异常捕获块可测试，我们需要对其进行改造。假设我们的业务逻辑在捕获到异常时会调用一个服务方法来记录错误。
MyService.java
package de.playground.so74236327;
public class MyService {
public void logError(Exception e) {
// 实际的错误记录逻辑，例如写入日志文件或发送告警
System.err.println("Error logged: " + e.getMessage());
}
}ExampleProductionCode.java (核心异常处理逻辑部分)
package de.playground.so74236327;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
public class ExampleProductionCode {
List<Future<Class>> futureData;
EnginesData enginesData;
MyService myService; // 注入MyService
public ExampleProductionCode(MyService myService) {
this.myService = myService;
futureData = new ArrayList<>();
enginesData = new EnginesData();
// 示例：添加两个真实Future对象，它们内部可能抛出异常
futureData.add(createAndStartAsyncTask());
futureData.add(createAndStartFutureTask());
}
// ... 其他方法，如getFutureData()，getEngineData()，createAndStartAsyncTask()，createAndStartFutureTask() ...
// createAndStartAsyncTask 和 createAndStartFutureTask 内部可以模拟抛出InterruptedException
public void collectAsyncResults() {
futureData.forEach(result -> {
try {
enginesData.add(result.get()); // 尝试获取Future结果
} catch (InterruptedException | ExecutionException e) {
// 关键：在捕获块中调用可验证的服务方法
myService.logError(e);
}
});
}
public class EnginesData {
public void add(Class aclass) {
// 实际的数据处理逻辑
}
}
}在collectAsyncResults()方法中，当result.get()抛出InterruptedException或ExecutionException时，myService.logError(e)方法会被调用。这就是我们测试的切入点。
2.2 测试用例设计
现在，我们可以编写测试用例来验证异常处理逻辑。
FutureExceptionTest.java
package de.playground.so74236327;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class) // 启用Mockito JUnit 5扩展
public class FutureExceptionTest {
@Mock // 使用@Mock注解创建Future的模拟对象
public Future<Class> futureMock;
@Test
public void testInterruptedException() throws ExecutionException, InterruptedException {
// 1. Spy MyService实例
// 我们需要监视MyService的真实行为，以便验证logError是否被调用
MyService mySpy = spy(new MyService());
// 2. 实例化生产代码，并注入spy后的MyService
ExampleProductionCode exampleProductionCode = new ExampleProductionCode(mySpy);
// 获取Future列表，其中包含两个真实Future对象（它们可能内部抛异常）
List<Future<Class>> futureData = exampleProductionCode.getFutureData();
// 3. 准备模拟的异常
InterruptedException interruptedException = new InterruptedException("模拟的Interrupted Exception");
// 4. 配置futureMock的get()方法在调用时抛出异常
// 注意：这里直接thenThrow(interruptedException)，而不是thenThrow(CompletableFuture.completedFuture(interruptedException))
when(futureMock.get()).thenThrow(interruptedException);
// 5. 将模拟的futureMock添加到futureData列表中
// 这样在collectAsyncResults执行时，会有一个Future对象是模拟的，会抛出我们设定的异常
futureData.add(futureMock);
// 在collectAsyncResults()调用之前，logError应该没有被调用过
verify(mySpy, times(0)).logError(interruptedException);
// 6. 执行生产代码中包含Future.get()调用的方法
exampleProductionCode.collectAsyncResults();
// 7. 验证logError方法是否被调用
// 假设collectAsyncResults()处理了3个Future：
// - 两个来自ExampleProductionCode内部创建的真实Future，它们可能抛出异常。
// - 一个是我们添加的futureMock，它会抛出interruptedException。
// 因此，logError应该被调用3次（如果所有Future都导致异常）。
verify(mySpy, times(3)).logError(any(Exception.class)); // 验证任何Exception类型的调用
// 如果想验证特定异常，可以这样：
// verify(mySpy, times(1)).logError(interruptedException); // 验证模拟的InterruptedException被捕获
}
}3. 关键点解析与注意事项
-
@Mock与spy的区别：
- @Mock用于创建一个完全模拟的对象，其所有方法默认不执行实际逻辑，需要通过when().thenReturn()或when().thenThrow()进行行为定义。
- spy(new MyService())用于监视一个真实的对象实例。它会执行对象的真实方法，但我们仍然可以通过doReturn()、doThrow()等方法对其部分行为进行桩化或验证。在本例中，我们希望MyService的logError方法被真实调用，以便我们能验证其调用次数和参数，因此使用spy是合适的。
- thenThrow()的正确用法： thenThrow()方法期望接收一个Throwable实例。不要传递Future或其他非Throwable对象。
- 可测试性设计： 单元测试的黄金法则之一是“可测试性优先”。如果一个代码块（如空的catch块）没有可观察的副作用，那么它就很难被有效地测试。通过引入myService.logError(e)这样的调用，我们为测试提供了验证点。
- 模拟真实异常场景： 除了模拟Future对象，生产代码中也可以通过CompletableFuture.completeExceptionally(e)或在FutureTask内部的call()/run()方法中抛出异常来模拟真实世界的异常情况。这在ExampleProductionCode的createAndStartAsyncTask和createAndStartFutureTask方法中有所体现。
4. 总结
通过以上方法，我们不仅能够成功模拟Future.get()方法抛出InterruptedException或ExecutionException，还能通过在捕获块中引入可验证的副作用，并结合Mockito的spy和verify功能，精确地测试和验证异常处理逻辑是否被正确触发和执行。这种测试策略确保了异步操作在面临异常时，程序能够按照预期进行错误处理，从而提升了代码的健壮性和可靠性。
