关于后端:你知道什么是-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 ，所以如果小伙伴看到本人的代码追踪的成果跟阿粉的不一样也不会奇怪，可能是因为版本不一样而已，不过实质上都是一样的。

本文由 mdnice 多平台公布