前言：
经过前面的方法，最后终于到了最困难的方法finishBeanFactoryInitialization()，实例化所有的单例bean。
这个方法以下面两个类为基础进行解析。
public class X {
@Autowired
Y y;
}
class Y {
@Autowired
X x;
}
- 点开finishBeanFactoryInitialization()这个方法，我们看一看具体实现：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { ... //实例化对象 beanFactory.preInstantiateSingletons(); ... }这个方法里我去掉了一些无关的代码，主要就是调用beanFactory.preInstantiateSingletons()实例化单例对象。接着往里看这个方法：位于：ConfigurableListableBeanFactory#preInstantiateSingletons()；
这是一个接口，我们需要看其实现类：DefaultListableBeanFactory#preInstantiateSingletons()。我们看看这个方法：
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// 1、从beanDefinitionNames获取所有的bean的名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 遍历
// 触发所有非延迟加载的单例bean的初始化
for (String beanName : beanNames) {
//合并父类的bd，在XML配置中配置的parent属性，这里也可以理解为就是beanDefinition。
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//如果当前bean----->不是抽象、是单例、不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//则判断bean是不是FactoryBean，一般情况下我们提供的bean都不是 FactoryBean
if (isFactoryBean(beanName)) {
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 {
// 如果不是FactoryBean
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
// 为所有适用的 bean 触发初始化回调
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();
}
}
}
}讲道理，我们一般情况不会提供FactoryBean，所以直接看getBean();
AbstractBeanFactory#getBean(java.lang.String)
接着点开doGetBean();doGetBean这个方法比较复杂，在这个方法里完成了实例化、初始化、属性填充，等工作。方法调用到这里我画一下调用流程：
我们看一看doGetBean()这个方法：
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//1-1 去掉名称的&符号
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 这里是在创建bean的时候去容器中获取bean,在大部分情况下都是获取不到的因为正在创建
// 为了处理lazy的bean,防止lazy的bean在之前创建过了
// 1-2
Object sharedInstance = getSingleton(beanName);
// sharedInstance这个对象99%的都是null，除非是特殊对象，或者是Sring 内置对象
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 + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 判断当前创建的类是否是原型(prototype),基本上不会发生，因为在前面已经有方法判断isSingleton了
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Create bean instance.
//创建
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;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
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);
}
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;
}
}
return (T) bean;
}在这个方法里，我删除了一些代码，我们只分析重要代码。
第一步：我们先看
final String beanName = transformedBeanName(name);当我们传的name=X的时候，在这个方法里会判断这个name是不是以&开头的，因为这个bean可能是一个FactoryBean类型的，如果是FactoryBean则去掉&符，获取真正的beanName。
第二步：getSingleton(beanName);
在上面这个代码里，我们首先从singletonObjects单例缓存池中获取beanName。
Object singletonObject = this.singletonObjects.get(beanName);为什么刚要创建bean就要从singletonObjects单例缓存池中获取？
那是因为Spring怕你要创建的bean是已经创建好的bean，如果是已经创建完成的bean就会放到这个缓存池，直接获取就好了（这个bean已经实例化完成，别的bean引入了这个bean会有这种情况）。此时由于我们是第一次调用，所以:singletonObject 肯定为null。
if语句的这个判断：isSingletonCurrentlyInCreation(beanName) 判断要创建的这个bean在不在当前正在创建的集合当中。这里肯定不存在，毕竟刚调用过来，什么事都还没做啊！所以说：下面这个判断整体为false不会进，直接返回null。
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { }
我们来看这个else语句，删除了一些无关代码，结构如下：
在这里首先通过beanName获取对应的RootBeanDefinition。
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);判断当前bean是否为单例的，这里我们的对象是X肯定符合所以进这个判断
//创建
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//被回调，创建对象，应用后置处理器
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}我们看这个If语句里面的内容，第二次调用getSingleton(); 如果有印象的话上面也调用了一次getSingleton，这是方法重载，两个getSingleton方法并不是同一个方法，看参数就知道了，为了区别这里我称为第二次调用getSingleton;这里使用的是lamda表达式，在这一次的getSingleton就会把我们的bean创建出来。我们先来看代码吧：
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
//singletonObjects是IOC的容器
// 这个创建过程是加锁的
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 + "'");
}
//把beanName添加到正在创建的集合中，表示正在创建。创建完成后移除，在下面的代码中
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//创建对象，应用后置处理，上一个方法的lambda表达式
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;
}
}Object singletonObject = this.singletonObjects.get(beanName);第二次调用getSingleton上来就调用了this.singletonObjects.get(beanName);直接从单例缓存池中获取这个对象，由于这里是创建一定返回null；接着看下面的代码：
//把beanName添加到正在创建的集合中，表示正在创建。创建完成后移除，在下面的代码中
beforeSingletonCreation(beanName);而后调用了beforeSingletonCreation()方法，此方法就把当前要创建的对象存放到正在创建的集合当中，也就是：singletonsCurrentlyInCreation。应该还记得吧，在第一次调用getSingleton的时候再if语句中就判断了bean是否在正在singletonsCurrentlyInCreation当中，那个时候返回的是null，程序运行到这里才将bean存入singletonsCurrentlyInCreation集合中。
Set<String> singletonsCurrentlyInCreation
这是一个set集合，用于缓存正在创建的集合，在第二次调用getSingleton中被添加，当对象创建完成之后会从此集合中移除。
我们继续向下看代码：
这里singletonFactory.getObject();调用的就是AbstractAutowireCapableBeanFactory#createBean()方法。
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.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
// lookup-method 和 replace-method ,spring将这两种配置统称为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.
//给BeanPostProcessor一个机会来返回代理而不是目标bean实例。
// 就是：InstantiationAwareBeanPostProcessors这个后置处理器，如果返回的是一个对象，
// 则不继续正常流程创建对象
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要不要进行创建，第二件事就是创建bean。我们先看第一件事：
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
|
|
V
在这个方法起去判断这个bean有没有实现 InstantiationAwareBeanPostProcessor 这个后置处理器
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.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
|
|
v
如果有实现InstantiationAwareBeanPostProcessor这个后置处理器，则会调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()方法
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;
}我们一般不会去实现InstantiationAwareBeanPostProcessor，对这个后置处理器不了解的可以看我这个篇文章 。而本次探讨的X类是没有的。我们继续往下看：
try {
//创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}掉用了doCreateBean();下面是代码
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 {
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.
// bd是一个单例 且 允许循环引用 且 当前bean为正在创建状态(正在创建状态在getSingleton方法中设置的)
// 则允许暴露早期单例
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 " +
"'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;
}第一步：
instanceWrapper = createBeanInstance(beanName, mbd, args);
createBeanInstance 顾名思义，就是创建一个实例对象。这个createBeanInstance方法是如何把对象创建出来的呢？ 就是利用构造方法反射实例化对象;那么构造方法是如何推断出来的呢？这个问题我不准备在此分析，因为Spring推断构造方式是源码中特别重要，特别难的一块，后面我会单独出一篇博客来分析。到此X对象就被创建出来了。我们接着往下看：
// bd是一个单例 且 允许循环引用 且 当前bean为正在创建状态(正在创建状态在getSingleton方法中设置的)
// 则允许暴露早期单例
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));这段代码就比较简单了，就是判断是否开启了循环依赖，如果返回true则Spring会做一些特殊的处理来完成循环依赖;
- mbd.isSingleton() 判断当前实例化的bean是否为单例;这里说明原型是不支持循环依赖的;因为如果是原型的这里就会返回false，这里环境是X默认是单例的，所以为true。
-
this.allowCircularReferences 整个全局变量Spring默认为true，但是Spring提供了API可以修改此变量。在没有修改的情况下这里返回true。 -
isSingletonCurrentlyInCreation(beanName)判断当前正在创建的bean是否处于正在创建的集合中，这里肯定为true。 这里三个判断都是true，结果为true。既然earlySingletonExposure 结果为true则Spring做一个特殊处理。我们看源码：
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));
}我们看addSingletonFactory方法：
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
//判断是否实例化完成
if (!this.singletonObjects.containsKey(beanName)) {
//添加到三级缓存
this.singletonFactories.put(beanName, singletonFactory);
//移除二级缓存
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}上述代码的意思是：
如果singletonObjects这个单例缓存池(也叫一级缓存)中不存在，则会把工厂对象put到
singletonFactories这个三级缓存中，再将二级缓存中的数据清除。singletonObjects 一级缓存单例池 ，主要存放单例beanearlySingletonObjects 二级缓存，主要存放半成品的bean(实例化之后属性填充之前的bean)singletonFactories 三级缓存，主要存放的是ObjectFactory类型的工厂对象
如果开启了循环依赖，Spring会将singletonFactory add 到三级缓存中，为什么要add到三级缓存的这个map中?主要是为了循环依赖，提前暴露这个工厂。
接下来看populateBean(beanName, mbd, instanceWrapper);
populateBean主要完成完成属性注入，也就是大家尝尝说的自动注入;
这里的代码又是比较复杂，我这里简单说一下：
属性填充：
会先判断自动注入模型，根据注入模型注入属性，拿到要注入的bean,调用getBean(y)，getBean的本质上面已经说过了，然后调用第一次的getSingleton方法，在这里首先会从单例缓存池中获取一下y,如果没有，则判断当前要创建的bean是不是处理正在创建的集合当中，如果也不存在则开始创建y，剩下的流程就跟创建x是一样的了，当开始填充Y 类的X属性时，会去getBean(x)，此时再一次走到getSingleton(x)，这一次获取也是null，但是当判断是否处于正在创建的集合当中时，返回true，判断成立，则会从三级缓存中获取x的实例，并将x添加到二级缓存中，移除三级缓存中的实例，使缓存升级，到此getBean(x)的属性就结束了。Y类的属性就填充完了。而X类中的y属性也就可以获取到了，属性填充结束，不管是循环依赖还是正常的属性填充都到此结束。
initializeBean(beanName, exposedObject, mbd);initializeBean 方法里主要完成了以下操作：
1、回调Aware相关的接口(BeanNameAware/BeanClassLoaderAware/BeanFactoryAware)
2、调用BeanPostProcessor#postProcessBeforeInitialization
3、invokeInitMethods @PostConstruct或 实现 InitializingBean 的方法
4、回调BeanPostProcessor#postProcessAfterInitialization()
bean实例创建完成之后返回DefaultSingletonBeanRegistry#getSingleton(）
返回singletonObject实例对象，接着往下走：
将实例化好的beanName从正在创建的集合当中移除
最后，bean添加到一级缓存，移除二级缓存与三级缓存.至此我们整个方法都结束了。
581
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
