本文深入探讨了在单元测试中，如何使用 Mockito 框架模拟 Future 对象的 get() 方法抛出 InterruptedException 或 ExecutionException，以有效覆盖代码中的异常处理逻辑。核心在于理解 thenThrow 的正确用法，以及通过 Mockito.spy() 监视在 catch 块内执行的副作用，从而验证异常路径的正确性。文章提供了详细的示例代码和最佳实践，帮助开发者编写健壮的异步代码测试。
一、理解 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 类型的 Mock 对象Future futureMock = mock(Future.class);// 模拟 futureMock.get() 抛出 InterruptedExceptionwhen(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.javapackage 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.javapackage de.playground.so74236327;import java.util.ArrayList;import java.util.List;import java.util.concurrent.*;public class ExampleProductionCode { private List<Future> 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> getFutureData() { return futureData; } // 模拟一个 CompletableFuture 异步任务，可能抛出异常 public Future createAndStartAsyncTask() { CompletableFuture 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 createAndStartFutureTask() { FutureTask 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.javapackage 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 类型的 Mock 对象 public Future 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> 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 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() 验证这些副作用是否按预期发生。通过这种方法，我们可以有效地覆盖异步代码中的异常路径，确保其在面对错误时能够健壮地运行。
以上就是模拟 Future 对象异常行为的测试策略与实践的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/136680.html
微信扫一扫 
支付宝扫一扫 
