Spring-IOC从ApplicationContext角度看bean的加载流程【五】finishBeanFactoryInitialization

重要方法：finishBeanFactoryInitialization：
实例化所有剩余的(非惰性初始化)单例。

finishBeanFactoryInitialization(beanFactory);

完成此上下文的bean工厂的初始化，初始化所有剩余的单例bean。

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));
    }

    // 如果之前没有任何bean后处理器(例如PropertyPlaceholderConfigurer bean)注册，
    // 则注册一个默认的嵌入式值解析器:此时，主要用于在注释属性值中解析。
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // 尽早初始化LoadTimeWeaverAware bean，以便尽早注册它们的转换器。
    // LoadTimeWeaver用于当类被载入jvm时，动态转化类。
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        // 实例化bean,最终会调用AbstractBeanFactory的doGetBean方法
        // doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly)
        getBean(weaverAwareName);
    }

    // 停止使用临时类加载器进行类型匹配
    beanFactory.setTempClassLoader(null);

    // 允许缓存所有bean定义元数据，不期望有进一步的更改。
    beanFactory.freezeConfiguration();

    // 实例化所有剩余的(非惰性初始化)单例。
    // 这里由DefaultListableBeanFactory实现
    beanFactory.preInstantiateSingletons();
}

有两块比较重要的部分：

1. weaverAware bean的加载，切面植入，入AspectJWeavingEnabler，AOP的知识打算后面再研究。
2. 实例化所有非惰性初始化的单例

1、beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);

根据LoadTimeWeaverAware类型获取所有的实现beanName,由DefaultListableBeanFactory实现：

@Override
   public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
       // 是否可以缓存所有bean的bean定义元数据。
       if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
           return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
       }
       //缓存中存在就从缓存中获取
       Map<Class<?>, String[]> cache =
               (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
       String[] resolvedBeanNames = cache.get(type);
       if (resolvedBeanNames != null) {
           return resolvedBeanNames;
       }
       resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
       //加入缓存
       if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {
           cache.put(type, resolvedBeanNames);
       }
       return resolvedBeanNames;
   }

   private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
       List<String> result = new ArrayList<>();

       // 检查所有bean定义。
       for (String beanName : this.beanDefinitionNames) {
           //只有当bean名称没有定义为其他bean的别名时，才认为bean是合格的。
           if (!isAlias(beanName)) {
               try {
                   //获取RootBeanDefinition
                   RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                   // 只有当bean定义完成时才检查它。
                   if (!mbd.isAbstract() && (allowEagerInit ||
                           (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
                                   !requiresEagerInitForType(mbd.getFactoryBeanName()))) {
                       // 对于FactoryBean，匹配FactoryBean创建的对象。
                       boolean isFactoryBean = isFactoryBean(beanName, mbd);
                       BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
                       boolean matchFound =
                               (allowEagerInit || !isFactoryBean ||
                                       (dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&
                                       (includeNonSingletons ||
                                               (dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&
                                       isTypeMatch(beanName, type);
                       if (!matchFound && isFactoryBean) {
                           // 对于FactoryBean，接下来尝试匹配FactoryBean实例本身。
                           beanName = FACTORY_BEAN_PREFIX + beanName;
                           matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
                       }
                       if (matchFound) {
                           result.add(beanName);
                       }
                   }
               } catch (CannotLoadBeanClassException ex) {
                   if (allowEagerInit) {
                       throw ex;
                   }
                   // Probably a class name with a placeholder: let's ignore it for type matching purposes.
                   if (logger.isTraceEnabled()) {
                       logger.trace("Ignoring bean class loading failure for bean '" + beanName + "'", ex);
                   }
                   onSuppressedException(ex);
               } catch (BeanDefinitionStoreException ex) {
                   if (allowEagerInit) {
                       throw ex;
                   }
                   // Probably some metadata with a placeholder: let's ignore it for type matching purposes.
                   if (logger.isTraceEnabled()) {
                       logger.trace("Ignoring unresolvable metadata in bean definition '" + beanName + "'", ex);
                   }
                   onSuppressedException(ex);
               }
           }
       }

       //也检查手动注册的单例。
       for (String beanName : this.manualSingletonNames) {
           try {
               // 对于FactoryBean，匹配FactoryBean创建的对象。
               if (isFactoryBean(beanName)) {
                   if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
                       result.add(beanName);
                       // 为这个bean找到匹配:不再匹配FactoryBean本身。
                       continue;
                   }
                   // 对于FactoryBean，接下来尝试匹配FactoryBean本身。
                   // "&"
                   beanName = FACTORY_BEAN_PREFIX + beanName;
               }
               // 匹配原始bean实例(可能是原始FactoryBean)。
               if (isTypeMatch(beanName, type)) {
                   result.add(beanName);
               }
           } catch (NoSuchBeanDefinitionException ex) {
               // 不应该发生-可能是循环引用解析的结果…
               if (logger.isTraceEnabled()) {
                   logger.trace("Failed to check manually registered singleton with name '" + beanName + "'", ex);
               }
           }
       }

       return StringUtils.toStringArray(result);
   }

2、beanFactory.preInstantiateSingletons();

实例化所有剩余的(非惰性初始化)单例。也由DefaultListableBeanFactory实现：

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

      // 迭代一个副本以允许init方法，而init方法反过来注册新的bean定义。
      // 虽然这可能不是常规的工厂引导程序的一部分，但它在其他方面也可以正常工作。
      List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

      // 触发所有非惰性单例bean的初始化…
      for (String beanName : beanNames) {
          //获取RootBeanDefinition
          RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
          //非惰性单例
          if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
              //isFactoryBean
              if (isFactoryBean(beanName)) {
                  //拼接"&"
                  //实例化bean
                  Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                  if (bean instanceof FactoryBean) {
                      final FactoryBean<?> factory = (FactoryBean<?>) bean;
                      boolean isEagerInit;
                      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) {
                          //实例化bean
                          getBean(beanName);
                      }
                  }
              } else {
                  //实例化bean
                  getBean(beanName);
              }
          }
      }

      // 为所有适用的bean触发初始化后回调…
      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();
              }
          }
      }
  }

最终都调用了getBean(beanName)方法。