（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()#invokeBeanFactoryPostProcessors

朴灿烈づ我的快乐病毒、 2023-05-30 09:25 4阅读 0赞

**AnnotationConfigApplicationContext容器初始化目录**  
[（Spring源码分析）AnnotationConfigApplicationContext容器初始化 this() && register()][Spring_AnnotationConfigApplicationContext_ this_ _ register]  
[（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()\#invokeBeanFactoryPostProcessors][Spring_AnnotationConfigApplicationContext_ refresh_invokeBeanFactoryPostProcessors]  
[（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()\#registerBeanPostProcessors][Spring_AnnotationConfigApplicationContext_ refresh_registerBeanPostProcessors]  
[（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()\#finishBeanFactoryInitialization][Spring_AnnotationConfigApplicationContext_ refresh_finishBeanFactoryInitialization]

### 目录 ###

*  3、refresh()
 *   *  3.1、invokeBeanFactoryPostProcessors(beanFactory)
     *   *  invokeBeanFactoryPostProcessors(beanFactory, beanFactoryPostProcessors)
         *  invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry)
         *  postProcessor.postProcessBeanDefinitionRegistry(registry)
         *  processConfigBeanDefinitions(registry)
         *  parser.parse(candidates)
         *  processConfigurationClass(new ConfigurationClass(metadata, beanName))
         *  doProcessConfigurationClass(configClass, sourceClass)
         *  this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName())
         *  scanner.doScan(StringUtils.toStringArray(basePackages))
         *  registerBeanDefinition(definitionHolder, this.registry)

# 3、refresh() #

> 在refresh()中，主要有12个方法，下面主要对`invokeBeanFactoryPostProcessors(beanFactory)`、`registerBeanPostProcessors(beanFactory)`、`finishBeanFactoryInitialization(beanFactory)`方法进行分析

@Override
    public void refresh() throws BeansException, IllegalStateException { 
      synchronized (this.startupShutdownMonitor) { 
        // 准备工作包括设置启动时间，是否激活标识位
        // 1.刷新预处理的前期准备
        prepareRefresh();
    
        // 2.获取内部的Bean工厂
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
        // 3.准备需要刷新后的工厂，为beanFactory属性设置初始值
        prepareBeanFactory(beanFactory);
    
        try { 
          // 4.这个方法在当前版本的Spring是没用，留着给扩展使用
          postProcessBeanFactory(beanFactory);
    
          // 5.在Spring的环境中去执行已经被注册的factory processors
          // 设置执行自定的ProcessBeanFactory和Spring内部自己定义的
          // 把类给扫描出来、处理@Import、@ImportSource导入资源文件，处理MapperScan
          // scan -- put beanDefinitionMap
          invokeBeanFactoryPostProcessors(beanFactory);
    
          // 6.注册beanPostProcessor
          registerBeanPostProcessors(beanFactory);
    
          // 7.初始化MessageSource
          initMessageSource();
    
          // 8.初始化应用实践广播器
          initApplicationEventMulticaster();
    
          // 9.这个方法在当前版本的Spring是没用，留着给扩展使用
          onRefresh();
    
          // 10.Check for listener beans and register them.
          registerListeners();
    
          // 11.new对象，单例，将beanFactory中的beanDefinitionMap中的bean进行初始化，然后放到单例池singletonObjects中
          finishBeanFactoryInitialization(beanFactory);
    
          // 12.Last step: publish corresponding event.
          finishRefresh();
        }
    
        catch (BeansException ex) { 
          if (logger.isWarnEnabled()) { 
            logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
          }
    
          // Destroy already created singletons to avoid dangling resources.
          destroyBeans();
    
          // Reset 'active' flag.
          cancelRefresh(ex);
    
          // Propagate exception to caller.
          throw ex;
        }
    
        finally { 
          // Reset common introspection caches in Spring's core, since we
          // might not ever need metadata for singleton beans anymore...
          resetCommonCaches();
        }
      }
    }

## 3.1、invokeBeanFactoryPostProcessors(beanFactory) ##

**invokeBeanFactoryPostProcessors(beanFactory)主要是作用如下：**

> 在Spring的环境中去执行已经被注册的BeanFactoryPostProcessors  
> 设置执行Spring内部自己定义的BeanFactoryPostProcessors  
> 将配置类中的bean扫描出来，添加到BeanDefinitionMap中  
> 处理@Import、@ImportSource导入资源文件

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { 
      PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
      // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
      // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
      if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { 
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
      }
    }

### invokeBeanFactoryPostProcessors(beanFactory, beanFactoryPostProcessors) ###

public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { 
    
      // Invoke BeanDefinitionRegistryPostProcessors first, if any.
      Set<String> processedBeans = new HashSet<>();
    
      if (beanFactory instanceof BeanDefinitionRegistry) { 
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>(); // 用来存放实现BeanFactoryPostProcessor接口的类
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>(); // 用来存放实现BeanDefinitionRegistryPostProcessor接口的类
    
        // 遍历beanFactoryPostProcessors，如果是实现BeanDefinitionRegistryPostProcessor的，直接执行实现类中实现的postProcessBeanDefinitionRegistry方法
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { 
          if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { 
            BeanDefinitionRegistryPostProcessor registryProcessor =
              (BeanDefinitionRegistryPostProcessor) postProcessor;
            registryProcessor.postProcessBeanDefinitionRegistry(registry);
            registryProcessors.add(registryProcessor);
          }
          else { 
            regularPostProcessors.add(postProcessor);
          }
        }
    
        // 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.
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>(); // 用来存放beanDefinitionMap中继承了BeanDefinitionRegistryPostProcessor接口的bean
    
        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        // 查找beanDefinitionMap中继承了BeanDefinitionRegistryPostProcessor接口的bean
        String[] postProcessorNames =
          beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) { 
          if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            processedBeans.add(ppName);
          }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors); // 将beanDefinitionMap中继承了BeanDefinitionRegistryPostProcessor接口的bean添加到registryProcessors以便后面执行postProcessBeanFactory方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();
    
        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        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;
          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();
        }
    
        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        // 执行实现了BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口实现的postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
      }
    
      else { 
        // Invoke factory processors registered with the context instance.
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
      }
    
      // Do not initialize FactoryBeans here: We need to leave all regular beans
      // uninitialized to let the bean factory post-processors apply to them!
      String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
      // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
      // Ordered, and the rest.
      List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
      List<String> orderedPostProcessorNames = new ArrayList<>();
      List<String> nonOrderedPostProcessorNames = new ArrayList<>();
      for (String ppName : postProcessorNames) { 
        if (processedBeans.contains(ppName)) { 
          // skip - already processed in first phase above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
          priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { 
          orderedPostProcessorNames.add(ppName);
        }
        else { 
          nonOrderedPostProcessorNames.add(ppName);
        }
      }
    
      // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
      sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
      invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
      // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
      List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
      for (String postProcessorName : orderedPostProcessorNames) { 
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
      }
      sortPostProcessors(orderedPostProcessors, beanFactory);
      invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
      // Finally, invoke all other BeanFactoryPostProcessors.
      List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
      for (String postProcessorName : nonOrderedPostProcessorNames) { 
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
      }
      invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    
      // Clear cached merged bean definitions since the post-processors might have
      // modified the original metadata, e.g. replacing placeholders in values...
      beanFactory.clearMetadataCache();
    }

### invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry) ###

private static void invokeBeanDefinitionRegistryPostProcessors(
      Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) { 
      // 执行postProcessors中实现了BeanFactoryPostProcessor接口中的postProcessBeanDefinitionRegistry方法
      for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) { 
        postProcessor.postProcessBeanDefinitionRegistry(registry);
      }
    }

### postProcessor.postProcessBeanDefinitionRegistry(registry) ###

@Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { 
      int registryId = System.identityHashCode(registry); // 获取registryId
      if (this.registriesPostProcessed.contains(registryId)) { 
        throw new IllegalStateException(
          "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
      }
      if (this.factoriesPostProcessed.contains(registryId)) { 
        throw new IllegalStateException(
          "postProcessBeanFactory already called on this post-processor against " + registry);
      }
      this.registriesPostProcessed.add(registryId);
    
      processConfigBeanDefinitions(registry);
    }

### processConfigBeanDefinitions(registry) ###

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { 
      List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
      String[] candidateNames = registry.getBeanDefinitionNames(); // 取出beanDefinition的className数组
    
      // 遍历beanDefinition的className数组
      for (String beanName : candidateNames) { 
        BeanDefinition beanDef = registry.getBeanDefinition(beanName); // 取出BeanDefinition
        if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
            ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) { 
          if (logger.isDebugEnabled()) { 
            logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
          }
        }
        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {  // 检查该BeanDefinition对象是否被@Configuration注解标识
          configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
      }
    
      // Return immediately if no @Configuration classes were found
      if (configCandidates.isEmpty()) { 
        return;
      }
    
      // Sort by previously determined @Order value, if applicable
      configCandidates.sort((bd1, bd2) -> { 
        int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
        int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
        return Integer.compare(i1, i2);
      });
    
      // Detect any custom bean name generation strategy supplied through the enclosing application context
      SingletonBeanRegistry sbr = null;
      if (registry instanceof SingletonBeanRegistry) { 
        sbr = (SingletonBeanRegistry) registry;
        if (!this.localBeanNameGeneratorSet) { 
          BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
          if (generator != null) { 
            this.componentScanBeanNameGenerator = generator;
            this.importBeanNameGenerator = generator;
          }
        }
      }
    
      if (this.environment == null) { 
        this.environment = new StandardEnvironment();
      }
    
      // Parse each @Configuration class
      ConfigurationClassParser parser = new ConfigurationClassParser(
        this.metadataReaderFactory, this.problemReporter, this.environment,
        this.resourceLoader, this.componentScanBeanNameGenerator, registry); // 创建Configuration配置解析器
    
      Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
      Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
      do { 
        parser.parse(candidates); // 解析带有@Configuration标识的配置bean
        parser.validate();
    
        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed);
    
        // Read the model and create bean definitions based on its content
        if (this.reader == null) { 
          this.reader = new ConfigurationClassBeanDefinitionReader(
            registry, this.sourceExtractor, this.resourceLoader, this.environment,
            this.importBeanNameGenerator, parser.getImportRegistry());
        }
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses);
    
        candidates.clear();
        if (registry.getBeanDefinitionCount() > candidateNames.length) { 
          String[] newCandidateNames = registry.getBeanDefinitionNames();
          Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
          Set<String> alreadyParsedClasses = new HashSet<>();
          for (ConfigurationClass configurationClass : alreadyParsed) { 
            alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
          }
          for (String candidateName : newCandidateNames) { 
            if (!oldCandidateNames.contains(candidateName)) { 
              BeanDefinition bd = registry.getBeanDefinition(candidateName);
              if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                  !alreadyParsedClasses.contains(bd.getBeanClassName())) { 
                candidates.add(new BeanDefinitionHolder(bd, candidateName));
              }
            }
          }
          candidateNames = newCandidateNames;
        }
      }
      while (!candidates.isEmpty());
    
      // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
      if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) { 
        sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
      }
    
      if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) { 
        // Clear cache in externally provided MetadataReaderFactory; this is a no-op
        // for a shared cache since it'll be cleared by the ApplicationContext.
        ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
      }
    }

### parser.parse(candidates) ###

public void parse(Set<BeanDefinitionHolder> configCandidates) { 
      this.deferredImportSelectors = new LinkedList<>();
    
      for (BeanDefinitionHolder holder : configCandidates) { 
        BeanDefinition bd = holder.getBeanDefinition();
        try { 
          if (bd instanceof AnnotatedBeanDefinition) {  // 该BeanDefinition的实现类是AnnotatedBeanDefinition
            parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName()); // getMetadata()是获取该AnnotatedBeanDefinition对象中的所有的注解
          }
          else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) { 
            parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
          }
          else { 
            parse(bd.getBeanClassName(), holder.getBeanName());
          }
        }
        catch (BeanDefinitionStoreException ex) { 
          throw ex;
        }
        catch (Throwable ex) { 
          throw new BeanDefinitionStoreException(
            "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
        }
      }
    
      processDeferredImportSelectors();
    }

### processConfigurationClass(new ConfigurationClass(metadata, beanName)) ###

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException { 
      if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) { 
        return;
      }
    
      ConfigurationClass existingClass = this.configurationClasses.get(configClass);
      if (existingClass != null) { 
        if (configClass.isImported()) { 
          if (existingClass.isImported()) { 
            existingClass.mergeImportedBy(configClass);
          }
          // Otherwise ignore new imported config class; existing non-imported class overrides it.
          return;
        }
        else { 
          // Explicit bean definition found, probably replacing an import.
          // Let's remove the old one and go with the new one.
          this.configurationClasses.remove(configClass);
          this.knownSuperclasses.values().removeIf(configClass::equals);
        }
      }
    
      // Recursively process the configuration class and its superclass hierarchy.
      // 递归处理配置类和它的父类
      SourceClass sourceClass = asSourceClass(configClass);
      do { 
        sourceClass = doProcessConfigurationClass(configClass, sourceClass);
      }
      while (sourceClass != null);
    
      this.configurationClasses.put(configClass, configClass);
    }

### doProcessConfigurationClass(configClass, sourceClass) ###

@Nullable
    protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
      throws IOException { 
    
      // Recursively process any member (nested) classes first
      processMemberClasses(configClass, sourceClass);
    
      // Process any @PropertySource annotations
      // 判断sourceClass的注解中是否有@PropertySource注解
      for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), PropertySources.class,
        org.springframework.context.annotation.PropertySource.class)) { 
        if (this.environment instanceof ConfigurableEnvironment) { 
          processPropertySource(propertySource);
        }
        else { 
          logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                      "]. Reason: Environment must implement ConfigurableEnvironment");
        }
      }
    
      // Process any @ComponentScan annotations
      // 判断sourceClass的注解中是否有@ComponentScan注解
      Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
      if (!componentScans.isEmpty() &&
          !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {  // @ComponentScan注解可以在同一个配置类中使用多次
        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()); // 使用ComponentScanAnnotationParser解析器去扫描并注册该bean
          // 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
      processImports(configClass, sourceClass, getImports(sourceClass), true);
    
      // Process any @ImportResource annotations
      AnnotationAttributes importResource =
        AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
      if (importResource != null) { 
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) { 
          String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
          configClass.addImportedResource(resolvedResource, readerClass);
        }
      }
    
      // Process individual @Bean methods
      Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
      for (MethodMetadata methodMetadata : beanMethods) { 
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
      }
    
      // Process default methods on interfaces
      processInterfaces(configClass, sourceClass);
    
      // Process superclass, if any
      if (sourceClass.getMetadata().hasSuperClass()) { 
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (superclass != null && !superclass.startsWith("java") &&
            !this.knownSuperclasses.containsKey(superclass)) { 
          this.knownSuperclasses.put(superclass, configClass);
          // Superclass found, return its annotation metadata and recurse
          return sourceClass.getSuperClass();
        }
      }
    
      // No superclass -> processing is complete
      return null;
    }

### this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName()) ###

/** * 得到basePackages */
    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)); // 扫描指定路径下的bean
    }

### scanner.doScan(StringUtils.toStringArray(basePackages)) ###

protected Set<BeanDefinitionHolder> doScan(String... basePackages) { 
      Assert.notEmpty(basePackages, "At least one base package must be specified");
      Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
    
      // 循环basePackage
      for (String basePackage : basePackages) { 
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage); // 扫描basePackage路径下所有的bean，返回BeanDefinition对象Set集合
        for (BeanDefinition candidate : candidates) { 
          ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
          candidate.setScope(scopeMetadata.getScopeName());
          String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
          if (candidate instanceof AbstractBeanDefinition) { 
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
          }
          if (candidate instanceof AnnotatedBeanDefinition) { 
            AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
          }
          if (checkCandidate(beanName, candidate)) { 
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            definitionHolder =
              AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            beanDefinitions.add(definitionHolder);
            registerBeanDefinition(definitionHolder, this.registry); // 注册bean到beanDefinitionMap中
          }
        }
      }
      return beanDefinitions;
    }

### registerBeanDefinition(definitionHolder, this.registry) ###

> 看到`BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry)`这个方法调用，其实就是在上一节已经讲过了，就是将bean注册到`BeanDefinitionMap`中

protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) { 
      BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    }

[Spring_AnnotationConfigApplicationContext_ this_ _ register]: https://blog.csdn.net/qq_35620501/article/details/102986216
[Spring_AnnotationConfigApplicationContext_ refresh_invokeBeanFactoryPostProcessors]: https://blog.csdn.net/qq_35620501/article/details/102986266
[Spring_AnnotationConfigApplicationContext_ refresh_registerBeanPostProcessors]: https://blog.csdn.net/qq_35620501/article/details/102986421
[Spring_AnnotationConfigApplicationContext_ refresh_finishBeanFactoryInitialization]: https://blog.csdn.net/qq_35620501/article/details/102986848