Spring源码系列（二）——@ComponentScan源码解析

置顶 KennorWooo

已于 2022-06-22 10:25:25 修改

阅读量1.4k

点赞数

分类专栏： spring源码文章标签： spring java 后端 ComponentScan解析

于 2021-12-24 15:22:10 首次发布

本文链接：https://blog.csdn.net/a1533588867/article/details/122128534

版权

spring源码专栏收录该内容

5 篇文章 3 订阅

订阅专栏

首先看一下本次用到的简单的示例代码
在这里插入图片描述

StudentA用@Component注解标识,Config用@ComponentScan标识，扫描的基础包路径为：com.kennor.test
在这里插入图片描述
最后Test运行的示例代码如下：

public static void main(String[] args) {
   AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Config.class);
   StudentA studentA = (StudentA) applicationContext.getBean("studentA");
   studentA.setName("Kennor");
   System.out.println(studentA.getName());
}

本篇我们先看一下AnnotationConfigApplicationContext是如何加载Config.class的
在这里插入图片描述
这里我们先看构造方法中的this()如何将ConfigurationClassPostProcessor注册到Spring容器中
这里我们要先记住ConfigurationClassPostProcessor是实现了BeanDefinitionRegistryPostProcessor接口。

接着我们继续看一下构造方法的具体流程
在这里插入图片描述

此外还添加了AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor

这里的AutowiredAnnotationBeanPostProcessor主要处理@Autowired和@Value注解，接下来的一篇文章中写到@Autowired解析的时候会再介绍。
而CommonAnnotationBeanPostProcessor主要处理@PostConstruct和@PreDestroy注解。
到这我们接着看registerPostProcessor方法的具体源码
在这里插入图片描述

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
      throws BeanDefinitionStoreException {
   ... ...
   BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
   if (existingDefinition != null) {
      ... ...
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   else {
      // 检查工厂的bean创建阶段是否已经开始
      // 由于我们目前处于ApplicationContext的构造方法阶段，所以不会通过检查，会走到else中
      if (hasBeanCreationStarted()) {
         // Cannot modify startup-time collection elements anymore (for stable iteration)
         synchronized (this.beanDefinitionMap) {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            removeManualSingletonName(beanName);
         }
      }
      else {
         // 将beanDefinition存放到beanDefinitionMap中，key为beanName
         this.beanDefinitionMap.put(beanName, beanDefinition);
         // 将beanName记录到beanDefinitionNames中
         this.beanDefinitionNames.add(beanName);
         removeManualSingletonName(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }
   ... ...
}

在这里插入图片描述
由上面的代码可以发现，ConfigurationClassPostProcessor被封装到BeanDefinition中，然后被保存到BeanFactory中的beanDefinitionMap中，这里的beanDefinitionMap将会保存spring所关联的类对应的BeanDefinition，例如后面扫描@Component注解的类也是一样，最后都会保存到beanDefinitionMap中
而ConfigurationClassPostProcessor接下来将会被获取出来调用到其扫描包路径下类的方法，这个我们下面会说明到。
接着我们看一下构造方法中的将Config.class注册到容器中的过程
在这里插入图片描述 Config.class最后会被封装到AnnotatedGenericBeanDefinition中，然后注册到容器中，
这里需要记住AnnotatedGenericBeanDefinition实现了AnnotatedBeanDefinition接口。

<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
      @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
   // 将Config.class封装到AnnotatedGenericBeanDefinition中
   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
   ... ...
   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

我们返回回去接着看一下AnnotationConfigApplicationContext构造方法中的refresh()方法

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      // 准备上下文，做一些初始化操作
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      // 主要创建BeanFactory对象和解析xml
      // 如果是使用xml配置的话会将xml里面的配置解析成BeanDefinition注册到容器中
      // 由于我们示例代码使用的是注解方式，因此此方法可以跳过
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      // 为beanFactory设置属性，例如ClassLoader、ApplicationListener等。
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         // 1.Spring提供的空方法，让开发者能够在BeanFactory准备工作完成后做一些定制化的处理，一般结合BeanPostProcessor接口的实现类一起使用
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         // 2.调用实现了BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口的类
         // 这里将会调用到AnnotationConfigApplicationContext构造方法中注册的AnnotationConfigApplicationContext类实现类的扫描
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         // 3.将实现了BeanPostProcessor接口的类实例化提交到BeanFactory类中的beanPostProcessors列表中。
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         // 初始化消息资源，用于设置国际化
         initMessageSource();

         // Initialize event multicaster for this context.
         // 初始化事件管理
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         // Spring提供的空方法，让开发者能够对一些特殊的Bean进行初始化
         // 在SpringBoot中使用此方法做内嵌Tomcat功能
         onRefresh();

         // Check for listener beans and register them.
         // 注册监听类
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         // 4.完成Bean的实例化和AOP的入口处理
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         // 完成刷新处理，清理缓存、发布刷新完成事件消息等。
         finishRefresh();
      }

        ... ...
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

1.首先我们可以看到注释第1点中的postProcessBeanFactory(beanFactory)方法，这是spring提供给外部去实现的钩子方法。
在这里插入图片描述
举个例子，我们可以通过此方法实现对StudentA的name属性设置我们想要的名称。

这样我们从spring容器获取到的StudentA打印出来的就是我们初始化的数据了。

具体何时调用到的我们自定义的BeanPostProcessor方法我们后续会说明。
2. 现在回到上面的refresh方法中，我们继续看注释第2点的方法invokeBeanFactoryPostProcessors(beanFactory);
这里方法将会调用实现了BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口的类的方法。
例如我们可以通过实现BeanDefinitionRegistryPostProcessor接口来对spring容器中的BeanDefinition进行修改，这里的BeanDefinition封装了类的所有信息，例如构造方法，属性，属性值等信息，后续我们会做介绍。
下面举个简单的例子。
在这里插入图片描述

打印如下：

这里我们需要重点关注一下AnnotationConfigApplicationContext构造方法中注册的ConfigurationClassPostProcessor类实现类的扫描的过程
具体源码如下：

invokeBeanFactoryPostProcessors方法的关键代码如下：

// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
// 记录当前已注册的BeanDefinitionRegistryPostProcessor类的列表
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 从BeanFacory中获取实现了PriorityOrdered和BeanDefinitionRegistryPostProcessor的类
String[] postProcessorNames =
      beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
   // 由于ConfigurationClassPostProcessor也实现了PriorityOrdered，所以通过if判断
   if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
      // 根据beanName获取对应的实体类并添加到列表中，getBean的具体流程后续我们会说明
      currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
      processedBeans.add(ppName);
   }
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 调用列表中的Processor的方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();

// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 获取实现Ordered和BeanDefinitionRegistryPostProcessor的类
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
   if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
      currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
      processedBeans.add(ppName);
   }
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();

// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
   reiterate = false;
   // 获取只实现了BeanDefinitionRegistryPostProcessor的类
   postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
   for (String ppName : postProcessorNames) {
      if (!processedBeans.contains(ppName)) {
         currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
         processedBeans.add(ppName);
         reiterate = true;
      }
   }
   sortPostProcessors(currentRegistryProcessors, beanFactory);
   registryProcessors.addAll(currentRegistryProcessors);
   invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
   currentRegistryProcessors.clear();
}

可以看到BeanDefinitionRegistryPostProcessor的实现类有执行的先后顺序，最后都调用invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry)方法
在这里插入图片描述
因此，我们需要到ConfigurationClassPostProcessor类中看一下postProcessBeanDefinitionRegistry的具体实现。

通过上面的代码可以看到Config.class类的信息封装类会被记录到configCandidates中，接着继续往下看

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
   ... ...
   ConfigurationClass existingClass = this.configurationClasses.get(configClass);
   ... ...
   // Recursively process the configuration class and its superclass hierarchy.
   // 获取SourceClass，此类主要获取configClass的注解信息
   SourceClass sourceClass = asSourceClass(configClass);
   do {
      // 根据获取到的注解信息进一步处理
      sourceClass = doProcessConfigurationClass(configClass, sourceClass);
   }
   while (sourceClass != null);
   this.configurationClasses.put(configClass, configClass);
}

上面的代码可以看到如果递归的方式去获取configClass类和其父类的注解信息，SourceClass类封装了configClass类上注解的详细信息，具体信息如下
在这里插入图片描述
接着我们继续看一下doProcessConfigurationClass(configClass, sourceClass)方法

@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
      throws IOException {
   // 处理类上的@Component注解
   if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
      // Recursively process any member (nested) classes first
      processMemberClasses(configClass, sourceClass);
   }
   // Process any @PropertySource annotations
   // 处理类上的@PropertySource注解
   for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), PropertySources.class,
         org.springframework.context.annotation.PropertySource.class)) {
      if (this.environment instanceof ConfigurableEnvironment) {
         processPropertySource(propertySource);
      }
   }
   // Process any @ComponentScan annotations
   // 处理类上的@ComponentScan注解
   Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
   if (!componentScans.isEmpty() &&
         !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
      for (AnnotationAttributes componentScan : componentScans) {
         // The config class is annotated with @ComponentScan -> perform the scan immediately
         // 扫描包路径下的类
         Set<BeanDefinitionHolder> scannedBeanDefinitions =
               this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
         // Check the set of scanned definitions for any further config classes and parse recursively if needed
         for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
            if (bdCand == null) {
               bdCand = holder.getBeanDefinition();
            }
            if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
               parse(bdCand.getBeanClassName(), holder.getBeanName());
            }
         }
      }
   }

   // Process any @Import annotations
   // 处理@Import注解
   processImports(configClass, sourceClass, getImports(sourceClass), true);

   // Process any @ImportResource annotations
   // 处理@ImportResource注解
   AnnotationAttributes importResource =
         AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
   if (importResource != null) {
      ... ...
   }

   // Process individual @Bean methods
   // 处理@Bean注解
   Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
   for (MethodMetadata methodMetadata : beanMethods) {
      configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
   }

   ... ...
   // No superclass -> processing is complete
   return null;
}

可以看到这里会对类上的多个注解进行处理，由于我们Config只使用到@ComponentScan注解，所以着重看一下这块的处理。

// 扫描包路径下的类
Set<BeanDefinitionHolder> scannedBeanDefinitions =
      this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
   ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
         componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

   Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
   boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
   scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
         BeanUtils.instantiateClass(generatorClass));

   ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
   if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
      scanner.setScopedProxyMode(scopedProxyMode);
   }
   else {
      Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
      scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
   }

   scanner.setResourcePattern(componentScan.getString("resourcePattern"));

   for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
      for (TypeFilter typeFilter : typeFiltersFor(filter)) {
         scanner.addIncludeFilter(typeFilter);
      }
   }
   for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
      for (TypeFilter typeFilter : typeFiltersFor(filter)) {
         scanner.addExcludeFilter(typeFilter);
      }
   }

   boolean lazyInit = componentScan.getBoolean("lazyInit");
   if (lazyInit) {
      scanner.getBeanDefinitionDefaults().setLazyInit(true);
   }

   Set<String> basePackages = new LinkedHashSet<>();
   // 获取配置的扫描包路径
   String[] basePackagesArray = componentScan.getStringArray("basePackages");
   for (String pkg : basePackagesArray) {
      String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      Collections.addAll(basePackages, tokenized);
   }
   for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
      basePackages.add(ClassUtils.getPackageName(clazz));
   }
   if (basePackages.isEmpty()) {
      basePackages.add(ClassUtils.getPackageName(declaringClass));
   }

   scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
      @Override
      protected boolean matchClassName(String className) {
         return declaringClass.equals(className);
      }
   });
   // 开始扫描
   return scanner.doScan(StringUtils.toStringArray(basePackages));
}

从上面的代码可以看到创建了一个ClassPathBeanDefinitionScanner扫描器去处理，将@ComponentScan注解上的信息设置到扫描器中，然后调用其doScan方法。
在这里插入图片描述

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
   // 记录扫描到的类
   Set<BeanDefinition> candidates = new LinkedHashSet<>();
   try {
      // 创建要扫描的classPath路径
      String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolveBasePackage(basePackage) + '/' + this.resourcePattern;
      // 获取class文件资源
      Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
      boolean traceEnabled = logger.isTraceEnabled();
      boolean debugEnabled = logger.isDebugEnabled();
      for (Resource resource : resources) {
         if (traceEnabled) {
            logger.trace("Scanning " + resource);
         }
         if (resource.isReadable()) {
            try {
               // 根据class文件获取MetadataReader，此类会封装class文件对应类的文件资源信息、类信息和类的注解信息
               MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
               // 判断此类的注解是不是我们要扫描的注解，即是否包含@Component
               if (isCandidateComponent(metadataReader)) {
                  // 封装到ScannedGenericBeanDefinition中
                  ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                  sbd.setSource(resource);
                  if (isCandidateComponent(sbd)) {
                     // 添加到candidates中
                     candidates.add(sbd);
                  }
                  ... ...
               }
               ... ...
   }
   ... ...
   return candidates;
}

sCandidateComponent的具体代码如下
在这里插入图片描述
其中两个过滤器中的数据如下

includeFilters的默认的过滤注解如下：

由于示例代码中在扫描的包路径下打印了两个包含@Component的类StudentA和StudentB，所以这两个类会通过校验被封装成BeanDefinition

这里ScannedGenericBeanDefinition的构造方法如下：

public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
   Assert.notNull(metadataReader, "MetadataReader must not be null");
   this.metadata = metadataReader.getAnnotationMetadata();
   setBeanClassName(this.metadata.getClassName());
   setResource(metadataReader.getResource());
}

现在扫描到BeanDefinition返回出去后，我们回到doScan方法中继续
在这里插入图片描述
最后我们会将扫描到的BeanDefinition注册到容器中，跟上面提到ConfigurationClassPostProcessor的BeanDefinition一样，被保存到BeanFactory中的beanDefinitionMap中。
这样，我们就完成了Config类上@ComponentScan注解的功能了。
3. 接着我们看回refresh()方法中注释第三点，通过registerBeanPostProcessors(beanFactory)我们可以把实现了BeanPostProcessor的类添加到BeanFacory中。
例如我们在注释1处使用的MyBeanPostProcessor，我们为其添加上@Component注解后，在这里registerBeanPostProcessors(beanFactory)会从beanFactory的容器中获取到之前扫描注册好的MyBeanPostProcessor，并添加到beanFactorybeanPostProcessors的列表中，然后在Bean实例化过程中会调用。
示例代码如下:
在这里插入图片描述

运行结果：

接着我们继续看回refresh方法，这里我们需要重点关注第4点注释的finishBeanFactoryInitialization(beanFactory)方法，此方法前面我们已经将包路径下的类信息都扫描封装到BeanFactory中了，所以在下一篇文章中我们将着重看一下spring是如何通过BeanFactory创建Bean的实例。

KennorWooo

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Spring源码系列（二）——@ComponentScan源码解析

首先看一下本次用到的简单的示例代码StudentA用@Component注解标识Config用@ComponentScan标识，扫描的基础包路径为：com.kennor.test最后Test运行的示例代码如下：public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Config
复制链接

扫一扫