当前位置：首页 > 文章列表 > 文章 > java教程 > 单元测试中异常捕获适配器模式实现方法

单元测试中异常捕获适配器模式实现方法

2025-12-09 10:51:35 0浏览收藏

推广推荐

支持 PC / 移动端，安全直达

一分耕耘，一分收获！既然打开了这篇文章《单元测试异常捕获块中的适配器模式怎么写》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

如何正确单元测试异常捕获块中的适配器模式

本文旨在指导开发者如何有效地单元测试Java中包含异常捕获块（`catch`）和异常适配器（`ExceptionAdapter`）的代码。我们将深入探讨在模拟（mocking）异常适配器行为时常见的误区，特别是区分方法是抛出异常还是返回异常对象，并提供正确的测试策略和代码示例，确保异常处理逻辑得到充分覆盖和验证。

理解异常捕获与适配器模式

在现代软件开发中，为了更好地管理和转换不同类型的异常，我们经常会引入异常适配器模式。当底层服务抛出特定异常时，适配器负责将其转换为上层服务预期的异常类型。以下是一个典型的Java方法，其中包含一个try-catch块，并在catch块中使用了serviceExceptionAdapter来处理捕获到的异常：

public Method execute(@NonNull final String test) throws ServiceException {
    Object object;
    try {
        object = javaClient.fetchInfo(test);
    } catch (ClientException | InternalServerError e) {
        // 异常适配器将捕获到的异常转换为ServiceException并抛出
        throw serviceExceptionAdapter.apply(e);
    }
    return object;
}

在这个execute方法中，javaClient.fetchInfo(test)可能会抛出ClientException或InternalServerError。当这些异常被捕获时，serviceExceptionAdapter.apply(e)会被调用。根据方法签名，apply方法预期会接收一个异常对象e，并返回一个ServiceException的实例，然后这个返回的ServiceException会被execute方法抛出。

单元测试异常捕获块的挑战

单元测试上述catch块的关键在于，如何正确模拟javaClient抛出异常，并验证serviceExceptionAdapter被调用且其返回值被正确地抛出。一个常见的错误是在模拟serviceExceptionAdapter.apply()方法时，将其设置为抛出异常，而不是返回异常对象。

考虑以下初始的测试尝试：

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

class ProxyTest {

    private ExceptionAdapter serviceExceptionAdapter;
    private JavaClient mockJavaClient;
    private Proxy proxy;

    @BeforeEach
    void setup() {
        this.serviceExceptionAdapter = mock(ExceptionAdapter.class);
        this.mockJavaClient = mock(JavaClient.class);
        proxy = new Proxy(mockJavaClient, serviceExceptionAdapter);
    }

    @Test
    void test_InternalServerError_IncorrectMocking() {
        String testParam = "someTestValue";
        // 模拟javaClient抛出InternalServerError
        when(mockJavaClient.fetchInfo(any())).thenThrow(InternalServerError.class);

        // 错误：模拟serviceExceptionAdapter.apply(any())抛出ServiceException
        // 而不是返回ServiceException实例
        when(serviceExceptionAdapter.apply(any())).thenThrow(ServiceException.class);

        // 验证execute方法是否抛出ServiceException
        assertThrows(ServiceException.class, () -> proxy.execute(testParam));

        // 验证serviceExceptionAdapter.apply方法是否被调用一次
        verify(serviceExceptionAdapter, times(1)).apply(any());
    }
}

在test_InternalServerError_IncorrectMocking测试中，when(serviceExceptionAdapter.apply(any())).thenThrow(ServiceException.class);这一行存在问题。

分析错误与正确模拟策略

核心问题在于对serviceExceptionAdapter.apply(e)行为的误解。回顾原始代码：

throw serviceExceptionAdapter.apply(e);

这行代码明确表示，serviceExceptionAdapter.apply(e)方法会返回一个ServiceException实例，然后这个返回的实例才会被throw关键字抛出。

然而，在错误的测试中，when(serviceExceptionAdapter.apply(any())).thenThrow(ServiceException.class);指示Mockito，当调用serviceExceptionAdapter.apply()时，它应该直接抛出一个ServiceException，而不是返回一个。这与被测试代码的实际逻辑不符，可能导致测试覆盖率不完整，或者在更复杂的场景中出现意料之外的行为。

正确的模拟策略是让serviceExceptionAdapter.apply()方法返回一个ServiceException的实例，就像它在实际运行中那样。

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

// 假设 ServiceException 是一个自定义异常
class ServiceException extends RuntimeException {
    public ServiceException(String message) {
        super(message);
    }
    public ServiceException(Throwable cause) {
        super(cause);
    }
}

// 假设 ExceptionAdapter 接口定义
interface ExceptionAdapter {
    ServiceException apply(Throwable e);
}

// 假设 JavaClient 接口定义
interface JavaClient {
    Object fetchInfo(String test) throws ClientException, InternalServerError;
}

// 假设 ClientException 和 InternalServerError 是自定义异常
class ClientException extends RuntimeException {}
class InternalServerError extends RuntimeException {}

// 被测试的 Proxy 类
class Proxy {
    private final JavaClient javaClient;
    private final ExceptionAdapter serviceExceptionAdapter;

    public Proxy(JavaClient javaClient, ExceptionAdapter serviceExceptionAdapter) {
        this.javaClient = javaClient;
        this.serviceExceptionAdapter = serviceExceptionAdapter;
    }

    public Object execute(final String test) throws ServiceException {
        Object object;
        try {
            object = javaClient.fetchInfo(test);
        } catch (ClientException | InternalServerError e) {
            throw serviceExceptionAdapter.apply(e);
        }
        return object;
    }
}


class ProxyTest {

    private ExceptionAdapter serviceExceptionAdapter;
    private JavaClient mockJavaClient;
    private Proxy proxy;

    @BeforeEach
    void setup() {
        this.serviceExceptionAdapter = mock(ExceptionAdapter.class);
        this.mockJavaClient = mock(JavaClient.class);
        proxy = new Proxy(mockJavaClient, serviceExceptionAdapter);
    }

    @Test
    void test_InternalServerError_CorrectMocking() {
        String testParam = "someTestValue";
        InternalServerError caughtException = new InternalServerError();
        ServiceException expectedServiceException = new ServiceException("Adapted from InternalServerError", caughtException);

        // 1. 模拟javaClient.fetchInfo()抛出InternalServerError
        when(mockJavaClient.fetchInfo(any())).thenThrow(caughtException);

        // 2. 模拟serviceExceptionAdapter.apply()返回一个ServiceException实例
        // 注意：这里使用thenReturn()而不是thenThrow()
        when(serviceExceptionAdapter.apply(caughtException)).thenReturn(expectedServiceException);

        // 3. 验证proxy.execute()是否抛出正确的ServiceException
        ServiceException actualException = assertThrows(ServiceException.class, () -> proxy.execute(testParam));
        assertEquals(expectedServiceException, actualException); // 验证抛出的异常是预期的实例

        // 4. 验证serviceExceptionAdapter.apply()方法是否被调用一次，并传入了正确的异常
        verify(serviceExceptionAdapter, times(1)).apply(caughtException);

        // 5. 验证javaClient.fetchInfo()方法是否被调用一次
        verify(mockJavaClient, times(1)).fetchInfo(testParam);
    }

    @Test
    void test_ClientException_CorrectMocking() {
        String testParam = "anotherTestValue";
        ClientException caughtException = new ClientException();
        ServiceException expectedServiceException = new ServiceException("Adapted from ClientException", caughtException);

        when(mockJavaClient.fetchInfo(any())).thenThrow(caughtException);
        when(serviceExceptionAdapter.apply(caughtException)).thenReturn(expectedServiceException);

        ServiceException actualException = assertThrows(ServiceException.class, () -> proxy.execute(testParam));
        assertEquals(expectedServiceException, actualException);

        verify(serviceExceptionAdapter, times(1)).apply(caughtException);
        verify(mockJavaClient, times(1)).fetchInfo(testParam);
    }
}

在上述修正后的测试中，我们现在使用when(serviceExceptionAdapter.apply(caughtException)).thenReturn(expectedServiceException);。这确保了当serviceExceptionAdapter.apply()被调用时，它会返回一个我们预设的ServiceException实例，从而与被测试代码的逻辑完全匹配。assertThrows随后会捕获到这个由execute方法抛出的ServiceException，并且我们可以进一步使用assertEquals来验证捕获到的异常就是我们期望的那个实例。

注意事项与最佳实践

区分thenThrow()与thenReturn()： 这是解决此类问题的关键。如果被测试的方法是return someObject;，那么模拟时应使用thenReturn(someObject)；如果被测试的方法是throw someException;，那么模拟时应使用thenThrow(someException)。
理解SUT（System Under Test）行为： 在编写测试之前，务必清晰地理解被测试代码的每一行行为，特别是方法调用和异常流。
精确匹配参数： 在when(mockObject.method(argument)).thenReturn(...)中，如果可能，尽量使用具体的参数值而不是any()，这样可以更精确地验证方法调用。例如，在我们的例子中，我们模拟了serviceExceptionAdapter.apply(caughtException)，确保适配器接收到的是我们期望的原始异常。
验证交互： 使用verify()来确认被测方法是否按预期与它的依赖（如serviceExceptionAdapter和javaClient）进行了交互，包括调用次数和传入的参数。
测试所有异常路径： 如果catch块处理多种异常类型（如ClientException | InternalServerError），应为每种类型编写独立的测试用例，以确保所有路径都被覆盖。

总结

正确单元测试包含异常捕获和适配器模式的代码需要对模拟框架（如Mockito）有深入的理解，并准确把握被测试代码的执行逻辑。核心在于区分一个方法是“抛出”异常还是“返回”异常对象。通过使用thenReturn()来模拟异常适配器返回一个异常实例，我们可以确保测试准确反映代码的实际行为，从而提高测试的有效性和覆盖率。遵循这些最佳实践，将有助于构建更健壮、更可靠的应用程序。

本篇关于《单元测试中异常捕获适配器模式实现方法》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！