聊聊Spring中的AutowiredAnnotationBeanPostProcessor(三)

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {


    if (logger.isTraceEnabled()) {
      logger.trace("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.
    //确保RootBeanDefinition定义中存在对应的bean class，否则抛异常
    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.
      //执行before-instantiation post-processors，在这个方法中执行了后置处理器InstantiationAwareBeanPostProcessor
      // 的postProcessBeforeInstantiation()方法，在bean实例化之前对bean进行处理,查阅相关资料，该扩展实现了aop相关功能，
      // 具体详细实现感兴趣读者可以自行研究
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      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.isTraceEnabled()) {
        logger.trace("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);
    }
  }
  
 ......
 //确认存在指定的bean class
 protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
      throws CannotLoadBeanClassException {


    try {
      if (mbd.hasBeanClass()) {
        return mbd.getBeanClass();
      }
      if (System.getSecurityManager() != null) {
        return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
          doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
      }
      else {
        return doResolveBeanClass(mbd, typesToMatch);
      }
    }
    catch (PrivilegedActionException pae) {
       ......
   }
    catch (ClassNotFoundException ex) {
      ......  
    }
    catch (LinkageError err) {
      ......
    }
  }

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {


    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    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应用MergedBeanDefinitionPostProcessors
          //AutowiredAnnotationBeanPostProcessor为其中一个实现，主要查找@Autowire等注解修饰的属性并缓存到injectionMetadataCache中
          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是否放入到singletonFactories中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
      if (logger.isTraceEnabled()) {
        logger.trace("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
      }
      //加入到singletonFactories中
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }


    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
      //填充bean的属性，首先执行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，判断是否需要填充属性
      //在AutowiredAnnotationBeanPostProcessor的父类InstantiationAwareBeanPostProcessorAdapter中的postProcessAfterInstantiation方法返回TRUE，继续填充属性，执行后续流程
      //后续填充属性流程调用InstantiationAwareBeanPostProcessor中的postProcessProperties方法填充属性，详细请看下文AutowiredAnnotationBeanPostProcessor的对应方法
      populateBean(beanName, mbd, instanceWrapper);
      //初始化方法，主要流程步骤如下：
      // 1. 执行invokeAwareMethods()方法，即执行实现Aware接口的方法，包括BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
      // 2. 执行所有后置处理器的postProcessBeforeInitialization方法
      // 3. 执行invokeInitMethods()方法，即执行((InitializingBean) bean).afterPropertiesSet() 和invokeCustomInitMethod()方法（@Bean注解中的 String initMethod() default "";）;
      // 4. 执行后置处理器的postProcessAfterInitialization方法
      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 {
      //注册销毁bean回调方法，实现DisposableBean接口
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }


    return exposedObject;
  }

  //在applyMergedBeanDefinitionPostProcessors方法中会调用此方法，查找Autowiring相关注解修饰属性，并返回InjectionMetadata对象
  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);
          }
          //查找@Autowired，@Value等修饰的属性
          metadata = buildAutowiringMetadata(clazz);
          this.injectionMetadataCache.put(cacheKey, metadata);
        }
      }
    }
    return metadata;
  }
  @Override
  //填充bean相关属性
  public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    try {
      metadata.inject(bean, beanName, pvs);
    }
    catch (BeanCreationException ex) {
      throw ex;
    }
    catch (Throwable ex) {
      throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    }
    return pvs;
  }