如何优雅复用JUnit测试实现？寻求避免继承链冗余的方案

针对你遇到的单继承导致依赖冗余的问题，推荐用组合替代继承的思路，结合JUnit扩展能力或模块化配置，实现按需加载Mock逻辑，以下是几种可行方案：

方案1：独立Mock工具类+组合调用 #

把每个Provider对应的Mock逻辑拆成独立的工具类，放弃继承链，测试类按需实例化并调用需要的工具类。

实现步骤： #

1. 为每个Provider创建独立的数据加载与Mock配置类，比如ADataLoader、EDataLoader：

public class ADataLoader {
    // 从CSV加载对应Provider的数据
    private List<AEntity> loadData() {
        // 实现CSV读取、解析逻辑，比如用OpenCSV或原生IO
        return CSVUtils.parse("a_provider_data.csv", AEntity.class);
    }

    // 配置ProviderA的Mock行为
    public void configureMock(ProviderA providerA) {
        List<AEntity> data = loadData();
        Mockito.when(providerA.queryById(anyString()))
               .thenAnswer(invocation -> {
                   String id = invocation.getArgument(0);
                   return data.stream()
                              .filter(entity -> entity.getId().equals(id))
                              .findFirst()
                              .orElse(null);
               });
    }
}

2. 测试类中只初始化需要的工具类，在@BeforeEach中配置Mock：

public class MyTest2 {
    @Mock
    private ProviderA providerA;
    @Mock
    private ProviderE providerE;

    private final ADataLoader aLoader = new ADataLoader();
    private final EDataLoader eLoader = new EDataLoader();

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        // 仅配置需要的Mock
        aLoader.configureMock(providerA);
        eLoader.configureMock(providerE);
    }

    // 测试方法...
}

方案2：JUnit 5注解驱动扩展 #

用JUnit 5的扩展机制，自定义注解声明需要Mock的Provider，自动完成数据加载与Mock配置，进一步简化测试类代码。

实现步骤： #

1. 定义自定义注解和Provider枚举：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EnableMockProviders {
    ProviderType[] value();
}

enum ProviderType { A, B, C, D, E, F }

2. 编写JUnit扩展类，扫描注解并自动配置Mock：

public class ProviderMockExtension implements BeforeEachCallback {
    @Override
    public void beforeEach(ExtensionContext context) throws Exception {
        Class<?> testClass = context.getTestClass().orElseThrow();
        EnableMockProviders annotation = testClass.getAnnotation(EnableMockProviders.class);
        if (annotation == null) return;

        Object testInstance = context.getTestInstance().orElseThrow();
        MockitoAnnotations.openMocks(testInstance);

        // 根据注解配置的Provider类型，自动加载对应Loader并配置Mock
        for (ProviderType type : annotation.value()) {
            switch (type) {
                case A:
                    ProviderA providerA = getField(testInstance, "providerA");
                    new ADataLoader().configureMock(providerA);
                    break;
                case E:
                    ProviderE providerE = getField(testInstance, "providerE");
                    new EDataLoader().configureMock(providerE);
                    break;
                // 其他Provider类型依此类推
            }
        }
    }

    // 反射获取测试类中的Mock字段
    private <T> T getField(Object instance, String fieldName) throws IllegalAccessException {
        Field field = FieldUtils.getField(instance.getClass(), fieldName, true);
        field.setAccessible(true);
        return (T) field.get(instance);
    }
}

3. 测试类只需添加注解声明需要的Mock：

@ExtendWith(ProviderMockExtension.class)
@EnableMockProviders({ProviderType.A, ProviderType.E})
public class MyTest2 {
    @Mock
    private ProviderA providerA;
    @Mock
    private ProviderE providerE;

    // 无需手动配置Mock，扩展自动完成
    // 测试方法...
}

方案3：Spring环境下的模块化Mock配置（如果用Spring Boot） #

如果你的测试基于Spring Boot，可以用@MockBean结合模块化配置类，按需引入需要的Mock配置。

实现步骤： #

1. 为每个Provider创建独立的Mock配置类：

@Configuration
public class AMockConfig {
    @Bean
    public ProviderA providerA() {
        ProviderA mock = Mockito.mock(ProviderA.class);
        new ADataLoader().configureMock(mock);
        return mock;
    }
}

@Configuration
public class EMockConfig {
    @Bean
    public ProviderE providerE() {
        ProviderE mock = Mockito.mock(ProviderE.class);
        new EDataLoader().configureMock(mock);
        return mock;
    }
}

2. 测试类通过@Import引入需要的配置类：

@SpringBootTest
@Import({AMockConfig.class, EMockConfig.class})
public class MyTest2 {
    @Autowired
    private ProviderA providerA;
    @Autowired
    private ProviderE providerE;

    // 测试方法...
}

方案优势 #

• 彻底摆脱继承链的依赖冗余，测试类仅引入需要的Mock逻辑；
• 每个Mock工具类职责单一，便于维护和修改，不会因基类变更影响无关测试；
• 注解或配置驱动的方式大幅简化测试类代码，提升可读性。

内容的提问来源于stack exchange，提问作者Paul Marcelin Bejan