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

AnnotationConfigApplicationContext容器初始化目录
（Spring源码分析）AnnotationConfigApplicationContext容器初始化 this() && register()
（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()#invokeBeanFactoryPostProcessors
（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()#registerBeanPostProcessors
（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()#finishBeanFactoryInitialization

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