Spring源码解析-IOC控制反转（四）准备Bean容器，初始化非懒加载的Singletons

特别声明： 以下内容均为个人研究学习，如有错误，请大牛提出指正。
接上篇《Spring源码解析-IOC控制反转（三）生成BeanDefinitionHolder，注册Bean》
上篇讲到将beanName和BeanDefinition 一对一放到BeanDefinitionMap中， 这个Map就是注册中心的核心。
我们再回到refresh（）方法中

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 记录启动时间
      // 标记为启动
      prepareRefresh();

      // 销毁旧的BeanFactory，创建新的BeanFactory
      // 将文件转成resource，再转成dom树，取值生成BeanDefinitionHolder
      // 将BeanDefinition保存到注册中心，并完成注册事件
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 准备Bean容器
      // 设置BeanFactory的内部属性
      prepareBeanFactory(beanFactory);

      try {
         // 提供给子类的拓展点，子类可以在此处实现一些订制
         postProcessBeanFactory(beanFactory);

         // 调用所有的BeanFactoryPostProcessors
         invokeBeanFactoryPostProcessors(beanFactory);

         // 注册所有能被创建的BeanPostProcessor
         registerBeanPostProcessors(beanFactory);

         // 在此可以实现国际化.
         initMessageSource();

         // 初始化ApplicationContext的事件广播器
         initApplicationEventMulticaster();

         // 钩子方法，提供给子类的拓展点
         onRefresh();

         // 注册事件监听器
         registerListeners();

         // 初始化所有非懒加载的singletons
         // 此处是重点核心
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

到目前为止就已经完成了初始化Bean容器，并进行了注册。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // 设置类加载器为AppliicationContext的类加载器.
   beanFactory.setBeanClassLoader(getClassLoader());
   // 设置Bean表达式解析器
   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   // 添加一个后置处理器，做ApplicationContextAwareProcessor包含的特殊的bean的回调
   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
   // 配置以下几个特殊的bean 不做处理，
   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

   // 配置几个特殊的Bean.
   // MessageSource 如果被自动注入的话，则注册为一个Bean.
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   //  添加一个后置处理器，也可以理解为注册事件监听器
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // 检测到LOAD_TIME_WEAVER_BEAN_NAME，添加特殊处理
   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      // Set a temporary ClassLoader for type matching.
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }

   // 如果以下几个默认的Bean没有被注册，则自动注册默认Bean
   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
   }
}

在准备Bean容器中，对一些特殊的Bean做了默认处理。比如设置默认值，自动注册等。还添加了一些特殊的后置处理器，注册了事件监听器。

refresh()中提到BeanPostProcessor和BeanFactoryPostProcessor，
此处补充说明一点：BeanPostProcessor是Bean级别的处理，BeanFactoryPostProcessor是BeanFactory级别的处理。因此执行顺序应当是初始化Bean容器之后调用BeanFactoryPostProcessor，然后初始化Bean，再调用BeanPostProcessor。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // 初始化 conversionService 
   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
      beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
   }

   // 注册一个默认的EmbeddedValueResolver
   // (such as a PropertyPlaceholderConfigurer bean) registered any before:
   // at this point, primarily for resolution in annotation attribute values.
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // 初始化LoadTimeWeaver
   // Spring用来在将类加载到Java虚拟机(JVM)中时动态地转换类
   // 可以在类加载的时候进行织入
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

   // 停止使用临时的类加载器
   beanFactory.setTempClassLoader(null);

   // 停止Bean执行其他的定义，解析，加载，注册
   beanFactory.freezeConfiguration();

   // 初始化剩下的非懒加载的Singletons
   beanFactory.preInstantiateSingletons();
}

接下来就是初始化剩下的非懒加载的Singletons。
这里补充说明一点：在BeanDefinition类定义中，只有2种类型
一种是SINGLETON，另一种是PROTOTYPE。

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

   /**
    * Scope identifier for the standard singleton scope: {@value}.
    * <p>Note that extended bean factories might support further scopes.
    * @see #setScope
    * @see ConfigurableBeanFactory#SCOPE_SINGLETON
    */
   String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;

   /**
    * Scope identifier for the standard prototype scope: {@value}.
    * <p>Note that extended bean factories might support further scopes.
    * @see #setScope
    * @see ConfigurableBeanFactory#SCOPE_PROTOTYPE
    */
   String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
}

// DefaultListableBeanFactory 846
public void preInstantiateSingletons() throws BeansException {
   if (logger.isTraceEnabled()) {
      logger.trace("Pre-instantiating singletons in " + this);
   }

   // 复制一份beanDefinitionNames的List
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   // 遍历beanDefinitionNames，触发所有的非懒加载singleton
   for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 只处理非抽象，非懒加载的Singleton
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         // 判断是否为FactoryBean
         if (isFactoryBean(beanName)) {
            // 若是，则在名字前面 加个 "&" 
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
               final FactoryBean<?> factory = (FactoryBean<?>) bean;
               boolean isEagerInit;
               // 判断是否是SmartFactoryBean
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                  isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                              ((SmartFactoryBean<?>) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean<?>) factory).isEagerInit());
               }
               if (isEagerInit) {
                  getBean(beanName);
               }
            }
         }
         else {
            getBean(beanName);
         }
      }
   }

   
   // 判断是否为SmartInitializingSingleton，是的话就回调
   for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
     
      if (singletonInstance instanceof SmartInitializingSingleton) {
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
               smartSingleton.afterSingletonsInstantiated();
               return null;
            }, getAccessControlContext());
         }
         else {
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

在以上代码中第一个循环就完成所有非懒加载的singleton的初始化。

接下篇《Spring源码解析-IOC控制反转（五）getBean,createBean》

特别声明，以上内容均是粗略解读， 还有许多细节未曾解析，等以后慢慢熟悉整个源码，会一一改进。欢迎各位大牛予以指正。