protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)      throws BeanCreationException {        // ====== 1 ======    // Instantiate the bean.    BeanWrapper instanceWrapper = null;    if (mbd.isSingleton()) {      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);    }    if (instanceWrapper == null) {      instanceWrapper = createBeanInstance(beanName, mbd, args);    }    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 {          applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);        }        catch (Throwable ex) {          throw new BeanCreationException(mbd.getResourceDescription(), beanName,              "Post-processing of merged bean definition failed", ex);        }        mbd.postProcessed = true;      }    }        // ====== 2 ======    // Eagerly cache singletons to be able to resolve circular references    // even when triggered by lifecycle interfaces like BeanFactoryAware.    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");      }      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));    }        // ====== 3 ======    // Initialize the bean instance.    Object exposedObject = bean;    try {      populateBean(beanName, mbd, instanceWrapper);      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);      }    }        // ====== 4 ======    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 " +                "'getBeanNamesForType' 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;  }