Spring的启动流程探索

刺骨的言语ヽ痛彻心扉 2023-10-14 21:36 21阅读 0赞

## run方法 ##

### 我们都知道springboot工程是通过run方法启动的，如图: ###

`Banner printedBanner = this.printBanner(environment);`就是我们熟悉的springboot工程启动的时候在控制台打印的log，我们也可以通过配置改变log的打印。

#### 一，context = this.createApplicationContext() ####

![image.png][]

我们先介绍`context = this.createApplicationContext();`方法，这个方法顾名思义是创建应用上下文的，应用上下文我们都知道是用来扫描Bean的，并且种类很多。那我们spring使用了应用上下文那些去获取Bean吗，打断点进入这个方法

![image.png][image.png 1]

可以看到在这里`new AnnotatedBeanDefinitionReader(this);`new了一个用于读取带有注解的Bean对应的BeanDefinition，还new了一个`new ClassPathBeanDefinitionScanner(this);`用于从路径读取Bean的BeanDefinition。

在new `AnnotatedBeanDefinitionReader`的时候会去调用它的构造方法，在它的构造方法里面会去将它的`AnnotatedBeanDefinitionReader`的BeanDefinition加入到`DefaultListableBeanFactory`这个类里面的`beanDefinitionNames`和`beanDefinitionMap`，这两个就是后面创建Bean必须的东西，所有Bean的注册底层都是使用的BeanDefinition。如图：

![图片1.png][1.png]

添加到`DefaultListableBeanFactory`这个类的`beanDefinitionNames`和`beanDefinitionMap`。

![image.png][image.png 2]

![图片3.png][3.png]

总的来说具体来说，`createApplicationContext()`方法会根据指定的配置文件（通常是XML文件）或Java配置类来创建和初始化ApplicationContext。配置文件中包含了应用程序中各种bean的定义和配置信息，Spring会根据这些信息创建出对应的bean实例，并将它们注入到相应的对象中，从而完成整个应用程序的初始化。

#### 二，this.prepareContext() ####

![image.png][image.png 3]

1`context.setEnvironment(environment);`这一步不用多说，就是将环境变量set到context中，设置上下文的环境。

2`this.postProcessApplicationContext(context);`这步操作主要是对`ApplicationContext`进行后置处理。那么做了哪些后置处理呢?我们点进去看下：

![image.png][image.png 4]

主要做了3部分：1.设置ApplicationContext的beanNameGenerator。2.设置ApplicationContext的ResourceLoader和ClassLoader。3.设置ApplicationContext类型转换service

3`this.applyInitializers(context);` 这个方法就是获取之前获取到的所有initializer类型的类，并进行初始化。

4`listeners.contextPrepared(context);`这个方法是通知监听器 context 准备完成；

5`if (this.logStartupInfo) { this.logStartupInfo(context.getParent() == null);`this.logStartupProfileInfo(context); \}这个代码就是打印日志，这里不做过多描述。

6`ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();`这个方法就是获取DefaultListableBeanFactory的实例。

7`beanFactory.registerSingleton(“springApplicationArguments”, applicationArguments);`这步操作是注册了一个单例，单例名为“springApplicationArguments”，值为applicationArguments。

8`if (printedBanner != null) {beanFactory.registerSingleton("springBootBanner", printedBanner);}`这步是判断printedBanner是否为空，如果不为空，就注册一个名为springBootBanner，值为printedBanner的单例

9`if (beanFactory instanceof DefaultListableBeanFactory) {((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);}`这个方法主要是配置bean如果重名，是否允许后一个bean覆盖前一个bean，默认是false，此时如果有同名的bean，注册到容器中，那么就会报异常。

10`Set<Object> sources = this.getAllSources();`获取sources列表，这里可以获取到启动类的class

![image.png][image.png 5]

11`this.load(context, sources.toArray(new Object[0]));`这个方法就是加载启动类，将启动类注入到容器里面。

![图片4.png][4.png]

可以看到`beanDefinitionNames`和`beanDefinitionMap`里面已经有6个了。都是主配置类。

![image.png][image.png 6]

12`listeners.contextLoaded(context);`这个方法我们点进去看下：

![image.png][image.png 7]

![image.png][image.png 8]

这里就是将在`SpringApplciation`的`Initialize()`方法中注册的`listener`中属于`ApplicationContextAware`类型的bean都执行方法`setApplicationContext`，同时将这些Listener都加入到`ApplicationContext`中，并发布事件`ApplicationPreparedEvent`

#### 三，this.refreshContext(context) ####

这个就是刷新容器的方法

![image.png][image.png 9]

1.`this.prepareRefresh()`，进入这个方法。

![image.png][image.png 10]

`this.startupDate = System.currentTimeMillis();`设置容器启动的时间

`this.closed.set(false);`容器的关闭标志位

`this.active.set(true);`将容器状态设置为有效，

`this.initPropertySources();`留给子类覆盖，初始化属性资源

`this.getEnvironment().validateRequiredProperties();`创建并获取环境对象，验证需要的属性文件是否都已经放入环境中。

最后去判断刷新前的应用程序监听器集合是否为空，如果为空，则将监听器添加到集合中。

#### 三，ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory() ####

这个用于获取设置容器序列化id和BeanFactory

![image.png][image.png 11]

1.`this.refreshBeanFactory();`，点进去看

![image.png][image.png 12]

首先使用了`CAS`去判断容器是否已经启动，没有启动就给`beanFactory`设置一个序列化id。

![image.png][image.png 13]

设置的序列化id就是你的服务名称。

2.`this.getBeanFactory();`，点进去看，调用了`getBeanFactory`方法获取了beanFactory，而beanFactory是在这个通用上下文构造方法里面就创建了的`DefaultListableBeanFactory`。

![image.png][image.png 14]

#### 四，this.prepareBeanFactory(beanFactory) ####

点进去看

![image.png][image.png 15]

这个方法就是给工厂设置必须的工具，比如el表达式解析器，资源解析器，后置处理器等。

#### 五，this.postProcessBeanFactory(beanFactory) ####

这个是留给子类的模板方法，允许子类对工厂执行一些处理，给Bean设置属性，单例Bean修改为多例，或者移除BeanDefinition从而避免某个Bean在spring容器中的创建。例如：

![image.png][image.png 16]

又或者用它的子类接口`BeanDefinitionRegistryPostProcessor`，如图

![image.png][image.png 17]

最后别忘记把这两个配置类注入到容器当中

![image.png][image.png 18]

#### 六，this.invokeBeanFactoryPostProcessors(beanFactory) ####

这个就是去调用Bean工厂主处理器，

![图片5.png][5.png]

java复制代码public static void invokeBeanFactoryPostProcessors(
                ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
            // Invoke BeanDefinitionRegistryPostProcessors first, if any.
            // 将已经执行过的BeanFactoryPostProcessor存储在processedBeans，防止重复执行
            Set<String> processedBeans = new HashSet<>();
    
            // 此处条件成立，BeanFactory类型为DefaultListableBeanFactory，而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口
            if (beanFactory instanceof BeanDefinitionRegistry) {
                BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
                // 用来存放BeanFactoryPostProcessor对象
                List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
                // 用来存放BeanDefinitionRegistryPostProcessor对象
                // 方便统一执行实现了BeanDefinitionRegistryPostProcessor接口父类的方法
                List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
    
                // 处理外部定义的BeanFactoryPostProcessor,将BeanDefinitionRegistryPostProcessor与BeanFactoryPostProcessor区分开
                for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                    // 如果为BeanDefinitionRegistryPostProcessor类型
                    if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                        // 强转成BeanDefinitionRegistryPostProcessor
                        BeanDefinitionRegistryPostProcessor registryProcessor =
                                (BeanDefinitionRegistryPostProcessor) postProcessor;
                        // 如果是BeanDefinitionRegistryPostProcessor类型，直接执行postProcessBeanDefinitionRegistry方法
                        registryProcessor.postProcessBeanDefinitionRegistry(registry);
                        registryProcessors.add(registryProcessor);
                    }
                    else {
                        // 如果不是BeanDefinitionRegistryPostProcessor类型
                        // 则将外部集合中的BeanFactoryPostProcessor存放到regularPostProcessors用于后续一起执行
                        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.
                // 此处的currentRegistryProcessors存放当前需要执行的BeanDefinitionRegistryPostProcessor
                List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    
                // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
                // TODO 首先，调用实现 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor。
                // 获取所有实现了BeanDefinitionRegistryPostProcessor接口的类名
                String[] postProcessorNames =
                        beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                for (String ppName : postProcessorNames) {
                    // 判断当前类是否实现了PriorityOrdered接口
                    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                        // 将BeanDefinitionRegistryPostProcessor存入currentRegistryProcessors
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        // 提前存放到processedBeans，避免重复执行，但是此处还未执行
                        processedBeans.add(ppName);
                    }
                }
                // 对currentRegistryProcessors接口中的BeanDefinitionRegistryPostProcessor进行排序，方便后续执行
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                // 添加到registryProcessors集合，用于后续执行父接口的postProcessBeanFactory方法
                registryProcessors.addAll(currentRegistryProcessors);
                // 遍历集合，执行BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry()方法
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                // 执行完毕后，将currentRegistryProcessors清空
                currentRegistryProcessors.clear();
    
                // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
                // TODO 接下来，调用实现 Ordered 的 BeanDefinitionRegistryPostProcessors。
                // 这里为什么要再次获取BeanDefinitionRegistryPostProcessor
                // 是因为有可能在上面方法执行过程中添加了BeanDefinitionRegistryPostProcessor，所以这里再次获取
                // 而下面处理BeanFactoryPostProcessor的时候又不需要重复获取了是为什么呢？
                // 因为添加BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor只能在BeanDefinitionRegistryPostProcessor
                // 中添加，在BeanFactoryPostProcessor是无法添加的，具体看方法参数就懂了
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                for (String ppName : postProcessorNames) {
                    // 判断当前bean没有被执行过，并且实现了Ordered接口
                    if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                        // getBean() 如果BeanFactory中没有该Bean则会去创建该Bean
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                    }
                }
                // 以下操作和上面是一样的，排序-->添加到registryProcessors-->执行-->清空currentRegistryProcessors
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                currentRegistryProcessors.clear();
    
                // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
                // TODO 最后处理没有实现Ordered与PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
                boolean reiterate = true;
                while (reiterate) {
                    reiterate = false;
                    // 再次获取BeanDefinitionRegistryPostProcessor
                    postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                    for (String ppName : postProcessorNames) {
                        if (!processedBeans.contains(ppName)) {
                            // 将本次要执行的BeanDefinitionRegistryPostProcessor存放到currentRegistryProcessors
                            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                            // 提前存放到processedBeans，避免重复执行
                            processedBeans.add(ppName);
                            reiterate = true;
                        }
                    }
                    // 此处的排序已经没有意义了
                    sortPostProcessors(currentRegistryProcessors, beanFactory);
                    // 将本次执行的BeanDefinitionRegistryPostProcessor添加到registryProcessors
                    registryProcessors.addAll(currentRegistryProcessors);
                    // 执行
                    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                    // 清空
                    currentRegistryProcessors.clear();
                }
    
                // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
                // TODO 现在，调用到目前为止处理的所有处理器的 postProcessBeanFactory 回调。
                invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
                invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
            }
    
            else {
                // Invoke factory processors registered with the context instance.
                // BeanFactory如果不归属于BeanDefinitionRegistry类型,则直接执行beanFactoryPostProcessor
                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.
            // 用于存放实现了priorityOrdered接口的BeanFactoryPostProcessor
            List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
            // 用于存放实现了ordered接口的BeanFactoryPostProcessor名称
            List<String> orderedPostProcessorNames = new ArrayList<>();
            // 用于存放无排序的BeanFactoryPostProcessor名称
            List<String> nonOrderedPostProcessorNames = new ArrayList<>();
            for (String ppName : postProcessorNames) {
                // 如果已经执行过了，则不做处理
                if (processedBeans.contains(ppName)) {
                    // skip - already processed in first phase above
                }
                // 如果实现了PriorityOrdered
                else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
                }
                // 如果实现了Ordered
                else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    orderedPostProcessorNames.add(ppName);
                }
                // 无排序
                else {
                    nonOrderedPostProcessorNames.add(ppName);
                }
            }
    
            // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
            // TODO 首先，调用实现 PriorityOrdered 的 BeanFactoryPostProcessor。
            sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
            // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
            // TODO 接下来，调用实现 Ordered 的 BeanFactoryPostProcessors。
            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.
            // TODO 最后，调用所有其他 BeanFactoryPostProcessor。
            List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
            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();
        }

总的来说回去执行实现了BeanFactoryPostProcessor接口的类重写的方法，直接说最重要的一个子类-ConfigurationClassPostProcessor 来看看详解：

java复制代码public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { List<BeanDefinitionHolder> configCandidates = new ArrayList<>(); //获取所有的BeanDefinitionName String[] candidateNames = registry.getBeanDefinitionNames(); for (String beanName : candidateNames) { BeanDefinition beanDef = registry.getBeanDefinition(beanName); // https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/core.html#beans-java-basic-concepts // Full @Configuration vs “lite” @Bean mode if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) || ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) { if (logger.isDebugEnabled()) { logger.debug("Bean definition has already been processed as a configuration class: " + beanDef); } } // 校验是否为配置类 // 配置类分为两种 Full @Configuration vs “lite” @Bean mode // 校验之后在 BeanDefinition 中添加标志属性 // 如果满足条件则加入到configCandidates else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) { // 如果是配置类,就放到 configCandidates 变量中 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; // 传入的 registry 是 DefaultListableBeanFactory if (registry instanceof SingletonBeanRegistry) { sbr = (SingletonBeanRegistry) registry; if (!this.localBeanNameGeneratorSet) { //获取自定义BeanNameGenerator,一般情况下为空 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(); } // Parse each @Configuration class // new ConfigurationClassParser,用来解析 @Configuration 类 ConfigurationClassParser parser = new ConfigurationClassParser( this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry); // 将 configCandidates 转成 set candidates , 去重 Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates); Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size()); do { // 解析配置类 parser.parse(candidates); parser.validate(); 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()); } // Import类,@Bean,@ImportResource 转化为 BeanDefinition this.reader.loadBeanDefinitions(configClasses); alreadyParsed.addAll(configClasses); candidates.clear(); // 再获取一下容器中BeanDefinition的数据,如果发现数量增加了,说明有新的BeanDefinition被注册了 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())) { 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(); } }

![图片1.png][1.png 1]

点进去看一下。

![image.png][image.png 19]

再点进去。

![image.png][image.png 20]

在这里会拿到主启动类，然后再去扫描主启动类下面的Bean。

从这里进去。

![image.png][image.png 21]

这就很清晰了，去获取项目中所有使用了`@Component`注解Bean。

![image.png][image.png 22]

当然，这个类`ConfigurationClassParser`里面不止扫描使用了`@Component`注解的Bean。还有`@Bean`注解等等，如图

![image.png][image.png 23]

光是知道在哪里把使用了这些注解的Bean解析出来还不够，需要知道怎么解析出来的，就像我们学习Spring的时候那样，是通过应用上下文扫描出来的，如图

![image.png][image.png 24]

点进`this.componentScanParser.parse`这个方法

![image.png][image.png 25]

可以看到`new ClassPathBeanDefinitionScanner`，在这里new了一个应用上下文扫描，这就是原理。 而且和我们介绍`context = this.createApplicationContext()`方法，里面构造函数创建的两个应用上下文中的一个是一样的。

至此项目中所有的Bean都被`invokeBeanFactoryPostProcessors`这个方法(`ConfigurationClassPostProcessor`最关键)解析出来。

![image.png][image.png 26]

并且通过`this.reader.loadBeanDefinitions(configClasses);`这个方法放到`DefaultListableBeanFactory`这个类里面的`beanDefinitionNames`和`beanDefinitionMap`，如图

![图片2.png][2.png]

点进去，再点进这个方法，

![图片3.png][3.png 1]

再点进这个方法，可以看到现在将我`beanName`为`getgiao`的Bean注册到`DefaultListableBeanFactory`这个类里面的`beanDefinitionNames`和`beanDefinitionMap`里面。

![图片4.png][4.png 1]

如图：

![image.png][image.png 27]

#### 七，this.finishBeanFactoryInitialization(beanFactory) ####

这个方法是将`DefaultListableBeanFactory`这个类里面的`beanDefinitionNames`和`beanDefinitionMap`初始化的，包括Spring三级缓存啊，这个下次再讲了。

[image.png]: https://img-blog.csdnimg.cn/img_convert/e865e933b938d2f7f0281f28f2f3d846.png
[image.png 1]: https://img-blog.csdnimg.cn/img_convert/b53def2887b12b01d24ab88b78a85dfb.png
[1.png]: https://img-blog.csdnimg.cn/img_convert/324b4f6b4b21098f1b0284f7744c934e.png
[image.png 2]: https://img-blog.csdnimg.cn/img_convert/ade208262cd09f9ca01f9ec9af1442dc.png
[3.png]: https://img-blog.csdnimg.cn/img_convert/b4743709cc8866434df6c3c6b8df7ae3.png
[image.png 3]: https://img-blog.csdnimg.cn/img_convert/f0eb684da652a0eb7511755023f7ff0c.png
[image.png 4]: https://img-blog.csdnimg.cn/img_convert/f6e18719963a31bea2e6a4630ef2705f.png
[image.png 5]: https://img-blog.csdnimg.cn/img_convert/856c37b7c48dbdfe6420c231e913d40b.png
[4.png]: https://img-blog.csdnimg.cn/img_convert/4b1fb86d66da284d719596a9f95fae26.png
[image.png 6]: https://img-blog.csdnimg.cn/img_convert/0ac7a7bf3ecd5044169a0877a4fe2fb4.png
[image.png 7]: https://img-blog.csdnimg.cn/img_convert/9b85df57d4c02f47cb6348d54461e4db.png
[image.png 8]: https://img-blog.csdnimg.cn/img_convert/c5eb07b408fa2bda9267f870a52f55a9.png
[image.png 9]: https://img-blog.csdnimg.cn/img_convert/bb0ccbec43a68c7257bbc6d852d9dc0d.png
[image.png 10]: https://img-blog.csdnimg.cn/img_convert/5bfd3dac9a50a39fbd5e6101e0579d23.png
[image.png 11]: https://img-blog.csdnimg.cn/img_convert/45d31576bfdc0f6b745f00cd909e2974.png
[image.png 12]: https://img-blog.csdnimg.cn/img_convert/8311c1f20a25983cfe584aea4cf0ea33.png
[image.png 13]: https://img-blog.csdnimg.cn/img_convert/43111219fd2b67d218dd80526ad7369e.png
[image.png 14]: https://img-blog.csdnimg.cn/img_convert/e6f07a74d67a35d559b896a00e5b65bd.png
[image.png 15]: https://img-blog.csdnimg.cn/img_convert/7402a97983a1c031b3f8a4e102f2ccc8.png
[image.png 16]: https://img-blog.csdnimg.cn/img_convert/56b69cb318340fd3242985f46b8c517c.png
[image.png 17]: https://img-blog.csdnimg.cn/img_convert/12e0895d3fc0fa99356893c533d980ca.png
[image.png 18]: https://img-blog.csdnimg.cn/img_convert/47ba2efb9914da5898cbe091fd2d4f36.png
[5.png]: https://img-blog.csdnimg.cn/img_convert/1eb9bfee2467a166987f2bcb321c9d05.png
[1.png 1]: https://img-blog.csdnimg.cn/img_convert/07b89921ce5e4d699538fcd05c10f3b7.png
[image.png 19]: https://img-blog.csdnimg.cn/img_convert/b600bc5827964c8eab785823c322d008.png
[image.png 20]: https://img-blog.csdnimg.cn/img_convert/2af76c72f93bb67be65f598cf1e27fa3.png
[image.png 21]: https://img-blog.csdnimg.cn/img_convert/ba58912f15af45dfa5efa56e0af9a4e9.png
[image.png 22]: https://img-blog.csdnimg.cn/img_convert/9b912547b4b5693410084e995ad50f86.png
[image.png 23]: https://img-blog.csdnimg.cn/img_convert/c506945497200dafdd7ab846f38bcdea.png
[image.png 24]: https://img-blog.csdnimg.cn/img_convert/edef0821a2c7a653229fe2d7c1d77a6c.png
[image.png 25]: https://img-blog.csdnimg.cn/img_convert/1b9380504b0581474847d332e3a9a101.png
[image.png 26]: https://img-blog.csdnimg.cn/img_convert/dad1c6b8472fbf5c67414485b21bc3ec.png
[2.png]: https://img-blog.csdnimg.cn/img_convert/38e8edef0bebddaa980dea81c19d6940.png
[3.png 1]: https://img-blog.csdnimg.cn/img_convert/4d2569b1d48a45c22342c3834ff8351d.png
[4.png 1]: https://img-blog.csdnimg.cn/img_convert/38291e46b89debe70350d51449d44b86.png
[image.png 27]: https://img-blog.csdnimg.cn/img_convert/7265fae650b0d4e453fe71a4e00d5b9a.png