一、Spring是如何發(fā)布事件的？ApplicationListener（觀察者模式）

1.1）自己寫一個(gè)TestApplicationListener 實(shí)現(xiàn)ApplicationListener?接口,并且把該組件加入到容器中.

@Configuration
@ComponentScan("com.test")
public class MainConfig {
}

@Component
public class TestApplicationListener implements ApplicationListener {

    // 接收到消息，回調(diào)該方法
    @Override
    public void onApplicationEvent(ApplicationEvent applicationEvent) {
        System.out.println("NiuhApplicationListener 接收到一個(gè)事件：" + applicationEvent);
    }
}

    
public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
    // 手動(dòng)發(fā)布一個(gè)事件

    context.publishEvent(new ApplicationEvent("我手動(dòng)發(fā)布了一個(gè)事件") {
        @Override
        public Object getSource() {
            return super.getSource();
        }
    });

    // 容器關(guān)閉也發(fā)布事件
    context.close();
}   

測(cè)試結(jié)果:

TestApplicationListener 接受到了一個(gè)事件org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@37bba400: startup date [Mon May 27 21:42:51 CST 2019]; root of context hierarchy]
TestApplicationListener 接受到了一個(gè)事件com.tuling.testapplicationlistener.MainClass$1[source=我手動(dòng)發(fā)布了一個(gè)事件]
TestApplicationListener 接受到了一個(gè)事件org.springframework.context.event.ContextClosedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@37bba400: startup date [Mon May 27 21:42:51 CST 2019]; root of context hierarchy]

1.2）源碼解析

i1>org.springframework.context.support.AbstractApplicationContext#refresh
 i2>org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster（初始化事件多播器）
     i3>org.springframework.context.support.AbstractApplicationContext#registerListeners（把事件監(jiān)聽器注冊(cè)到多播器上去）

i2(初始化事件多播器源碼解析)

/**
 * Initialize the ApplicationEventMulticaster.
 * Uses SimpleApplicationEventMulticaster if none defined in the context.
 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
 */
protected void initApplicationEventMulticaster() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 判斷IOC容器中包含applicationEventMulticaster事件多播器的Bean的name
   if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
      // 創(chuàng)建一個(gè)applicationEventMulticaster 的bean放在IOC容器中，bean的name為applicationEventMulticaster 
      this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
      if (logger.isDebugEnabled()) {
         logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
      }
   }
   // 容器中不包含一個(gè)beanName 為applicationEventMulticaster的多播器組件
   else {
      // 創(chuàng)建一個(gè) SimpleApplicationEventMulticaster 多播器
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      // 注冊(cè)到容器中
      beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
      if (logger.isDebugEnabled()) {
         logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
               APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
               "': using default [" + this.applicationEventMulticaster + "]");
      }
   }
}

i3：把容器中的監(jiān)聽器注冊(cè)到多播器上去 源碼解析

    /**
 * Add beans that implement ApplicationListener as listeners.
 * Doesn't affect other listeners, which can be added without being beans.
 */
protected void registerListeners() {
   // Register statically specified listeners first.
   // 去容器中把a(bǔ)pplicationListener撈取出來注冊(cè)到多播器上去 （系統(tǒng)的）
   for (ApplicationListener<?> listener : getApplicationListeners()) {
      getApplicationEventMulticaster().addApplicationListener(listener);
   }

   // Do not initialize FactoryBeans here: We need to leave all regular beans
   // uninitialized to let post-processors apply to them!
   // 我們自己實(shí)現(xiàn)了ApplicationListener的組件
   String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
   for (String listenerBeanName : listenerBeanNames) {
      getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
   }

   // Publish early application events now that we finally have a multicaster...
   // 在這里之前，我們?cè)缙谙氚l(fā)布的事件由于沒有多播器沒有發(fā)布，在這里我們總算有了自己的多播器，可以在這里發(fā)布早期堆積的事件了
   Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
   this.earlyApplicationEvents = null;
   if (earlyEventsToProcess != null) {
      for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
         getApplicationEventMulticaster().multicastEvent(earlyEvent);
      }
   }
}



-------------------------------如何發(fā)布事件的--------------------------------
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
   ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
   // 獲取到所有的監(jiān)聽器
   for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
      // 看spring容器中是否支持線程池，異步發(fā)送事件 
      Executor executor = getTaskExecutor();
      if (executor != null) {
         executor.execute(() -> invokeListener(listener, event));
      }
      else {
         // 同步發(fā)送事件 
         invokeListener(listener, event);
      }
   }
}

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
   try {
      // 調(diào)用對(duì)于listener的onApplicationEvent事件 
      listener.onApplicationEvent(event);
   }
   catch (ClassCastException ex) {
      String msg = ex.getMessage();
      if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
         // Possibly a lambda-defined listener which we could not resolve the generic event type for
         // -> let's suppress the exception and just log a debug message.
         Log logger = LogFactory.getLog(getClass());
         if (logger.isDebugEnabled()) {
            logger.debug("Non-matching event type for listener: " + listener, ex);
         }
      }
      else {
         throw ex;
      }
   }
}

二:BeanDefinitionRegistryPostProcessor? 的處理源碼流程

接口定義

/**
 * Extension to the standard {@link BeanFactoryPostProcessor} SPI, allowing for
 * the registration of further bean definitions <i>before</i> regular
 * BeanFactoryPostProcessor detection kicks in. In particular,
 * BeanDefinitionRegistryPostProcessor may register further bean definitions
 * which in turn define BeanFactoryPostProcessor instances.
 *
 * @author Juergen Hoeller
 * @since 3.0.1
 * @see org.springframework.context.annotation.ConfigurationClassPostProcessor
 */
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

    /**
     * Modify the application context's internal bean definition registry after its
     * standard initialization. All regular bean definitions will have been loaded,
     * but no beans will have been instantiated yet. This allows for adding further
     * bean definitions before the next post-processing phase kicks in.
     * @param registry the bean definition registry used by the application context
     * @throws org.springframework.beans.BeansException in case of errors
     */
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

BeanDefinitionRegistryPostProcessor繼承自BeanFactoryPostProcessor，是一種比較特殊的BeanFactoryPostProcessor。
BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry方法可實(shí)現(xiàn)自定義的bean注冊(cè)定義。
通常spring注冊(cè)bean使用靜態(tài)方式, 如:xml、@Bean注解或@Component方式實(shí)現(xiàn)注冊(cè).不能通過程序來選擇是否注冊(cè)。

而實(shí)現(xiàn)BeanDefinitionRegistryPostProcessor的類可以獲得BeanDefinitionRegistry 對(duì)象，通過它可以動(dòng)態(tài)的注冊(cè)組件,是實(shí)現(xiàn)動(dòng)態(tài)注冊(cè)的鉤子函數(shù)。spring典型的ConfigurationClassPostProcessor拓展BeanDefinitionRegistryPostProcessor 解析@Configuration配置類
推薦參考博文https://www.cnblogs.com/xiaoxing/p/10297202.html

執(zhí)行時(shí)機(jī):所有的bean定義信息將要被加載到容器中，Bean實(shí)例還沒有被初始化。

@Component
public class TestBeanDefinationRegisterPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("TulingBeanDefinationRegisterPostProcessor的postProcessBeanDefinitionRegistry方法");
        System.out.println("bean定義的數(shù)據(jù)量:"+registry.getBeanDefinitionCount());
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(TulingLog.class);
        registry.registerBeanDefinition("tulingLog",rootBeanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("TulingBeanDefinationRegisterPostProcessor的postProcessBeanFactory方法");
        System.out.println(beanFactory.getBeanDefinitionCount());
    }
}?

三、BeanFactoryPostProcessor?處理流程

執(zhí)行時(shí)間

所有的Bean定義信息已經(jīng)加載到容器中，但是Bean實(shí)例還沒有被初始化.

@Component
public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("IOC 容器調(diào)用了TestBeanFactoryPostProcessor的postProcessBeanFactory方法");
        for(String name:beanFactory.getBeanDefinitionNames()) {
            if("tulingLog".equals(name)) {
                BeanDefinition beanDefinition = beanFactory.getBeanDefinition(name);
                beanDefinition.setLazyInit(true);
            }

        }
    }
}

調(diào)用鏈

i1:org.springframework.context.support.AbstractApplicationContext#refresh
>i2:org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors
   >i3:org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
     >i4:org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
       >i5:org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions
        > i6:org.springframework.context.annotation.ConfigurationClassParser#parse
           >i7:org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
              >i8:org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass

i3標(biāo)記處源碼解析

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

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

   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
   Set<String> processedBeans = new HashSet<>();
   // 判斷IOC容器是不是BeanDefinitionRegistry 
   if (beanFactory instanceof BeanDefinitionRegistry) {
      // 把IOC容器強(qiáng)制轉(zhuǎn)為BeanDefinitionRegistry類型的 
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      // 創(chuàng)建一個(gè)普通的PostProcessors的list組件
      List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
      // 創(chuàng)建一個(gè)BeanDefinitionRegistryPostProcessor類型的list
      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
      
      // 處理容器硬編碼（new 出來的）帶入的beanFactoryProcessor    
      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
          //判斷是不是BeanDefinitionRegistryPostProcessor
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            //調(diào)用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry      
            registryProcessor.postProcessBeanDefinitionRegistry(registry);
            //加入到list集合中ConfigurationClassPostProcessor
            registryProcessors.add(registryProcessor);
         }
         else {//判斷不是BeanDefinitionRegistryPostProcessor
             //加入到集合中
            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.
      //創(chuàng)建一個(gè)當(dāng)前注冊(cè)的RegistryProcessors的集合
      List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

      // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
      // 第一步:去容器中查詢是否有BeanDefinitionRegistryPostProcessor類型的
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
          //判斷是不是實(shí)現(xiàn)了PriorityOrdered接口的
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
             //添加到currentRegistryProcessors的集合中
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            //添加到processedBeans的集合中
            processedBeans.add(ppName);
         }
      }
      //進(jìn)行排序
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      //調(diào)用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
      // 第二步:去容器中查詢是否有BeanDefinitionRegistryPostProcessor類型的
      postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
          //排除被處理過的，并且實(shí)現(xiàn)了Ordered接口的
         if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            //加到以處理的list中
            processedBeans.add(ppName);
         }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      //調(diào)用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
      //調(diào)用普通的BeanDefinitionRegistryPostProcessors沒用實(shí)現(xiàn) PriorithOrdered和Ordered接口
      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.
      //調(diào)用上訴實(shí)現(xiàn)了也實(shí)現(xiàn)了BeanFactoryPostProcessors的接口
      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!
   //去IOC 容器中獲取BeanFactoryPostProcessor 類型的
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   //分離實(shí)現(xiàn)了PriorityOrdered接口的 Ordered 接口的   普通的
   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.
   // 調(diào)用 PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
   //調(diào)用 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.
   //調(diào)用普通的
   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();
}

i5標(biāo)記處源碼解析

org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
   //沒有解析之前，系統(tǒng)候選的bean定義配置(有自己的 有系統(tǒng)自帶的)
   String[] candidateNames = registry.getBeanDefinitionNames();
   //循環(huán)Bean定義的名稱 找出自己的傳入的主配置類的bean定義信息  configCandidates
   for (String beanName : candidateNames) {
      BeanDefinition beanDef = registry.getBeanDefinition(beanName);
      //檢查該bean定義對(duì)象是不是用來描述配置類
      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)) {
         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
   // bean的名稱生成策略
   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();
   }

    /***創(chuàng)建一個(gè)配置類解析器
        1)元數(shù)據(jù)讀取器工廠
        this.metadataReaderFactory = metadataReaderFactory;
        2)問題報(bào)告器
        this.problemReporter = problemReporter;
        //設(shè)置環(huán)境
        this.environment = environment;
        3)資源加載器
        this.resourceLoader = resourceLoader;
        4）創(chuàng)建了一個(gè)組件掃描器
        this.componentScanParser = new ComponentScanAnnotationParser(
                environment, resourceLoader, componentScanBeanNameGenerator, registry);
        this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
        ****/
   // Parse each @Configuration class
   ConfigurationClassParser parser = new ConfigurationClassParser(
         this.metadataReaderFactory, this.problemReporter, this.environment,
         this.resourceLoader, this.componentScanBeanNameGenerator, registry);
    //將要被解析的配置類(把自己的configCandidates加入到 候選的)
   Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
   //已經(jīng)被解析的配置類(由于do while 那么mainclass就一定會(huì)被解析,被解析的size為1)
   Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
   do {
       //通過配置解析器真正的解析配置類
      parser.parse(candidates);
      //進(jìn)行校驗(yàn)
      parser.validate();
      //獲取ConfigClass (把解析過的配置bean定義信息獲取出來)
      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());
      }
      
      //@CompentScan是直接注冊(cè)Bean定義信息的    但是通過獲取@Import,@Bean這種的注解還沒有注冊(cè)的bean定義,
      this.reader.loadBeanDefinitions(configClasses);
      //把系統(tǒng)解析過我們自己的組件放在alreadyParsed
      alreadyParsed.addAll(configClasses);
      //清除解析過的 配置文件 
      candidates.clear();
      
      //已經(jīng)注冊(cè)的bean定義個(gè)數(shù)大于最新 開始系統(tǒng)+主配置類的(發(fā)生過解析)
      if (registry.getBeanDefinitionCount() > candidateNames.length) {
          //獲取系統(tǒng)+自己解析的+mainconfig的bean定義信息
         String[] newCandidateNames = registry.getBeanDefinitionNames();
         //系統(tǒng)的+mainconfig的bean定義信息
         Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
         //已經(jīng)解析過的自己的組件
         Set<String> alreadyParsedClasses = new HashSet<>();
         for (ConfigurationClass configurationClass : alreadyParsed) {
            alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
         }
         for (String candidateName : newCandidateNames) {
             //老的（系統(tǒng)+mainconfig） 不包含解析的
            if (!oldCandidateNames.contains(candidateName)) {
                //把當(dāng)前bean定義獲取出來
               BeanDefinition bd = registry.getBeanDefinition(candidateName);
               //檢查是否為解析過的
               if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                     !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                  //若不是解析過且通過檢查的     把當(dāng)前的bean定義 加入到candidates中      
                  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();
   }
}

i6標(biāo)記處源碼解析 org.springframework.context.annotation.ConfigurationClassParser#parse

public void parse(Set<BeanDefinitionHolder> configCandidates) {
   this.deferredImportSelectors = new LinkedList<>();

   for (BeanDefinitionHolder holder : configCandidates) {
      BeanDefinition bd = holder.getBeanDefinition();
      try {
          //注解形式的bean定義信息
         if (bd instanceof AnnotatedBeanDefinition) {
             //解析配置類的bean定義
            parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
         }
         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();
}
===================================================================
>org.springframework.context.annotation.ConfigurationClassParser#parse
    >org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
 
 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.
   // 遞歸處理配置類及其超類層次結(jié)構(gòu)。
   SourceClass sourceClass = asSourceClass(configClass);
   do {
      sourceClass = doProcessConfigurationClass(configClass, sourceClass);
   }
   while (sourceClass != null);

   this.configurationClasses.put(configClass, configClass);
}

===================================================================
>org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
      throws IOException {

   // 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);
      }
      else {
         logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
               "]. Reason: Environment must implement ConfigurableEnvironment");
      }
   }

    //處理@ComponentScan注解
    //解析@ComponentScans注解的屬性 封裝成一個(gè)一個(gè)的componentscan對(duì)象
   // Process any @ComponentScan annotations
   Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
   if (!componentScans.isEmpty() &&
         !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
      //循環(huán)componentScans的set
      for (AnnotationAttributes componentScan : componentScans) {
         // The config class is annotated with @ComponentScan -> perform the scan immediately
         // 立即執(zhí)行掃描解析
         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
         //檢查任何其他配置類的掃描定義集，并在需要時(shí)遞歸解析
         for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            //獲取原始的bean定義信息
            BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
            if (bdCand == null) {
               bdCand = holder.getBeanDefinition();
            }
            //檢查當(dāng)前的bean定義信息是不是配置類  比如MainConfig的bean定義信息
            if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
               //遞歸調(diào)用來解析MainConfig,解析出來配置類的中導(dǎo)入的bean定義信息
               parse(bdCand.getBeanClassName(), holder.getBeanName());
            }
         }
      }
   }
   
   //處理@Import注解   解析Import 注解的ImportSelector  ImportBeanDefinitionRegister,@Bean這種
    //存放在ConfigClass中
   // Process any @Import annotations
   processImports(configClass, sourceClass, getImports(sourceClass), true);

   //處理 @ImportResource annotations
   // 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);
      }
   }
   // 處理  @Bean methods
   // 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;
}

=========================================================
//通過組件掃描器進(jìn)行真正的解析
>org.springframework.context.annotation.ComponentScanAnnotationParser#parse

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
   //創(chuàng)建一個(gè)類路徑下的bean定義掃描器
   ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
         componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

   //為掃描器設(shè)置一個(gè)bean 名稱的生成器
   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));
}

===========================================================
>org.springframework.context.annotation.ClassPathBeanDefinitionScanner#ClassPathBeanDefinitionScanner

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
      Environment environment, @Nullable ResourceLoader resourceLoader) {

   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   this.registry = registry;

   //使用默認(rèn)的掃描規(guī)則
   if (useDefaultFilters) {
      registerDefaultFilters();
   }
   //設(shè)置環(huán)境變量
   setEnvironment(environment);
   //設(shè)置資源加載器
   setResourceLoader(resourceLoader);
}

=====================================
//默認(rèn)的掃描規(guī)則
protected void registerDefaultFilters() {
    //添加了Componet的解析，這就是我們?yōu)樯禓Componet @Respository @Service @Controller的  @AspectJ
   this.includeFilters.add(new AnnotationTypeFilter(Component.class));
   ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
   try {
      //添加Jsr 250規(guī)范的注解 
      this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
      logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
   }
   catch (ClassNotFoundException ex) {
      // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
   }
   try {
      //JSR330的注解 
      this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
      logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
   }
   catch (ClassNotFoundException ex) {
      // JSR-330 API not available - simply skip.
   }
}

===================================================
使用掃描器去真正的掃描類,返回Set<BeanDefinitionHolder>
>org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
   Assert.notEmpty(basePackages, "At least one base package must be specified");
   ////創(chuàng)建一個(gè)Bean定義 holder的 set
   Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
   //循環(huán)掃描路徑
   for (String basePackage : basePackages) {
      //找到候選的組件集合 
      Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
      //循環(huán)候選組件集合
      for (BeanDefinition candidate : candidates) {
         ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
         candidate.setScope(scopeMetadata.getScopeName());
         //生成bean的名稱
         String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
         //判斷是不是抽象的bean定義
         if (candidate instanceof AbstractBeanDefinition) {
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
         }
         
         //注解的bean定義
         if (candidate instanceof AnnotatedBeanDefinition) {
            AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
         }
         if (checkCandidate(beanName, candidate)) { //檢查當(dāng)前的和存主的bean定義是否有沖突
            //把候選的組件封裝成BeanDefinitionHolder
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            definitionHolder =
                  AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            //加入到bean定義的集合中
            beanDefinitions.add(definitionHolder);
            //注冊(cè)當(dāng)前的bean定義信息
            registerBeanDefinition(definitionHolder, this.registry);
         }
      }
   }
   return beanDefinitions;
}

=========================================================
>org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents 
    找到候選的組件 返回Set<BeanDefinition>的集合
    >org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents
    
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    // //候選的bean定義信息
   Set<BeanDefinition> candidates = new LinkedHashSet<>();
   try {
       //拼接需要掃描包下面的類的路徑   classpath*:com/niuh/testapplicationlistener/**/*.class
      String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolveBasePackage(basePackage) + '/' + this.resourcePattern;
      //把路徑解析成一個(gè)個(gè).class文件         
      Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
      boolean traceEnabled = logger.isTraceEnabled();
      boolean debugEnabled = logger.isDebugEnabled();
      //循環(huán).class文件的resource對(duì)象
      for (Resource resource : resources) {
         if (traceEnabled) {
            logger.trace("Scanning " + resource);
         }
         //判斷class文件是否可讀
         if (resource.isReadable()) {
            try {
               //把resource對(duì)象 變?yōu)橐粋€(gè)類的原信息讀取器 
               MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
               //判斷類的源信息讀取器是否為候選的組件
               if (isCandidateComponent(metadataReader)) { //是候選的組件
                  //把類元信息讀取器封裝成一個(gè)ScannedGenericBeanDefinition
                  ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                  sbd.setResource(resource);
                  sbd.setSource(resource);
                  //是候選的組件
                  if (isCandidateComponent(sbd)) {
                     if (debugEnabled) {
                        logger.debug("Identified candidate component class: " + resource);
                     }
                     //把當(dāng)前解析出來的定義的加入到 BeanDefinition的集合中
                     candidates.add(sbd);
                  }
                  else {
                     if (debugEnabled) {
                        logger.debug("Ignored because not a concrete top-level class: " + resource);
                     }
                  }
               }
               else {
                  if (traceEnabled) {
                     logger.trace("Ignored because not matching any filter: " + resource);
                  }
               }
            }
            catch (Throwable ex) {
               throw new BeanDefinitionStoreException(
                     "Failed to read candidate component class: " + resource, ex);
            }
         }
         else {
            if (traceEnabled) {
               logger.trace("Ignored because not readable: " + resource);
            }
         }
      }
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
   }
   return candidates;
}    
===========================================
是不是需要掃描的組件  
org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isCandidateComponent
    protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
        //是不是被排除的
        for (TypeFilter tf : this.excludeFilters) {
            if (tf.match(metadataReader, this.metadataReaderFactory)) {
                return false;
            }
        }
        //在被包含的組件
        for (TypeFilter tf : this.includeFilters) {
            if (tf.match(metadataReader, this.metadataReaderFactory)) {
                return isConditionMatch(metadataReader);
            }
        }
        return false;
    }   
    ==============================================================
    是否能夠進(jìn)行@Conditional判斷
    org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isConditionMatch
    private boolean isConditionMatch(MetadataReader metadataReader) {
        if (this.conditionEvaluator == null) {
            this.conditionEvaluator = new ConditionEvaluator(getRegistry(), getEnvironment(), getResourceLoader());
        }
        return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
    }