你知道什么是 @Component 注解的派生性吗？

对于 ​​@Component​​​ 注解在日常的工作中相信很多小伙伴都会使用到，作为一种 ​​Spring​​​ 容器托管的通用模式组件，任何被 ​​@Component​​​ 注解标注的组件都会被 ​​Spring​​ 容器扫描。

那么有的小伙伴就要问了，很多时候我们并没有直接写 ​​@Component​​​ 注解呀，写的是类似于 ​​@Service​​​，​​@RestController​​​，​​@Configuration​​​ 等注解，不也是一样可以被扫描到吗？那这个 ​​@Component​​ 有什么特别的吗？

元注解

在回答上面的问题之前，我们先来了解一下什么叫元注解，所谓元注解就是指一个能声明在其他注解上的注解，换句话说就是如果一个注解被标注在其他注解上，那么它就是元注解。

要说明的是这个元注解并不是 ​​Spring​​​ 领域的东西， 而是 ​​Java​​​ 领域的，像 ​​Java​​​ 中的很多注解比如 ​​@Document​​​，​​@Repeatable​​​ ，​​@Target​​ 等都属于元注解。

根据上面的解释我们可以发现在 ​​Spring​​​ 容器里 ​​@Component​​ 

@Component 的派生性

通过上面的内容我们是不是可以猜测一下那就是 ​​@Component​​​ 注解的特性被"继承"下来了？这就可以解释为什么我们可以直接写​​@Service​​​，​​@RestController​​​ 注解也是可以被扫描到的。但是由于 ​​Java​​ 的注解是不支持继承的，比如你想通过下面的方式来实现注解的继承是不合法的。

为了验证我们的猜想，可以通过跟踪源代码来验证一下，我们的目的是研究为什么不直接使用 ​​@Component​​​ 注解也能被 ​​Spring​​​ 扫描到，换句话说就是使用 ​​@Service​​​ 和 ​​@RestController​​​ 的注解也能成为 ​​Spring Bean​​。

那我们很自然的就可以想到，在扫描的时候一定是根据注解来进行了判断是否要初始化成 ​​Spring Bean​​ 的。我们只要找到了判断条件就可以解决我们的疑惑了。

由于 ​​SpringBoot​​​ 项目是通过 ​​main​​​ 方法进行启动的，调试起来还是很方便的，阿粉这边准备了一个简单的 ​​SpringBoot​​​ 工程，里面除了启动类之外只有一个​​DemoController.java​​ 代码如下

package com.example.demojar.controller;

import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {
}

启动类如下

package com.example.demojar;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication(scanBasePackages = {"com.example.demojar"})
public class DemoJarApplication {

 public static void main(String[] args){
  SpringApplication.run(DemoJarApplication.class, args);
 }
}

​​Debug run​​​ 方法，我们可以定位到 ​​org.springframework.boot.SpringApplication#run(java.lang.String...) ​​​方法，该方法里面会初始化 ​​SpringBoot​​​ 上下文 ​​context​​。

context = createApplicationContext();

默认情况下会进到下面的方法，并创建 ​​AnnotationConfigServletWebServerApplicationContext​​​ 并且其构造函数中构造了 ​​ClassPathBeanDefinitionScanner​​ 类路径 Bean 扫描器。此处已经越来越接近扫描相关的内容了。

​​org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext.Factory#create​​

​​context​​​ 上下文创建完成过后，接下来我们我们会接入到 ​​org.springframework.context.support.AbstractApplicationContext#refresh​​​，再到 ​​org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors​​

​​org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry​​

​​org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions​​

经过上面的步骤，最终可以可以定位到扫描的代码在下面的方法 ​​org.springframework.context.annotation.ComponentScanAnnotationParser#parse​​​ 里面，调用前面上下文初始化的扫描器的 ​​org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan​​ 方法，

到这里我们已经定位到了扫描具体包路径的方法，这个方法里面主要看 ​​findCandidateComponents(basePackage);​​ 方法的内容，这个方法就是返回合法的候选组件。说明这个方法会最终返回需要被注册成 Spring Bean 的候选组件，那我们重点就要看这个方法的实现。

跟踪这个方法 ​​org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents​​​ 进去我们可以看到通过加进类路径里面的资源文件，然后再根据资源文件生成 ​​MetadataReader​​​ 对象，最后判断这个 ​​MetadataReader​​​ 对象是否满足候选组件的条件，如果满足就添加到 ​​Set​​ 集合中进行返回。

继续追踪源码我们可以找到具体的判断方法在 ​​org.springframework.core.type.filter.AnnotationTypeFilter#matchSelf​​​ 方法中，如下所示，可以看到这里对 ​​MetadataReader​​​ 对象进行了判断是否有元注解 ​​@Component​​​。在调试的时候我们会发现 ​​DemoController​​​ 在此处会返回 ​​true​​​，并且该 ​​MetadataReader​​​ 对象里面还有多个 ​​mappings​​​ ，其实这些 ​​mappings​​​ 对应的就是 ​​Spring​​ 的注解。

这个 ​​mappings​​​ 里面的注解确实包含了 ​​@Component​​​ 注解，因此会返回 ​​true​​​。那么接下来问题就转换成，我们的 ​​DemoController​​​ 对应的 ​​MetadataReader​​ 对象是如何创建的。

我们看回到​​org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents​​​ 方法，看看具体 MetadataReader 对象是如何创建的，​​MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);​​

通过构造方法 ​​org.springframework.core.type.classreading.SimpleMetadataReader#SimpleMetadataReader​​​ 进行 ​​MetadataReader​​​  对象的创建，​​org.springframework.core.type.classreading.SimpleAnnotationMetadataReadingVisitor#visitEnd​​​，最终定位到 ​​org.springframework.core.annotation.MergedAnnotationsCollection#MergedAnnotationsCollection​​​ 这里进行 ​​mappings​​ 赋值。

继续定位到 ​​org.springframework.core.annotation.AnnotationTypeMappings.Cache#createMappings​​​，​​org.springframework.core.annotation.AnnotationTypeMappings#addAllMappings​​​，​​addAllmappings​​​ 方法，内部使用了一个 ​​while​​​ 循环和 ​​Deque​​​ 来循环查询元注解进行赋值，代码如下所示，重点是这一行 ​​Annotation[] metaAnnotations = AnnotationsScanner.getDeclaredAnnotations(source.getAnnotationType(), false);​​

private void addAllMappings(Class<? extends Annotation> annotationType,
   Set<Class<? extends Annotation>> visitedAnnotationTypes){

  Deque<AnnotationTypeMapping> queue = new ArrayDeque<>();
  addIfPossible(queue, null, annotationType, null, visitedAnnotationTypes);
  while (!queue.isEmpty()) {
   AnnotationTypeMapping mapping = queue.removeFirst();
   this.mappings.add(mapping);
   addMetaAnnotationsToQueue(queue, mapping);
  }
 }

 private void addMetaAnnotationsToQueue(Deque<AnnotationTypeMapping> queue, AnnotationTypeMapping source){
  Annotation[] metaAnnotations = AnnotationsScanner.getDeclaredAnnotations(source.getAnnotationType(), false);
  for (Annotation metaAnnotation : metaAnnotations) {
   if (!isMappable(source, metaAnnotation)) {
    continue;
   }
   Annotation[] repeatedAnnotations = this.repeatableContainers.findRepeatedAnnotations(metaAnnotation);
   if (repeatedAnnotations != null) {
    for (Annotation repeatedAnnotation : repeatedAnnotations) {
     if (!isMappable(source, repeatedAnnotation)) {
      continue;
     }
     addIfPossible(queue, source, repeatedAnnotation);
    }
   }
   else {
    addIfPossible(queue, source, metaAnnotation);
   }
  }
 }

综上所述我们可以发现尽管我们没有直接写 ​​@Component​​​ 注解，只要我们加了类似于 ​​@Service​​​，​​@RestController​​​ 等注解也是可以成功被 ​​Spring​​​ 扫描到注册成 ​​Spring Bean​​​ 的，本质的原因是因为这些注解底层都使用了 ​​@Component​​​ 作为元注解，经过源码分析我们发现了只要有 ​​@Component​​ 元注解标注的注解类也是同样会被进行扫描的。

总结

上面的源码追踪过程可能会比较枯燥和繁琐，最后我们来简单总结一下上面的内容：

1. 方法​​org.springframework.boot.SpringApplication#run(java.lang.String...) ​​​中进行​​Spring​​ 上下文的创建；
2. 在初始化上下文的时候会创建扫描器​​ClassPathBeanDefinitionScanner​​；
3. 在​​org.springframework.context.support.AbstractApplicationContext#refresh​​​ 进行​​beanFactory​​ 准备；
4. ​​org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan​​ 进行资源扫描
5. 在​​org.springframework.core.annotation.MergedAnnotationsCollection#MergedAnnotationsCollection​​​ 进行注解​​mappings​​ 的赋值；
6. ​​org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents​​ 方法中进行候选组件的判断；

上面追踪的过程可能会比较复杂，但是只要我们理解了原理还是可以慢慢跟上的，因为我们只要把握好了方向，知道首先肯定会进行资源扫描，扫描完了肯定是根据注解之间的关系进行判断，最终得到我们需要的候选组件集合。至于如何创建 MetadataReader 和如何获取元注解，只要我们一步步看下去就是可以找到的。

最后说明一下，​​Spring Framework​​​ 每个版本的具体实现会有差异，阿粉使用的版本是 ​​5.3.24 ​​，所以如果小伙伴看到自己的代码追踪的效果跟阿粉的不一样也不会奇怪，可能是因为版本不一样而已，不过本质上都是一样的。

本文转载自公众号：java极客技术