Mockito 源码分析（4）——Annotation

在本篇文章中，将主要对 Mockito 中 @Mock、@Spy、@InjectMocks 这三个主要注解进行源码分析。

我们知道，如果想要使用 Mockito，要么需要在测试类的 @Before，执行 org.mockito.MockitoAnnotations#initMocks，要么在测试类上添加 @RunWith(MockitoJUnitRunner.class) 注解。下面就让我们从 MockitoAnnotations#initMocks 方法看起吧。

MockitoAnnotations#initMocks

initMocks() 方法一共就两行代码：加载 AnnotationEngine，调用 process() 方法，传入的 testClass 为需要启用 Mockito 的测试类：

先来看下 AnnotationEngine 的获取逻辑：

• 当 GlobalConfiguration 实例化时，调用 createConfig() 方法，得到 IMockitoConfiguration 实现。只要没有进行额外配置，这里的实现是 DefaultMockitoConfiguration

• 调用 GlobalConfiguration#tryGetPluginAnnotationEngine 得到 AnnotationEngine。对于默认实现（DefaultMockitoConfiguration ）来说，直接从 Plugins 读取实现即可：

  org.mockito.internal.configuration.InjectingAnnotationEngine

  Plugins 的源码追踪过程就不赘述了，前文在分析 MockerMaker 时已经带大家走过一次了。

接下来让我们看 process 方法，功能也比较清晰：

• processIndependentAnnotations() 初始化 @Mock、@Spy 等注解标识的对象
• processInjectMocks() 尝试将 Mock 对象注入到 @InjectMocks 中

InjectingAnnotationEngine#processIndependentAnnotations

这个方法的功能是：

• 通过 IndependentAnnotationEngine#process 方法，初始化 @Mock 等注解标识的对象
• 通过 SpyAnnotationEngine#process 方法，初始化 @Spy 等注解标识的对象
• 向上查找当前类的父类，重复执行，直到当前类为 Object 为止

IndependentAnnotationEngine#process

• 获取当前 class 标注了注解的字段
• 调用 createMockFor() 方法
• 校验注解是否是有效的注解，比如 @Mock
• 如果是有效注解，Mockito 生成一个对象（即 proxy 代理类实例）
• alreadyAssigned 字段确保一个字段仅能标注一个有效注解
• 调用 setField() 方法，将生成的对象赋上去

① createMockFor() 方法实现如下：

• IndependentAnnotationEngine 仅支持 @Mock 和 @Captor 注解，每个注解有自己对应的处理器
• 如果是其他注解，返回一个用于容错的 FieldAnnotationProcessor 注解

下面以 @Mock 注解为例，它的处理器是 MockAnnotationProcessor，让我们看下它的 process() 实现：

• 通过 @Mock 的 Annotation 属性，初始化 MockSettings
• 然后调用 Mockito#mock()，至此完成对该字段的 mock

② setField() 方法实现如下，比较简单就不介绍了。

SpyAnnotationEngine#process

• 获取当前 class 标注了 @Spy 但没有同时标注 @InjectMocks 注解的字段

• 如果这些字段，同时标注了 @Mock 和 @Captor，则抛出异常

  由此可见，@Spy 和 @Mock、@Captor 是不能共存的

• 尝试直接获取字段的实例

  • 如果实例不为 null，且已经是 Mcok 对象了：这里调用了 Mockito.reset，注释解释了可能连续两次调用 initMocks 导致的
  • 如果实例不为 null，且还不是 Mcok 对象：调用 spyInstance() 方法，返回一个 Mock 对象，并赋到字段上
  • 如果实例为 null：调用 spyNewInstance()，框架帮忙初始化，返回一个 Mock 对象，并赋到字段上

对于 spyInstance() 方法，跟 Mockito#spy() 方法比较，几乎一模一样，就不再介绍了。

下面再看 spyNewInstance() 方法，主体的思想，也是想办法构造出一个实例出来，然后走 Mockito Spy 那一套：

看 spyNewInstance() 这一段代码时候，我其实有一些疑惑的：

（1）Mockito#spy() 也有一个根据 class 构建的 API 方法，这边为什么不能直接用那个呢，而要再写这么一大堆？

（2）前文在分析 Mock 那块代码时，看到对 proxy class 的实例化，使用的是 objenesis 框架，为什么这边不也用这个框架来做呢？

InjectingAnnotationEngine#processInjectMocks

这个方法的功能是：

• 执行 injectMocs() 方法，完成当前 class 的 @InjectMocks 注入
• 向上查找当前类的父类，重复执行，直到当前类为 Object 为止

重点看 injectMock() 方法：

① 这行代码的逻辑，找到当前类下所有标注了 @InjectMocks 注解的字段，并保存到 mockDependentFields 集合中。

② 这行代码逻辑，把当前类字段中，被 Mockito 管理的属性，都保存到 mocks 集合中。

③ 上面两行代码完成了数据准备，得到了：当前类及其父类中，所有要执行 InjectMock 的字段，所有已经准备好的 Mock 对象。

调用 DefaultInjectionEngine#injectMocksOnFields 真正开始注入：

可以看到采用责任链模式：

• injectionStrategies 字段的责任链：ConstructorInjection -> PropertyAndSetterInjection
• postInjectionStrategies字段的责任链：SpyOnInjectedFieldsHandler

FieldInitializer

在分析最后一个 apply() 方法前，先插队分析下 org.mockito.internal.util.reflection.FieldInitializer 这个类，会在下面的 apply() 方法中用到。

先看下这个类的成员变量：

• field：字段，这里其实就是指 @InjectMocks 标注的那个字段
• fieldOwner：指明了这个 field 属于哪个对象
• instantiator：当 field 字段默认没有初始化时实例，提供一个初始化策略：
  • ParameterizedConstructorInstantiator：通过有参构造的方式实例化，它就是 ConstructorInjection 的策略
  • NoArgConstructorInstantiator：通过无参构造 + 设置属性的方式实例化，它就是 PropertyAndSetterInjection 的策略

再看下 initialize() 方法，它返回一个 FieldInitializationReport 对象，这个对象中最关键的就是 fieldInstance 字段，它其实就是 @InjectMocks 标注的那个字段的实例。

通过调用 acquireFieldInstance() 方法来获取这个实例，而在这个方法中：

• 先直接获取字段对应的实例（基本为 null）
• 如果取不到，就得走 instantiator 的初始化策略了（这个到下面分析 OngoingMockInjection#apply 再来看）

OngoingMockInjection#apply

现在来分析 apply() 这个方法，这里的 field 就是单个 injectMocks 字段：

// org.mockito.internal.configuration.injection.MockInjection.OngoingMockInjection#apply
public void apply() {
    for (Field field : fields) {
        injectionStrategies.process(field, fieldOwner, mocks);
        postInjectionStrategies.process(field, fieldOwner, mocks);
    }
}

先看 injectionStrategies 负责的责任链：

（1）org.mockito.internal.configuration.injection.ConstructorInjection#process

如上图所示，它构造的 FieldInitializer 对象中的 instantiator 策略是 ParameterizedConstructorInstantiator，在这个策略中：

• 先对所有的构造方法排序，选出其中一个构造方法
• 从所有的 mock 对象中，筛出构造方法需要的参数
• 尝试通过这个构造方法创建实例
• 如果创建成功，则设置到 field 上；如果失败，则抛出异常，由上层捕获。

① 如何选取出一个构造方法呢？规则是：优先取参数数量少的，但至少也得有一个参数。如下图所所示：

② 从所有的 mock 对象中，筛出上一步构造方法中需要的对象。如下图所所示：

（2）org.mockito.internal.configuration.injection.PropertyAndSetterInjection

如果 ConstructorInjection 无法选出的话，就走到 PropertyAndSetterInjection 了，在这个方法中：

• 通过 NoArgConstructorInstantiator，调用无参构造，初始化对象，并赋值到字段上
• 如果获初始化失败，cannotInitializeForInjectMocksAnnotation() 抛出异常
• 从所有的 mock 对象中，尝试获取到一个匹配的

① NoArgConstructorInstantiator#instantiate 方法比较简单，单纯的通过无参构造创建实例。

② PropertyAndSetterInjection#injectMockCandidates方法主要功能是：

• orderedInstanceFieldsFrom() 确定需要被注入的所有字段

• injectMockCandidatesOnFields() 负责注入

  没太明白为什么要调用两次 injectMockCandidatesOnFields()，有懂的同学吗？

• mockCandidateFilter() 责任链模式实现了字段匹配的功能

这里重点看下如何匹配的那个责任链：

• TypeBasedCandidateFilter#TypeBasedCandidateFilter：匹配类型

  

• NameBasedCandidateFilter#filterCandidate：匹配参数名

  

• TerminalMockCandidateFilter#filterCandidate：先尝试走 set 方法赋值，不行的话走反射赋值。

  

Conclusion

通过上面的内容，为大家讲解了 @Mock、@Spy、@InjectMocks 注解是如何工作的。