在Java并发编程中，Future接口及其get()方法是获取异步任务结果的关键。然而，get()方法声明可能抛出InterruptedException和ExecutionException，这使得在编写单元测试时，模拟这些异常的发生以覆盖相应的catch块成为一项常见的挑战。本教程将详细阐述如何克服这一挑战。
理解Future.get()与异常模拟的挑战
当我们的业务代码处理Future结果时，通常会包含一个try-catch块来捕获get()方法可能抛出的异常，例如：
public class ExampleProductionCode {
// ... 其他成员和方法 ...
private MyService myService; // 用于处理异常的服务
public ExampleProductionCode(MyService myService) {
this.myService = myService;
// ...
}
public void collectAsyncResults() {
// enginesData 是一个用于收集结果的容器
EnginesData enginesData = this.getEngineData();
futureData.forEach(result -> {
try {
enginesData.add(result.get()); // 尝试获取Future结果
} catch (InterruptedException | ExecutionException e) {
// 期望被测试的catch块
myService.logError(e); // 在catch块中执行一个可观察的操作
}
});
}
// 内部类或辅助类
public class EnginesData { /* ... */ }
}
public class MyService {
public void logError(Exception e) {
// 实际的错误日志记录或处理逻辑
}
}在测试上述代码中的catch块时，我们希望模拟result.get()抛出异常。初学者可能会尝试使用类似when(oneFutureData.get()).thenThrow(CompletableFuture.completedFuture(interruptedException));的方式，但这通常会导致编译错误或无法达到预期效果。原因在于thenThrow()期望直接接收一个Throwable实例，而不是一个包裹了Throwable的Future对象。
正确模拟Future.get()抛出异常
要让一个被Mock的Future对象在调用get()时抛出特定异常，正确的Mockito语法是直接传入异常实例：
import org.mockito.Mockito;
import java.util.concurrent.Future;
import java.util.concurrent.InterruptedException;
import java.util.concurrent.ExecutionException;
// 假设 futureMock 是一个通过 @Mock 注解或 Mockito.mock() 创建的 Future<Class> 实例
Future<Class> futureMock = Mockito.mock(Future.class);
InterruptedException interruptedException = new InterruptedException("模拟中断异常");
// 当 futureMock.get() 被调用时，抛出 interruptedException
Mockito.when(futureMock.get()).thenThrow(interruptedException);
// 如果需要模拟 ExecutionException
ExecutionException executionException = new ExecutionException("模拟执行异常", new Throwable("内部原因"));
Mockito.when(futureMock.get()).thenThrow(executionException);验证catch块的执行
仅仅模拟异常的抛出不足以证明catch块被覆盖。单元测试的目的是验证代码的行为，这意味着我们需要一个可观察的副作用来确认catch块确实被执行了。在上述示例中，我们在catch块中调用了myService.logError(e)。我们可以利用Mockito的spy()功能来监视这个服务方法。
spy()允许我们对真实对象进行部分模拟，即我们可以在调用真实方法的同时，验证这些方法的调用情况。
以下是完整的测试用例示例：
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 java.util.ArrayList; // 导入 ArrayList
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class) // 启用 Mockito 注解
public class FutureExceptionTest {
@Mock // 声明一个 Future 的 Mock 对象
public Future<Class> futureMock;
@Test
public void testInterruptedExceptionInFutureGet() throws ExecutionException, InterruptedException {
// 1. 准备被测试的服务实例
// MyService 是一个真实的服务，我们对其进行 spy
MyService mySpy = spy(new MyService());
// ExampleProductionCode 依赖 MyService，注入 spy 后的 MyService
ExampleProductionCode exampleProductionCode = new ExampleProductionCode(mySpy);
// 获取生产代码中用于处理 Future 对象的列表
List<Future<Class>> futureData = exampleProductionCode.getFutureData();
// 2. 模拟异常
InterruptedException interruptedException = new InterruptedException("模拟中断异常");
// 当 futureMock.get() 被调用时，抛出 interruptedException
when(futureMock.get()).thenThrow(interruptedException);
// 将模拟的 Future 对象添加到生产代码的 Future 列表中
// 这样在 collectAsyncResults() 执行时，会处理到这个模拟的 Future
futureData.add(futureMock);
// 在调用 collectAsyncResults() 之前，验证 logError 尚未被调用
verify(mySpy, times(0)).logError(interruptedException);
// 3. 执行被测试的方法
// collectAsyncResults() 方法会遍历 futureData 并调用 Future.get()
exampleProductionCode.collectAsyncResults();
// 4. 验证 catch 块是否被执行
// 验证 mySpy 的 logError 方法是否被调用了指定次数，并传入了任意 Exception
// 这里假设 exampleProductionCode 内部原有2个 Future，加上我们添加的1个 Mock Future，总共会调用3次
verify(mySpy, times(3)).logError(any(Exception.class));
}
}为了使上述测试代码能够运行，我们需要提供ExampleProductionCode、MyService以及EnginesData的完整实现。这些实现应与问题描述中的生产代码结构相符。
// 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;
public ExampleProductionCode(MyService myService) {
this.myService = myService;
futureData = new ArrayList<>();
enginesData = new EnginesData();
// 生产代码中可能存在的真实 Future 对象
futureData.add(createAndStartAsyncTask());
futureData.add(createAndStartFutureTask());
}
public EnginesData getEngineData() {
return enginesData;
}
public List<Future<Class>> getFutureData() {
return futureData;
}
// 模拟一个异步任务，可能抛出异常
public Future<Class> createAndStartAsyncTask() {
CompletableFuture<Class> completableFuture = new CompletableFuture<>();
Executors.newCachedThreadPool().submit(() -> {
try {
Thread.sleep(50); // 模拟耗时操作
throw new InterruptedException("模拟CompletableFuture内部中断");
} catch (Exception e) {
completableFuture.completeExceptionally(e);
}
});
return completableFuture;
}
// 模拟另一个异步任务，可能抛出异常
public Future<Class> createAndStartFutureTask() {
FutureTask<Class> ftask = new FutureTask<>(() -> {
Thread.sleep(50); // 模拟耗时操作
throw new InterruptedException("模拟FutureTask内部中断");
});
// 注意：这里直接运行 ftask.run()，通常异步任务由 ExecutorService 提交
// 在实际场景中，FutureTask 会提交给 ExecutorService
// 为了演示，这里简化直接运行
new Thread(ftask).start(); // 在单独线程中启动，以便 get() 阻塞
return ftask;
}
public void collectAsyncResults() {
ExampleProductionCode.EnginesData enginesData = this.getEngineData();
futureData.forEach(result -> {
try {
enginesData.add(result.get());
} catch (InterruptedException | ExecutionException e) {
myService.logError(e); // 异常处理逻辑
}
});
}
public class EnginesData {
public void add(Class aclass) {
// 实际的数据添加逻辑
}
}
}
// MyService.java
package de.playground.so74236327;
public class MyService {
public void logError(Exception e) {
// 实际的错误日志记录逻辑，例如：
// System.err.println("Error occurred: " + e.getMessage());
}
}关键点与注意事项
- thenThrow()的参数类型： 确保thenThrow()方法接收的是一个Throwable实例，而不是一个Future或CompletableFuture对象。
- 可观察的副作用： 为了验证catch块的执行，必须在catch块内部执行一个可被外部测试代码观察到的操作，例如调用一个服务方法、修改一个共享变量等。
- spy()与verify()： 当需要验证真实对象的某个方法是否被调用时，spy()是比mock()更合适的选择。spy()允许对象的大部分行为保持真实，同时可以对特定方法进行验证或桩化。verify()则用于断言方法被调用的次数和参数。
- 异常类型匹配： 确保模拟抛出的异常类型与Future.get()方法签名中声明的异常类型（InterruptedException或ExecutionException）以及catch块捕获的异常类型相匹配。
- 测试的隔离性： 尽管本例为了演示完整流程包含了生产代码中的真实Future创建，但在实际单元测试中，应尽量隔离被测试单元，确保测试结果仅受控于模拟对象。
总结
通过本教程，我们学习了如何在Mockito中高效地模拟Future.get()方法抛出异常，并验证相应的catch块是否被正确触发。核心在于理解thenThrow()的正确用法，以及通过引入可观测的服务方法，并结合spy()和verify()机制来构建健壮的单元测试，从而确保异步任务的异常处理逻辑得到了充分的测试覆盖。这种方法不仅适用于Future，也适用于任何需要测试异常处理逻辑的场景。
