Spring IoC源码：createBean（下）

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {
    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
    //如果是单例并且是FactoryBean则尝试移除
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
      //创建Bean实例，通过策略进行创建，如果选择有参构造或无参构造
      instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    //获取当前实例对象
    final Object bean = instanceWrapper.getWrappedInstance();
    //当前实例的Calss对象
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
      //设置当前bean定义信息的目标类型
      mbd.resolvedTargetType = beanType;
    }
    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
        try {
          //执行MergedBeanDefinitionPostProcessor类型后置处理器的postProcessMergedBeanDefinition方法，
          //如@Autowire注解，就是通过该后置处理器进行解析
          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.
    //如果是单例，允许循环依赖，并且beanName正在创建中
    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");
      }
      //包装成FactoryObject对象，并添加到三级缓存中
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
      //初始化过程，进行属性注入。该过程递归创建其依赖的属性。如果A中有B，B中有C，则创建B跟C。
      populateBean(beanName, mbd, instanceWrapper);
      //该过程执行后置处理器的before方法，bean的init方法，后置处理器的after方法，可能会生成新的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) {
      //从缓存中获取，因为上面我们将其添加到三级缓存中，从三级缓存中获取会调用FactoryObject对象的getObject方法，可能会触发AOP代理。返回代理对象
      Object earlySingletonReference = getSingleton(beanName, false);
      if (earlySingletonReference != null) {
        //如果bean对象还是原来的，则将三级缓存中获取的对象赋值过去
        if (exposedObject == bean) {
          exposedObject = earlySingletonReference;
        }
        //如果exposedObject在initializeBean方法中被增强 && 不允许在循环引用的情况下使用注入原始bean实例
        else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
          //  获取依赖当前beanName的所有bean名称
          String[] dependentBeans = getDependentBeans(beanName);
          Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
          //尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
          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，执行销毁操作的有三种：自定义destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }
    return exposedObject;
  }

  protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        invokeAwareMethods(beanName, bean);
        return null;
      }, getAccessControlContext());
    }
    else {
      //对bean的aware属性进行填充
      invokeAwareMethods(beanName, bean);
    }
    Object wrappedBean = bean;
    //执行BeanPostProcessors的postProcessBeforeInitialization方法，可能会返回新的对象值
    if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    try {
      //调用初始化方法
      invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
      throw new BeanCreationException(
          (mbd != null ? mbd.getResourceDescription() : null),
          beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
      //执行BeanPostProcessors的postProcessAfterInitialization方法，AOP代理就是在这个步骤进行处理的
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
  }

  private void invokeAwareMethods(final String beanName, final Object bean) {
    //如果实现了Aware接口，根据实现不同接口，对属性进行填充
    if (bean instanceof Aware) {
      //填充beanName值
      if (bean instanceof BeanNameAware) {
        ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
        //填充ClassLoader 
        ClassLoader bcl = getBeanClassLoader();
        if (bcl != null) {
          ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
        }
      }
      if (bean instanceof BeanFactoryAware) {
        //填充当前beanFactory工厂
        ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
    }
  }

  public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException {
    Object result = existingBean;
    //执行BeanPostProcessors的postProcessBeforeInitialization方法，可能会返回新的对象值。
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
      Object current = processor.postProcessBeforeInitialization(result, beanName);
      if (current == null) {
        return result;
      }
      result = current;
    }
    return result;
  }

  protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
      throws Throwable {
    //判断是否实现了InitializingBean接口，如果是则调用afterPropertiesSet方法
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
      if (logger.isTraceEnabled()) {
        logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
      }
      if (System.getSecurityManager() != null) {
        try {
          AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
            ((InitializingBean) bean).afterPropertiesSet();
            return null;
          }, getAccessControlContext());
        }
        catch (PrivilegedActionException pae) {
          throw pae.getException();
        }
      }
      else {
        ((InitializingBean) bean).afterPropertiesSet();
      }
    }
    //调用自定义初始化方法
    if (mbd != null && bean.getClass() != NullBean.class) {
      String initMethodName = mbd.getInitMethodName();
      if (StringUtils.hasLength(initMethodName) &&
          !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
          !mbd.isExternallyManagedInitMethod(initMethodName)) {
        invokeCustomInitMethod(beanName, bean, mbd);
      }
    }
  }

  protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd)
      throws Throwable {
    //获取配置的init方法名称
    String initMethodName = mbd.getInitMethodName();
    Assert.state(initMethodName != null, "No init method set");
    //获取初始化方法
    Method initMethod = (mbd.isNonPublicAccessAllowed() ?
        BeanUtils.findMethod(bean.getClass(), initMethodName) :
        ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
    //如果找不到则判断是否强制执行，强制则抛异常，非强制则警告提示
    if (initMethod == null) {
      if (mbd.isEnforceInitMethod()) {
        throw new BeanDefinitionValidationException("Could not find an init method named '" +
            initMethodName + "' on bean with name '" + beanName + "'");
      }
      else {
        if (logger.isTraceEnabled()) {
          logger.trace("No default init method named '" + initMethodName +
              "' found on bean with name '" + beanName + "'");
        }
        // Ignore non-existent default lifecycle methods.
        return;
      }
    }
    if (logger.isTraceEnabled()) {
      logger.trace("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
    }
    Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);
    if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        ReflectionUtils.makeAccessible(methodToInvoke);
        return null;
      });
      try {
        AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
            methodToInvoke.invoke(bean), getAccessControlContext());
      }
      catch (PrivilegedActionException pae) {
        InvocationTargetException ex = (InvocationTargetException) pae.getException();
        throw ex.getTargetException();
      }
    }
    else {
      try {
      //设置权限
        ReflectionUtils.makeAccessible(methodToInvoke);
        //执行
        methodToInvoke.invoke(bean);
      }
      catch (InvocationTargetException ex) {
        throw ex.getTargetException();
      }
    }
  }

  public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {
    //执行BeanPostProcessors的postProcessAfterInitialization方法，AOP代理就是在这个步骤进行处理的
    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
      Object current = processor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
        return result;
      }
      result = current;
    }
    return result;
  }

  protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
    //如果不是多例&&需要销毁
    if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
      //如果是单例
      if (mbd.isSingleton()) {
        // Register a DisposableBean implementation that performs all destruction
        // work for the given bean: DestructionAwareBeanPostProcessors,
        // DisposableBean interface, custom destroy method.
        //
        registerDisposableBean(beanName,
            new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
      }
      else {
        // A bean with a custom scope...
        //根据自定义的Scope ，注册销毁回调方式
        Scope scope = this.scopes.get(mbd.getScope());
        if (scope == null) {
          throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
        }
        scope.registerDestructionCallback(beanName,
            new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
      }
    }
  }

  protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
    //当前bean不是null
     // 1.DisposableBeanAdapter.hasDestroyMethod(bean, mbd)：判断bean是否有destroy方法
     // 2.hasDestructionAwareBeanPostProcessors()：判断当前BeanFactory是否注册过DestructionAwareBeanPostProcessor
     // 3.DisposableBeanAdapter.hasApplicableProcessors：是否存在适用于bean的DestructionAwareBeanPostProcessor
    return (bean.getClass() != NullBean.class &&
        (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() &&
            DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
  }

    public static boolean hasDestroyMethod(Object bean, RootBeanDefinition beanDefinition) {
    //bean实现了DisposableBean 或AutoCloseable接口
    if (bean instanceof DisposableBean || bean instanceof AutoCloseable) {
      return true;
    }
    //获取销毁方法名称
    String destroyMethodName = beanDefinition.getDestroyMethodName();
    //如果自定销毁方法名称为 "(inferred)"
    if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName)) {
      //判断是否有close或shutdown方法
      return (ClassUtils.hasMethod(bean.getClass(), CLOSE_METHOD_NAME) ||
          ClassUtils.hasMethod(bean.getClass(), SHUTDOWN_METHOD_NAME));
    }
    return StringUtils.hasLength(destroyMethodName);
  }

  public static boolean hasApplicableProcessors(Object bean, List<BeanPostProcessor> postProcessors) {
    if (!CollectionUtils.isEmpty(postProcessors)) {
      //遍历后置处理器
      for (BeanPostProcessor processor : postProcessors) {
        //如果有类型为DestructionAwareBeanPostProcessor的后置处理器
        if (processor instanceof DestructionAwareBeanPostProcessor) {
          DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
          //判断是否需要由这个后置处理器进行销毁
          if (dabpp.requiresDestruction(bean)) {
            return true;
          }
        }
      }
    }
    return false;
  }