升级Mockito至5.x后泛型类型Mock无法注入的问题求助

场景说明 #

技术栈升级过程中：Java 11 升级至 17，同步升级Spring、Hibernate等框架，同时将测试依赖从Mockito 1.10迁移至5.8.0，发现依赖@InjectMocks注入泛型字段的单元测试失效。简化后的复现案例如下：

案例1：带泛型字段的类注入失败 #

@Nested
public class ClassWithGenericFieldsTest {
    public class UnderTestWithGenericField<T> {
        T toBeInjected;
    }
    public class ConcreteClass {}

    @Mock ConcreteClass injectedMock;

    @InjectMocks UnderTestWithGenericField<ConcreteClass> underTestWithGenericField = new UnderTestWithGenericField<ConcreteClass>();

    @Test
    void testWithGenericFields() {
        assertNotNull(injectedMock);
        // 验证泛型类型参数匹配是否正常
        assertEquals(injectedMock, underTestWithGenericField.toBeInjected);
    }
}

注：将toBeInjected改为List<T>可修复测试，但不符合实际代码结构。

案例2：父类带泛型字段的子类注入失败 #

@Nested
public class SuperClassWithGenericFieldsTest {
    public class SuperWithGenericField<T> {
        List<T> listToBeInjected;
        T instanceToBeInjected;
    }
    public class ChildClass extends SuperWithGenericField<ConcreteClass> {}
    public class ConcreteClass {}

    @Mock List<ConcreteClass> injectedList;
    @Mock ConcreteClass injectedInstance;

    @InjectMocks ChildClass underTestWithGenericField = new ChildClass();

    @Test
    void testWithGenericFields() {
        assertNotNull(injectedList);
        assertNotNull(injectedInstance);
        // 验证泛型类型参数匹配是否正常
        assertEquals(injectedList, underTestWithGenericField.listToBeInjected);
        assertEquals(injectedInstance, underTestWithGenericField.instanceToBeInjected);
    }
}

问题原因 #

Mockito 5.x对泛型类型的解析逻辑与1.10版本存在差异：

• 对于非容器类的直接泛型字段，默认注入机制无法正确识别泛型参数的实际类型，无法匹配对应的@Mock实例；
• 对于继承自父类的泛型字段，Mockito 5.x的默认类型解析无法穿透子类获取父类的泛型实际参数，导致注入失败。

解决方案 #

方案1：手动注入泛型字段（简单场景） #

放弃@InjectMocks的自动注入，在测试初始化阶段手动将Mock实例设置到目标对象的泛型字段中，适用于案例1这类简单场景：

@Nested
public class ClassWithGenericFieldsTest {
    public class UnderTestWithGenericField<T> {
        T toBeInjected;
    }
    public class ConcreteClass {}

    @Mock ConcreteClass injectedMock;
    UnderTestWithGenericField<ConcreteClass> underTestWithGenericField = new UnderTestWithGenericField<>();

    @BeforeEach
    void setUp() {
        underTestWithGenericField.toBeInjected = injectedMock;
    }

    @Test
    void testWithGenericFields() {
        assertNotNull(injectedMock);
        assertEquals(injectedMock, underTestWithGenericField.toBeInjected);
    }
}

方案2：自定义TypeInjector扩展（父类泛型场景） #

针对案例2中父类泛型字段的注入问题，通过自定义Mockito的TypeInjector扩展，手动解析泛型类型参数，实现精准注入：

1. 实现自定义TypeInjector

public class GenericTypeInjector implements TypeInjector {
    @Override
    public boolean canInject(Field field, Object target, List<Object> mocks) {
        // 判断是否为需要处理的泛型字段
        Type fieldType = field.getGenericType();
        return fieldType instanceof ParameterizedType 
                || target.getClass().getGenericSuperclass() instanceof ParameterizedType;
    }

    @Override
    public void inject(Field field, Object target, List<Object> mocks) throws IllegalAccessException {
        field.setAccessible(true);
        Class<?> actualType = resolveActualGenericType(field, target.getClass());
        // 匹配对应类型的Mock实例并注入
        for (Object mock : mocks) {
            if (actualType.isAssignableFrom(mock.getClass().getSuperclass())) {
                field.set(target, mock);
                break;
            }
        }
    }

    private Class<?> resolveActualGenericType(Field field, Class<?> targetClass) {
        // 处理字段自身的泛型参数（如List<T>）
        if (field.getGenericType() instanceof ParameterizedType paramType) {
            return (Class<?>) paramType.getActualTypeArguments()[0];
        }
        // 处理父类的泛型参数
        Type superType = targetClass.getGenericSuperclass();
        if (superType instanceof ParameterizedType paramSuperType) {
            return (Class<?>) paramSuperType.getActualTypeArguments()[0];
        }
        return field.getType();
    }
}

2. 在测试类中注册扩展

@ExtendWith(MockitoExtension.class)
@MockitoSettings(typeInjectors = {GenericTypeInjector.class})
public class SuperClassWithGenericFieldsTest {
    // 原有测试代码保持不变
    public class SuperWithGenericField<T> {
        List<T> listToBeInjected;
        T instanceToBeInjected;
    }
    public class ChildClass extends SuperWithGenericField<ConcreteClass> {}
    public class ConcreteClass {}

    @Mock List<ConcreteClass> injectedList;
    @Mock ConcreteClass injectedInstance;

    @InjectMocks ChildClass underTestWithGenericField = new ChildClass();

    @Test
    void testWithGenericFields() {
        assertNotNull(injectedList);
        assertNotNull(injectedInstance);
        assertEquals(injectedList, underTestWithGenericField.listToBeInjected);
        assertEquals(injectedInstance, underTestWithGenericField.instanceToBeInjected);
    }
}

方案3：临时降级至Mockito 4.x #

如果需要快速兼容原有测试代码，可临时降级至Mockito 4.x系列版本，其泛型注入逻辑更接近1.10版本，但不推荐长期使用，建议逐步适配Mockito 5.x的新特性。

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