Spring IOC容器源码解析之扩展原理

知识点：spring源码解析之扩展原理BeanFactoryPostProcessor和BeanDefinitionPostProcessor和ApplicationListener

1、Spring 是如何发布事件？ApplicationListener

一、 本身写一个NiuhApplicationListener 实现 ApplicationListener，而且把该组件加到容器中

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

@Component
public class NiuhApplicationListener implements ApplicationListener {

    // 接收到消息，回调该方法
    @Override
    public void onApplicationEvent(ApplicationEvent applicationEvent) {
        System.out.println("NiuhApplicationListener 接收到一个事件：" + applicationEvent);
    }
}

    
public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
    // 手动发布一个事件

    context.publishEvent(new ApplicationEvent("我手动发布了一个事件") {
        @Override
        public Object getSource() {
            return super.getSource();
        }
    });

    // 容器关闭也发布事件
    context.close();
}   
复制代码

测试结果：

NiuhApplicationListener 接收到一个事件：org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@7bfcd12c: startup date [Fri Jul 05 12:58:12 CST 2019]; root of context hierarchy]
NiuhApplicationListener 接收到一个事件：com.niuh.SpringTest$1[source=我手动发布了一个事件]
NiuhApplicationListener 接收到一个事件：org.springframework.context.event.ContextClosedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@7bfcd12c: startup date [Fri Jul 05 12:58:12 CST 2019]; root of context hierarchy]
复制代码

源码解析：

i1>org.springframework.context.support.AbstractApplicationContext#refresh
i2 >org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster （初始化事件多播器）
i3  >org.springframework.context.support.AbstractApplicationContext#registerListeners （把事件监听器注册到多播器）
复制代码

• 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)) {
      // 建立一个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 + "]");
      }
   }
   // 容器中不包含一个beanName 为applicationEventMulticaster的多播器组件
   else {
      // 建立一个 SimpleApplicationEventMulticaster 多播器
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      // 注册到容器中
      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： 把容器中的监听器注册到多播器上去 源码解析

/**
 * 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. // 去容器中把applicationListener捞取出来注册到多播器上去 （系统的） 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! // 咱们本身实现了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... // 在这里以前，咱们早期想发布的事件因为没有多播器没有发布，在这里咱们总算有了本身的多播器，能够在这里发布早期堆积的事件了 Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents; this.earlyApplicationEvents = null; if (earlyEventsToProcess != null) { for (ApplicationEvent earlyEvent : earlyEventsToProcess) { getApplicationEventMulticaster().multicastEvent(earlyEvent); } } } -------------------------------如何发布事件的-------------------------------- public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) { ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event)); // 获取到全部的监听器 for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) { // 看spring容器中是否支持线程池，异步发送事件 Executor executor = getTaskExecutor(); if (executor != null) { executor.execute(() -> invokeListener(listener, event)); } else { // 同步发送事件 invokeListener(listener, event); } } } private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) { try { // 调用对于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;
      }
   }
}
复制代码

2、BeanDefinitionRegistryPostProcessor 的处理源码流程

执行时机：全部的bean定义信息将要被加载到容器中，Bean实例尚未被初始化。

@Component
public class NiuhBeanDefinationRegisterPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println("NiuhBeanDefinationRegisterPostProcessor的postProcessBeanDefinitionRegistry方法");
        System.out.println("bean定义的数量：" + beanDefinitionRegistry.getBeanDefinitionCount());
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(NiuhLog.class);
        beanDefinitionRegistry.registerBeanDefinition("niuhLog",rootBeanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("NiuhBeanDefinationRegisterPostProcessor的postProcessBeanFactory方法");
        System.out.println(configurableListableBeanFactory.getBeanDefinitionCount());
    }
}
复制代码

3、BeanFactoryPostProcessor 处理流程

执行时间：全部的Bean定义信息已经加载到容器中，可是Bean实例尚未被初始化。

@Component
public class NiuhBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("IOC容器调用了NiuhBeanFactoryPostProcessor的postProcessBeanFactory方法");
        for(String name:beanFactory.getBeanDefinitionNames()) {
            if("niuhLog".equals(name)) {
                BeanDefinition beanDefinition = beanFactory.getBeanDefinition(name);
                beanDefinition.setLazyInit(true);
            }

        }
    }
}
复制代码

调用链：

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标记处源码解析 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容器强制转为BeanDefinitionRegistry类型的 
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      // 建立一个普通的PostProcessors的list组件
      List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
      // 建立一个BeanDefinitionRegistryPostProcessor类型的list
      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
      
      // 处理容器硬编码（new 出来的）带入的beanFactoryProcessor    
      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
          //判断是否是BeanDefinitionRegistryPostProcessor
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            //调用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.
      //建立一个当前注册的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) {
          //判断是否是实现了PriorityOrdered接口的
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
             //添加到currentRegistryProcessors的集合中
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            //添加到processedBeans的集合中
            processedBeans.add(ppName);
         }
      }
      //进行排序
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      //调用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) {
          //排除被处理过的，而且实现了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);
      //调用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
      //调用普通的BeanDefinitionRegistryPostProcessors没用实现 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.
      //调用上诉实现了也实现了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.
   //分离实现了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.
   // 调用 PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
   //调用 Ordered.
   List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
   for (String postProcessorName : orderedPostProcessorNames) {
      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

   // Finally, invoke all other BeanFactoryPostProcessors.
   //调用普通的
   List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
   for (String postProcessorName : nonOrderedPostProcessorNames) {
      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

   // Clear cached merged bean definitions since the post-processors might have
   // modified the original metadata, e.g. replacing placeholders in values...
   beanFactory.clearMetadataCache();
}
复制代码

• i5标记处源码解析，org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
   //没有解析以前，系统候选的bean定义配置(有本身的 有系统自带的)
   String[] candidateNames = registry.getBeanDefinitionNames();
   //循环Bean定义的名称 找出本身的传入的主配置类的bean定义信息  configCandidates
   for (String beanName : candidateNames) {
      BeanDefinition beanDef = registry.getBeanDefinition(beanName);
      //检查该bean定义对象是否是用来描述配置类
      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();
   }

    /***建立一个配置类解析器
		1)元数据读取器工厂
		this.metadataReaderFactory = metadataReaderFactory;
		2)问题报告器
		this.problemReporter = problemReporter;
		//设置环境
		this.environment = environment;
		3)资源加载器
		this.resourceLoader = resourceLoader;
		4）建立了一个组件扫描器
		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);
   //已经被解析的配置类(因为do while 那么mainclass就必定会被解析,被解析的size为1)
   Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
   do {
       //经过配置解析器真正的解析配置类
      parser.parse(candidates);
      //进行校验
      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是直接注册Bean定义信息的    可是经过获取@Import,@Bean这种的注解尚未注册的bean定义,
      this.reader.loadBeanDefinitions(configClasses);
      //把系统解析过咱们本身的组件放在alreadyParsed
      alreadyParsed.addAll(configClasses);
      //清除解析过的 配置文件 
      candidates.clear();
      
      //已经注册的bean定义个数大于最新 开始系统+主配置类的(发生过解析)
      if (registry.getBeanDefinitionCount() > candidateNames.length) {
          //获取系统+本身解析的+mainconfig的bean定义信息
         String[] newCandidateNames = registry.getBeanDefinitionNames();
         //系统的+mainconfig的bean定义信息
         Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
         //已经解析过的本身的组件
         Set<String> alreadyParsedClasses = new HashSet<>();
         for (ConfigurationClass configurationClass : alreadyParsed) {
            alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
         }
         for (String candidateName : newCandidateNames) {
             //老的（系统+mainconfig） 不包含解析的
            if (!oldCandidateNames.contains(candidateName)) {
                //把当前bean定义获取出来
               BeanDefinition bd = registry.getBeanDefinition(candidateName);
               //检查是否为解析过的
               if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                     !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                  //若不是解析过且经过检查的     把当前的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标记处源码解析 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. // 递归处理配置类及其超类层次结构。 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注解的属性 封装成一个一个的componentscan对象 // 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)) { //循环componentScans的set for (AnnotationAttributes componentScan : componentScans) { // The config class is annotated with @ComponentScan -> perform the scan immediately // 当即执行扫描解析 Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName()); // Check the set of scanned definitions for any further config classes and parse recursively if needed //检查任何其余配置类的扫描定义集，并在须要时递归解析 for (BeanDefinitionHolder holder : scannedBeanDefinitions) { //获取原始的bean定义信息 BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition(); if (bdCand == null) { bdCand = holder.getBeanDefinition(); } //检查当前的bean定义信息是否是配置类 好比MainConfig的bean定义信息 if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) { //递归调用来解析MainConfig,解析出来配置类的中导入的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; } ========================================================= //经过组件扫描器进行真正的解析 >org.springframework.context.annotation.ComponentScanAnnotationParser#parse public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) { //建立一个类路径下的bean定义扫描器 ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader); //为扫描器设置一个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; //使用默认的扫描规则 if (useDefaultFilters) { registerDefaultFilters(); } //设置环境变量 setEnvironment(environment); //设置资源加载器 setResourceLoader(resourceLoader); } ===================================== //默认的扫描规则 protected void registerDefaultFilters() { //添加了Componet的解析，这就是咱们为啥@Componet @Respository @Service @Controller的 @AspectJ this.includeFilters.add(new AnnotationTypeFilter(Component.class)); ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader(); try { //添加Jsr 250规范的注解 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"); ////建立一个Bean定义 holder的 set Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>(); //循环扫描路径 for (String basePackage : basePackages) { //找到候选的组件集合 Set<BeanDefinition> candidates = findCandidateComponents(basePackage); //循环候选组件集合 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)) { //检查当前的和存主的bean定义是否有冲突 //把候选的组件封装成BeanDefinitionHolder BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName); definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); //加入到bean定义的集合中 beanDefinitions.add(definitionHolder); //注册当前的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; //把路径解析成一个个.class文件 Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath); boolean traceEnabled = logger.isTraceEnabled(); boolean debugEnabled = logger.isDebugEnabled(); //循环.class文件的resource对象 for (Resource resource : resources) { if (traceEnabled) { logger.trace("Scanning " + resource); } //判断class文件是否可读 if (resource.isReadable()) { try { //把resource对象 变为一个类的原信息读取器 MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource); //判断类的源信息读取器是否为候选的组件 if (isCandidateComponent(metadataReader)) { //是候选的组件 //把类元信息读取器封装成一个ScannedGenericBeanDefinition ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); sbd.setResource(resource); sbd.setSource(resource); //是候选的组件 if (isCandidateComponent(sbd)) { if (debugEnabled) { logger.debug("Identified candidate component class: " + resource); } //把当前解析出来的定义的加入到 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; } ============================================================== 是否可以进行@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()); } 复制代码