《Spring源码深度解析 郝佳 第2版》bean的加载、循环依赖的解决

往期博客：

《Spring源码深度解析 郝佳 第2版》容器的基本实现与XML文件的加载

《Spring源码深度解析 郝佳 第2版》XML标签的解析

往期博客完成了xml文件加载和内容解析，将BeanDefinition相关信息保存在容器中，接着就是bean的加载即getBean()的流程

 BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("beanFactory.xml"));
 // 就是对下面语句的分析，手动getBean流程
 //注意：对于单例，如果没有配置lazy-init，那么spring容器启动的时候，就会提前创建，而对于多例，则是用到的时候才创建
 Object sichaolong = beanFactory.getBean("sichaolong");

目录

一、getBean()的流程

1. FactoryBean
2. ObjectFactory
3. 主要流程
4. 重要流程
   • 尝试从缓存获取bean
   • 完善从缓存获取的bean
   • 缓存中不存在bean，并且该bean不在创建中，需要 createBean()然后通过ObjectFactory返回bean
     • 验证覆盖方法
     • 添加BeanPostProcessor处理器
     • 真正的doCreateBean()

二、如何解决的循环依赖？

一、getBean()的流程

1、FactoryBean

一般情况下Spring通过xml配置bean信息通过反射创建对象，但是需要配置很多的属性在xml中，这时候如果能在代码中提供一种简单的方式就好了

FactoryBean就是为了解决这个问题，它是一个工厂类接口，用户可以通过实现该接口定制实例化bean的逻辑

Spring本身就带有70个FactoryBean的实现，3.0之后开始支持泛型。如MyBatis中的sqlSessionFactoryBean就是此类型。

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}

当配置的<bean>标签内的class的实现类是FactoryBean时候，通过getBean()方法返回的不是Factory本身，而是他的getObject()方法返回的我们需要的bean，相当于getObject()方法代理了getBean()方法

2、ObjectFactory

ObjectFactory和FactoryBean有点类似，它主要用作于三级缓存中来解决单例循环依赖问题

ObjectFactory就是一个普通的工厂对象接口，对于spring在doGetBean处的使用时，在于创建对象的过程由框架通过ObjectFactory定义，而创建的时机交给拓展接口Scope。除此之外ObjectFactory就是一个普通的接口

此外在将给依赖注入列表注册一个ObjectFactory类型的对象，在注入过程中会调用objectFactory.getObject()来创建目标对象注入进去。（如beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());）

package org.springframework.beans.factory;

import org.springframework.beans.BeansException;

@FunctionalInterface
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

他们二者的区别： 简单来说就是通过FactoryBean你可以控制对象如何创建，而ObjectFactory借助Scope接口自定义scope你可以控制对象的创建时机

3、主要流程

1. 转换对应的beanName：传入的String可能不是beanName而是别名，也可能是FactoryBean(前面需要加上&)
2. 尝试从缓存中加载单例getSingleton()：检查一、二、三级缓存
3. 能从缓存获取的到，还需要进行bean的完全实例化：为了解决循环依赖即使缓存中存在bean也是半实例化的，使用工厂模式的getObjectForBeanInstance()才能获取到完全实例化的bean
4. 缓存中不存在，需要原型模式依赖检查，只有到哪里模式下才能解决循环依赖
5. 检测parentFactory：如果beanDefinitionMap不包含beanName，尝试从parentFactory查找
6. 将GenericBeanDefinition转为RootBeanDefinition便于后续处理，当bean是某个bean的子bean的时候会合并父bean的相关属性，即ChildrenBeanDefinition和并RootBeanDefinition中的属性
7. 寻找bean内的依赖，先将依赖半实例化
8. 针对不同scope的bean进行创建
9. 类型转换，如将创建的bean转为requireType的类型

// 实现子类AbstractBeanFactory#getBean()
 public Object getBean(String name) throws BeansException {
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }
//重载方法
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
		// 1、转换对应BeanName
        String beanName = this.transformedBeanName(name);
          /**
            检查一、二级缓存或者三级缓存（实例工厂）是否有对应的实例
            Spring为了解决循环依赖，在bean刚开始创建未完成创建的时候，就将bean的ObjectFactory提早曝光到三级缓存
            **/
		// 2、直接尝试从缓存中获取，为了解决循环依赖
        Object sharedInstance = this.getSingleton(beanName);
        
        Object bean;
        // 一、缓存中存在
        if (sharedInstance != null && args == null) {
            if (this.logger.isTraceEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
          // 3、返回完全实例化的bean，因为从缓存中取得bean可能是半实例化的
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        }
        // 二、缓存中还未存在
		else {
			// 4、原型情况下存在循环依赖就报错
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            // 5、如果beanDefinitionMap不包含beanName，尝试从parentFactory查找
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }

                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                if (requiredType != null) {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }

                return parentBeanFactory.getBean(nameToLookup);
            }
			// 6、如果不是仅仅做类型检查而是创建bean,这里需要记录
            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            try {
            // 7、将存在DefaultListableBeanDefinitionFactory变量beanDefinitionMap中
            //的GenericBeanDefinition转为RootBeanDefinition
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                // 8、当bean是某个bean的子bean的时候会合并父bean的相关属性，即ChildrenBeanDefinition和并RootBeanDefinition中的属性
                this.checkMergedBeanDefinition(mbd, beanName, args);
                // 9、若该bean中依赖其他的bean,需要递归实例化那些bean
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dep = var11[var13];
                        if (this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }

                        this.registerDependentBean(dep, beanName);

                        try {
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }
				// 10、实例化依赖的那些bean就可以实例化自己了，拿着自己的BeanDefinition
				// （1）单例
                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                        	// 11、createBean()实例化，注意这里是半实例化，为了解决循环依赖
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    // 12、已经解决了循环依赖，获取完全实例化的bean
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } 
                // （2）原型 
                else if (mbd.isPrototype()) {
                    var11 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }
                //（3）其他 
                else {
                    String scopeName = mbd.getScope();
                    if (!StringUtils.hasLength(scopeName)) {
                        throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
                    }

                    Scope 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, () -> {
                            this.beforePrototypeCreation(beanName);

                            Object var4;
                            try {
                                var4 = this.createBean(beanName, mbd, args);
                            } finally {
                                this.afterPrototypeCreation(beanName);
                            }

                            return var4;
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) {
                        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", var23);
                    }
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }

        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                } else {
                    return convertedBean;
                }
            } catch (TypeMismatchException var25) {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

4、重要流程

// 2、尝试从缓存中获取getSingleton()，为了解决循环依赖，检查三级缓存

• singletonObjects：用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用
• earlySingletonObjects：提前曝光的单例对象的cache，存放原始的 bean 对象（尚未填充属性），用于解决循环依赖，可以使用getBean(）拿到半实例化的bean
• singletonFactories：单例对象工厂的cache，存放 bean 工厂对象ObjectFactory，用于解决循环依赖

// DefalutSingletonBeanRegistry#getSingleton()
 @Nullable
    public Object getSingleton(String beanName) {
    // 设置参数true表示只允许早期依赖
        return this.getSingleton(beanName, true);
    }

// 重载
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //1、尝试从一级缓存获取 singletonObjects
        Object singletonObject = this.singletonObjects.get(beanName);
        // 一级缓存不存在，并且bean正在创建中
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
        // 2、尝试从二级缓存中获取 earlySingletonObjects
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 二级缓存获取不到，并且支持循环引用，并且该bean正在创建中
            if (singletonObject == null && allowEarlyReference) {
            	// 加锁
                synchronized(this.singletonObjects) {
                // 3、再次尝试从一级缓存获取
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                    // 4、再次尝试从二级缓存获取
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                        	// 5、尝试从三级缓存中获取该bean对应的ObjectFactory
                            ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                            // 能从三级缓存中获取到该bean对应的ObjectFactory
                            if (singletonFactory != null) {
                            	// 6、使用ObjectFactory的getObject()方法获取bean
                                singletonObject = singletonFactory.getObject();
                                // 7、将该半实例化的bean从三级缓存移除，添加到二级缓存
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }

        return singletonObject;
    }

// 3、缓存中可能返回完全实例化的bean，需要调用getObjectForBeanInstance()

无论是从缓存中获取的bean还是根据不同的scope策略加载bean，得到bean之后第一步就是调用这个方法检查一下正确性，其实就是检查当前bean的类型是不是FactoryBean，是的话需要getObject()得到真正需要的bean

1. 对FactoryBean正确性的验证
2. 对非FactoryBean不做处理直接返回
3. 对bean进行转化
4. 将从Factory中解析bean的委托给getObjectFromFactoryBean()

 // AbstractBeanFactory#getObjectForBeanInstance()
 
 protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
 		// 1、如果指定bean是工厂相关的（以&为前缀）
        if (BeanFactoryUtils.isFactoryDereference(name)) {
            if (beanInstance instanceof NullBean) {
                return beanInstance;
                // 验证不通过，直接抛异常
            } else if (!(beanInstance instanceof FactoryBean)) {
                throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
            } else {
                if (mbd != null) {
                	// 设置RootBeanDefinition的属性isFactoryBean
                    mbd.isFactoryBean = true;
                }

                return beanInstance;
            }
        }
        // 2、是直接的bean,直接返回 
        else if (!(beanInstance instanceof FactoryBean)) {
            return beanInstance;
        } else {
        	// 3、加载FactoryBean
            Object object = null;
            if (mbd != null) {
                mbd.isFactoryBean = true;
            } else {
                object = this.getCachedObjectForFactoryBean(beanName);
            }

            if (object == null) {
                FactoryBean<?> factory = (FactoryBean)beanInstance;
                if (mbd == null && this.containsBeanDefinition(beanName)) {
                    mbd = this.getMergedLocalBeanDefinition(beanName);
                }
				// 是否是用户定义的而不是应用程序定义的
                boolean synthetic = mbd != null && mbd.isSynthetic();
                // 3、委托从Factory解析bean
                object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);
            }

            return object;
        }
    }

// 委托getObjectFromFactoryBean()从Factory获取bean
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
        if (factory.isSingleton() && this.containsSingleton(beanName)) {
            synchronized(this.getSingletonMutex()) {
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                	// 4、真正执行
                    object = this.doGetObjectFromFactoryBean(factory, beanName);
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    } else {
                        if (shouldPostProcess) {
                            if (this.isSingletonCurrentlyInCreation(beanName)) {
                                return object;
                            }

                            this.beforeSingletonCreation(beanName);

                            try {
                                object = this.postProcessObjectFromFactoryBean(object, beanName);
                            } catch (Throwable var14) {
                                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", var14);
                            } finally {
                                this.afterSingletonCreation(beanName);
                            }
                        }

                        if (this.containsSingleton(beanName)) {
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }

                return object;
            }
        } else {
        	// 真正执行
            Object object = this.doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                    object = this.postProcessObjectFromFactoryBean(object, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", var17);
                }
            }

            return object;
        }
    }
    
  //  委托doGetObjectFromFactoryBean

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
        Object object;
        try {
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = this.getAccessControlContext();

                try {
                // 5、相当于调用factory.getObject()
                    object = AccessController.doPrivileged(factory::getObject, acc);
                } catch (PrivilegedActionException var6) {
                    throw var6.getException();
                }
            } else {
            	// 5、调用factory.getObject()
                object = factory.getObject();
            }
        } catch (FactoryBeanNotInitializedException var7) {
            throw new BeanCurrentlyInCreationException(beanName, var7.toString());
        } catch (Throwable var8) {
            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);
        }

        if (object == null) {
            if (this.isSingletonCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");
            }

            object = new NullBean();
        }

        return object;
    }

…
…

// 10、一级缓存中不存在，并且bean不再创建中，需要createBean()

只不过createBean()的入口是使用ObjectFactory的getObject()定制的

ObjectFactory为函数式接口，内部getObject()返回的是createBean()返回的半实例化的bean直接return，这也就是解决缓存依赖巧妙的地方，而不再调用下面的this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

			// 判断单例
			if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                    	//ObjectFactory为函数式接口，内部getObject()返回的是createBean()返回的半实例化的bean
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var11 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else { ... }

拿着自己的BeanDefinition调用重载的DefaultSingletonBeanRegistry#getSingleton(beanName,ObjectFactory)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        // 1、锁住一级缓存
        synchronized(this.singletonObjects) {
        	// 2、再次尝试从一级缓存中获取
            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 (this.logger.isDebugEnabled()) {
                    this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
				// 3、前置处理
                this.beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = this.suppressedExceptions == null;
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet();
                }

                try {
                	// 4、初始化bean，其实也就是调用createBean()方法
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                } catch (IllegalStateException var16) {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw var16;
                    }
                } catch (BeanCreationException var17) {
                    BeanCreationException ex = var17;
                    if (recordSuppressedExceptions) {
                        Iterator var8 = this.suppressedExceptions.iterator();

                        while(var8.hasNext()) {
                            Exception suppressedException = (Exception)var8.next();
                            ex.addRelatedCause(suppressedException);
                        }
                    }

                    throw ex;
                } finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
					// 5、后置处理
                    this.afterSingletonCreation(beanName);
                }

                if (newSingleton) {
                	// 6、将结果记录在缓存并且删除加载过程中所记录的各种辅助状态
                    this.addSingleton(beanName, singletonObject);
                }
            }

            return singletonObject;
        }
    }
// 7、createBean()返回bean
// 由AbstractBeanFactory的实现类AbstractAutowireCapableBeanFactory重写createBean()方法
public <T> T createBean(Class<T> beanClass) throws BeansException {
        RootBeanDefinition bd = new RootBeanDefinition(beanClass);
        bd.setScope("prototype");
        bd.allowCaching = ClassUtils.isCacheSafe(beanClass, this.getBeanClassLoader());
        return this.createBean(beanClass.getName(), bd, (Object[])null);
    }
// 重载
 protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Creating instance of bean '" + beanName + "'");
        }

        RootBeanDefinition mbdToUse = mbd;
        // 8、解析bean的Class
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        try {
        	// 9、验证准备覆盖的方法
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var9) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
        }

        Object beanInstance;
        try {
        	// 10、给BeanPostProcessors一个机会来返回代理来代理真正的实例
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if (beanInstance != null) {
                return beanInstance;
            }
        } catch (Throwable var10) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
        }

        try {
        	// 11、委托给doCreateBean()
            beanInstance = this.doCreateBean(beanName, mbdToUse, args);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Finished creating instance of bean '" + beanName + "'");
            }

            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
            throw var7;
        } catch (Throwable var8) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
        }
    }
    

验证准备覆盖的方法

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
        if (this.hasMethodOverrides()) {
            this.getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
        }

    }

    protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
        int count = ClassUtils.getMethodCountForName(this.getBeanClass(), mo.getMethodName());
        if (count == 0) {
            throw new BeanDefinitionValidationException("Invalid method override: no method with name '" + mo.getMethodName() + "' on class [" + this.getBeanClassName() + "]");
        } else {
            if (count == 1) {
                mo.setOverloaded(false);
            }

        }
    }

添加BeanPostProcessor处理器

给BeanPostProcessors一个机会来返回代理来代理真正的bean，主要是方便易以后拓展

• bean实例化前的后置处理：InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()
• bean实例化后的后置处理：BeanPostProcessor#postProcessAfterInitialization()

@Nullable
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = this.determineTargetType(beanName, mbd);
                if (targetType != null) {
                	// 实例化前处理
                    bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                    	// 实例化后处理
                        bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }

            mbd.beforeInstantiationResolved = bean != null;
        }

        return bean;
    }
 
 // 实例化前处理
 @Nullable
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        Iterator var3 = this.getBeanPostProcessors().iterator();

        while(var3.hasNext()) {
            BeanPostProcessor bp = (BeanPostProcessor)var3.next();
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }

        return null;
    }

// 实例化后处理
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;

        Object current;
        for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
            BeanPostProcessor processor = (BeanPostProcessor)var4.next();
            current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
        }

        return result;
    }

真正的doCreateBean()

// AbstractAutowireCapableBeanFactory#doCreateBean()
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

        if (instanceWrapper == null) {
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                }

                mbd.postProcessed = true;
            }
        }

        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }

            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }

        Object exposedObject = bean;

        try {
            this.populateBean(beanName, mbd, instanceWrapper);
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;
                    int var13 = dependentBeans.length;

                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dependentBean = var12[var14];
                        if (!this.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.");
                    }
                }
            }
        }

        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }

二、如何解决的循环依赖？