public class AnnotationACTest {
   public static void main(String[] args) {
      // new一個應用上下文的時候,會注冊一些內(nèi)部的BeanFactoryPostProcessor的beanDefinition
 AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
 ac.register(BeanConfig.class);
 ac.refresh();
 }
}

@Configuration
@ComponentScan("com.mfy.test.bean")
@EnableAspectJAutoProxy
public class BeanConfig {
   @Bean
 public User getUser(){
      this.getWoman();
 return new User();
 }
   @Bean("women")
   public Woman getWoman(){
      System.out.println("測試@Configuration的類方法內(nèi)部調(diào)用");
 return new Woman();
 }
}

@Component
public class PropertyBean {
    private String username;
 private String password;
 public String getUsername() {
      return username;
 }
   public void setUsername(String username) {
      this.username = username;
 }
   public String getPassword() {
      return password;
 }
   public void setPassword(String password) {
      this.password = password;
 }
}

public AnnotationConfigApplicationContext() {
   // 隱式的會調(diào)用父類的構(gòu)造方法,this.beanFactory = new DefaultListableBeanFactory();
 // 此處會添加內(nèi)部的一些beanDefinition,存儲到BeanFactory的beanDefinitionMap
 this.reader = new AnnotatedBeanDefinitionReader(this);
 this.scanner = new ClassPathBeanDefinitionScanner(this);
}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
      BeanDefinitionRegistry registry, @Nullable Object source) {
   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
 if (beanFactory != null) {
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
 }
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
         beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
 }
   }
   Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
 // 判斷BeanFactory中不存在此BeanDefinition,添加ConfigurationClassPostProcessor
 // ConfigurationClassPostProcessor類負責解析處理所有@Configuration類，并將BeanDefinition注冊到BeanFactory中。
 if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
 }
   // AutowiredAnnotationBeanPostProcessor類負責處理@Autowired
 if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
 }
   // CommonAnnotationBeanPostProcessor類負責處理@Resource,@PostConstruct,@PreDestroy
 if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
 }
   // 省略了部分代碼
   return beanDefs;
}

protected void registerDefaultFilters() {
   // 此處將Component注入,用于后面的識別
 this.includeFilters.add(new AnnotationTypeFilter(Component.class));
 ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
// 省略部分代碼
}

public void register(Class<?>... componentClasses) {
   Assert.notEmpty(componentClasses, "At least one component class must be specified");
 // 解析給定的class對象,并存儲到beanDefinitionMap
 this.reader.register(componentClasses);
}

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
 @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
 @Nullable BeanDefinitionCustomizer[] customizers) {
   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
 if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
      return;
 }
   abd.setInstanceSupplier(supplier);
 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
 // 設(shè)置單例還是原型
 abd.setScope(scopeMetadata.getScopeName());
 // 設(shè)置beanName,當傳入的name為null,按照規(guī)則,自動生成名稱
 String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
 // 解析部分公共的注解(@Lazy,@Primary,@DependsOn,@Role,@Description),并將解析出來的信息填充到beanDefinition中
 AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
 if (qualifiers != null) {
      for (Class<? extends Annotation> qualifier : qualifiers) {
         if (Primary.class == qualifier) {
            abd.setPrimary(true);
 }
         else if (Lazy.class == qualifier) {
            abd.setLazyInit(true);
 }
         else {
            abd.addQualifier(new AutowireCandidateQualifier(qualifier));
 }
      }
   }
   if (customizers != null) {
      for (BeanDefinitionCustomizer customizer : customizers) {
         customizer.customize(abd);
 }
   }
   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
 definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
 // 將解析完成的beanDefinition放入beanFactory中
 BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
 prepareRefresh();
 // 獲取BeanFactory,其實是DefaultListableBeanFactory
 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 // 設(shè)置BeanFactory的類加載器，添加幾個BeanPostProcessor，手動注冊幾個特殊的bean
 prepareBeanFactory(beanFactory);
 try {
 // 擴展點,可以對beanFactory做修改
 postProcessBeanFactory(beanFactory);
 // 實例化BeanFactoryPostProcessor(new應用上下文的時候注冊的beanDefinition)并調(diào)用,作用是修改beanDefinition的信息
 // 例如internalConfigurationAnnotationProcessor,用來解析@Configuration注解類管轄的beanDefinition信息
 invokeBeanFactoryPostProcessors(beanFactory);
 // 實例化各種BeanPostProcessors,并注冊到beanFactory的beanPostProcessors屬性中
 registerBeanPostProcessors(beanFactory);
 // Initialize message source for this context.
 initMessageSource();
 // 初始化事件廣播器(給applicationEventMulticaster賦值)
 initApplicationEventMulticaster();
 // Initialize other special beans in specific context subclasses.
 onRefresh();
 // 注冊監(jiān)聽器(非@EventListener注解方式,注冊的是實現(xiàn)了ApplicationListener接口的類)
 registerListeners();
 // Instantiate all remaining (non-lazy-init) singletons.
 finishBeanFactoryInitialization(beanFactory);
 // Last step: publish corresponding event.
 finishRefresh();
 }
// 省略部分代碼
}

public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 已經(jīng)完成調(diào)用的后置處理器集合
Set<String> processedBeans = new HashSet<>();
 // 省略部分代碼
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
 // 獲取實現(xiàn)了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor實現(xiàn)類,排序之后,按順序調(diào)用
 String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 for (String ppName : postProcessorNames) {
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 processedBeans.add(ppName);
 }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
 registryProcessors.addAll(currentRegistryProcessors);
 // 目前是調(diào)用ConfigurationClassPostProcessor,解析“配置類”的包含的bean信息，變成beanDefinition存入map中
 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 currentRegistryProcessors.clear();
 // 獲取實現(xiàn)了Ordered接口的BeanDefinitionRegistryPostProcessor實現(xiàn)類,排序之后,按順序調(diào)用
 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 for (String ppName : postProcessorNames) {
         if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 processedBeans.add(ppName);
 }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
 registryProcessors.addAll(currentRegistryProcessors);
 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 currentRegistryProcessors.clear();
 // 死循環(huán)獲取其他所有的BeanDefinitionRegistryPostProcessor實現(xiàn)類,排序之后,按順序調(diào)用
 // 死循環(huán)BeanDefinitionRegistryPostProcessor實現(xiàn)類的原因是,前面的BeanDefinitionRegistryPostProcessor可能會注入新的實現(xiàn)類,
 // 所以必須重新再獲取并調(diào)用一遍
 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);
 // 遍歷BeanDefinitionRegistryPostProcessor的實現(xiàn)類,調(diào)用postProcessBeanDefinitionRegistry()
 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 currentRegistryProcessors.clear();
 }
      // 遍歷BeanDefinitionRegistryPostProcessor實現(xiàn)類,調(diào)用postProcessBeanFactory()
 // 對于ConfigurationClassPostProcessor,生成“配置”類(@Configuration)的代理類
 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
 // 遍歷非BeanDefinitionRegistryPostProcessor實現(xiàn)類(自己加進來的),調(diào)用postProcessBeanFactory(),基本不會執(zhí)行
 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
 }
   else {
      // 遍歷非BeanDefinitionRegistryPostProcessor實現(xiàn)類(自己加進來的),調(diào)用postProcessBeanFactory(),基本不會執(zhí)行
 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
 }
   // Do not initialize FactoryBeans here: We need to leave all regular beans
 // uninitialized to let the bean factory post-processors apply to them! String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
 // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
 // Ordered, and the rest. List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
 List<String> orderedPostProcessorNames = new ArrayList<>();
 List<String> nonOrderedPostProcessorNames = new ArrayList<>();
 for (String ppName : postProcessorNames) {
      // 跳過前面已經(jīng)處理過的BeanFactoryPostProcessor實現(xiàn)類
 if (processedBeans.contains(ppName)) {
         // skip - already processed in first phase above
 }
      else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
         // 通過beanFactory的getBean(),實例化BeanFactoryPostProcessor
 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
 }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
 }
      else {
         nonOrderedPostProcessorNames.add(ppName);
 }
   }
 // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
 // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
 List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
 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<>(nonOrderedPostProcessorNames.size());
 for (String postProcessorName : nonOrderedPostProcessorNames) {
      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 }
   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
   beanFactory.clearMetadataCache();
}

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
   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);
 }
   this.registriesPostProcessed.add(registryId);
 // 解析@Component,@ComponentScan,@Import,@ImportResource注解
 processConfigBeanDefinitions(registry);
}

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
 String[] candidateNames = registry.getBeanDefinitionNames();
 // 篩選具有@Component,@ComponentScan,@Import,@ImportResource注解信息的BeanDefinition
 for (String beanName : candidateNames) {
      BeanDefinition beanDef = registry.getBeanDefinition(beanName);
 if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
         if (logger.isDebugEnabled()) {
            logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
 }
      }
      else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
         // 若是無xml方式配置的,此處只會篩選出@Configuration注解的類(即ac.register(BeanConfig.class))
 configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
 }
   }
   // Return immediately if no @Configuration classes were found
 if (configCandidates.isEmpty()) {
      return;
 }
   // Sort by previously determined @Order value, if applicable
 configCandidates.sort((bd1, bd2) -> {
      int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
 int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
 return Integer.compare(i1, i2);
 });
 // Detect any custom bean name generation strategy supplied through the enclosing application context
 SingletonBeanRegistry sbr = null;
 if (registry instanceof SingletonBeanRegistry) {
      sbr = (SingletonBeanRegistry) registry;
 if (!this.localBeanNameGeneratorSet) {
         BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
               AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
 if (generator != null) {
            this.componentScanBeanNameGenerator = generator;
 this.importBeanNameGenerator = generator;
 }
      }
   }
   if (this.environment == null) {
      this.environment = new StandardEnvironment();
 }
   // 實例化ConfigurationClassParser時,會new一個ComponentScanAnnotationParser對象,
 // 用來解析@ComponentScan注解對應的bean信息
 ConfigurationClassParser parser = new ConfigurationClassParser(
         this.metadataReaderFactory, this.problemReporter, this.environment,
 this.resourceLoader, this.componentScanBeanNameGenerator, registry);
 Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
 Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
 do {
      // 解析配置類,變成beanDefinition加入beanFactory的beanDefinitionMap中
 // 最終的解析過程是委托給了一個實例化的ClassPathBeanDefinitionScanner類
 // 解析出來的配置類,存儲在parser的configurationClasses屬性中
 parser.parse(candidates);
 parser.validate();
 // 得到所有配置類的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());
 }
      // 通過ConfigurationClass加載更多的BeanDefinition,通過前面parser.parse(candidates),解析了@bean注解并保存在ConfigurationClass的beanMethods
 // 再通過beanMethods,生成BeanDefinition信息并注冊到beanDefinitionMap中
 // 將@ImportResource注解的資源引入spring
 // 將@Import注解的類,生成BeanDefinition信息并注冊到beanDefinitionMap中
 this.reader.loadBeanDefinitions(configClasses);
 alreadyParsed.addAll(configClasses);
 candidates.clear();
 // 如果進入到下面的代碼中,則表示原工程中有@Configuration注解的配置類
 if (registry.getBeanDefinitionCount() > candidateNames.length) {
         String[] newCandidateNames = registry.getBeanDefinitionNames();
 Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
 Set<String> alreadyParsedClasses = new HashSet<>();
 for (ConfigurationClass configurationClass : alreadyParsed) {
            alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
 }
         for (String candidateName : newCandidateNames) {
            if (!oldCandidateNames.contains(candidateName)) {
               BeanDefinition bd = registry.getBeanDefinition(candidateName);
 if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                     !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                  // 類似遞歸,若@Configuration注解的配置類管轄了另外的@Configuration(不在oldCandidateNames集合中),再次循環(huán)
 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();
 }
}

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) 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);
 }
   }
   // 遞歸的處理配置類configClass及其所繼承的父類
 // 從當前配置類configClass開始向上沿著類繼承結(jié)構(gòu)逐層執(zhí)行doProcessConfigurationClass(),
 // 直到遇到的父類是由Java提供的類結(jié)束循環(huán)
 SourceClass sourceClass = asSourceClass(configClass, filter);
 do {
      sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
 }
   while (sourceClass != null);
 // 需要被處理的配置類configClass已經(jīng)被分析處理，將它記錄到已處理配置類記錄
 this.configurationClasses.put(configClass, configClass);
}

protected final SourceClass doProcessConfigurationClass(
      ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
      throws IOException {
   if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
      // 遞歸處理內(nèi)部類(內(nèi)部類也有@Component注解,需要注冊到容器中)
 processMemberClasses(configClass, sourceClass, filter);
 }
   // 處理@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.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
               "]. Reason: Environment must implement ConfigurableEnvironment");
 }
   }
   // 處理@ComponentScan注解
 Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
 if (!componentScans.isEmpty() &&
         !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
      for (AnnotationAttributes componentScan : componentScans) {
         // 此configClass存在@ComponentScan注解,掃描獲取basePackages的所有bean信息
 Set<BeanDefinitionHolder> scannedBeanDefinitions =
               this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
 // Check the set of scanned definitions for any further config classes and parse recursively if needed
 for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
 if (bdCand == null) {
               bdCand = holder.getBeanDefinition();
 }
            // 判斷通過@ComponentScan掃描新加入的bdCand,是否存在@Configuration,@ComponentScan,@Component,@ImportResource,@Import注解,
 // 若有,則再次進入配置類的解析處理流程
 if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
               parse(bdCand.getBeanClassName(), holder.getBeanName());
 }
         }
      }
   }
   // 處理@Import注解,給configClass加入ImportBeanDefinitionRegistrar,后續(xù)會調(diào)用
 // getImports(),遍歷并遞歸獲取sourceClass的所有注解中包含@import注解的value值
 processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
 // 處理@ImportResource注解
 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注解，獲取注解的方法的相關(guān)元數(shù)據(jù)，比如方法名、所在類全名、返回類型、是否靜態(tài)、是否不可覆蓋等等信息
 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;
}