Spring 源码阅读-bean的创建、循环依赖的处理以及代理

本文档基于Spring 5.1.4.RELEASE版本进行编写。

• 下文很多地方出现默认配置，有点抽象，但大概指的就是例如：不自己编写ApplicationContext的子类、不手动注册BeanDefinition这一类的操作。
• 下文很多地方在if判断的括号后写的注释表示的是括号内的条件怎样才会成立
• 下文都是基于本文展示的调用链进行说明的。

关于循环依赖、动态代理可以搜索补充-{0}直接跳转过去，懒得搞目录了。

在阅读过程中，如果遇到循环依赖的注释，可以先不管，在了解循环依赖时再看也不迟，有写的

1. getBean(String) & doGetBean(String, Class, Object[], boolean)

getBean(String)方法负责bean的实例化以及内部参数的注入等初始化操作。

本节主要完成了dependsOn的处理，dependsOn循环依赖的处理具体见 3.1 小节。
bean的创建过程交由之后的调用链完成。

// AbstractBeanFactory
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

// AbstractBeanFactory
protected  T doGetBean(final String name, @Nullable final Class requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    // 在本段代码中将用数字表明默认情况一个单例Bean被创建的过程

    // 1.找到最终的 beanName, 会对 FactoryBean、配置了别名的bean进行名称处理，得到最终的 beanName
    final String beanName = transformedBeanName(name);
    Object bean;

    // 2.从bean的单例缓存中获取值 (如果不为null，代表bean已经创建过/正在在创建中；但相反如果为null，不一定没创建过)
    // 在解决属性的循环依赖中发挥了重要作用
    Object sharedInstance = getSingleton(beanName);
    // 3.判断bean是否已经创建过/正在在创建中
    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 { // 进入这里时，bean可能已经在创建了
        // 如果一个bean在创建期间重复进入这里，代表出现了属性的循环依赖，见3.2小节

        // 4.判断当前原型 bean 是否正在创建中 (这个是对多例的处理)
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // Check if bean definition exists in this factory.
        BeanFactory parentBeanFactory = getParentBeanFactory();

        // 5.判断有没有父容器(在示例代码中，内部IOC容器是没有父容器的，Application容器只是持有内部IOC容器)
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // 有父容器且当前容器内没找到这个bean的元数据
            // 就尝试在父容器中创建bean
            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);
            }
        }

        // 6.判断typeCheckOnly是否为true (由上层调用者传入，提供的所有getBean方法传入的都是false)。
        // 如果为 true 代表获取实例是为了进行类型检查，而不是为了实际使用，
        // 有一种情况会传入true，调用AbstractBeanFactory#isTypeMatch方法，且目标bean实现了FactoryBean时。
        if (!typeCheckOnly) {
            // 7.标记bean为已创建，添加到AbstractBeanFactory的alreadyCreated集合中，并把bean的元数据删除。
            markBeanAsCreated(beanName);
        }

        try {
            // 8.获取BeanDefinition，并检查BeanDefinition是否是抽象的
            /*
            * RootBeanDefinition 这里简单说一下它跟什么有关系，的parent属性，它在Spring有同名对应的类。
            * 我们配置的bean在被解析时，首先会被解析为GenericBeanDefinition对象实例，但是下面的getMergedLocalBeanDefinition方法调用后
            * 都会转变为RootBeanDefinition，只不过有没有parent属性决定了它们的处理逻辑的不同。
            * 可以理解为，RootBeanDefinition是一个和可能存在的parent合并而来的产物。
            * !关于的parent属性使用示例:
            *  如果 Parent 类里没有定义 name 属性，那么可以给标签添加 abstract=true 或者 lazy-init=true 来避免容器启动失败。
            *     
            * 
            *  Child类中必须有 name 属性才行
            *     
            * 
            * Child 会继承 name 属性的值, 但是在Java代码层面2个类并没有关系，一般这情况都是用来当模板减少配置的。 
            *
            * MergedBeanDefinition 没有同名对应的类，但在getMergedLocalBeanDefinition方法中，会把转变后的RootBeanDefinition
            * 当成MergedBeanDefinition，存放到AbstractBeanFactory类的mergedBeanDefinitions属性中
            */
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 如果，而且尝试主动通过了doGetBean方法实例化，到下面这个方法就会抛出BeanIsAbstractException异常。
            // 保证了抽象的bean不可能完成实例化。
            checkMergedBeanDefinition(mbd, beanName, args);

            // 9.优先创建当前bean所依赖的bean，与标签中的depends-on属性有关
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    // 检测双向以来，在这一步执行时，见 1.6 小节
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 每个depends-on都要注册为双向依赖关系，用于支持isDependent方法进行循环依赖检测，见 3.1 小节
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep); // 对依赖的的bean先进行处理。
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // 创建bean实例
            if (mbd.isSingleton()) { // 单例
                // 10.使用传入的lambda函数创建bean (实例化 + 初始化)
                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;
                    }
                });
                // 11.如果当前bean是FactoryBean,尝试调用FactoryBean中的getObject()获取目标结果。
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            // ... 省略了多例以及其它Scope的创建方式
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // 12.保证获取的bean实例为所需的类型，如果不一致，需要通ConversionService服务转换
    // 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.2. getSingleton(String) & getSingleton(String, boolean)

这个方法要配合属性的循环依赖来看，如果还没看到先跳过本节，关于属性的循环依赖见 3.2 小节。

/** 单例对象的缓存: Key是beanName  Value是bean对象实例. */
private final Map singletonObjects = new ConcurrentHashMap<>(256);

/** 早期的单例对象的缓存: Key是beanName  Value是bean对象实例. */
private final Map earlySingletonObjects = new HashMap<>(16);

/** 单例的创建方式的缓存: Key是beanName  Value是一个lambda函数，代表了bean应该如何实例化. */
private final Map> singletonFactories = new HashMap<>(16);

// DefaultSingletonBeanRegistry
public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}

// DefaultSingletonBeanRegistry
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 提前说明，这里的this指的就是内部IOC容器，是一个DefaultListableBeanFactory实例对象

    // 先尝试从单例缓存中读取，如果读取到了直接返回
    // 要是能读取到，代表当前bean实例已经创建完成。
    Object singletonObject = this.singletonObjects.get(beanName);

    // 如果缓存中没有，且当前的 bean 正在创建的过程中
    // 要是符合这个条件，就代表存在bean的创建过程中存在属性间的循环依赖。
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                // 如果不为空，代表allowCircularReferences为true，也就是说允许属性之间的循环依赖。
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    // 从singletonFactories晋升到earlySingletonObjects中。
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

1.3. getSingleton(String, ObjectFactory)

/** 按注册顺序存放着已经注册的单例的name */
private final Set registeredSingletons = new LinkedHashSet<>(256);

/** 当前正在创建的bean的名称集合. */
private final Set singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

/** Names of beans currently excluded from in creation checks. */
private final Set inCreationCheckExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
        
// DefaultSingletonBeanRegistry
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) { // 缓存中没有
            // ------------------------- singletonsCurrentlyInDestruction的验证 -------------------------
        
            // 判断单例集合是否正在销毁，如果为true意味着IOC容器刷新失败，或者应用正在关闭。
            /* 
            * 在之前说过的代码中有2个地方会把这个值设置为true
            * 第1个地方：AbstractApplicationContext#refresh() 中的obtainFreshBeanFactory()逻辑里
            * 第2个地方：AbstractApplicationContext#refresh() 的catch块内调用的destroyBeans()
            */
            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 + "'");
            }
            
            // --------------------------------------- 执行单例创建前的逻辑 ---------------------------
            
            /* 如果不在 inCreationCheckExclusions 集合中，则添加到 singletonsCurrentlyInCreation 集合中，如果集合中已经存在就抛出循环依赖异常
            * singletonsCurrentlyInCreation 集合标记了当前正在创建的bean，在循环依赖的确定中发挥作用。
            * 
            * 这行代码是属性循环依赖检查的重要逻辑点，用以在不允许属性循环依赖时抛出异常，见 3.2 节。
            */
            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) {
                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;
                }
                // --------------------------------------- 执行单例创建后的逻辑 ---------------------------

                // 如果不在 inCreationCheckExclusions 集合中，则从 singletonsCurrentlyInCreation 集合中移除出去
                // 在 singletonsCurrentlyInCreation 集合中一进一出代表bean的创建完成。
                afterSingletonCreation(beanName);
            }
            // 判断是刚创建的单例对象 还是 从缓存中拿出来的
            if (newSingleton) { // 是刚创建的
                // 把刚创建的bean放到缓存对象里 并 对其他集合进行数据处理，在解决属性的循环依赖中发挥了重要作用，见 3.2 节。
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

// DefaultSingletonBeanRegistry
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 存入到单例缓存中
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        // 从早期的单例对象的缓存中移除
        this.earlySingletonObjects.remove(beanName);
        // 存入已经注册的单例
        this.registeredSingletons.add(beanName);
    }
}

1.3.1. beforeSingletonCreation & afterSingletonCreation

// DefaultSingletonBeanRegistry
protected void beforeSingletonCreation(String beanName) {
    // 如果不在 inCreationCheckExclusions 集合中，则添加到 singletonsCurrentlyInCreation 集合中
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
        // 见 3.2 节
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

// DefaultSingletonBeanRegistry
protected void afterSingletonCreation(String beanName) {
    // 如果不在 inCreationCheckExclusions 集合中，则从 singletonsCurrentlyInCreation 集合中移除出去
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }
}

1.3.2. createBean(String, RootBeanDefinition, Object[])

// 只看lambda里面
sharedInstance = getSingleton(beanName, () -> {
    try {
        return createBean(beanName, mbd, args); // 创建bean
    }
    catch (BeansException ex) {
        // 实例化过程出现异常 销毁bean实例化过程中的一切相关项
        destroySingleton(beanName);
        throw ex;
    }
});

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

    // ... 日志打印  "Creating instance of bean '" + beanName + "'"
    RootBeanDefinition mbdToUse = mbd; 

    // ----------------------------------------- 解析出要实例化的Class ----------------------------------

    // 将配置文件中标签的class属性指定的符号引用加载为一个类，在一般情况下会直接把这个类放入mbd中。
    // 如果进入下面的if里面就代表不一般。
    // 如果这个过程中出现异常则会抛出 CannotLoadBeanClassException 异常。
    Class resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        /* 如果你使用了SpEL表达式配置标签的class属性，会进入这里。
        * 例如：
        *
        * 针对于进入到这里的bean，其原始的BeanDefinition的beanClassName是一个表达式显然是不方便使用的
        * 这里会复制原始的BeanDefinition，并设置BeanClass，作为即将使用的RootBeanDefinition。
        */
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // --------------------------------------- 处理 MethodOverride ----------------------------------

    // Prepare method overrides.
    try {
        // 这个是对  和  标签的简单标记 
        // 方法内部对元数据内的 MethodOverride进行了setOverloaded(false)行为。
        // 这两个标签都会被处理成MethodOverride对象，在实例化对象时，如果有MethodOverride，会使用CGLIB生成代理类，见AbstractAutowireCapableBeanFactory#createBean。
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    // --------------------------------- 尝试靠BeanPostProcessors来生成代理类 ----------------------------

    try {
        // 给BeanPostProcessors一个返回目标类的代理实现的机会，如果返回了代理类，那就不需要再实例化bean了，见 4.1 小结
        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);
    }

    // --------------------------------------- 执行创建bean的行为 ---------------------------------------

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

1.3.2.1. doCreateBean(String, RootBeanDefinition, Object[])

完成bean的实例化与初始化(填充属性、调用Aware相关方法等)

// AbstractAutowireCapableBeanFactory
/** 还没有实例化完成的FactoryBean的缓存: FactoryBean name to BeanWrapper. */
private final ConcurrentMap factoryBeanInstanceCache = new ConcurrentHashMap<>();

// AbstractAutowireCapableBeanFactory
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); 
    }
    // ---------------------------------------- 实例化bean --------------------------------------
    
    // 这里是为了确认一下是不是还没有实例化结束的FactoryBean
    if (instanceWrapper == null) { // (如果)不是
        // 创建bean实例，返回的BeanWrapper包含有已经实例化的bean实例，但还没有进行属性填充
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance(); // 实例化的bean
    Class beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // ------------------------------- 应用BeanDefinitionPostProcessor ----------------------------
    
    // 调用MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition方法。
    // 对bean中使用的注解进行解析与检查(例如@Autowired、@Resource、@PostConstruct、@PreDestroy等)，
    // 方便后续参数注入等合适的时机使用。
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) { // (如果)还没有被BeanDefinitionPostProcessor处理过
            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;
        }
    }

    // ---------------------------------------- 准备处理循环依赖的数据 -------------------------------------

    /*
    * 1.当前要实例化的bean是单例
    * 2.内部IOC容器允许循环引用
    *   如果内部IOC容器是非自定义的，那么总是为true的，可以手动设置。
    * 3.当前bean正在创建 (检测是否在singletonsCurrentlyInCreation集合中)
    *   在上层调用者getSingleton(String, ObjectFactory)中调用createBean之前已经把当前bean添加到了这个集合中。
    * 满足这3点就把当前bean放入到singletonFactories列表中，让程序支持bean内属性的循环引用。
    */
    // 如果当前bean是单例，默认情况下 earlySingletonExposure 的值就为 true，后面两个判断项在当前调用链中
    // 可以忽视，三个判断缩减为一个判断，也就是只要是单例这里就为true (谨慎使用这种缩减理解)。
    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");
        }
        // getEarlyBeanReference方法内部的逻辑涉及到了代理类的创建，见 4.3 小结。
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // ------------------------------------- 初始化bean实例 ----------------------------------------

    // 之前是bean的实例化工作(创建实例对象)，这里是进行对bean实例进行初始化(设置属性)
    Object exposedObject = bean;
    try {
        // 填充属性
        populateBean(beanName, mbd, instanceWrapper);
        // 调用bean的InitMethods、处理bean的其他注解等
        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);
        }
    }
    
    // 到这里，当前bean的实例化与初始化工作已经完成了

    if (earlySingletonExposure) {
        // 主要目的是为了尝试从earlySingletonObjects中拿到数据
        Object earlySingletonReference = getSingleton(beanName, false);
        // 想让这个成立，可以写个Bean，里面写2+个自身的依赖的属性。
        if (earlySingletonReference != null) { // (如果)不为空
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            // 这里两者不相等，是因为在循环引用的逻辑中，BeanPostProcessor的初始化前/后的后处理可能对bean的实例发生变动。
            // 这种情况是应该尽量避免的，自定义BeanPostProcessor的逻辑时应该注意一下
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set 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 {
        // (有前提条件的)尝试注册到容器的disposableBeans集合中，用于在必要时执行相关的自定义销毁逻辑，下面有说明。
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

1.3.2.1.1. createBeanInstance(String, RootBeanDefinition, Object[])

这个方法的功能是：选用合适的方式创建bean实例。

// AbstractAutowireCapableBeanFactory
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // 上面已经调用过这个方法了，这里直接取出来RootBeanDefinition对象里的BeanClass
    Class beanClass = resolveBeanClass(mbd, beanName);

    // 1.类存在  2.类的访问修饰符不包含public  3.不允许非公开的访问，满足这3点就会进入 if 代码块然后报异常。
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }

    // ----------------------------------- 使用instanceSupplier实例化bean -------------------------------
    
    // 这是一种自定义实例化过程的方式，下面有使用说明，方法内部很简单不进行说明
    Supplier instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }

    // ----------------------------------- 使用factory-method实例化bean ---------------------------

    // 这是一种自定义实例化过程的方式，下面有使用说明，方法内部很简单不进行说明
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // ----------------------------------- 重新创建同一bean时的快捷方式 -----------------------------
    // 使用factory-method、BeanPostProcessor机制、默认构造的首选构造函数这3种情况时，都是要解析构造函数或工厂方法的，重复的不断解析显然是性能亏损的，所以可以缓存起来下次直接使用，所计叫快捷方式。

    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            // resolvedConstructorOrFactoryMethod 和 constructorArgumentsResolved 属性的赋值在
            // ConstructorResolver的 instantiateUsingFactoryMethod 和 autowireConstructor 两个方法中都存在
            // 见 ConstructorResolver#storeCache
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            // 通过autowire构造函数实例化bean。
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            // 与这个方法最后一行逻辑一样。
            return instantiateBean(beanName, mbd);
        }
    }
    
    // ------------------------------ 使用BeanPostProcessor机制实例化bean ----------------------------

    // 使用BeanPostProcessor机制获取bean的构造函数，然后使用构造函数进行实例化bean。
    /* 
    * 见 AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors
    * 其中对添加了@Lookup注解的方法、添加了@Autowired的构造函数有相应的处理，见下文
    */
    Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    // 1.构造函数不为null   
    // 2.AutowireMode为constructor -> 和标签的autowire属性有关
    // 3.有构造函数参数值(ConstructorArgumentValues) -> 和标签下的子标签有关
    // 4.args = null || args.length == 0  -> 本文展示的调用链的逻辑里，是一直为null的
    // 只要满足其中任意一个，就能进入if代码块
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // ----------------------------- 使用默认构造的首选构造函数实例化bean ------------------------------

    // RootBeanDefinition的这个方法会返回null
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }

    // ----------------------------- 使用默认的方式(无参构造函数)实例化bean ------------------------------
    // 上面的那么多种形式都是特殊的实例化方式，只有这个是默认的，默认使用无参构造函数。
    
    // 如果当前bean使用了 或 ，Spring会为当前bean创建CGLIB子类，并返回子类的实例化对象，而不是原始的类的。
    // 见CglibSubclassingInstantiationStrategy#instantiate(Constructor, Object[])
    return instantiateBean(beanName, mbd);
}

1.3.2.1.1.1. InstanceSupplier的使用

这个属性在BeanDefinition的多个实现类中都可以用，它提供一种仍受内部IOC容器管控的独特的实例化bean的方式。
它允许用户自定义bean的实例化逻辑，不需要再使用默认情况下通过反射去实例化bean的做法。

// 示例代码

public static void main(String[] args) {
    GenericBeanDefinition helloServiceBeanDefinition = new GenericBeanDefinition();
    helloServiceBeanDefinition.setBeanClassName("com.example.demo.springtest.base.HelloServiceImpl");
    // 自定义bean的实例化过程
    helloServiceBeanDefinition.setInstanceSupplier(() -> {
        HelloServiceImpl helloService = new HelloServiceImpl();
        helloService.setContent("自定义实例化逻辑");
        return helloService;
    });
    // 交由Spring完成内部属性的注入(DI)
    MutablePropertyValues propertyValues = helloServiceBeanDefinition.getPropertyValues();
    propertyValues.addPropertyValue("outputService", new RuntimeBeanReference("outputService"));

    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring-config.xml"}, true, null);
    // 这里注意，要让refresh=true，否则内部IOC容器还没有创建就注册BeanDefinition会报错
    ((BeanDefinitionRegistry) ac.getBeanFactory()).registerBeanDefinition("helloService1", helloServiceBeanDefinition);

    // bean的获取与方法调用
    HelloService helloService = ac.getBean("helloService1", HelloService.class);
    helloService.sayHello();
}

1.3.2.1.1.2. factory-method的使用

可以通过配置标签的factory-method属性来使用，它也提供一种仍受内部IOC容器管控的独特的实例化bean的方式，允许用户自定义bean的实例化逻辑。

public class ServiceFactory {
   // 非静态方法
   public XXService createService() { return new XXService(); }
   // 静态方法2
   public static XXService createStaticService2(String arg) { return new XXService(arg); }
   // 静态方法1
   public static XXService createStaticService() { return new XXService(); }
}








      

1.3.2.1.1.3. 使用BeanPostProcessor机制获取bean的构造函数

默认情况下只会被AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors处理。

使用@Autowired注解构造函数这种情况比较罕见，当类中有多个构造函数时可以使用这个机制。
1.只有无参构造函数，返回null。
2.有无参构造函数也有有参构造函数，不使用@Autowired，返回null。
3.只有一个有参构造函数，不使用@Autowired，返回有参构造函数，但是入参有严格要求，必须是可以被容器管理的。
4.有多个有参构造函数，不使用@Autowired，返回null，之后抛出异常。
5.有任意数量构造函数，使用一个@Autowired，返回被注解的那个构造函数，入参必须是可以被容器管理的。

// 使用实例

@Service
public class TestService {
    private MessageSource messageSource;

    public TestService() {}

    @Autowired
    public TestService(MessageSource messageSource) {
        this.messageSource = messageSource;
    }
}

同时这个方法中也有对@Lookup注解的处理逻辑。
@Lookup和标签的lookup-method属性是等效的。
@Lookup Annotation in Spring

public class A {
    public void test() { System.out.println(getA()); }

    public B getB() { return null; }
}

public class B() {}



    


@Test
public void testLookup() {
    A a = this.context.getBean(A.class);
    a.test();
}

1.3.2.1.2. addSingletonFactory & getEarlyBeanReference

// DefaultSingletonBeanRegistry
protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
    // 传入的singletonFactory是一个lambda函数，它内部的逻辑涉及到了代理类的创建，很值得注意。
    
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        /* 这个判断如果成立，代表当前bean还没有完成实例化与初始化这整个步骤，
        * 当前方法在由createBean(String, RootBeanDefinition, Object[])产生的调用链过程内，
        * 也就是说在执行这个方法时，bean已经实例化完成了，但还没有完成赋值等后续操作。
        * 只有完成这个调用链，那么这个bean才会被放入singletonObjects中。
        */ 
        if (!this.singletonObjects.containsKey(beanName)) { // (如果)单例对象缓存中不包含当前bean
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

至于getEarlyBeanReference方法，它涉及到了代理类的创建，这里不进行代码展示，它的说明在下文 4.3 小节。

1.3.2.1.3. populateBean(String, RootBeanDefinition, BeanWrapper)

这个方法的功能是：向bean的实例对象内填充属性值。

// AbstractAutowireCapableBeanFactory
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // ------------------------------------------ 先行的校验 -------------------------------------------

    // 一个先行的校验，确保要被填充的的实例对象存在。(BeanWrapper持有bean实例对象)
    if (bw == null) {
        if (mbd.hasPropertyValues()) { // (如果)bean的元数据设置有属性值
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
        }
        else { // 没有属性值
            // Skip property population phase for null instance.
            return;
        }
    }

    // -------------- 执行 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation -------------
    // 在(给bean实例)设置属性前，给InstantiationAwareBeanPostProcessor这个类型的BeanPostProcessor一个机会，让它们修改bean的状态。
    // 例如，这可以用来支持字段注入的方式。
    
    boolean continueWithPropertyPopulation = true;

    // 1.类不是桥接的  2.有InstantiationAwareBeanPostProcessor类型的BeanPostProcessor   满足这两点就会进入 if 代码块
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor);
                // 基于默认提供的实现，下面的if代码块不会进入。在这里就可以靠自定义BeanPostProcessor，完成自定义方式的属性的注入行为。
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false; // 标记不再需要后续的属性注入行为。
                    break;
                }
            }
        }
    }

    // 检测还是否需要继续属性注入操作
    if (!continueWithPropertyPopulation) { // 不需要
        return;
    }
    
    // bean元数据中定义的属性，和标签有关，表示所有的property指定的属性。
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    // ------------------------------------- 处理标签的autowired属性 --------------------------------
    // 会根据指定的方式(byName/byType)从内部IOC容器中获取到属性的实例对象，然后再设置给BeanDefinition

    // getResolvedAutowireMode() 方法的执行结果和标签的autowired属性有关
    // 如果值为byName则代表根据名称注入；如果值为byTime则代表根据类型注入，只要满足一个条件则进入 if 代码块。
    // 默认情况下为0，也就是说不会进入 if 代码块，这个属性好像在老版本中有使用过。
    if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // Add property values based on autowire by name if applicable.
        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // Add property values based on autowire by type if applicable.
        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }

    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    // getDependencyCheck()的返回值和标签的dependency-check属性有关，高版本spring已经不允许xml配置它了。
    // 默认情况为0，也就是DEPENDENCY_CHECK_NONE，所以这里会得到false。
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); 

    // ------------------------------------- 给使用注解方式的属性注入值 ----------------------------------
    // 调用InstantiationAwareBeanPostProcessor#postProcessProperties时完成注入操作

    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) { // 有InstantiationAwareBeanPostProcessor类型的Bean后处理器
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 对使用注解的属性进行值注入(这些值不会放到PropertyValues里)，值得关注的实现类有
                // AutowiredAnnotationBeanPostProcessor -> 给@Autowired注解的属性注入值
                // CommonAnnotationBeanPostProcessor -> 给@Resource注解的属性注入值
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) { // 内部的逻辑默认情况下不会被执行。(大概这块的逻辑已经被放弃了)
                    // 在bean元数据没有配置属性时，对bean内必须注入的属性进行处理。(例如@Required注解)
                    if (filteredPds == null) {
                        /* 过滤出需要依赖检查的属性。
                        * 1.通过反射获取BeanClass的属性
                        * 2.然后去除掉 忽略的依赖关系类型 和 在忽略的依赖关系接口上存在Setter方法的属性
                        *   -前者见AbstractAutowireCapableBeanFactory中的ignoredDependencyTypes属性，
                        *   默认情况下，它是没有值的，可以手动向内部IOC容器中添加，
                        *   手动添加方式：重写refresh()中调用的postProcessBeanFactory方法，然后手动添加。
                        *  
                        *   -后者见AbstractAutowireCapableBeanFactory中的ignoredDependencyInterfaces属性，
                        *   默认情况下，它有被设置值，见refresh()中调用的prepareBeanFactory方法。
                        * 3.得到最后的结果。(如果允许缓存就缓存一下)
                        */
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }
                    // 比较特殊的是 RequiredAnnotationBeanPostProcessor，这个类中有对@Required注解的处理
                    // 但是现在这个类和这个注解都已经弃用，默认情况下也不会被处理。
                    // 如果想要恢复使用，可以看下面给出示例。
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }
                }
                pvs = pvsToUse;
            }
        }
    }
    
    // ------------------------------ 处理标签配置的dependency-check相关内容 ----------------------
    // 根据dependency-check指定的模式进行对参数的验证
    
    if (needsDepCheck) { // 这个代码块默认情况下也不会执行
        if (filteredPds == null) {
            // 这个方法在上面有说过，过滤出需要依赖检查的属性。
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        // 按照标签配置的dependency-check指定的模式进行验证
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }

    // ---------------------------------- 对PropertyValues中的属性进行注入 -------------------------------
    // 这种方式不会对使用了@Autowired、@Resource这类注解的属性进行值的注入，它们的值注入在上面就已经完成了。
    // 也就是在 ‘给使用注解方式的属性注入值’ 这一块代码内完成的。
    
    if (pvs != null) {
        // 把PropertyValues中的内容填充到bean的实例对象内。
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

1.3.2.1.3.1. 恢复@Required注解的做法

// xml配置
 // 不提供任何参数

// bean
class HelloServiceImpl implements HelloService {
    // ... 其他属性
    private OutputService outputService;
    
    //... 其他逻辑
    @Required  // 必须的的参数
    public void setOutputService(OutputService outputService) {
        this.outputService = outputService;
    }
}

// 自定义的容器实现
class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {

    public MyClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
        super(configLocations, refresh, parent);
    }

    @Override
    protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // 恢复@Required注解的作用
        beanFactory.addBeanPostProcessor(new RequiredAnnotationBeanPostProcessor());
        super.registerBeanPostProcessors(beanFactory);
    }
}

// 测试
@Test
public void test() {
    ApplicationContext ac = new MyClassPathXmlApplicationContext(new String[]{"spring-config.xml"}, true, null);

    HelloService helloService = ac.getBean(HelloService.class);
    helloService.sayHello();
}

1.3.2.1.3.2. 关于property属性对引用的赋值

这里不想展示完全的逻辑，很多都不用关心，主要展示一下对于RuntimeBeanReference类型参数的解析以及向对象内填充值，并且简单说明为什么默认情况下两个bean中以参数形式出现的循环依赖不会出现问题。

AbstractAutowireCapableBeanFactory#populateBean(String, RootBeanDefinition,BeanWrapper)
    AbstractAutowireCapableBeanFactory#applyPropertyValues(String, BeanDefinition, BeanWrapper, PropertyValues)
        BeanDefinitionValueResolver#resolveValueIfNecessary(Object, Object)
            BeanDefinitionValueResolver#resolveReference(Object, RuntimeBeanReference)
        AbstractPropertyAccessor#setPropertyValues(PropertyValues)
            AbstractPropertyAccessor#setPropertyValues(PropertyValues, boolean, boolean)
                AbstractNestablePropertyAccessor#setPropertyValue(PropertyValue)

// BeanDefinitionValueResolver
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
    // 对应
    if (value instanceof RuntimeBeanReference) {
        RuntimeBeanReference ref = (RuntimeBeanReference) value;
        return resolveReference(argName, ref);
    }
    // .... 其他类型的属性处理
}


// BeanDefinitionValueResolver
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
    try {
        Object bean;
        String refName = ref.getBeanName();
        refName = String.valueOf(doEvaluate(refName));
        if (ref.isToParent()) {
            if (this.beanFactory.getParentBeanFactory() == null) {
                throw new BeanCreationException(
                        this.beanDefinition.getResourceDescription(), this.beanName,
                        "Can't resolve reference to bean '" + refName +
                        "' in parent factory: no parent factory available");
            }
            // 尝试从父容器中获取
            bean = this.beanFactory.getParentBeanFactory().getBean(refName);
        }

        else {
            // 尝试从当前容器中获取，主要就是关注这里，属性的值的获取方法。
            bean = this.beanFactory.getBean(refName);
            // 注册双向依赖关系。
            this.beanFactory.registerDependentBean(refName, this.beanName);
        }
        if (bean instanceof NullBean) {
            bean = null;
        }
        return bean;
    }
    catch (BeansException ex) {
        throw new BeanCreationException(
                this.beanDefinition.getResourceDescription(), this.beanName,
                "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
    }
}


// AbstractAutowireCapableBeanFactory
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    // ... 省略逻辑

    // Set our (possibly massaged) deep copy.
    try {
        // 通过反射，把值填充进去
        bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    }
    catch (BeansException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    }
}

关于属性的循环依赖最核心的就是在这段代码里对getBean(refName)方法的调用。
关于属性的循环应用在之后会有补充，见 3.2 小节。

1.3.2.1.4 initializeBean(String, Object, RootBeanDefinition)

这个方法做了以下几件事
1.调用实现了Aware这一类接口的bean内重写的方法。
2.执行BeanPostProcessor#postProcessBeforeInitialization方法。
3.执行InitializingBean和init-method相关的内容。
4.执行BeanPostProcessor#postProcessAfterInitialization方法

// AbstractAutowireCapableBeanFactory
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    // -------------------------------- 执行实现了Aware接口的bean内的相关方法 ------------------------------
    // Aware这东西太简单了不细说了，就上层向下层的主动数据传递，自己可以实现一个BeanFactoryAware测试一下。

    if (System.getSecurityManager() != null) {
        // 这个看上篇文章，里面有说 AccessController
        AccessController.doPrivileged((PrivilegedAction