Spring 源码阅读 24：单例 Bean 实例的创建过程（1）

// Create bean instance.if (mbd.isSingleton()) {
sharedInstance=getSingleton(beanName, () -> {
try {
returncreateBean(beanName, mbd, args);
      }
catch (BeansExceptionex) {
// 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);
throwex;
      }
   });
bean=getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
elseif (mbd.isPrototype()) {
// It's a prototype -> create a new instance.ObjectprototypeInstance=null;
try {
beforePrototypeCreation(beanName);
prototypeInstance=createBean(beanName, mbd, args);
   }
finally {
afterPrototypeCreation(beanName);
   }
bean=getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
StringscopeName=mbd.getScope();
finalScopescope=this.scopes.get(scopeName);
if (scope==null) {
thrownewIllegalStateException("No Scope registered for scope name '"+scopeName+"'");
   }
try {
ObjectscopedInstance=scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
returncreateBean(beanName, mbd, args);
         }
finally {
afterPrototypeCreation(beanName);
         }
      });
bean=getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
   }
catch (IllegalStateExceptionex) {
thrownewBeanCreationException(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);
   }
}

sharedInstance=getSingleton(beanName, () -> {
try {
returncreateBean(beanName, mbd, args);
  }
catch (BeansExceptionex) {
// 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);
throwex;
  }
});
bean=getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

// org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java:207publicObjectgetSingleton(StringbeanName, ObjectFactory<?>singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
ObjectsingletonObject=this.singletonObjects.get(beanName);
if (singletonObject==null) {
if (this.singletonsCurrentlyInDestruction) {
thrownewBeanCreationNotAllowedException(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);
booleannewSingleton=false;
booleanrecordSuppressedExceptions= (this.suppressedExceptions==null);
if (recordSuppressedExceptions) {
this.suppressedExceptions=newLinkedHashSet<>();
         }
try {
singletonObject=singletonFactory.getObject();
newSingleton=true;
         }
catch (IllegalStateExceptionex) {
// 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) {
throwex;
            }
         }
catch (BeanCreationExceptionex) {
if (recordSuppressedExceptions) {
for (ExceptionsuppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
               }
            }
throwex;
         }
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions=null;
            }
afterSingletonCreation(beanName);
         }
if (newSingleton) {
addSingleton(beanName, singletonObject);
         }
      }
returnsingletonObject;
   }
}

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#beforeSingletonCreationprotectedvoidbeforeSingletonCreation(StringbeanName) {
if (!this.inCreationCheckExclusions.contains(beanName) &&!this.singletonsCurrentlyInCreation.add(beanName)) {
thrownewBeanCurrentlyInCreationException(beanName);
   }
}
// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#afterSingletonCreationprotectedvoidafterSingletonCreation(StringbeanName) {
if (!this.inCreationCheckExclusions.contains(beanName) &&!this.singletonsCurrentlyInCreation.remove(beanName)) {
thrownewIllegalStateException("Singleton '"+beanName+"' isn't currently in creation");
   }
}

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonprotectedvoidaddSingleton(StringbeanName, ObjectsingletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
   }
}

@FunctionalInterfacepublicinterfaceObjectFactory<T> {
TgetObject() throwsBeansException;
}

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])@OverrideprotectedObjectcreateBean(StringbeanName, RootBeanDefinitionmbd, @NullableObject[] args)
throwsBeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '"+beanName+"'");
   }
RootBeanDefinitionmbdToUse=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=newRootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
   }
// Prepare method overrides.try {
mbdToUse.prepareMethodOverrides();
   }
catch (BeanDefinitionValidationExceptionex) {
thrownewBeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
   }
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.Objectbean=resolveBeforeInstantiation(beanName, mbdToUse);
if (bean!=null) {
returnbean;
      }
   }
catch (Throwableex) {
thrownewBeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
   }
try {
ObjectbeanInstance=doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '"+beanName+"'");
      }
returnbeanInstance;
   }
catch (BeanCreationException|ImplicitlyAppearedSingletonExceptionex) {
// A previously detected exception with proper bean creation context already,// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.throwex;
   }
catch (Throwableex) {
thrownewBeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
   }
}

// org.springframework.beans.factory.support.BeanDefinitionValidationExceptionpublicvoidprepareMethodOverrides() throwsBeanDefinitionValidationException {
// Check that lookup methods exist and determine their overloaded status.if (hasMethodOverrides()) {
getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
   }
}
// org.springframework.beans.factory.support.BeanDefinitionValidationExceptionprotectedvoidprepareMethodOverride(MethodOverridemo) throwsBeanDefinitionValidationException {
intcount=ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
if (count==0) {
thrownewBeanDefinitionValidationException(
"Invalid method override: no method with name '"+mo.getMethodName() +"' on class ["+getBeanClassName() +"]");
   }
elseif (count==1) {
// Mark override as not overloaded, to avoid the overhead of arg type checking.mo.setOverloaded(false);
   }
}

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation@NullableprotectedObjectresolveBeforeInstantiation(StringbeanName, RootBeanDefinitionmbd) {
Objectbean=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);
   }
returnbean;
}

bean=applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
bean=applyBeanPostProcessorsAfterInitialization(bean, beanName);

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation@NullableprotectedObjectapplyBeanPostProcessorsBeforeInstantiation(Class<?>beanClass, StringbeanName) {
for (BeanPostProcessorbp : getBeanPostProcessors()) {
if (bpinstanceofInstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessoribp= (InstantiationAwareBeanPostProcessor) bp;
Objectresult=ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result!=null) {
returnresult;
         }
      }
   }
returnnull;
}
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization@OverridepublicObjectapplyBeanPostProcessorsAfterInitialization(ObjectexistingBean, StringbeanName)
throwsBeansException {
Objectresult=existingBean;
for (BeanPostProcessorprocessor : getBeanPostProcessors()) {
Objectcurrent=processor.postProcessAfterInitialization(result, beanName);
if (current==null) {
returnresult;
      }
result=current;
   }
returnresult;
}