原创-spring源码-@Configuration和@ComponentScan解析原理

spring容器启动的核心refresh方法我相信大家都不陌生，其中invokeBeanFactoryPostProcessors方法是处理beanFactory的一个非常重要的方法，@Component @Bean等等都是在该方法里实现解析的。

@Configuration
@ComponentScan("org.springframework.context.annotation")
public class MyComponentScan {
    @ComponentScan("org.springframework.context.annotation")
    @Configuration
    class InnerClass{
    }
}

下面以MyComponentScan 为例debug进入invokeBeanFactoryPostProcessors方法。

@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.
      // 创建容器对象：DefaultListableBeanFactory
      // 加载xml配置文件的属性值到当前工厂中，最重要的就是BeanDefinition
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      // beanFactory的准备工作，对各种属性进行填充
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         // 子类覆盖方法做额外的处理，此处我们自己一般不做任何扩展工作，但是可以查看web中的代码，是有具体实现的
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         // 调用各种beanFactory处理器
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         // 注册bean处理器，这里只是注册功能，真正调用的是getBean方法
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         // 为上下文初始化message源，即不同语言的消息体，国际化处理,在springmvc的时候通过国际化的代码重点讲
         initMessageSource();

         // Initialize event multicaster for this context.
         // 初始化事件监听多路广播器
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         // 留给子类来初始化其他的bean
         onRefresh();

         // Check for listener beans and register them.
         // 在所有注册的bean中查找listener bean,注册到消息广播器中
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         // 初始化剩下的单实例（非懒加载的）
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         // 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
         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.
         // 为防止bean资源占用，在异常处理中，销毁已经在前面过程中生成的单件bean
         destroyBeans();

         // Reset 'active' flag.
         // 重置active标志
         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();
      }
   }
}

这个方法里面就不得不提到一个接口-BeanFactoryPostProcessor，BeanFactoryPostProcessor作为一个后置处理器，主要用来处理BeanFactory的一些信息，但是如果只有BeanFactoryPostProcessor的话，就需要在BeanFactoryPostProcessor的方法里定义对各种对象的相关操作，而BeanDefinition（还没实例化之前，配置文件定义的对象加载到spring容器中的一种表现形式）是比较核心比较关键的点，所以把这个东西抽象一层，做了一个子类BeanDefinitionRegistryPostProcessor专门对BeanDefinition进行增删改查操作。我们这里解析这些注解，就要用到BeanDefinitionRegistryPostProcessor类的实现类ConfigurationClassPostProcessor类了。如下代码所示，在遍历循环众多的BeanFactoryPostProcessor中，我们重点看第64行的处理环节

public static void invokeBeanFactoryPostProcessors(
            ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

        // Invoke BeanDefinitionRegistryPostProcessors first, if any.
        // 无论是什么情况，优先执行BeanDefinitionRegistryPostProcessors
        // 将已经执行过的BFPP存储在processedBeans中，防止重复执行
        Set<String> processedBeans = new HashSet<>();

        // 判断beanfactory是否是BeanDefinitionRegistry类型，此处是DefaultListableBeanFactory,实现了BeanDefinitionRegistry接口，所以为true
        if (beanFactory instanceof BeanDefinitionRegistry) {
            // 类型转换
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            // 此处希望大家做一个区分，两个接口是不同的，BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子集
            // BeanFactoryPostProcessor主要针对的操作对象是BeanFactory，而BeanDefinitionRegistryPostProcessor主要针对的操作对象是BeanDefinition
            // 存放BeanFactoryPostProcessor的集合
            List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
            // 存放BeanDefinitionRegistryPostProcessor的集合
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

            // 首先处理入参中的beanFactoryPostProcessors,遍历所有的beanFactoryPostProcessors，将BeanDefinitionRegistryPostProcessor
            // 和BeanFactoryPostProcessor区分开
            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                // 如果是BeanDefinitionRegistryPostProcessor
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor =
                            (BeanDefinitionRegistryPostProcessor) postProcessor;
                    // 直接执行BeanDefinitionRegistryPostProcessor接口中的postProcessBeanDefinitionRegistry方法
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    // 添加到registryProcessors，用于后续执行postProcessBeanFactory方法
                    registryProcessors.add(registryProcessor);
                } else {
                    // 否则，只是普通的BeanFactoryPostProcessor，添加到regularPostProcessors，用于后续执行postProcessBeanFactory方法
                    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.
            // 用于保存本次要执行的BeanDefinitionRegistryPostProcessor
            List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

            // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
            // 调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
            // 找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName
            String[] postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            // 遍历处理所有符合规则的postProcessorNames
            for (String ppName : postProcessorNames) {
                // 检测是否实现了PriorityOrdered接口
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    // 获取名字对应的bean实例，添加到currentRegistryProcessors中
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
                    processedBeans.add(ppName);
                }
            }
            // 按照优先级进行排序操作
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
            registryProcessors.addAll(currentRegistryProcessors);
            // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 执行完毕之后，清空currentRegistryProcessors
            currentRegistryProcessors.clear();

            // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
            // 调用所有实现Ordered接口的BeanDefinitionRegistryPostProcessor实现类
            // 找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName，
            // 此处需要重复查找的原因在于上面的执行过程中可能会新增其他的BeanDefinitionRegistryPostProcessor
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                // 检测是否实现了Ordered接口，并且还未执行过
                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    // 获取名字对应的bean实例，添加到currentRegistryProcessors中
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
                    processedBeans.add(ppName);
                }
            }
            // 按照优先级进行排序操作
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
            registryProcessors.addAll(currentRegistryProcessors);
            // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 执行完毕之后，清空currentRegistryProcessors
            currentRegistryProcessors.clear();

            // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
            // 最后，调用所有剩下的BeanDefinitionRegistryPostProcessors
            boolean reiterate = true;
            while (reiterate) {
                reiterate = false;
                // 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                // 遍历执行
                for (String ppName : postProcessorNames) {
                    // 跳过已经执行过的BeanDefinitionRegistryPostProcessor
                    if (!processedBeans.contains(ppName)) {
                        // 获取名字对应的bean实例，添加到currentRegistryProcessors中
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
                        processedBeans.add(ppName);
                        reiterate = true;
                    }
                }
                // 按照优先级进行排序操作
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
                registryProcessors.addAll(currentRegistryProcessors);
                // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                // 执行完毕之后，清空currentRegistryProcessors
                currentRegistryProcessors.clear();
            }

            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
            // 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            // 最后，调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        } else {
            // Invoke factory processors registered with the context instance.
            // 如果beanFactory不归属于BeanDefinitionRegistry类型，那么直接执行postProcessBeanFactory方法
            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
        }

        // 到这里为止，入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕，下面开始处理容器中
        // 所有的BeanFactoryPostProcessor
        // 可能会包含一些实现类，只实现了BeanFactoryPostProcessor，并没有实现BeanDefinitionRegistryPostProcessor接口

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // 找到所有实现BeanFactoryPostProcessor接口的类
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        // 用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        // 用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
//    List<String> orderedPostProcessorNames = new ArrayList<>();
        List<BeanFactoryPostProcessor> orderedPostProcessor = new ArrayList<>();
        // 用于存放普通BeanFactoryPostProcessor的beanName
//    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        List<BeanFactoryPostProcessor> nonOrderedPostProcessorNames = new ArrayList<>();
        // 遍历postProcessorNames,将BeanFactoryPostProcessor按实现PriorityOrdered、实现Ordered接口、普通三种区分开
        for (String ppName : postProcessorNames) {
            // 跳过已经执行过的BeanFactoryPostProcessor
            if (processedBeans.contains(ppName)) {
                // skip - already processed in first phase above
            }
            // 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor到priorityOrderedPostProcessors
            else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            }
            // 添加实现了Ordered接口的BeanFactoryPostProcessor的beanName到orderedPostProcessorNames
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
//          orderedPostProcessorNames.add(ppName);
                orderedPostProcessor.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            } else {
                // 添加剩下的普通BeanFactoryPostProcessor的beanName到nonOrderedPostProcessorNames
//          nonOrderedPostProcessorNames.add(ppName);
                nonOrderedPostProcessorNames.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            }
        }

        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
        // 对实现了PriorityOrdered接口的BeanFactoryPostProcessor进行排序
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        // 遍历实现了PriorityOrdered接口的BeanFactoryPostProcessor，执行postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
        // 创建存放实现了Ordered接口的BeanFactoryPostProcessor集合
//    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
        // 遍历存放实现了Ordered接口的BeanFactoryPostProcessor名字的集合
//    for (String postProcessorName : orderedPostProcessorNames) {
        // 将实现了Ordered接口的BeanFactoryPostProcessor添加到集合中
//       orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
//    }
        // 对实现了Ordered接口的BeanFactoryPostProcessor进行排序操作
//    sortPostProcessors(orderedPostProcessors, beanFactory);
        sortPostProcessors(orderedPostProcessor, beanFactory);
        // 遍历实现了Ordered接口的BeanFactoryPostProcessor，执行postProcessBeanFactory方法
//    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(orderedPostProcessor, beanFactory);

        // Finally, invoke all other BeanFactoryPostProcessors.
        // 最后，创建存放普通的BeanFactoryPostProcessor的集合
//    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
        // 遍历存放实现了普通BeanFactoryPostProcessor名字的集合
//    for (String postProcessorName : nonOrderedPostProcessorNames) {
        // 将普通的BeanFactoryPostProcessor添加到集合中
//       nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
//    }
        // 遍历普通的BeanFactoryPostProcessor，执行postProcessBeanFactory方法
//    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessorNames, beanFactory);

        // Clear cached merged bean definitions since the post-processors might have
        // modified the original metadata, e.g. replacing placeholders in values...
        // 清除元数据缓存（mergeBeanDefinitions、allBeanNamesByType、singletonBeanNameByType）
        // 因为后置处理器可能已经修改了原始元数据，例如，替换值中的占位符
        beanFactory.clearMetadataCache();
    }

进入第12行的处理环节

/**
 * 调用给定 BeanDefinitionRegistryPostProcessor Bean对象
 *
 * Invoke the given BeanDefinitionRegistryPostProcessor beans.
 */
private static void invokeBeanDefinitionRegistryPostProcessors(
        Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

    //遍历 postProcessors
    for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
        //调用 postProcessor 的 postProcessBeanDefinitionRegistry以使得postProcess往registry注册BeanDefinition对象
        postProcessor.postProcessBeanDefinitionRegistry(registry);
    }
}

进入第22行的处理环节

/**
 * 定位、加载、解析、注册相关注解
 *
 * Derive further bean definitions from the configuration classes in the registry.
 */
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
   // 根据对应的registry对象生成hashcode值，此对象只会操作一次，如果之前处理过则抛出异常
   int registryId = System.identityHashCode(registry);
   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);
   }
   // 将马上要进行处理的registry对象的id值放到已经处理的集合对象中
   this.registriesPostProcessed.add(registryId);

   // 处理配置类的bean定义信息
   processConfigBeanDefinitions(registry);
}

如下方法是核心处理环节，BeanDefinitionHolder是BeanDefinition的包装类，既包括BeanDefinition、beanName以及别名，配置文件加载后所有东西都会放到BeanDefinitionMap和BeanDefinitionNames中，BeanDefinitionNames放的是name集合，BeanDefinitionMap放的是name和完整的BeanDefinition对象的KV键值对集合，在这里取出所有的name集合。

循环只做了一件事，将被某些注解所修饰的BeanDefinition筛选出来。

获取BeanDefinition，判断BeanDefinition是否包含CONFIGURATION_CLASS_ATTRIBUTE属性值（），不包含，126行工具类进去。

/**
 * 构建和验证一个类是否被@Configuration修饰，并做相关的解析工作
 *
 * 如果你对此方法了解清楚了，那么springboot的自动装配原理就清楚了
 *
 * Build and validate a configuration model based on the registry of
 * {@link Configuration} classes.
 */
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   // 创建存放BeanDefinitionHolder的对象集合
   List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
   // 当前registry就是DefaultListableBeanFactory，获取所有已经注册的BeanDefinition的beanName
   String[] candidateNames = registry.getBeanDefinitionNames();

   // 遍历所有要处理的beanDefinition的名称,筛选对应的beanDefinition（被注解修饰的）
   for (String beanName : candidateNames) {
      // 获取指定名称的BeanDefinition对象
      BeanDefinition beanDef = registry.getBeanDefinition(beanName);
      // 如果beanDefinition中的configurationClass属性不等于空，那么意味着已经处理过，输出日志信息
      if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
         if (logger.isDebugEnabled()) {
            logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
         }
      }
      // 判断当前BeanDefinition是否是一个配置类，并为BeanDefinition设置属性为lite或者full，此处设置属性值是为了后续进行调用
      // 如果Configuration配置proxyBeanMethods代理为true则为full
      // 如果加了@Bean、@Component、@ComponentScan、@Import、@ImportResource注解，则设置为lite
      // 如果配置类上被@Order注解标注，则设置BeanDefinition的order属性值
      else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
         // 添加到对应的集合对象中
         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
   // 如果适用，则按照先前确定的@Order的值排序
   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类型
   SingletonBeanRegistry sbr = null;
   if (registry instanceof SingletonBeanRegistry) {
      // 类型的强制转换
      sbr = (SingletonBeanRegistry) registry;
      // 判断是否有自定义的beanName生成器
      if (!this.localBeanNameGeneratorSet) {
         // 获取自定义的beanName生成器
         BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
               AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
         // 如果有自定义的命名生成策略
            if (generator != null) {
            //设置组件扫描的beanName生成策略
            this.componentScanBeanNameGenerator = generator;
            // 设置import bean name生成策略
            this.importBeanNameGenerator = generator;
         }
      }
   }

   // 如果环境对象等于空，那么就重新创建新的环境对象
   if (this.environment == null) {
      this.environment = new StandardEnvironment();
   }

   // Parse each @Configuration class
   // 实例化ConfigurationClassParser类，并初始化相关的参数，完成配置类的解析工作
   ConfigurationClassParser parser = new ConfigurationClassParser(
         this.metadataReaderFactory, this.problemReporter, this.environment,
         this.resourceLoader, this.componentScanBeanNameGenerator, registry);

   // 创建两个集合对象，
   // 存放相关的BeanDefinitionHolder对象
   Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
   // 存放扫描包下的所有bean
   Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
   do {
      // 解析带有@Controller、@Import、@ImportResource、@ComponentScan、@ComponentScans、@Bean的BeanDefinition
      parser.parse(candidates);
      // 将解析完的Configuration配置类进行校验，1、配置类不能是final，2、@Bean修饰的方法必须可以重写以支持CGLIB
      parser.validate();

      // 获取所有的bean,包括扫描的bean对象，@Import导入的bean对象
      Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
      // 清除掉已经解析处理过的配置类
      configClasses.removeAll(alreadyParsed);

      // Read the model and create bean definitions based on its content
      // 判断读取器是否为空，如果为空的话，就创建完全填充好的ConfigurationClass实例的读取器
      if (this.reader == null) {
         this.reader = new ConfigurationClassBeanDefinitionReader(
               registry, this.sourceExtractor, this.resourceLoader, this.environment,
               this.importBeanNameGenerator, parser.getImportRegistry());
      }
      // 核心方法，将完全填充好的ConfigurationClass实例转化为BeanDefinition注册入IOC容器
      this.reader.loadBeanDefinitions(configClasses);
      // 添加到已经处理的集合中
      alreadyParsed.addAll(configClasses);

      candidates.clear();
      // 这里判断registry.getBeanDefinitionCount() > candidateNames.length的目的是为了知道reader.loadBeanDefinitions(configClasses)这一步有没有向BeanDefinitionMap中添加新的BeanDefinition
      // 实际上就是看配置类(例如AppConfig类会向BeanDefinitionMap中添加bean)
      // 如果有，registry.getBeanDefinitionCount()就会大于candidateNames.length
      // 这样就需要再次遍历新加入的BeanDefinition，并判断这些bean是否已经被解析过了，如果未解析，需要重新进行解析
      // 这里的AppConfig类向容器中添加的bean，实际上在parser.parse()这一步已经全部被解析了
      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());
         }
         // 如果有未解析的类，则将其添加到candidates中，这样candidates不为空，就会进入到下一次的while的循环中
         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();
   }
}

需要注意的是如果是从配置文件直接读的BeanDefinition，实现类是GenericBeanDefinition。而如果是以注解方式，实现类是ScannedGenericBeanDefinition，实现了AnnotatedBeanDefinition接口，其实就多了一个注解的相关元数据信息特殊处理。

public interface AnnotatedBeanDefinition extends BeanDefinition {
   /**
    * 获取注解的元数据
    *
    * Obtain the annotation metadata (as well as basic class metadata)
    * for this bean definition's bean class.
    * @return the annotation metadata object (never {@code null})
    */
   AnnotationMetadata getMetadata();
   /**
    * 获取工厂方法的元数据
    *
    * Obtain metadata for this bean definition's factory method, if any.
    * @return the factory method metadata, or {@code null} if none
    * @since 4.1.1
    */
   @Nullable
   MethodMetadata getFactoryMethodMetadata();
}

26行，不管三种方式匹配任何一个情况，最终目的都是为了获取AnnotatedMetadata对象，获取注解元数据信息后才知道当前BeanDefinition有什么样的注解。下面66行先判断是否是Configuration类，往下走isConfigurationCandidate里面判断是否含有其他注解，72行进去。

/**
 * 检查当前给定的beanDefinition中是否是一个配置类的候选者，
 * 判断在嵌套的关系中是否包含配置类或者组件类或者自动注册进去的，并做相应的标记
 *
 * Check whether the given bean definition is a candidate for a configuration class
 * (or a nested component class declared within a configuration/component class,
 * to be auto-registered as well), and mark it accordingly.
 * @param beanDef the bean definition to check
 * @param metadataReaderFactory the current factory in use by the caller
 * @return whether the candidate qualifies as (any kind of) configuration class
 */
public static boolean checkConfigurationClassCandidate(
      BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {

   // 获取bean定义信息中的class类名
   String className = beanDef.getBeanClassName();
   // 如果className为空，或者bean定义信息中的factoryMethod不等于空，那么直接返回
   if (className == null || beanDef.getFactoryMethodName() != null) {
      return false;
   }

   AnnotationMetadata metadata;
   // 通过注解注入的db都是AnnotatedGenericBeanDefinition，实现了AnnotatedBeanDefinition
   // spring内部的bd是RootBeanDefinition，实现了AbstractBeanDefinition
   // 此处主要用于判断是否归属于AnnotatedBeanDefinition
   if (beanDef instanceof AnnotatedBeanDefinition &&
         className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
      // Can reuse the pre-parsed metadata from the given BeanDefinition...
      // 从当前bean的定义信息中获取元数据信息
      metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
   }
   // 判断是否是spring中默认的BeanDefinition
   else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
      // Check already loaded Class if present...
      // since we possibly can't even load the class file for this Class.
      // 获取当前bean对象的Class对象
      Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
      // 如果class实例是下面四种类或接口的子类、父接口等任何一种情况，直接返回
      if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
            BeanPostProcessor.class.isAssignableFrom(beanClass) ||
            AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
            EventListenerFactory.class.isAssignableFrom(beanClass)) {
         return false;
      }
      // 为给定类创建新的AnnotationMetadata实例
      metadata = AnnotationMetadata.introspect(beanClass);
   }
   // 如果上述两种情况都不符合
   else {
      try {
         // 获取className的MetadataReader实例
         MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
         // 读取底层类的完整注释元数据，包括带注解方法的元数据
         metadata = metadataReader.getAnnotationMetadata();
      }
      catch (IOException ex) {
         if (logger.isDebugEnabled()) {
            logger.debug("Could not find class file for introspecting configuration annotations: " +
                  className, ex);
         }
         return false;
      }
   }

   // 获取bean定义的元数据被@Configuration注解标注的属性字典值
   Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
   // 如果bean被@Configuration注解标注，且属性proxyBeanMethods为false(使用代理模式)，则将bean定义记为full
   if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
      beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
   }
   // 如果bean被@configuration注解标注，且被注解@Component，@ComponentScan、@Import、@ImportResource或者@Bean标记的方法，则将bean定义标记为lite
   else if (config != null || isConfigurationCandidate(metadata)) {
      beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
   }
   else {
      return false;
   }

   // It's a full or lite configuration candidate... Let's determine the order value, if any.
   // bean定义是一个标记为full或lite的候选项，如果设置order则设置order属性值
   Integer order = getOrder(metadata);
   // 如果值不为空的话，那么直接设置值到具体的beanDefinition
   if (order != null) {
      // 设置bean定义的order值
      beanDef.setAttribute(ORDER_ATTRIBUTE, order);
   }

   return true;
}

方法里面19行循环遍历集合，集合里面定义了4个注解：Component、ComponentScan、Import、ImportResource。如果都匹配不到，检查一下是否含有@Bean标注的方法

/**
 * 检查给定的元数据，以查找给定的候选配置类是否被指定的注解标注
 *
 * Check the given metadata for a configuration class candidate
 * (or nested component class declared within a configuration/component class).
 * @param metadata the metadata of the annotated class
 * @return {@code true} if the given class is to be registered for
 * configuration class processing; {@code false} otherwise
 */
public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
   // Do not consider an interface or an annotation...
   // 不考虑接口或注解
   if (metadata.isInterface()) {
      return false;
   }

   // Any of the typical annotations found?
   // 检查是否被注解@Component、@ComponentScan、@Import、@ImportResource标注
   for (String indicator : candidateIndicators) {
      if (metadata.isAnnotated(indicator)) {
         return true;
      }
   }

   // Finally, let's look for @Bean methods...
   // 最后检查是否有@Bean标注的方法
   try {
      return metadata.hasAnnotatedMethods(Bean.class.getName());
   }
   catch (Throwable ex) {
      if (logger.isDebugEnabled()) {
         logger.debug("Failed to introspect @Bean methods on class [" + metadata.getClassName() + "]: " + ex);
      }
      return false;
   }
}

我们的MyComponentScan 包含@Component，所以73行加进来了，往当前BeanDefinition设置属性值key为configurationClass，属性值是LinkedHashMap结构，属性值的value为full或lite，当前注解是@Configuration标注的标注为full，非@Configuration标注的配置类标注为lite，最后返回true

/**
 * 检查当前给定的beanDefinition中是否是一个配置类的候选者，
 * 判断在嵌套的关系中是否包含配置类或者组件类或者自动注册进去的，并做相应的标记
 *
 * Check whether the given bean definition is a candidate for a configuration class
 * (or a nested component class declared within a configuration/component class,
 * to be auto-registered as well), and mark it accordingly.
 * @param beanDef the bean definition to check
 * @param metadataReaderFactory the current factory in use by the caller
 * @return whether the candidate qualifies as (any kind of) configuration class
 */
public static boolean checkConfigurationClassCandidate(
      BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {

   // 获取bean定义信息中的class类名
   String className = beanDef.getBeanClassName();
   // 如果className为空，或者bean定义信息中的factoryMethod不等于空，那么直接返回
   if (className == null || beanDef.getFactoryMethodName() != null) {
      return false;
   }

   AnnotationMetadata metadata;
   // 通过注解注入的db都是AnnotatedGenericBeanDefinition，实现了AnnotatedBeanDefinition
   // spring内部的bd是RootBeanDefinition，实现了AbstractBeanDefinition
   // 此处主要用于判断是否归属于AnnotatedBeanDefinition
   if (beanDef instanceof AnnotatedBeanDefinition &&
         className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
      // Can reuse the pre-parsed metadata from the given BeanDefinition...
      // 从当前bean的定义信息中获取元数据信息
      metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
   }
   // 判断是否是spring中默认的BeanDefinition
   else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
      // Check already loaded Class if present...
      // since we possibly can't even load the class file for this Class.
      // 获取当前bean对象的Class对象
      Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
      // 如果class实例是下面四种类或接口的子类、父接口等任何一种情况，直接返回
      if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
            BeanPostProcessor.class.isAssignableFrom(beanClass) ||
            AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
            EventListenerFactory.class.isAssignableFrom(beanClass)) {
         return false;
      }
      // 为给定类创建新的AnnotationMetadata实例
      metadata = AnnotationMetadata.introspect(beanClass);
   }
   // 如果上述两种情况都不符合
   else {
      try {
         // 获取className的MetadataReader实例
         MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
         // 读取底层类的完整注释元数据，包括带注解方法的元数据
         metadata = metadataReader.getAnnotationMetadata();
      }
      catch (IOException ex) {
         if (logger.isDebugEnabled()) {
            logger.debug("Could not find class file for introspecting configuration annotations: " +
                  className, ex);
         }
         return false;
      }
   }

   // 获取bean定义的元数据被@Configuration注解标注的属性字典值
   Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
   // 如果bean被@Configuration注解标注，且属性proxyBeanMethods为false(使用代理模式)，则将bean定义记为full
   if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
      beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
   }
   // 如果bean被@configuration注解标注，且被注解@Component，@ComponentScan、@Import、@ImportResource或者@Bean标记的方法，则将bean定义标记为lite
   else if (config != null || isConfigurationCandidate(metadata)) {
      beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
   }
   else {
      return false;
   }

   // It's a full or lite configuration candidate... Let's determine the order value, if any.
   // bean定义是一个标记为full或lite的候选项，如果设置order则设置order属性值
   Integer order = getOrder(metadata);
   // 如果值不为空的话，那么直接设置值到具体的beanDefinition
   if (order != null) {
      // 设置bean定义的order值
      beanDef.setAttribute(ORDER_ATTRIBUTE, order);
   }

   return true;
}

第31行，当前BeanDefinition封装成BeanDefinitionHolder对象加到configCandidates集合中，标明这是一个配置类，后续进行解析。

按照order进行排序操作，判断当前的配置里面是否有自定义的beanName生成器，有的话加载。

提前创建一个配置类的解析器对象，提前准备存放holder对象的集合，提前准备已经处理过的存放集合。

第88行，开始处理整个的解析工作。

/**
 * 构建和验证一个类是否被@Configuration修饰，并做相关的解析工作
 *
 * 如果你对此方法了解清楚了，那么springboot的自动装配原理就清楚了
 *
 * Build and validate a configuration model based on the registry of
 * {@link Configuration} classes.
 */
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   // 创建存放BeanDefinitionHolder的对象集合
   List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
   // 当前registry就是DefaultListableBeanFactory，获取所有已经注册的BeanDefinition的beanName
   String[] candidateNames = registry.getBeanDefinitionNames();

   // 遍历所有要处理的beanDefinition的名称,筛选对应的beanDefinition（被注解修饰的）
   for (String beanName : candidateNames) {
      // 获取指定名称的BeanDefinition对象
      BeanDefinition beanDef = registry.getBeanDefinition(beanName);
      // 如果beanDefinition中的configurationClass属性不等于空，那么意味着已经处理过，输出日志信息
      if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
         if (logger.isDebugEnabled()) {
            logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
         }
      }
      // 判断当前BeanDefinition是否是一个配置类，并为BeanDefinition设置属性为lite或者full，此处设置属性值是为了后续进行调用
      // 如果Configuration配置proxyBeanMethods代理为true则为full
      // 如果加了@Bean、@Component、@ComponentScan、@Import、@ImportResource注解，则设置为lite
      // 如果配置类上被@Order注解标注，则设置BeanDefinition的order属性值
      else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
         // 添加到对应的集合对象中
         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
   // 如果适用，则按照先前确定的@Order的值排序
   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类型
   SingletonBeanRegistry sbr = null;
   if (registry instanceof SingletonBeanRegistry) {
      // 类型的强制转换
      sbr = (SingletonBeanRegistry) registry;
      // 判断是否有自定义的beanName生成器
      if (!this.localBeanNameGeneratorSet) {
         // 获取自定义的beanName生成器
         BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
               AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
         // 如果有自定义的命名生成策略
            if (generator != null) {
            //设置组件扫描的beanName生成策略
            this.componentScanBeanNameGenerator = generator;
            // 设置import bean name生成策略
            this.importBeanNameGenerator = generator;
         }
      }
   }

   // 如果环境对象等于空，那么就重新创建新的环境对象
   if (this.environment == null) {
      this.environment = new StandardEnvironment();
   }

   // Parse each @Configuration class
   // 实例化ConfigurationClassParser类，并初始化相关的参数，完成配置类的解析工作
   ConfigurationClassParser parser = new ConfigurationClassParser(
         this.metadataReaderFactory, this.problemReporter, this.environment,
         this.resourceLoader, this.componentScanBeanNameGenerator, registry);

   // 创建两个集合对象，
   // 存放相关的BeanDefinitionHolder对象
   Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
   // 存放扫描包下的所有bean
   Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
   do {
      // 解析带有@Controller、@Import、@ImportResource、@ComponentScan、@ComponentScans、@Bean的BeanDefinition
      parser.parse(candidates);
      // 将解析完的Configuration配置类进行校验，1、配置类不能是final，2、@Bean修饰的方法必须可以重写以支持CGLIB
      parser.validate();

      // 获取所有的bean,包括扫描的bean对象，@Import导入的bean对象
      Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
      // 清除掉已经解析处理过的配置类
      configClasses.removeAll(alreadyParsed);

      // Read the model and create bean definitions based on its content
      // 判断读取器是否为空，如果为空的话，就创建完全填充好的ConfigurationClass实例的读取器
      if (this.reader == null) {
         this.reader = new ConfigurationClassBeanDefinitionReader(
               registry, this.sourceExtractor, this.resourceLoader, this.environment,
               this.importBeanNameGenerator, parser.getImportRegistry());
      }
      // 核心方法，将完全填充好的ConfigurationClass实例转化为BeanDefinition注册入IOC容器
      this.reader.loadBeanDefinitions(configClasses);
      // 添加到已经处理的集合中
      alreadyParsed.addAll(configClasses);

      candidates.clear();
      // 这里判断registry.getBeanDefinitionCount() > candidateNames.length的目的是为了知道reader.loadBeanDefinitions(configClasses)这一步有没有向BeanDefinitionMap中添加新的BeanDefinition
      // 实际上就是看配置类(例如AppConfig类会向BeanDefinitionMap中添加bean)
      // 如果有，registry.getBeanDefinitionCount()就会大于candidateNames.length
      // 这样就需要再次遍历新加入的BeanDefinition，并判断这些bean是否已经被解析过了，如果未解析，需要重新进行解析
      // 这里的AppConfig类向容器中添加的bean，实际上在parser.parse()这一步已经全部被解析了
      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());
         }
         // 如果有未解析的类，则将其添加到candidates中，这样candidates不为空，就会进入到下一次的while的循环中
         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();
   }
}

入参是一个集合，解析要循环进行判定，获取当前BeanDefinition，判断BeanDefinition归属于哪个类型。

public void parse(Set<BeanDefinitionHolder> configCandidates) {
   // 循环遍历configCandidates
   for (BeanDefinitionHolder holder : configCandidates) {
      // 获取BeanDefinition
      BeanDefinition bd = holder.getBeanDefinition();
      // 根据BeanDefinition类型的不同，调用parse不同的重载方法，实际上最终都是调用processConfigurationClass()方法
      try {
         // 注解类型
         if (bd instanceof AnnotatedBeanDefinition) {
            parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
         }
         // 有class对象的
         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);
      }
   }

   // 执行找到的DeferredImportSelector
   // DeferredImportSelector是ImportSelector的一个子类
   // ImportSelector被设计成和@Import注解同样的效果，但是实现了ImportSelector的类可以条件性的决定导入某些配置
   // DeferredImportSelector的设计魔都是在所有其他的配置类被处理后才进行处理
   this.deferredImportSelectorHandler.process();
}

首先判断是否含有@Conditional注解，做相应的条件判断再做解析。第9行，相当于一个本地缓存，比如最开始有一个配置类MyComponentScan类，后面可以再通过@Import(MyComponentScan.class)注入进来。没有必要对MyComponentScan进行两遍处理，所以后面要把处理的configClass保存起来。若要解析当前类，需要不断循环解析父类。进入第36行，doXxx方法开始对当前类包含的注解都进行解析和处理。

protected void  processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
   // 判断是否跳过解析
   if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
      return;
   }

   // 第一次进入的时候，configurationClass的size为0，existingClass肯定为null，在此处处理configuration重复import
   // 如果同一个配置类被处理两次，两次都属于被import的则合并导入类，返回，如果配置类不是被导入的，则移除旧的使用新的配置类
   ConfigurationClass existingClass = this.configurationClasses.get(configClass);
   if (existingClass != null) {
      if (configClass.isImported()) {
         if (existingClass.isImported()) {
            // 如果要处理的配置类configclass在已经分析处理的配置类记录中已存在，合并两者的importBy属性
            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.

   // 处理配置类，由于配置类可能存在父类(若父类的全类名是以java开头的，则除外)，所有需要将configClass变成sourceClass去解析，然后返回sourceClass的父类。
   // 如果此时父类为空，则不会进行while循环去解析，如果父类不为空，则会循环的去解析父类
   // SourceClass的意义：简单的包装类，目的是为了以统一的方式去处理带有注解的类，不管这些类是如何加载的
   // 如果无法理解，可以把它当做一个黑盒，不会影响看spring源码的主流程
   SourceClass sourceClass = asSourceClass(configClass, filter);
   do {
      // 解析各种注解
      sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
   }
   while (sourceClass != null);

   // 将解析的配置类存储起来，这样回到parse方法时，能取到值
   this.configurationClasses.put(configClass, configClass);
}

当前的类如果被@Component注解所修饰（注意@Configuration继承了@Component，@Configuration包括@Component），递归处理内部类，注意是外部类@Component注解递归调内部类解析，从最内部的类解析剩下的注解，往外层解析，直到最外部类解析完全部注解。

对当前的@PropertySource做一个解析工作，加载外部配置文件进来，加入到beanFactory中。

第37行判断是否包含@ComponentScan注解，如果包含创建componentScanParser结果集对象，第47行调用扫描包的解析器方法去解析。

第67行解析@Import注解，导入一些额外的配置类，同时完成具体类的实例化工作，接着处理@ImportResource

处理@Bean，注意是通过asm直接读取字节码技术获取的方法，由于具有标准的顺序，而用反射顺序会乱。最后把处理完的beanMethod对象加到configClass中，configClass是由LinkedHashSet实现的。

/**
 * Apply processing and build a complete {@link ConfigurationClass} by reading the
 * annotations, members and methods from the source class. This method can be called
 * multiple times as relevant sources are discovered.
 * @param configClass the configuration class being build
 * @param sourceClass a source class
 * @return the superclass, or {@code null} if none found or previously processed
 */
@Nullable
protected final SourceClass doProcessConfigurationClass(
      ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
      throws IOException {
   // @Configuration继承了@Component
   if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
      // Recursively process any member (nested) classes first
      // 递归处理内部类，因为内部类也是一个配置类，配置类上有@configuration注解，该注解继承@Component，if判断为true，调用processMemberClasses方法，递归解析配置类中的内部类
      processMemberClasses(configClass, sourceClass, filter);
   }

   // Process any @PropertySource annotations
   // 如果配置类上加了@PropertySource注解，那么就解析加载properties文件，并将属性添加到spring上下文中
   for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), PropertySources.class,
         org.springframework.context.annotation.PropertySource.class)) {
      if (this.environment instanceof ConfigurableEnvironment) {
         processPropertySource(propertySource);
      }
      else {
         logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
               "]. Reason: Environment must implement ConfigurableEnvironment");
      }
   }

   // Process any @ComponentScan annotations
   // 处理@ComponentScan或者@ComponentScans注解，并将扫描包下的所有bean转换成填充后的ConfigurationClass
   // 此处就是将自定义的bean加载到IOC容器，因为扫描到的类可能也添加了@ComponentScan和@ComponentScans注解，因此需要进行递归解析
   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
         // 解析@ComponentScan和@ComponentScans配置的扫描的包所包含的类
         // 比如 basePackages = com.mashibing, 那么在这一步会扫描出这个包及子包下的class，然后将其解析成BeanDefinition
         // (BeanDefinition可以理解为等价于BeanDefinitionHolder)
         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
         // 通过上一步扫描包com.mashibing，有可能扫描出来的bean中可能也添加了ComponentScan或者ComponentScans注解.
         //所以这里需要循环遍历一次，进行递归(parse)，继续解析，直到解析出的类上没有ComponentScan和ComponentScans
         for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
            if (bdCand == null) {
               bdCand = holder.getBeanDefinition();
            }
            // 判断是否是一个配置类，并设置full或lite属性
            if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
               // 通过递归方法进行解析
               parse(bdCand.getBeanClassName(), holder.getBeanName());
            }
         }
      }
   }

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

   // Process any @ImportResource annotations
   // 处理@ImportResource注解，导入spring的配置文件
   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
   // 处理加了@Bean注解的方法，将@Bean方法转化为BeanMethod对象，保存再集合中
   Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
   for (MethodMetadata methodMetadata : beanMethods) {
      configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
   }

   // Process default methods on interfaces
   // 处理接口的默认方法实现，从jdk8开始，接口中的方法可以有自己的默认实现，因此如果这个接口的方法加了@Bean注解，也需要被解析
   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;
}

解析并设置注解中包括的所有属性值，第67行开始对包下所有类进行解析工作，最后把扫描到的类调用registerBeanDefinition方法注册到beanFactory去。遍历扫描到的beanDefinition，递归解析处理。

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
   // 创建对应的扫描类
   ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
         componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

   // 获取@ComponentScan的参数，并进行参数的设置工作
   Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
   boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
   scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
         BeanUtils.instantiateClass(generatorClass));

   // 获取scopedProxy属性
   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));
   }

   // 获取resourcePattern属性
   scanner.setResourcePattern(componentScan.getString("resourcePattern"));

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

   // 获取lazyInit属性
   boolean lazyInit = componentScan.getBoolean("lazyInit");
   if (lazyInit) {
      scanner.getBeanDefinitionDefaults().setLazyInit(true);
   }

   Set<String> basePackages = new LinkedHashSet<>();
   // 获取basePackages属性
   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);
   }
   // 获取basePackageClasses属性
   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);
      }
   });
   // 开始执行扫描，最终的扫描器是ClassPathBeanDefinitionScanner
   return scanner.doScan(StringUtils.toStringArray(basePackages));
}

开始进行包扫描方法，遍历包路径，根据包名扫描basePackage，将符合要求的beanDefinition全部找出来进行属性设置，注册beanFactory返回。

/**
 * Perform a scan within the specified base packages,
 * returning the registered bean definitions.
 * <p>This method does <i>not</i> register an annotation config processor
 * but rather leaves this up to the caller.
 * @param basePackages the packages to check for annotated classes
 * @return set of beans registered if any for tooling registration purposes (never {@code null})
 */
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
   Assert.notEmpty(basePackages, "At least one base package must be specified");
   Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
   // 遍历basePackages
   for (String basePackage : basePackages) {
      // 扫描basePackage,将符合要求的bean定义全部找出来
      Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
      // 遍历所有候选的bean定义
      for (BeanDefinition candidate : candidates) {
         // 解析@Scope注解，包括scopeName和proxyMode
         ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
         candidate.setScope(scopeMetadata.getScopeName());
         // 使用beanName生成器来生成beanName
         String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
         if (candidate instanceof AbstractBeanDefinition) {
            // 处理beanDefinition对象，例如，此bean是否可以自动装配到其他bean中
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
         }
         if (candidate instanceof AnnotatedBeanDefinition) {
            // 处理定义在目标类上的通用注解，包括@Lazy，@Primary，@DependsOn，@Role，@Description
            AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
         }
         // 检查beanName是否已经注册过，如果注册过，检查是否兼容
         if (checkCandidate(beanName, candidate)) {
            // 将当前遍历be
            an的bean定义和beanName封装成BeanDefinitionHolder
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            // 根据proxyMode的值，选择是否创建作用域代理
            definitionHolder =
                  AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            beanDefinitions.add(definitionHolder);
            // 注册beanDefinition
            registerBeanDefinition(definitionHolder, this.registry);
         }
      }
   }
   return beanDefinitions;
}