一、理解 Future 异常处理与测试挑战
在 java 并发编程中，future 接口代表异步计算的结果。当通过 future.get() 方法尝试获取结果时，可能会遇到两种受检异常：
- InterruptedException: 当线程在等待结果时被中断。
- ExecutionException: 当异步计算过程中抛出异常时，该异常会被包装在 ExecutionException 中抛出。
在编写单元测试时，为了确保代码对这些异常情况的处理是正确的，我们需要模拟 Future.get() 方法抛出这些异常，并验证相应的 catch 块是否被执行。然而，这常常面临以下挑战：
- thenThrow 的误用: 开发者可能错误地尝试使用 when(mock.get()).thenThrow(someFutureContainingException)，但 thenThrow 方法期望的是一个 Throwable 实例，而非一个包装了异常的 Future 对象。
- catch 块的验证: catch 块本身是代码逻辑，无法直接通过 Mockito 验证其“被执行”。要验证 catch 块是否被触发，我们需要在 catch 块内部执行一个可观测的动作（例如，调用一个日志服务、更新一个状态变量），然后通过 Mockito 验证这个动作是否发生。
二、Mockito 模拟 Future 异常的正确姿势
要让 Mockito 模拟的 Future 对象在调用 get() 方法时抛出异常，应直接使用 thenThrow 方法并传入异常实例。
基本语法：
import static org.mockito.Mockito.*;
import java.util.concurrent.Future;
import java.util.concurrent.InterruptedException;
// 假设 futureMock 是一个 Future<Class> 类型的 Mock 对象
Future<Class> futureMock = mock(Future.class);
// 模拟 futureMock.get() 抛出 InterruptedException
when(futureMock.get()).thenThrow(new InterruptedException("模拟中断异常"));
// 模拟 futureMock.get() 抛出 ExecutionException
// ExecutionException 通常包装了实际的业务异常
when(futureMock.get()).thenThrow(new ExecutionException("模拟执行异常", new RuntimeException("内部业务错误")));请注意，thenThrow 期望的是一个 Exception 对象，而不是一个 CompletableFuture 或其他 Future 的实例。如果传入一个 Future，会导致编译错误或运行时错误。
三、验证 Catch 块执行的关键策略：Spy 与 Verify
仅仅模拟异常抛出不足以完成测试。核心在于如何验证包含 Future.get() 调用的 catch 块确实被触发并执行了预期的异常处理逻辑。
核心思想：
在 catch 块中，引入一个可被测试框架监视的“副作用”操作。这个操作可以是调用一个日志服务、统计异常次数、或者更新某个状态。然后，在测试中，我们可以使用 Mockito.spy() 来监视这个执行副作用的真实对象，并通过 Mockito.verify() 来确认该副作用方法是否被调用。
示例场景：
假设我们的业务逻辑在处理 Future 结果时，如果发生异常，会调用一个 MyService 的 logError 方法来记录错误。
1. 生产代码结构
首先，我们定义一个简单的服务 MyService 来处理错误日志：
// MyService.java
package de.playground.so74236327;
public class MyService {
public void logError(Exception e) {
// 实际的日志记录逻辑，例如：
// System.err.println("Error occurred: " + e.getMessage());
// logger.error("Async operation failed", e);
}
}接着，是包含 Future 异步结果收集逻辑的 ExampleProductionCode：
// ExampleProductionCode.java
package de.playground.so74236327;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
public class ExampleProductionCode {
private List<Future<Class>> futureData;
private EnginesData enginesData;
private MyService myService; // 注入 MyService
public ExampleProductionCode(MyService myService) {
this.myService = myService;
futureData = new ArrayList<>();
enginesData = new EnginesData();
// 示例：添加一些真实的 Future 对象，它们也可能抛出异常
futureData.add(createAndStartAsyncTask());
futureData.add(createAndStartFutureTask());
}
public List<Future<Class>> getFutureData() {
return futureData;
}
// 模拟一个 CompletableFuture 异步任务，可能抛出异常
public Future<Class> createAndStartAsyncTask() {
CompletableFuture<Class> completableFuture = new CompletableFuture<>();
Executors.newCachedThreadPool().submit(() -> {
try {
Thread.sleep(100); // 模拟耗时操作
throw new InterruptedException("模拟 CompletableFuture 内部中断");
} catch (Exception e) {
completableFuture.completeExceptionally(e); // 异常完成
}
});
return completableFuture;
}
// 模拟一个 FutureTask 异步任务，可能抛出异常
public Future<Class> createAndStartFutureTask() {
FutureTask<Class> ftask = new FutureTask<>(() -> {
Thread.sleep(100); // 模拟耗时操作
throw new InterruptedException("模拟 FutureTask 内部中断");
// return MySOClass.class; // 正常返回
});
// 注意：FutureTask 的 run() 方法在当前线程执行任务
// 如果要模拟异步执行，需要提交给 ExecutorService
ftask.run();
return ftask;
}
public void collectAsyncResults() {
futureData.forEach(result -> {
try {
enginesData.add(result.get()); // 尝试获取结果
} catch (InterruptedException | ExecutionException e) {
// 当 Future.get() 抛出异常时，调用 MyService 的 logError 方法
myService.logError(e); // 这是我们要在测试中验证的副作用
}
});
}
public class EnginesData {
public void add(Class aclass) {
// 实际的数据添加逻辑
}
}
}2. 单元测试代码
现在，我们可以编写测试来验证 catch 块中的 myService.logError(e) 是否被调用。
// 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 注解
public class FutureExceptionTest {
@Mock // 声明一个 Future<Class> 类型的 Mock 对象
public Future<Class> futureMock;
@Test
public void testInterruptedExceptionInFutureGet() throws ExecutionException, InterruptedException {
// 1. 准备 Spy 对象：对 MyService 的真实实例进行 Spy
// 这样可以调用 MyService 的真实方法，同时也能验证其方法调用
MyService mySpy = spy(new MyService());
// 2. 实例化生产代码类，并注入 Spy 对象
// ExampleProductionCode 内部会创建两个真实的 Future 实例
ExampleProductionCode exampleProductionCode = new ExampleProductionCode(mySpy);
List<Future<Class>> futureData = exampleProductionCode.getFutureData();
// 3. 模拟 futureMock 的行为：当 get() 被调用时抛出 InterruptedException
InterruptedException interruptedException = new InterruptedException("模拟中断异常");
when(futureMock.get()).thenThrow(interruptedException);
// 4. 将模拟的 Future 对象添加到生产代码的 Future 列表中
// 这样在 collectAsyncResults() 中会处理到这个模拟对象
futureData.add(futureMock);
// 5. 在调用业务方法之前，验证 logError 尚未被调用
verify(mySpy, times(0)).logError(interruptedException);
// 6. 调用业务方法，该方法会遍历 Future 列表并调用 get()
exampleProductionCode.collectAsyncResults();
// 7. 验证 catch 块中的副作用：
// 预期会有 3 次 logError 调用：
// 1st: 来自 CompletableFuture.completeExceptionally() 导致的 ExecutionException (或 InterruptedException)
// 2nd: 来自 FutureTask 内部抛出的 InterruptedException
// 3rd: 来自我们模拟的 futureMock 抛出的 InterruptedException
verify(mySpy, times(3)).logError(any(Exception.class));
// 也可以更精确地验证特定异常实例：
// verify(mySpy).logError(interruptedException); // 验证模拟的异常被处理
}
}代码解释：
- @ExtendWith(MockitoExtension.class): 启用 Mockito JUnit 5 扩展，允许使用 @Mock 等注解。
- @Mock public Future<Class> futureMock;: 声明一个 Future 接口的 Mock 对象。
- MyService mySpy = spy(new MyService());: 创建 MyService 的一个真实实例，并对其进行 spy。spy 允许我们调用真实对象的方法，同时也能记录这些方法的调用情况，以便后续 verify。
- when(futureMock.get()).thenThrow(interruptedException);: 这是关键的模拟部分。它指示当 futureMock 对象的 get() 方法被调用时，直接抛出 interruptedException。
- futureData.add(futureMock);: 将我们模拟的 futureMock 添加到 ExampleProductionCode 内部处理的 Future 列表中，确保它会被遍历到。
- verify(mySpy, times(3)).logError(any(Exception.class));: 这是验证 catch 块被触发的核心。它检查 mySpy 对象的 logError 方法是否被调用了 3 次（因为示例中除了模拟的 futureMock，还有两个真实的 Future 实例也会抛出异常）。any(Exception.class) 是一个参数匹配器，表示只要传入的是任何 Exception 类型的参数即可。
四、注意事项与最佳实践
- 区分 InterruptedException 和 ExecutionException: Future.get() 方法签名中明确抛出这两种异常。在模拟时，根据需要选择抛出哪种异常。通常，业务逻辑错误会被包装在 ExecutionException 中，而线程中断则直接抛出 InterruptedException。
- CompletableFuture.completeExceptionally() 的模拟: 如果你的代码中使用 CompletableFuture，其内部异常处理通常是通过 completeExceptionally(Throwable ex) 方法完成的。在测试中，你可以模拟 CompletableFuture 内部抛出异常，或者直接模拟 Future.get() 抛出 ExecutionException。
- 测试的粒度与可读性: 尽量让每个测试方法关注一个特定的场景。例如，一个测试方法模拟 InterruptedException，另一个模拟 ExecutionException。
- 避免过度模拟: 只有当你需要控制外部依赖的行为（如 Future.get() 的结果或异常）时才使用 Mock。对于业务逻辑本身，应尽量保持其真实性。
- 明确 catch 块的职责: 确保你的 catch 块有明确的、可测试的副作用（如日志记录、状态更新、通知其他组件），这样才能有效地验证其执行。
五、总结
在 Java 中测试 Future 对象的异常处理逻辑，关键在于两点：一是使用 Mockito.when().thenThrow(exceptionInstance) 正确模拟 Future.get() 方法抛出异常；二是通过 Mockito.spy() 监视 catch 块内部执行的副作用，并使用 Mockito.verify() 验证这些副作用是否按预期发生。通过这种方法，我们可以有效地覆盖异步代码中的异常路径，确保其在面对错误时能够健壮地运行。
