protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
// 处理beanName 与factoryBean有关
String beanName = transformedBeanName(name);
Object bean;
//如果是外部调用的 此时就在这里返回了 因为已经有了 如果不是外部调用的 我就要创建了
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 + "'");}}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);}else{
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if(isPrototypeCurrentlyInCreation(beanName)){
throw new BeanCurrentlyInCreationException(beanName);}
// 处理父子baanDefination的
BeanFactory parentBeanFactory = getParentBeanFactory();if(parentBeanFactory != null &&!containsBeanDefinition(beanName)){
// Not found -> check parent.
String nameToLookup = originalBeanName(name);if(parentBeanFactory instanceof AbstractBeanFactory){return((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);// Guarantee initialization of beans that the current bean depends on.
// 处理@DependOn注解的 如果一个bean被@DependOn注解标注 我先创建@DependOn这个类
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)){
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}
registerDependentBean(dep, beanName);
try {
getBean(dep);}
catch (NoSuchBeanDefinitionException ex){
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);}}}
// 创建单例bean
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);}
// 创建原型bean
elseif(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();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");}
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;}}
// Check if required type matches the type of the actual bean instance.
if(requiredType != null &&!requiredType.isInstance(bean)){
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);if(convertedBean == null){
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}return convertedBean;}
catch (TypeMismatchException ex){if(logger.isTraceEnabled()){
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}}return(T) bean;}
他这段代码的主要逻辑
1.处理beanName
2.处理父子beanDefination
3.合并bd处理 dependOn 如果被DependOn标注的的bean 我首先创建 @DependOn指定的bean
4.单例bean----> bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);{factorybean 会走这里}5. 原型bean----> bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);{factorybean 会走这里}
呢么接下来我们要看他是如何创建单例bean的,我们需要看下面的方法
@接下来我们再着重看createBean不管是单例的还是原型的你总归要去创建的 他 就不会关心你创建的是单例的还是原型的
@Override
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 incase of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
/ 根据据beanName 拿到class对象 此时通过类加载器 来加载class对象
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);if(resolvedClass != null &&!mbd.hasBeanClass()&& mbd.getBeanClassName()!= null){
mbdToUse = new RootBeanDefinition(mbd);
/// 将class对象赋值进去
mbdToUse.setBeanClass(resolvedClass);}
// Prepare method 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.
# 实例化前 InstantiationAwareBeanPostProcessor 如果有类实现了他,可以创建某一个Bean{我程序员可以通过eBeanPostProcessor 来干预Springbean的创建}
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);}}
他这里的createBean 管是单例的还是原型的你总归要去创建的 他 就不会关心你创建的是单例的还是原型的
1.>根据beanName以及beanDefination拿到对应的class 我要创建bean 我肯定要加载class
2.>实例化bean之前,如果是InstantiationAwareBeanPostProcessor 这种的bd 返回了一个bean 的化 我就返回对应的Bean 就不会走你spring默认的bean
// 实例化bean
3.> Object beanInstance = doCreateBean(beanName, mbdToUse, args);
######## 我通过个方法就可以根据也给beanName ,bd可以进行实例化Bean了
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;if(mbd.isSingleton()){
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if(instanceWrapper == null){######### 通过这里实例化Bean的
instanceWrapper = createBeanInstance(beanName, mbd, args);}############ 实例化bean 之后拿到的bean
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 {########### MergedBeanDefinitionPostProcessor 这种bd也是一个扩展点 我程序员可以在Spring实例化之后来控制Bd 比方说我可以自己做属性赋值
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.
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;}elseif(!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;}# 这个方法的大致逻辑1.>创建bean 实例化bean涉及到了Spring断言构造方法的过程
2> 如果某一个类实现了 MergedBeanDefinitionPostProcessor 这种bd也是一个扩展点 我程序员可以在Spring实例化之后来控制Bd 比方说我可以自己做属性赋值
3>属性赋值
4.>初始化