（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()#finishBeanFactoryInitialization

叁歲伎倆 2023-05-30 09:26 15阅读 0赞

**AnnotationConfigApplicationContext容器初始化目录**  
[（Spring源码分析）AnnotationConfigApplicationContext容器初始化 this() && register()][Spring_AnnotationConfigApplicationContext_ this_ _ register]  
[（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()\#invokeBeanFactoryPostProcessors][Spring_AnnotationConfigApplicationContext_ refresh_invokeBeanFactoryPostProcessors]  
[（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()\#registerBeanPostProcessors][Spring_AnnotationConfigApplicationContext_ refresh_registerBeanPostProcessors]  
[（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()\#finishBeanFactoryInitialization][Spring_AnnotationConfigApplicationContext_ refresh_finishBeanFactoryInitialization]

### 目录 ###

*  3.3、finishBeanFactoryInitialization(beanFactory)
 *   *  beanFactory.preInstantiateSingletons()
     *   *  getBean(beanName)
         *  doGetBean(name, null, null, false)
         *   *  getSingleton(beanName)
             *   *  getSingleton(beanName, true)
             *  createBean(beanName, mbd, args)
             *   *  resolveBeforeInstantiation(beanName, mbdToUse)
                 *   *  applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)
                     *  applyBeanPostProcessorsAfterInitialization(bean, beanName)
                 *  doCreateBean(beanName, mbdToUse, args)
                 *   *  applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)
                     *  bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName)
                 *  populateBean(beanName, mbd, instanceWrapper)
                 *   *  applyPropertyValues(beanName, mbd, bw, pvs)
                     *  valueResolver.resolveValueIfNecessary(pv, originalValue)
                     *  resolveReference(argName, ref)
             *  getSingleton(beanName, singletonFactory)
             *   *   *  addSingleton(beanName, singletonObject)

# 3.3、finishBeanFactoryInitialization(beanFactory) #

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
    	// Initialize conversion service for this context.
    	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.
    	if (!beanFactory.hasEmbeddedValueResolver()) { 
    		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    	}
    
    	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    	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.
    	beanFactory.freezeConfiguration();
    
    	// Instantiate all remaining (non-lazy-init) singletons.
    	// 初始化非懒加载的bean
    	beanFactory.preInstantiateSingletons();
    }

## beanFactory.preInstantiateSingletons() ##

@Override
    public void preInstantiateSingletons() throws BeansException { 
      if (logger.isDebugEnabled()) { 
        logger.debug("Pre-instantiating singletons in " + this);
      }
    
      // 所有bean的beanName
      // 可能需要实例化的class（lazy、scope）：懒加载的不实例化，非单例的不实例化
      List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
      // 触发所有非延迟加载单例beans的初始化，主要步骤为调用getBean()方法来对bean进行初始化
      for (String beanName : beanNames) { 
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {  // 当BeanDefinition是抽象的，并且不是单例的，并且是懒加载的就不实例化bean
          if (isFactoryBean(beanName)) {  // 当该bean继承了FactoryBean时
            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) { 
                getBean(beanName);
              }
            }
          }
          else { 
            getBean(beanName); // 初始化该bean
          }
        }
      }
    
      // Trigger post-initialization callback for all applicable beans...
      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) ###

@Override
    public Object getBean(String name) throws BeansException { 
      return doGetBean(name, null, null, false);
    }

### doGetBean(name, null, null, false) ###

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                              @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { 
    
      // 这里不直接name主要是因为alias和FactoryBean的原因
      // 1、别名需要转换成真正的beanName
      // 2、如果传入的name是实现了FactoryBean接口的话，那么传入的name是以&开头的，需要将首字母&移除
      final String beanName = transformedBeanName(name); // 获取beanName
      Object bean;
    
      // 这个方法在初始化的时候会调用，在getBean的时候也会调用，原因：
      //
      // 尝试从三级缓存中获取bean实例
      //
      // Spring循环依赖的原理：
      // 在创建单例bean的时候会存在依赖注入的情况，为了避免循环依赖，Spring在创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光，添加到singletonFactories中
      // 将ObjectFactory加入到缓存中，一旦下一个bean创建的时候需要依赖注入上个bean则直接从缓存中获取ObjectFactory
      Object sharedInstance = getSingleton(beanName); // 根据beanName尝试从三级缓存中获取bean实例
    
      // 当三级缓存中存在此bean，表示当前该bean已创建完成 || 正在创建
      if (sharedInstance != null && args == null) { 
        if (logger.isDebugEnabled()) { 
          // 该bean在singletonFactories，但是还未初始化，因为此bean存在循环依赖
          if (isSingletonCurrentlyInCreation(beanName)) { 
            logger.debug("Returning eagerly caFFched instance of singleton bean '" + beanName +
                         "' that is not fully initialized yet - a consequence of a circular reference");
          }
          else { 
            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
          }
        }
        // 返回对应的实例，有时候存在诸如BeanFactory的情况并不是直接返回实例本身而是返回指定方法返回的实例
        // 如果sharedInstance是普通的单例bean，下面的方法会直接返回，但如果sharedInstance是FactoryBean类型的，
        // 则需要调用getObject工厂方法获取bean实例，如果用户想获取FactoryBean本身，这里也不会做特别的处理
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
      }
    
      // 当bean还未创建
      else { 
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        // 如果该bean的scope是原型(phototype)不应该在初始化的时候创建
        if (isPrototypeCurrentlyInCreation(beanName)) { 
          throw new BeanCurrentlyInCreationException(beanName);
        }
    
        // Check if bean definition exists in this factory.
        // 检查当前容器是否有父容器
        BeanFactory parentBeanFactory = getParentBeanFactory();
    
        // 如果父容器中存在此bean的实例，直接从父容器中获取bean的实例并返回
        // 父子容器：Spring和SpringMVC都是一个容器，Spring容器是父容器，SpringMVC是子容器
        // controller的bean放在SpringMVC的子容器中，service、mapper放在Spring父容器中
        // 子容器可以访问父容器中的bean实例，父容器不可以访问子容器中的实例
        // controller中可以注入service的依赖，但是service不能注入controller的依赖
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
          // Not found -> check parent.
          String nameToLookup = originalBeanName(name);
          if (parentBeanFactory instanceof AbstractBeanFactory) { 
            return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
              nameToLookup, requiredType, args, typeCheckOnly);
          }
          else if (args != null) { 
            // Delegation to parent with explicit args.
            return (T) parentBeanFactory.getBean(nameToLookup, args);
          }
          else { 
            // No args -> delegate to standard getBean method.
            return parentBeanFactory.getBean(nameToLookup, requiredType);
          }
        }
    
        if (!typeCheckOnly) { 
          // 添加到alreadyCreated set集合当中，表示他已经创建过了
          markBeanAsCreated(beanName);
        }
    
        try { 
          // 从父容器中的BeanDefinitionMap和子容器中的BeanDefinitionMap合并的BeanDefinitionMap中获取BeanDefinition对象
          final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
          checkMergedBeanDefinition(mbd, beanName, args);
    
          // Guarantee initialization of beans that the current bean depends on.
          // 获取当前bean依赖注入的的属性，bean的初始化之前里面依赖的属性必须先初始化
          String[] dependsOn = mbd.getDependsOn();
          if (dependsOn != null) { 
            for (String dep : dependsOn) { 
              if (isDependent(beanName, dep)) { 
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
              }
              registerDependentBean(dep, beanName);
              try { 
                getBean(dep);
              }
              catch (NoSuchBeanDefinitionException ex) { 
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
              }
            }
          }
    
          // Create bean instance.
          // 正式开始创建bean实例
          if (mbd.isSingleton()) {  // 当该bean的scope为singleton或者为空时
            sharedInstance = getSingleton(beanName, () -> {  // 从三级缓存中获取bean实例
              try { 
                return createBean(beanName, mbd, args); // 真正创建bean
              }
              catch (BeansException ex) { 
                // Explicitly remove instance from singleton cache: It might have been put there
                // eagerly by the creation process, to allow for circular reference resolution.
                // Also remove any beans that received a temporary reference to the bean.
                destroySingleton(beanName);
                throw ex;
              }
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
          }
    
          // 创建 prototype 类型的 bean 实例
          else if (mbd.isPrototype()) { 
            // It's a prototype -> create a new instance.
            Object prototypeInstance = null;
            try { 
              beforePrototypeCreation(beanName);
              prototypeInstance = createBean(beanName, mbd, args);
            }
            finally { 
              afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
          }
    
          // 创建其他类型的bean实例
          else { 
            String scopeName = mbd.getScope();
            final Scope scope = this.scopes.get(scopeName);
            if (scope == null) { 
              throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
            }
            try { 
              Object scopedInstance = scope.get(beanName, () -> { 
                beforePrototypeCreation(beanName);
                try { 
                  return createBean(beanName, mbd, args);
                }
                finally { 
                  afterPrototypeCreation(beanName);
                }
              });
              bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
            }
            catch (IllegalStateException ex) { 
              throw new BeanCreationException(beanName,
                                              "Scope '" + scopeName + "' is not active for the current thread; consider " +
                                              "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                                              ex);
            }
          }
        }
        catch (BeansException ex) { 
          cleanupAfterBeanCreationFailure(beanName);
          throw ex;
        }
      }
    
      // Check if required type matches the type of the actual bean instance.
      // 类型转换
      if (requiredType != null && !requiredType.isInstance(bean)) { 
        try { 
          T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
          if (convertedBean == null) { 
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
          }
          return convertedBean;
        }
        catch (TypeMismatchException ex) { 
          if (logger.isDebugEnabled()) { 
            logger.debug("Failed to convert bean '" + name + "' to required type '" +
                         ClassUtils.getQualifiedName(requiredType) + "'", ex);
          }
          throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
      }
      return (T) bean;
    }

#### getSingleton(beanName) ####

@Override
    @Nullable
    public Object getSingleton(String beanName) { 
      return getSingleton(beanName, true);
    }

##### getSingleton(beanName, true) #####

@Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {  // allowEarlyReference表示是否允许从singletonFactories中通过getObject拿到对象
      // 尝试从三级缓存中获取bean实例
      Object singletonObject = this.singletonObjects.get(beanName); // 从一级缓存中获取bean
    
      // 如果一级缓存中不存在该bean实例 && 该bean正在创建中
      if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {  // isSingletonCurrentlyInCreation(beanName)判断这个bean是否在创建过程中，对象是否有循环依赖
        synchronized (this.singletonObjects) { 
          singletonObject = this.earlySingletonObjects.get(beanName); // 尝试从二级缓存中获取bean实例
    
          // 如果二级缓存中不存在giantbean实例 && 允许从singletonFactories从获取bean实例
          if (singletonObject == null && allowEarlyReference) { 
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); // 从三级缓存中获取bean实例
    
            // 如果bean存在，将该bean实例从三级缓存升级到二级缓存中，并且从三级缓存中删除
            if (singletonFactory != null) { 
              singletonObject = singletonFactory.getObject();
              this.earlySingletonObjects.put(beanName, singletonObject);
              this.singletonFactories.remove(beanName);
            }
          }
        }
      }
      return singletonObject;
    }

#### createBean(beanName, mbd, args) ####

@Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException { 
    
      if (logger.isDebugEnabled()) { 
        logger.debug("Creating instance of bean '" + beanName + "'");
      }
      RootBeanDefinition mbdToUse = mbd;
    
      // Make sure bean class is actually resolved at this point, and
      // clone the bean definition in case of a dynamically resolved Class
      // which cannot be stored in the shared merged bean definition.
      // 确认bean真实加载进行来了
      Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
      if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
      }
    
      // Prepare method overrides.
      try { 
        mbdToUse.prepareMethodOverrides();
      }
      catch (BeanDefinitionValidationException ex) { 
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                                               beanName, "Validation of method overrides failed", ex);
      }
    
      try { 
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        // 主要是来执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcesser，但是返回的bean始终为null
        // AOP核心方法，用来处理使用@Aspect注解标识的bean，以便后面生成动态代理
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    
        // 生成的bean实例存在就返回
        if (bean != null) { 
          return bean;
        }
      }
      catch (Throwable ex) { 
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                                        "BeanPostProcessor before instantiation of bean failed", ex);
      }
    
      try { 
        // 实例化bean
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isDebugEnabled()) { 
          logger.debug("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
      }
      catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { 
        // A previously detected exception with proper bean creation context already,
        // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
        throw ex;
      }
      catch (Throwable ex) { 
        throw new BeanCreationException(
          mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
      }
    }

##### resolveBeforeInstantiation(beanName, mbdToUse) #####

@Nullable
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { 
      Object bean = null;
      // 检测是否被解析过
      if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { 
        // Make sure bean class is actually resolved at this point.
    
        // hasInstantiationAwareBeanPostProcessors()是来判断容器中是否有InstantiationAwareBeanPostProcessor的实现bean
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
          Class<?> targetType = determineTargetType(beanName, mbd); // 获取bean的目标类型
          if (targetType != null) { 
            // 执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcessor中的前置处理方法postProcessBeforeInstantiation方法
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
            if (bean != null) { 
              // 执行实现了InstantiationAwareBeanPostProcessor接口的BeanPostProcessor中的后置处理方法postProcessAfterInitialization方法
              bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
          }
        }
        mbd.beforeInstantiationResolved = (bean != null);
      }
      return bean;
    }

###### applyBeanPostProcessorsBeforeInstantiation(targetType, beanName) ######

@Nullable
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) { 
      for (BeanPostProcessor bp : getBeanPostProcessors()) { 
        if (bp instanceof InstantiationAwareBeanPostProcessor) { 
          InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
          Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
          if (result != null) { 
            return result;
          }
        }
      }
      return null;
    }

###### applyBeanPostProcessorsAfterInitialization(bean, beanName) ######

@Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException { 
    
      Object result = existingBean;
      for (BeanPostProcessor processor : getBeanPostProcessors()) { 
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) { 
          return result;
        }
        result = current;
      }
      return result;
    }

##### doCreateBean(beanName, mbdToUse, args) #####

/** * 初始化bean实例（解决循环依赖问题） */
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException { 
    
      // Instantiate the bean.
      BeanWrapper instanceWrapper = null;
      if (mbd.isSingleton()) { 
    	// 调用bean的构造方法进行初始化,经过这一步，bean属性并没有被赋值，只是一个空壳，这是bean初始化的【早期对象】
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
      }
    
      // 创建bean实例转化成BeanWrapper对象
      if (instanceWrapper == null) { 
        instanceWrapper = createBeanInstance(beanName, mbd, args);
      }
      final Object bean = instanceWrapper.getWrappedInstance();
      Class<?> beanType = instanceWrapper.getWrappedClass();
      if (beanType != NullBean.class) { 
        mbd.resolvedTargetType = beanType;
      }
    
      // Allow post-processors to modify the merged bean definition.
      synchronized (mbd.postProcessingLock) { 
        if (!mbd.postProcessed) { 
          try { 
            // 处理bean中实现了MergedBeanDefinitionPostProcessor后置处理器的类中的postProcessMergedBeanDefinition方法
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
          }
          catch (Throwable ex) { 
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                            "Post-processing of merged bean definition failed", ex);
          }
          mbd.postProcessed = true;
        }
      }
    
      // Eagerly cache singletons to be able to resolve circular references
      // even when triggered by lifecycle interfaces like BeanFactoryAware.
      // 判断bean是否存在循环依赖
      // 如果当前bean是单例，且支持循环依赖，且当前bean正在创建，通过往singletonFactories添加一个objectFactory，这样后期如果有其他bean依赖该bean 可以从singletonFactories获取到bean
      boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
      if (earlySingletonExposure) { 
        if (logger.isDebugEnabled()) { 
          logger.debug("Eagerly caching bean '" + beanName +
                       "' to allow for resolving potential circular references");
        }
        // 解决Spring循环依赖问题
        // 添加工厂对象到singletonFactories缓存中【提前暴露早期对象】
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
      }
    
      // Initialize the bean instance.
      // 初始化bean实例
      Object exposedObject = bean;
      try { 
        // 给已经已经初始化的属性赋值，包括完成bean的依赖注入
        populateBean(beanName, mbd, instanceWrapper);
    
        // 初始化bean实例
        exposedObject = initializeBean(beanName, exposedObject, mbd);
      }
      catch (Throwable ex) { 
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 
          throw (BeanCreationException) ex;
        }
        else { 
          throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
      }
    
      // 解决循环依赖
      if (earlySingletonExposure) { 
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) { 
          if (exposedObject == bean) { 
            exposedObject = earlySingletonReference;
          }
          else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
            String[] dependentBeans = getDependentBeans(beanName);
            Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
            for (String dependentBean : dependentBeans) { 
              if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
                actualDependentBeans.add(dependentBean);
              }
            }
            if (!actualDependentBeans.isEmpty()) { 
              throw new BeanCurrentlyInCreationException(beanName,
                                                         "Bean with name '" + beanName + "' has been injected into other beans [" +
                                                         StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                                         "] in its raw version as part of a circular reference, but has eventually been " +
                                                         "wrapped. This means that said other beans do not use the final version of the " +
                                                         "bean. This is often the result of over-eager type matching - consider using " +
                                                         "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
            }
          }
        }
      }
    
      // Register bean as disposable.
      // 销毁
      try { 
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
      }
      catch (BeanDefinitionValidationException ex) { 
        throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
      }
    
      return exposedObject;
    }

###### applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName) ######

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) { 
      for (BeanPostProcessor bp : getBeanPostProcessors()) { 
        if (bp instanceof MergedBeanDefinitionPostProcessor) { 
          MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
          bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
        }
      }
    }

###### bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName) ######

**MergedBeanDefinitionPostProcessor的实现类可以用来处理@Autowired、@Value、@PostConstruct、@PreDestroy、@Scheduled等Spring提供的注解**

**下面以实现类AutowiredAnnotationBeanPostProcessor用来处理@Autowired、@Value注解举例**

**当bdp的实现类是AutowiredAnnotationBeanPostProcessor时，将调用AutowiredAnnotationBeanPostProcessor重写的postProcessMergedBeanDefinition方法**

@Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) { 
    	InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
    	metadata.checkConfigMembers(beanDefinition);
    }

findAutowiringMetadata(beanName, beanType, null)

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) { 
    	// Fall back to class name as cache key, for backwards compatibility with custom callers.
    	String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
    	// Quick check on the concurrent map first, with minimal locking.
    	InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
    	if (InjectionMetadata.needsRefresh(metadata, clazz)) { 
    		synchronized (this.injectionMetadataCache) { 
    			metadata = this.injectionMetadataCache.get(cacheKey);
    			if (InjectionMetadata.needsRefresh(metadata, clazz)) { 
    				if (metadata != null) { 
    					metadata.clear(pvs);
    				}
    
    				// 解析等待依赖注入类的所有属性，构建InjectionMetadata对象，它是通过分析类中所有属性和所有方法中是否有该注解
    				metadata = buildAutowiringMetadata(clazz);
    				this.injectionMetadataCache.put(cacheKey, metadata);
    			}
    		}
    	}
    	return metadata;
    }

buildAutowiringMetadata(clazz)

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) { 
    	List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
    	Class<?> targetClass = clazz;
    
    	do { 
    		final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
    
    		// 扫描所有属性
    		ReflectionUtils.doWithLocalFields(targetClass, field -> { 
    			// 通过分析属于一个字段的所有注解来查找@Autowired注解
    			AnnotationAttributes ann = findAutowiredAnnotation(field);
    
    			if (ann != null) { 
    				if (Modifier.isStatic(field.getModifiers())) { 
    					if (logger.isWarnEnabled()) { 
    						logger.warn("Autowired annotation is not supported on static fields: " + field);
    					}
    					return;
    				}
    				boolean required = determineRequiredStatus(ann);
    				currElements.add(new AutowiredFieldElement(field, required));
    			}
    		});
    
    		// 扫描所有方法
    		ReflectionUtils.doWithLocalMethods(targetClass, method -> { 
    			Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
    			if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) { 
    				return;
    			}
    
    			// 通过分析属于一个方法的所有注解来查找@Autowired注解
    			AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
    
    			if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) { 
    				if (Modifier.isStatic(method.getModifiers())) { 
    					if (logger.isWarnEnabled()) { 
    						logger.warn("Autowired annotation is not supported on static methods: " + method);
    					}
    					return;
    				}
    				if (method.getParameterCount() == 0) { 
    					if (logger.isWarnEnabled()) { 
    						logger.warn("Autowired annotation should only be used on methods with parameters: " +
    								method);
    					}
    				}
    				boolean required = determineRequiredStatus(ann);
    				PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
    				currElements.add(new AutowiredMethodElement(method, required, pd));
    			}
    		});
    
    		elements.addAll(0, currElements);
    		targetClass = targetClass.getSuperclass();
    	}
    	while (targetClass != null && targetClass != Object.class);
    
    	return new InjectionMetadata(clazz, elements);
    }

##### populateBean(beanName, mbd, instanceWrapper) #####

/** * 给已经已经初始化的属性赋值，包括完成bean的依赖注入 * 这个方法最重要就是最后一个方法applyPropertyValues(beanName, mbd, bw, pvs)：为属性赋值 */
    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { 
    
        // 这一大段代码省略
        ......
        
    	// 为属性赋值
    	if (pvs != null) { 
    		applyPropertyValues(beanName, mbd, bw, pvs);
    	}
    }

###### applyPropertyValues(beanName, mbd, bw, pvs) ######

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { 
    
        // 这一大段代码省略
        ......
    
    	// 为当前bean中属性赋值，包括依赖注入的属性
    	Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
    	
    	// 这一大段代码省略
        ......
    }

###### valueResolver.resolveValueIfNecessary(pv, originalValue) ######

/** * 如果当前初始化的bean有属性需要注入的，将会调用resolveReference(argName, ref)来返回需要注入的bean */
    public Object resolveValueIfNecessary(Object argName, @Nullable Object value) { 
    	// 获取需要依赖注入属性的值
    	if (value instanceof RuntimeBeanReference) { 
    		RuntimeBeanReference ref = (RuntimeBeanReference) value;
    		return resolveReference(argName, ref);
    	}
    	
    	// 这一大段代码省略
        ......
    }

###### resolveReference(argName, ref) ######

private Object resolveReference(Object argName, RuntimeBeanReference ref) { 
    	try { 
    		Object bean;
    		String refName = ref.getBeanName();
    		refName = String.valueOf(doEvaluate(refName));
    		if (ref.isToParent()) { 
    			if (this.beanFactory.getParentBeanFactory() == null) { 
    				throw new BeanCreationException(
    						this.beanDefinition.getResourceDescription(), this.beanName,
    						"Can't resolve reference to bean '" + refName +
    								"' in parent factory: no parent factory available");
    			}
    			bean = this.beanFactory.getParentBeanFactory().getBean(refName);
    		}
    		else { 
    		    // 当前初始化bean主要为属性注入另外一个bean，调用getBean()方法获取需要注入的bean，最终注入到属性中
    			bean = this.beanFactory.getBean(refName);
    			this.beanFactory.registerDependentBean(refName, this.beanName);
    		}
    		if (bean instanceof NullBean) { 
    			bean = null;
    		}
    		return bean;
    	}
    	catch (BeansException ex) { 
    		throw new BeanCreationException(
    				this.beanDefinition.getResourceDescription(), this.beanName,
    				"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
    	}
    }

#### getSingleton(beanName, singletonFactory) ####

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { 
      Assert.notNull(beanName, "Bean name must not be null");
      synchronized (this.singletonObjects) { 
        // 尝试从一级缓存中获取bean实例
        Object singletonObject = this.singletonObjects.get(beanName);
    
        if (singletonObject == null) { 
          if (this.singletonsCurrentlyInDestruction) { 
            throw new BeanCreationNotAllowedException(beanName,
                                                      "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                                                      "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
          }
          if (logger.isDebugEnabled()) { 
            logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
          }
    
          // 将beanName添加到singletonsCurrentlyInCreation集合中，
          // 用于表明beanName对应的bean正在创建中
          beforeSingletonCreation(beanName);
          boolean newSingleton = false;
          boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
          if (recordSuppressedExceptions) { 
            this.suppressedExceptions = new LinkedHashSet<>();
          }
    
          try { 
            // 调用FactoryBean接口中的getObject()方法获取bean实例
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
          }
          catch (IllegalStateException ex) { 
            // Has the singleton object implicitly appeared in the meantime ->
            // if yes, proceed with it since the exception indicates that state.
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) { 
              throw ex;
            }
          }
          catch (BeanCreationException ex) { 
            if (recordSuppressedExceptions) { 
              for (Exception suppressedException : this.suppressedExceptions) { 
                ex.addRelatedCause(suppressedException);
              }
            }
            throw ex;
          }
          finally { 
            if (recordSuppressedExceptions) { 
              this.suppressedExceptions = null;
            }
    
            // 从singletonsCurrentlyInCreation实现FactoryBean接口中的bean，表明实现了FactoryBean接口的bean获取完毕
            afterSingletonCreation(beanName);
          }
          if (newSingleton) { 
            // 最后将singletonObject添加到singletonObjects一级缓存中，同时将二级、三级缓存中的bean删除
            addSingleton(beanName, singletonObject);
          }
        }
        return singletonObject;
      }
    }

###### addSingleton(beanName, singletonObject) ######

/** * 将singletonObject添加到singletonObjects一级缓存中，同时将二级、三级缓存中的bean删除 */
    protected void addSingleton(String beanName, Object singletonObject) { 
    	synchronized (this.singletonObjects) { 
    		this.singletonObjects.put(beanName, singletonObject);
    		this.singletonFactories.remove(beanName);
    		this.earlySingletonObjects.remove(beanName);
    		this.registeredSingletons.add(beanName);
    	}
    }

[Spring_AnnotationConfigApplicationContext_ this_ _ register]: https://blog.csdn.net/qq_35620501/article/details/102986216
[Spring_AnnotationConfigApplicationContext_ refresh_invokeBeanFactoryPostProcessors]: https://blog.csdn.net/qq_35620501/article/details/102986266
[Spring_AnnotationConfigApplicationContext_ refresh_registerBeanPostProcessors]: https://blog.csdn.net/qq_35620501/article/details/102986421
[Spring_AnnotationConfigApplicationContext_ refresh_finishBeanFactoryInitialization]: https://blog.csdn.net/qq_35620501/article/details/102986848