Spring Boot中抽象类方法的JUnit单元测试策略：Spy与测试子类-java教程-PHP中文网

Spring Boot中抽象类方法的JUnit单元测试策略：Spy与测试子类

碧海醫心

发布： 2025-10-30 11:59:01

原创

614人浏览过

spring boot中抽象类方法的junit单元测试策略：spy与测试子类

本文探讨了在Spring Boot应用中，如何使用JUnit 5和Mockito有效单元测试抽象类中依赖抽象方法的具体实现。我们将通过一个CSV服务示例，详细介绍两种核心策略：利用Mockito的spy进行部分模拟，以及创建测试专用的子类来重写抽象方法，从而实现对文件读取等外部依赖的隔离和控制，确保测试的准确性和独立性。

在开发Spring Boot应用时，我们经常会遇到抽象类（Abstract Class）的设计模式，它允许我们定义一个通用骨架，并由具体的子类来实现其抽象方法。然而，当我们需要对抽象类中那些依赖于子类实现的具体方法进行单元测试时，可能会遇到挑战。本文将以一个处理CSV文件的服务为例，详细介绍两种有效的单元测试策略：使用Mockito的spy进行部分模拟，以及创建测试专用子类。

1. 问题场景：测试抽象类的具体方法

假设我们有一个抽象的CsvService，它提供了一个通用的readFromCsv方法来读取CSV文件。这个方法依赖于几个抽象方法，如getFileName()、getColumns()和getData()，这些方法由具体的子类实现。

// CsvBean 接口（标记接口或包含通用字段）
public interface CsvBean {}

// Airport类实现CsvBean
public class Airport implements CsvBean {
    private int id;
    private String code;

    public Airport() {}
    public Airport(int id, String code) {
        this.id = id;
        this.code = code;
    }
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getCode() { return code; }
    public void setCode(String code) { this.code = code; }
    // toString, equals, hashCode omitted for brevity
}

// 抽象的CsvService
public abstract class CsvService<T extends CsvBean> {

    // 假设存在一个日志记录器，实际代码中应注入或使用SLF4J
    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(CsvService.class);
    private static final String FILE_READ_ERROR = "Error reading CSV file";

    public List<T> readFromCsv(Class<T> type, CsvToBeanFilter filter) {
        List<T> data = new ArrayList<>();

        try {
            // 从类路径加载资源，依赖getFileName()
            Resource resource = new ClassPathResource("data/" + getFileName());
            Reader reader = new FileReader(resource.getFile());

            ColumnPositionMappingStrategy<T> strategy =
                new ColumnPositionMappingStrategy<>();
            strategy.setType(type);
            strategy.setColumnMapping(getColumns()); // 依赖getColumns()

            CsvToBean<T> csvToBean = new CsvToBeanBuilder<T>(reader)
                    .withMappingStrategy(strategy) // 添加映射策略
                    .withFilter(filter)
                    .build();

            data = getData(csvToBean); // 依赖getData()
            reader.close();

        } catch (IOException ex) {
            log.error(FILE_READ_ERROR, ex);
            ex.printStackTrace();
        }
        return data;
    }

    protected abstract String getFileName();
    protected abstract String[] getColumns();
    protected abstract List<T> getData(CsvToBean<T> csvToBean);
}

登录后复制

其具体实现类AirportService如下：

@Service
public class AirportService extends CsvService<Airport> {

    @Override
    protected String getFileName() {
        return "airports.csv"; // 实际的文件名
    }

    @Override
    protected String[] getColumns() {
        return new String[]{"id", "code"}; // CSV列名
    }

    @Override
    protected List<Airport> getData(CsvToBean<Airport> csvToBean) {
        List<Airport> airports = new ArrayList<>();
        for (Airport bean : csvToBean) {
            // 假设Airport构造函数可以直接接收解析后的bean
            Airport airport = new Airport(bean.getId(), bean.getCode());
            airports.add(airport);
        }
        return airports;
    }
}

登录后复制

我们的目标是单元测试CsvService中的readFromCsv()方法。这个方法内部会调用getFileName()来确定要读取的文件，并通过ClassPathResource尝试从类路径加载该文件。如果getFileName()返回的是真实文件名，测试就会尝试读取实际的文件，这违背了单元测试的隔离原则。我们需要一种方法来模拟getFileName()的行为，使其返回一个指向测试数据的路径，或者完全避免文件系统操作。

为了实现这一点，我们首先需要在src/test/resources/data/目录下创建一个模拟的CSV文件，例如mock_airport_data.csv，内容如下：

id,code
101,DK
102,US

登录后复制

2. 策略一：使用Mockito.spy进行部分模拟

Mockito的spy允许我们对一个真实对象进行“部分模拟”。这意味着对象的大部分行为仍是真实的，但我们可以选择性地模拟其某些方法。这对于测试抽象类的具体方法非常有用，因为我们可以创建一个具体子类的spy实例，然后模拟其抽象方法（或任何其他方法）的行为。

青柚面试

简单好用的日语面试辅助工具

查看详情

核心思路：

创建一个AirportService的spy实例。
使用Mockito.doReturn().when(spy).method()来模拟getFileName()和getColumns()方法，使其返回测试所需的值。这样，readFromCsv在执行时会使用我们模拟的文件名和列映射，而不是真实的文件。
让getData()方法调用真实的实现，因为它会处理由readFromCsv提供的CsvToBean实例，从而验证整个CSV解析流程。

示例代码：

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import com.opencsv.bean.CsvToBeanFilter; // 假设CsvToBeanFilter是OpenCSV库的接口
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class CsvServiceSpyTest {

    private AirportService serviceSpy; // 使用spy实例
    @Mock
    private CsvToBeanFilter filter; // 模拟CSV过滤器

    @BeforeEach
    void setup() {
        // 创建AirportService的spy实例
        serviceSpy = Mockito.spy(new AirportService());
    }

    @Test
    void testReadFromCsv_withSpy() {
        // 1. 模拟getFileName()，使其返回测试资源文件
        Mockito.doReturn("mock_airport_data.csv").when(serviceSpy).getFileName();
        // 2. 模拟getColumns()，提供测试所需的列名
        Mockito.doReturn(new String[]{"id", "code"}).when(serviceSpy).getColumns();

        // 3. 模拟过滤器行为，这里假设允许所有行
        when(filter.allowLine(any(String[].class))).thenReturn(true);

        // 调用待测试方法
        List<Airport> result = serviceSpy.readFromCsv(Airport.class, filter);

        // 断言结果
        assertNotNull(result);
        assertEquals(2, result.size());
        assertEquals(101, result.get(0).getId());
        assertEquals("DK", result.get(0).getCode());
        assertEquals(102, result.get(1).getId());
        assertEquals("US", result.get(1).getCode());

        // 验证抽象方法是否被调用
        Mockito.verify(serviceSpy).getFileName();
        Mockito.verify(serviceSpy).getColumns();
        // 验证getData是否被调用（它会处理由readFromCsv生成的CsvToBean）
        Mockito.verify(serviceSpy).getData(any());
    }
}

登录后复制

注意事项：