Spring Boot中如何测试接口所有实现类是否已执行？

你的原代码存在语法错误，会导致Spring无法正常完成依赖注入，先修正为可运行的版本：

// 接口定义
public interface I {
    void doSomething();
}

// 实现类1：实现接口并添加@Component注解
@Component
public class I1 implements I {
    @Override
    public void doSomething() {
        // 具体业务实现
    }
}

// 实现类2：实现接口并添加@Component注解（原代码重复定义I2类，需删除重复项）
@Component
public class I2 implements I {
    @Override
    public void doSomething() {
        // 具体业务实现
    }
}

// Service类：推荐使用构造注入替代字段注入，更安全易测试
@Service
public class SomeService {
    private final List<I> rules;

    public SomeService(List<I> rules) {
        this.rules = rules;
    }

    public void someMethod() {
        rules.forEach(I::doSomething);
    }
}

针对你遇到的「开发者忘加@Component导致实现类未被注入」的问题，提供两种测试方案：

方案1：集成测试（真实模拟Spring容器注入） #

这种测试会加载完整的Spring上下文，能自动扫描所有实现类，确保没有遗漏的实现类未被注册，同时验证方法执行情况。

测试代码示例 #

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.reflections.Reflections;

import java.util.Set;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;

@SpringBootTest
class SomeServiceIntegrationTest {

    @Autowired
    private SomeService someService;

    @Autowired
    private ApplicationContext applicationContext;

    @Test
    void allIImplementationsAreInjectedAndExecuted() {
        // 1. 扫描项目中所有实现I接口的类（替换为你的接口所在包路径）
        Reflections reflections = new Reflections("com.yourpackage");
        Set<Class<? extends I>> allIImplementations = reflections.getSubTypesOf(I.class);

        // 2. 从Spring容器中获取所有已注册的I类型Bean
        I[] injectedBeans = applicationContext.getBeansOfType(I.class).values().toArray(new I[0]);

        // 3. 验证数量一致：确保所有实现类都被Spring注册
        assertEquals(allIImplementations.size(), injectedBeans.length, "存在未被Spring注册的I接口实现类");

        // 4. 为每个Bean创建Spy对象，跟踪方法调用
        for (I bean : injectedBeans) {
            I spyBean = spy(bean);
            int index = someService.rules.indexOf(bean);
            someService.rules.set(index, spyBean);
        }

        // 5. 调用目标方法
        someService.someMethod();

        // 6. 验证每个实现类的doSomething方法都被执行
        for (I bean : injectedBeans) {
            verify((I) spy(bean)).doSomething();
        }
    }
}

注意：需要添加reflections依赖用于类扫描（仅测试环境使用）：
Maven依赖：

<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.10.2</version>
    <scope>test</scope>
</dependency>

方案2：单元测试（手动注入实现类） #

这种测试不加载Spring上下文，执行速度更快，适合单独验证SomeService的逻辑，但需要手动维护所有实现类的实例。

测试代码示例 #

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.util.List;

import static org.mockito.Mockito.verify;

class SomeServiceUnitTest {

    @Test
    void allIImplementationsAreExecuted() {
        // 1. 创建所有I接口实现类的Mock实例
        I i1 = Mockito.mock(I1.class);
        I i2 = Mockito.mock(I2.class);
        // 新增实现类时，需手动添加对应的Mock实例

        // 2. 构造SomeService并注入所有实现类
        SomeService someService = new SomeService(List.of(i1, i2));

        // 3. 调用目标方法
        someService.someMethod();

        // 4. 验证每个实现类的doSomething方法都被执行
        verify(i1).doSomething();
        verify(i2).doSomething();
    }
}

• 集成测试：自动发现新增实现类，无需修改测试代码，能真实模拟生产环境，但测试速度较慢
• 单元测试：执行速度快，适合快速验证逻辑，但新增实现类时需手动更新测试代码

内容的提问来源于stack exchange，提问作者Makruzz