Spring源码分析--IOC流程

1 @Configuration//java配置类注解
2 @ComponentScan("com.wk")//设置扫描包的路径
3 public class MyAnnotation {
4 }

 1 /**
 2  * 测试类
 3  */
 4 public class Test {
 5     public static void main(String[] args) {
 6         //把spring所有的前提环境准备好了，包括spring容器还有类的实例化都完成了。
 7         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyAnnotation.class);
 8 
 9         IndexService service = (IndexService)context.getBean("service");
10         service.query();
11     }
12 }

 1     /**
 2      * 这个构造方法需要传入一个被Javaconfig注解过的配置类
 3      * 然后会把这个被注解了的配置类通过注解读取器读取后进行解析
 4      * @param annotatedClasses
 5      */
 6     public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
 7         //这里由于它有父类，故而会先调用父类的构造方法，然后才会调用自己的构造方法，
 8         //在自己的构造方法中初始化一个读取器和扫描器
 9         this();
10         //注册单个bean给容器，比如有新加的类可以使用这个方法
11         //但是注册之后需要手动调用refresh()方法去触发容器解析注解
12         register(annotatedClasses);
13         refresh();
14     }

 1 public AnnotationConfigApplicationContext() {
 2         /**
 3          * 创建一个读取注解的Bean定义读取器
 4          * 什么是Bean定义？BeanDefinition
 5          * BeanDefinition这个类是描述springBean对象的类。
 6          */
 7         this.reader = new AnnotatedBeanDefinitionReader(this);
 8         /**
 9          * 创建一个扫描器，扫描所有加了注解的类
10          * 可以用来扫描包或者类，继而转成BeanDefinition
11          * 但是我们在自己项目中使用自动扫描注解的时候，扫描包的工作不是在这个scanner对象中完成的
12          * 这里的scanner对象仅仅是为了程序员能够在外部调用AnnotationConfigApplicationContext对象的scan方法
13          */
14         this.scanner = new ClassPathBeanDefinitionScanner(this);
15     }

 1 public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
 2             BeanDefinitionRegistry registry, @Nullable Object source) {
 3 
 4         DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
 5         if (beanFactory != null) {
 6             if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
 7                 beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
 8             }
 9             if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
10                 beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
11             }
12         }
13 
14         Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
15 
16         if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
17             RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
18             def.setSource(source);
19             beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
20         }
21 
22         if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
23             RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
24             def.setSource(source);
25             beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
26         }
27 
28         // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
29         if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
30             RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
31             def.setSource(source);
32             beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
33         }
34 
35         // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
36         if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
37             RootBeanDefinition def = new RootBeanDefinition();
38             try {
39                 def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
40                         AnnotationConfigUtils.class.getClassLoader()));
41             }
42             catch (ClassNotFoundException ex) {
43                 throw new IllegalStateException(
44                         "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
45             }
46             def.setSource(source);
47             beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
48         }
49 
50         if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
51             RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
52             def.setSource(source);
53             beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
54         }
55 
56         if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
57             RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
58             def.setSource(source);
59             beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
60         }
61 
62         return beanDefs;
63     }

 1 public void refresh() throws BeansException, IllegalStateException {
 2         synchronized (this.startupShutdownMonitor) {
 3             // Prepare this context for refreshing.
 4             // 准备工作，包括设置启动时间，是否激活标识位，
 5             // 初始化属性源(property source)设置
 6             prepareRefresh();
 7 
 8             // Tell the subclass to refresh the internal bean factory.
 9             // 通过子类来获取之前注册了bean的容器工厂beanFactory
10             // 这里我们是获得DefaultListableBeanFactory这个工厂类
11             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
12 
13             // Prepare the bean factory for use in this context.
14             // 准备工厂
15             prepareBeanFactory(beanFactory);
16 
17             try {
18                 // Allows post-processing of the bean factory in context subclasses.
19                 postProcessBeanFactory(beanFactory);
20 
21                 // Invoke factory processors registered as beans in the context.
22                 // 在spring的环境中去执行已经被注册的factory processors
23                 // 设置执行自定义的ProcessorsBeanFactory和spring内部自己定义的
24                 // 其实就是执行spring内部的ConfigurationClassPostProcessor这个类
25                 invokeBeanFactoryPostProcessors(beanFactory);
26 
27                 // Register bean processors that intercept bean creation.
28                 registerBeanPostProcessors(beanFactory);
29 
30                 // Initialize message source for this context.
31                 initMessageSource();
32 
33                 // Initialize event multicaster for this context.
34                 initApplicationEventMulticaster();
35 
36                 // Initialize other special beans in specific context subclasses.
37                 onRefresh();
38 
39                 // Check for listener beans and register them.
40                 registerListeners();
41 
42                 // Instantiate all remaining (non-lazy-init) singletons.
43                 finishBeanFactoryInitialization(beanFactory);
44 
45                 // Last step: publish corresponding event.
46                 finishRefresh();
47             }
48 
49             catch (BeansException ex) {
50                 if (logger.isWarnEnabled()) {
51                     logger.warn("Exception encountered during context initialization - " +
52                             "cancelling refresh attempt: " + ex);
53                 }
54 
55                 // Destroy already created singletons to avoid dangling resources.
56                 destroyBeans();
57 
58                 // Reset ‘active‘ flag.
59                 cancelRefresh(ex);
60 
61                 // Propagate exception to caller.
62                 throw ex;
63             }
64 
65             finally {
66                 // Reset common introspection caches in Spring‘s core, since we
67                 // might not ever need metadata for singleton beans anymore...
68                 resetCommonCaches();
69             }
70         }
71     }

 1 /**
 2      * 配置其标准特征，比如上下文的加载器，ClassLoader和post-processors回调
 3      * @param beanFactory
 4      */
 5     protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 6         // Tell the internal bean factory to use the context‘s class loader etc.
 7         beanFactory.setBeanClassLoader(getClassLoader());
 8         // bean的表达式解析
 9         beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
10         // 注册属性编辑器，对象与string类型的转换
11         beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
12 
13         // Configure the bean factory with context callbacks.
14         // 添加一个后置管理器
15         beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
16         // 忽略一些接口的实现，不自动注入
17         beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
18         beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
19         beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
20         beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
21         beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
22         beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
23 
24         // BeanFactory interface not registered as resolvable type in a plain factory.
25         // MessageSource registered (and found for autowiring) as a bean.
26         beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
27         beanFactory.registerResolvableDependency(ResourceLoader.class, this);
28         beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
29         beanFactory.registerResolvableDependency(ApplicationContext.class, this);
30 
31         // Register early post-processor for detecting inner beans as ApplicationListeners.
32         beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
33 
34         // Detect a LoadTimeWeaver and prepare for weaving, if found.
35         if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
36             beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
37             // Set a temporary ClassLoader for type matching.
38             beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
39         }
40 
41         // Register default environment beans.
42         // 意思是如果自定义的Bean中没有名为"systermProperties"和"systermEnvironment"的bean
43         // 则注册两个bean，key为"systermProperties"和"systermEnvironment"，value为Map
44         // 这两个bean就是一些系统配置和系统环境信息
45         if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
46             beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
47         }
48         if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
49             beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
50         }
51         if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
52             beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
53         }
54     }

 1 protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
 2         // 这个地方需要注意getBeanFactoryPostProcessors()是获取自己继承BeanFactoryPostProcessors接口实现的类
 3         // 需要我们在AnnotationConfigApplicationContext实例对象中通过context.addBeanFactoryPostProcessor()来添加自己定义的类
 4         PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
 5 
 6         // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
 7         // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
 8         if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
 9             beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
10             beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
11         }
12     }

  1 public static void invokeBeanFactoryPostProcessors(
  2             ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  3 
  4         // Invoke BeanDefinitionRegistryPostProcessors first, if any.
  5         Set<String> processedBeans = new HashSet<>();
  6 
  7         if (beanFactory instanceof BeanDefinitionRegistry) {
  8             BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  9             List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
 10             List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
 11             //  自定义的BeanFactoryPostProcessors
 12             for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
 13                 if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
 14                     BeanDefinitionRegistryPostProcessor registryProcessor =
 15                             (BeanDefinitionRegistryPostProcessor) postProcessor;
 16                     registryProcessor.postProcessBeanDefinitionRegistry(registry);
 17                     registryProcessors.add(registryProcessor);
 18                 }
 19                 else {
 20                     regularPostProcessors.add(postProcessor);
 21                 }
 22             }
 23 
 24             // Do not initialize FactoryBeans here: We need to leave all regular beans
 25             // uninitialized to let the bean factory post-processors apply to them!
 26             // Separate between BeanDefinitionRegistryPostProcessors that implement
 27             // PriorityOrdered, Ordered, and the rest.
 28             // 这个currentRegistryProcessors放的是spring内部自己实现了的BeanDefinitionRegistryPostProcessor
 29             List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
 30 
 31             // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
 32             // getBeanNamesForType根据类的类型获取类的名字。
 33             String[] postProcessorNames =
 34                     beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 35             for (String ppName : postProcessorNames) {
 36                 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 37                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 38                     processedBeans.add(ppName);
 39                 }
 40             }
 41             // 进行排序
 42             sortPostProcessors(currentRegistryProcessors, beanFactory);
 43             // 合并list（为什么要合并，因为还有自己写的）
 44             registryProcessors.addAll(currentRegistryProcessors);
 45             // 这里很重要
 46             // currentRegistryProcessors 这个集合中只有ConfigurationClassPostProcessor这一个类
 47          invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 48 
 49             // 这个list是一个临时变量，故而要删除
 50             currentRegistryProcessors.clear();
 51 
 52             // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
 53             postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 54             for (String ppName : postProcessorNames) {
 55                 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
 56                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 57                     processedBeans.add(ppName);
 58                 }
 59             }
 60             sortPostProcessors(currentRegistryProcessors, beanFactory);
 61             registryProcessors.addAll(currentRegistryProcessors);
 62             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 63             currentRegistryProcessors.clear();
 64 
 65             // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
 66             boolean reiterate = true;
 67             while (reiterate) {
 68                 reiterate = false;
 69                 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 70                 for (String ppName : postProcessorNames) {
 71                     if (!processedBeans.contains(ppName)) {
 72                         currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 73                         processedBeans.add(ppName);
 74                         reiterate = true;
 75                     }
 76                 }
 77                 sortPostProcessors(currentRegistryProcessors, beanFactory);
 78                 registryProcessors.addAll(currentRegistryProcessors);
 79                 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 80                 currentRegistryProcessors.clear();
 81             }
 82 
 83             // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
 84             invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
 85             invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
 86         }
 87 
 88         else {
 89             // Invoke factory processors registered with the context instance.
 90             invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
 91         }
 92 
 93         // Do not initialize FactoryBeans here: We need to leave all regular beans
 94         // uninitialized to let the bean factory post-processors apply to them!
 95         String[] postProcessorNames =
 96                 beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
 97 
 98         // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
 99         // Ordered, and the rest.
100         List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
101         List<String> orderedPostProcessorNames = new ArrayList<>();
102         List<String> nonOrderedPostProcessorNames = new ArrayList<>();
103         for (String ppName : postProcessorNames) {
104             if (processedBeans.contains(ppName)) {
105                 // skip - already processed in first phase above
106             }
107             else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
108                 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
109             }
110             else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
111                 orderedPostProcessorNames.add(ppName);
112             }
113             else {
114                 nonOrderedPostProcessorNames.add(ppName);
115             }
116         }
117 
118         // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
119         sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
120         invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
121 
122         // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
123         List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
124         for (String postProcessorName : orderedPostProcessorNames) {
125             orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
126         }
127         sortPostProcessors(orderedPostProcessors, beanFactory);
128         invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
129 
130         // Finally, invoke all other BeanFactoryPostProcessors.
131         List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
132         for (String postProcessorName : nonOrderedPostProcessorNames) {
133             nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
134         }
135         invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
136 
137         // Clear cached merged bean definitions since the post-processors might have
138         // modified the original metadata, e.g. replacing placeholders in values...
139         beanFactory.clearMetadataCache();
140     }

1 private static void invokeBeanDefinitionRegistryPostProcessors(
2             Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
3         // 因为只有一条数据，所以实现的就是ConfigurationClassPostProcessor这个类中的postProcessBeanDefinitionRegistry方法
4         for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
5             postProcessor.postProcessBeanDefinitionRegistry(registry);
6         }
7     }

 1 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
 2         int registryId = System.identityHashCode(registry);
 3         if (this.registriesPostProcessed.contains(registryId)) {
 4             throw new IllegalStateException(
 5                     "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
 6         }
 7         if (this.factoriesPostProcessed.contains(registryId)) {
 8             throw new IllegalStateException(
 9                     "postProcessBeanFactory already called on this post-processor against " + registry);
10         }
11         this.registriesPostProcessed.add(registryId);
12 
13         processConfigBeanDefinitions(registry);
14     }

  1 public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
  2         // app 提供的bean也就是我们程序内提供的bean
  3         List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
  4         // 获取容器中注册的所有bean的名字
  5         String[] candidateNames = registry.getBeanDefinitionNames();
  6 
  7         for (String beanName : candidateNames) {
  8             BeanDefinition beanDef = registry.getBeanDefinition(beanName);
  9             if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
 10                 if (logger.isDebugEnabled()) {
 11                     logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
 12                 }
 13             }
 14             else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
 15                 configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
 16             }
 17         }
 18 
 19         // Return immediately if no @Configuration classes were found
 20         if (configCandidates.isEmpty()) {
 21             return;
 22         }
 23 
 24         // Sort by previously determined @Order value, if applicable
 25         configCandidates.sort((bd1, bd2) -> {
 26             int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
 27             int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
 28             return Integer.compare(i1, i2);
 29         });
 30 
 31         // Detect any custom bean name generation strategy supplied through the enclosing application context
 32         SingletonBeanRegistry sbr = null;
 33         if (registry instanceof SingletonBeanRegistry) {
 34             sbr = (SingletonBeanRegistry) registry;
 35             if (!this.localBeanNameGeneratorSet) {
 36                 BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
 37                         AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
 38                 if (generator != null) {
 39                     this.componentScanBeanNameGenerator = generator;
 40                     this.importBeanNameGenerator = generator;
 41                 }
 42             }
 43         }
 44 
 45         if (this.environment == null) {
 46             this.environment = new StandardEnvironment();
 47         }
 48 
 49         // Parse each @Configuration class
 50         ConfigurationClassParser parser = new ConfigurationClassParser(
 51                 this.metadataReaderFactory, this.problemReporter, this.environment,
 52                 this.resourceLoader, this.componentScanBeanNameGenerator, registry);
 53 
 54         Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
 55         Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
 56         do {
 57             parser.parse(candidates);
 58             parser.validate();
 59 
 60             Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
 61             configClasses.removeAll(alreadyParsed);
 62 
 63             // Read the model and create bean definitions based on its content
 64             if (this.reader == null) {
 65                 this.reader = new ConfigurationClassBeanDefinitionReader(
 66                         registry, this.sourceExtractor, this.resourceLoader, this.environment,
 67                         this.importBeanNameGenerator, parser.getImportRegistry());
 68             }
 69             this.reader.loadBeanDefinitions(configClasses);
 70             alreadyParsed.addAll(configClasses);
 71 
 72             candidates.clear();
 73             if (registry.getBeanDefinitionCount() > candidateNames.length) {
 74                 String[] newCandidateNames = registry.getBeanDefinitionNames();
 75                 Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
 76                 Set<String> alreadyParsedClasses = new HashSet<>();
 77                 for (ConfigurationClass configurationClass : alreadyParsed) {
 78                     alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
 79                 }
 80                 for (String candidateName : newCandidateNames) {
 81                     if (!oldCandidateNames.contains(candidateName)) {
 82                         BeanDefinition bd = registry.getBeanDefinition(candidateName);
 83                         if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
 84                                 !alreadyParsedClasses.contains(bd.getBeanClassName())) {
 85                             candidates.add(new BeanDefinitionHolder(bd, candidateName));
 86                         }
 87                     }
 88                 }
 89                 candidateNames = newCandidateNames;
 90             }
 91         }
 92         while (!candidates.isEmpty());
 93 
 94         // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
 95         if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
 96             sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
 97         }
 98 
 99         if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
100             // Clear cache in externally provided MetadataReaderFactory; this is a no-op
101             // for a shared cache since it‘ll be cleared by the ApplicationContext.
102             ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
103         }
104     }