https://zhuanlan.zhihu.com/p/83475033

一、前言

在介绍了 obtainFreshBeanFactory、invokeBeanFactoryPostProcessors、registerBeanPostProcessors 三个重要方法后，我们终于来到了最后一个重要方法：finishBeanFactoryInitialization。finishBeanFactoryInitialization 是这四个方法中最复杂也是最重要的，是整个 Spring IoC 核心中的核心。

二、概述

该方法会实例化所有剩余的非懒加载单例 bean。除了一些内部的 bean、实现了 BeanFactoryPostProcessor 接口的 bean、实现了 BeanPostProcessor 接口的 bean，其他的非懒加载单例 bean 都会在这个方法中被实例化，并且 BeanPostProcessor 的触发也是在这个方法中。

三、前置知识

不过在阅读源码之前，还是需要了解一些知识的。

  1. 什么是 FactoryBean ？
  2. FactoryBean 是如何使用的 ？

参考文章：14(1)-Spring源码refresh-BeanFactory和FactoryBean

四、正文

首先我们回到AbstractApplicationContext.refresh() 方法，找到代码：finishBeanFactoryInitialization(beanFactory)，单击该行代码跳转到具体的实现。

  1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  2.     // Initialize conversion service for this context.
  3.     // 初始化类型转换器
  4.     if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  5.             beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  6.         beanFactory.setConversionService(
  7.                 beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  8.     }
  10.     // Register a default embedded value resolver if no bean post-processor
  11.     // (such as a PropertyPlaceholderConfigurer bean) registered any before:
  12.     // at this point, primarily for resolution in annotation attribute values.
  13.     // 主要用于注释属性值的解析
  14.     if (!beanFactory.hasEmbeddedValueResolver()) {
  15.         beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  16.     }
  18.     // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  19.     // 尽早初始化 LoadTimeWeaverAware Bean，以便尽早注册其转换器。
  20.     String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  21.     for (String weaverAwareName : weaverAwareNames) {
  22.         getBean(weaverAwareName);
  23.     }
  25.     // Stop using the temporary ClassLoader for type matching.
  26.     // 停止使用临时的ClassLoader进行类型匹配。
  27.     beanFactory.setTempClassLoader(null);
  29.     // Allow for caching all bean definition metadata, not expecting further changes.
  30.     // 设置 beanDefinition 元数据 不可以再修改
  31.     beanFactory.freezeConfiguration();
  33.     // Instantiate all remaining (non-lazy-init) singletons.
  34.     // 实例化单例 bean
  35.     beanFactory.preInstantiateSingletons();
  36. }

这里重点关注最后一行
beanFactory.preInstantiateSingletons();


4.1、preInstantiateSingletons

  1. @Override
  2. public void preInstantiateSingletons() throws BeansException {
  3.     // 1.创建beanDefinitionNames的副本beanNames用于后续的遍历，
  4.     // 以允许init等方法注册新的bean定义
  5.     List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
  7.     // 2.遍历beanNames，触发所有非懒加载单例bean的初始化
  8.     for (String beanName : beanNames) {
  9.         // 3.获取beanName对应的MergedBeanDefinition
  10.         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  11.         // 4.bd对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载
  12.         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  13.             // 5.判断beanName对应的bean是否为FactoryBean
  14.             if (isFactoryBean(beanName)) {
  15.                 // 5.1 通过beanName获取FactoryBean实例
  16.                 // 通过getBean(&beanName)拿到的是FactoryBean本身；通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
  17.                 final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
  18.                 // 5.2 判断这个FactoryBean是否希望急切的初始化
  19.                 boolean isEagerInit;
  20.                 if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  21.                     isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
  22.                         @Override
  23.                         public Boolean run() {
  24.                             return ((SmartFactoryBean<?>) factory).isEagerInit();
  25.                         }
  26.                     }, getAccessControlContext());
  27.                 } else {
  28.                     isEagerInit = (factory instanceof SmartFactoryBean &&
  29.                             ((SmartFactoryBean<?>) factory).isEagerInit());
  30.                 }
  31.                 if (isEagerInit) {
  32.                     // 5.3 如果希望急切的初始化，则通过beanName获取bean实例
  33.                     getBean(beanName);
  34.                 }
  35.             } else {
  36.                 // 6.如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例
  37.                 getBean(beanName);
  38.             }
  39.         }
  40.     }
  41.     // Trigger post-initialization callback for all applicable beans...
  42.     // 7.遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
  43.     for (String beanName : beanNames) {
  44.         // 7.1 拿到beanName对应的bean实例
  45.         Object singletonInstance = getSingleton(beanName);
  46.         // 7.2 判断singletonInstance是否实现了SmartInitializingSingleton接口
  47.         if (singletonInstance instanceof SmartInitializingSingleton) {
  48.             final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  49.             // 7.3 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
  50.             if (System.getSecurityManager() != null) {
  51.                 AccessController.doPrivileged(new PrivilegedAction<Object>() {
  52.                     @Override
  53.                     public Object run() {
  54.                         smartSingleton.afterSingletonsInstantiated();
  55.                         return null;
  56.                     }
  57.                 }, getAccessControlContext());
  58.             } else {
  59.                 smartSingleton.afterSingletonsInstantiated();
  60.             }
  61.         }
  62.     }
  63. }

MergedBeanDefinition可以参考
14(3)-Spring源码-MergeBeanDefinition源码分析

关于FactoryBean和BeanFactory的可以参考
14-Spring源码扩展-BeanFactory和FactoryBean
判断**beanName**对应的**bean**是**FactoryBean**的时候执行的逻辑：