public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)
Object sharedInstance = getSingleton(beanName)

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  
  // Instantiate all remaining (non-lazy-init) singletons.
  beanFactory.preInstantiateSingletons();
	}

@Override
	public void preInstantiateSingletons() throws BeansException {
  if (logger.isTraceEnabled()) {
  	logger.trace("Pre-instantiating singletons in " + this);
  }

  // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

  // Trigger initialization of all non-lazy singleton beans...
  for (String beanName : beanNames) {
  	RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  	if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    if (isFactoryBean(beanName)) {
    	Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    	if (bean instanceof FactoryBean) {
      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);
    }
  	}
  }

AbstractBeanFactory的getBean跟doGetBean方法
public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

protected <T> T doGetBean(
  	String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
  	throws BeansException {

  String beanName = transformedBeanName(name);
  Object beanInstance;

  // Eagerly check singleton cache for manually registered singletons.
  Object sharedInstance = getSingleton(beanName);
  if (sharedInstance != null && args == null) {
  	if (logger.isTraceEnabled()) {
    if (isSingletonCurrentlyInCreation(beanName)) {
    	logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
      	"' that is not fully initialized yet - a consequence of a circular reference");
    }
    else {
    	logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
    }
  	}
  	beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  }

  else {
  
    if (mbd.isSingleton()) {
    	sharedInstance = getSingleton(beanName, () -> {
      try {
      	return createBean(beanName, mbd, args);
      }
      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;
      }
    	});
    	beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
  }

  return adaptBeanInstance(name, beanInstance, requiredType);
	}

sharedInstance = getSingleton(beanName, () -> {
      try {
      	return createBean(beanName, mbd, args);
      }
      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;
      }

() -> {
      try {
      	return createBean(beanName, mbd, args);
      }
      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;
      }
    	}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(beanName, "Bean name must not be null");
  synchronized (this.singletonObjects) {
  	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 + "'");
    }
    beforeSingletonCreation(beanName);
    boolean newSingleton = false;
    boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
    if (recordSuppressedExceptions) {
    	this.suppressedExceptions = new LinkedHashSet<>();
    }
    try {
    	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;
    	}
    	afterSingletonCreation(beanName);
    }
    if (newSingleton) {
    	addSingleton(beanName, singletonObject);
    }
  	}
  	return singletonObject;
  }
	}

singletonObject = singletonFactory.getObject()

Object sharedInstance = getSingleton(beanName)


@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // Quick check for existing instance without full singleton lock
  //从一级缓存中获取bean
  Object singletonObject = this.singletonObjects.get(beanName);
  //如果没有获取到并且正在创建中进入，正在创建中含义就是：实例化但是没有初始化（earlySingleton）
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  	//从二级缓存中获取
  	singletonObject = this.earlySingletonObjects.get(beanName);
  	if (singletonObject == null && allowEarlyReference) {
    synchronized (this.singletonObjects) {
    	// Consistent creation of early reference within full singleton lock
    	singletonObject = this.singletonObjects.get(beanName);
    	if (singletonObject == null) {
      singletonObject = this.earlySingletonObjects.get(beanName);
      if (singletonObject == null) {
      	//三级缓存中获取，三级缓存中存放的是内部代码块
      	ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
      	if (singletonFactory != null) {
        //通过三级缓存中的内部代码块进行创建依赖Bean
        singletonObject = singletonFactory.getObject();
        //将创建的放入二级缓存
        this.earlySingletonObjects.put(beanName, singletonObject);
        //删除三级缓存中数据
        this.singletonFactories.remove(beanName);
      	}
      }
    	}
    }
  	}
  }
  return singletonObject;
	}

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

  if (instanceWrapper == null) {
  	//实力化
  	instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
  //实例化完成，此时属性全部为空
  Object bean = instanceWrapper.getWrappedInstance();
  Class<?> beanType = instanceWrapper.getWrappedClass();
  if (beanType != NullBean.class) {
  	mbd.resolvedTargetType = beanType;
  }

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

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

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