spring解决互相依赖问题

以 AbstractApplicationContext 的 refresh() 方法出发，进入 finishBeanFactoryInitialization() 方法再进入 preInstantiateSingletons() 方法再进入 getBean() 方法再进入 doGetBean() 方法。

/**
 * 根据指定的名称、类型、参数等获取Bean实例。
 *
 * @param name           Bean的名称
 * @param requiredType   被请求Bean的类型
 * @param args           构造函数参数
 * @param typeCheckOnly  是否只进行类型检查
 * @return 被请求的Bean实例
 * @throws BeansException 如果无法获取Bean实例
 */
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    String beanName = this.transformedBeanName(name);  // 转换Bean名称（别名或者FactoryBean名称）
    Object sharedInstance = this.getSingleton(beanName);  // 获取单例Bean实例
    Object beanInstance;
​
    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 + "'");
            }
        }
        beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition) null);  // 获取缓存的单例Bean实例
    } else {
        if (this.isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        BeanFactory parentBeanFactory = this.getParentBeanFactory();
        if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {  // 在父级BeanFactory中查找Bean定义
            String nameToLookup = this.originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);  // 在父级BeanFactory中获取Bean实例
            }
            if (args != null) {
                return parentBeanFactory.getBean(nameToLookup, args);  // 在父级BeanFactory中根据名称和参数获取Bean实例
            }
            if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);  // 在父级BeanFactory中根据名称和类型获取Bean实例
            }
            return parentBeanFactory.getBean(nameToLookup);  // 在父级BeanFactory中根据名称获取Bean实例
        }
​
        if (!typeCheckOnly) {
            this.markBeanAsCreated(beanName);
        }
​
        StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate").tag("beanName", name);
        try {
            if (requiredType != null) {
                beanCreation.tag("beanType", requiredType::toString);
            }
            RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);  // 获取合并的Bean定义
            this.checkMergedBeanDefinition(mbd, beanName, args);  // 检查合并的Bean定义
​
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {  // 处理依赖关系
                for (String dep : dependsOn) {
                    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);  // 获取依赖的Bean实例
                    } catch (NoSuchBeanDefinitionException var31) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var31);
                    }
                }
            }
​
            if (mbd.isSingleton()) {  // 单例Bean
                sharedInstance = this.getSingleton(beanName, () -> {
                    try {
                        return this.createBean(beanName, mbd, args);  // 创建单例Bean实例
                    } catch (BeansException var5) {
                        this.destroySingleton(beanName);
                        throw var5;
                    }
                });
                beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  // 获取单例Bean实例
            } else if (mbd.isPrototype()) {  // 原型Bean
                Object prototypeInstance;
                try {
                    this.beforePrototypeCreation(beanName);
                    prototypeInstance = this.createBean(beanName, mbd, args);  // 创建原型Bean实例
                } finally {
                    this.afterPrototypeCreation(beanName);
                }
                beanInstance = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);  // 获取原型Bean实例
            } else {  // 其他作用域的Bean
                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);  // 创建作用域Bean实例
                        } finally {
                            this.afterPrototypeCreation(beanName);
                        }
                        return var4;
                    });
                    beanInstance = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);  // 获取作用域Bean实例
                } catch (IllegalStateException var30) {
                    throw new ScopeNotActiveException(beanName, scopeName, var30);
                }
            }
        } catch (BeansException var32) {
            beanCreation.tag("exception", var32.getClass().toString());
            beanCreation.tag("message", String.valueOf(var32.getMessage()));
            this.cleanupAfterBeanCreationFailure(beanName);
            throw var32;
        } finally {
            beanCreation.end();
        }
    }
    return this.adaptBeanInstance(name, beanInstance, requiredType);  // 转换Bean实例类型并返回
}

调用createBean接口，实现类createBean（）

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
  
    // 检查是否是单例，并从factoryBeanInstanceCache中移除实例包装器
    if (mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }
​
    // 如果实例包装器为null，则创建一个实例
    if (instanceWrapper == null) {
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }
​
    // 获取bean的实例和类型，将类型设置为已解析的目标类型
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }
​
    // 在同步块中应用合并后的Bean定义的后置处理器
    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");
        }
        // 将提前暴露的单例存储到getSingletonMutex()中
        this.addSingletonFactory(beanName, () -> {
            return this.getEarlyBeanReference(beanName, mbd, bean);
        });
    }
​
    Object exposedObject = bean;
​
    try {
        // 填充bean的属性值
        this.populateBean(beanName, mbd, instanceWrapper);
        // 初始化bean
        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) {
            // 如果exposedObject和bean相同，则将exposedObject设置为提前暴露的单例
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                // 检查是否存在依赖该bean的其他bean，如果存在，则抛出异常
                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 {
        // 注册用于销毁的bean（DisposableBean）
        this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
        return exposedObject;
    } catch (BeanDefinitionValidationException var16) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
    }
}

创建bean时会判断是否需要其他对象，如果是，丢入addgetEarlyBeanReference（也就是二级缓存），暴露引用，这也是为aop做准备的操作之一，并将其丢入addSingletonFactory（也就是三级缓存）

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    SmartInstantiationAwareBeanPostProcessor bp;
​
    // 检查是否存在实例化感知的Bean后置处理器，并对每个后置处理器应用提前引用逻辑
    if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
        for (Iterator var5 = this.getBeanPostProcessorCache().smartInstantiationAware.iterator(); var5.hasNext(); exposedObject = bp.getEarlyBeanReference(exposedObject, beanName)) {
            bp = (SmartInstantiationAwareBeanPostProcessor) var5.next();
        }
    }
​
    return exposedObject;
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
​
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            // 将单例工厂对象加入singletonFactories中，用于创建bean实例
            this.singletonFactories.put(beanName, singletonFactory);
            // 从earlySingletonObjects中移除beanName，提前暴露的bean实例将不再被访问
            this.earlySingletonObjects.remove(beanName);
            // 将beanName加入registeredSingletons中，表示该bean已经注册为单例
            this.registeredSingletons.add(beanName);
        }
    }
}