Spring源码-Bean的生命周期

• 一、finishBeanFactoryInitialization(beanFactory)
• • 1.1 preInstantiateSingletons()
• 二、getBean(name)方法
• 三、doGetBean(name, null, null, false)方法
• • 3.1 用于FactoryBean的解析：transformedBeanName(name)
  • 3.2 getSingleton(beanName)
• 四、getSingleton(beanName,singletonFactory)
• • 4.1 创建单例前操作：beforeSingletonCreation(name)
  • 4.2 singletonFactory.getObject()
  • 4.3 创建单例后的操作：afterSingletonCreation(name)
  • 4.4 添加到缓存中：addSingleton(beanName, singletonObject)
• 五、createBean(beanName, mbd, args)
• • 5.1 实例化前处理：resolveBeforeInstantiation(beanName, mbdToUse)
  • • 5.1.1 applyBeanPostProcessorsBeforeInstantiation()
    • 5.1.2 applyBeanPostProcessorsAfterInitialization()
• 六、真正创建 bean 实例的方法：doCreateBean()
• • 6.1 实例化：createBeanInstance(beanName, mbd, args)
  • 6.2 applyMergedBeanDefinitionPostProcessors
  • 6.3 提前暴露对象：addSingletonFactory(name,singletonFactory)
  • 6.4 获取早期引用：getEarlyBeanReference()
  • 6.5 属性赋值：populateBean(beanName, mbd, instanceWrapper)
  • • 6.5.1 ibp.postProcessAfterInstantiation()
    • 6.5.2 根据属性名称注入：autowireByName（待补）
    • 6.5.3 根据类型进行注入：autowireByType（待补）
    • 6.5.4 自动装配功能：ibp.postProcessPropertyValues()
  • 6.6 初始化操作：initializeBean(beanName, exposedObject, mbd)
  • • 6.6.1 invokeAwareMethods(beanName, bean)
    • 6.6.2 applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)
    • 6.6.3 初始化方法：invokeInitMethods(beanName, wrappedBean, mbd)
    • 6.6.4 applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)
  • 6.7 registerDisposableBeanIfNecessary(beanName, bean, mbd)
• 七、总结

实例化所有剩余的非懒加载单例，比如invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类，在这个时候都会被初始化。实例化的过程各种BeanPostProcessor开始起作用。

• finishBeanFactoryInitialization(beanFactory)：

  protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
      // Initialize conversion service for this context.
      // 1.初始化此上下文的转换服务
      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));
      }
   
      // Register a default embedded value resolver if no bean post-processor
      // (such as a PropertyPlaceholderConfigurer bean) registered any before:
      // at this point, primarily for resolution in annotation attribute values.
      // 2.如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
      if (!beanFactory.hasEmbeddedValueResolver()) {
          beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
              @Override
              public String resolveStringValue(String strVal) {
                  return getEnvironment().resolvePlaceholders(strVal);
              }
          });
      }
   
      // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
      // 3.初始化LoadTimeWeaverAware Bean实例对象
      String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
      for (String weaverAwareName : weaverAwareNames) {
          getBean(weaverAwareName);
      }
   
      // Stop using the temporary ClassLoader for type matching.
      beanFactory.setTempClassLoader(null);
   
      // Allow for caching all bean definition metadata, not expecting further changes.
      // 4.冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了
      beanFactory.freezeConfiguration();
   
      // Instantiate all remaining (non-lazy-init) singletons.
      // 5.实例化所有剩余（非懒加载）单例对象
      beanFactory.preInstantiateSingletons();
  }
  

• preInstantiateSingletons()

  @Override
  public void F() throws BeansException {
      if (this.logger.isDebugEnabled()) {
          this.logger.debug("Pre-instantiating singletons in " + this);
      }
   
      // Iterate over a copy to allow for init methods which in turn register new bean definitions.
      // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
      // 1.创建beanDefinitionNames的副本beanNames用于后续的遍历，以允许init等方法注册新的bean定义
      List beanNames = new ArrayList(this.beanDefinitionNames);
   
      // Trigger initialization of all non-lazy singleton beans...
      // 2.遍历beanNames，触发所有非懒加载单例bean的初始化
      for (String beanName : beanNames) {
          // 3.获取beanName对应的MergedBeanDefinition
          RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
          // 4.bd对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载
          if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
              // 5.判断beanName对应的bean是否为FactoryBean
              if (isFactoryBean(beanName)) {
                  // 5.1.1 通过beanName获取FactoryBean实例
                  // 通过getBean(&beanName)拿到的是FactoryBean本身；通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
                  final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
                  // 5.1.2 判断这个FactoryBean是否希望急切的初始化
                  boolean isEagerInit;
                  if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                      isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
                          @Override
                          public Boolean run() {
                              return ((SmartFactoryBean) factory).isEagerInit();
                          }
                      }, getAccessControlContext());
                  } else {
                      isEagerInit = (factory instanceof SmartFactoryBean &&
                              ((SmartFactoryBean) factory).isEagerInit());
                  }
                  if (isEagerInit) {
                      // 5.1.3 如果希望急切的初始化，则通过beanName获取bean实例
                      getBean(beanName);
                  }
              } else {
                  // 5.2.1 如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例
                  getBean(beanName);
              }
          }
      }
   
      // Trigger post-initialization callback for all applicable beans...
      // 6.遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
      for (String beanName : beanNames) {
          // 6.1 拿到beanName对应的bean实例
          Object singletonInstance = getSingleton(beanName);
          // 6.2 判断singletonInstance是否实现了SmartInitializingSingleton接口
          if (singletonInstance instanceof SmartInitializingSingleton) {
              final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
              // 6.3 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
              if (System.getSecurityManager() != null) {
                  AccessController.doPrivileged(new PrivilegedAction