建议收藏！利用Spring解决循环依赖，深入源码给你讲明白！

前置知识

• 只有单例模式下的bean会通过三级缓存提前暴露来解决循环依赖的问题。而非单例的bean每次获取都会重新创建，并不会放入三级缓存，所以多实例的bean循环依赖问题不能解决。
• 首先需要明白处于各个阶段的bean被放在哪里。在DefaultSingletonBeanRegistry类中

    /** 一级缓存，存放经历完整生命周期的bean*/
    private final Map singletonObjects = new ConcurrentHashMap(256);
 
    /** 三级缓存，存放FactoryBean */
    private final Map> singletonFactories = new HashMap>(16);
 
    /** 二级缓存，存放刚刚创建出来还未进行属性赋值的bean */
    private final Map earlySingletonObjects = new HashMap(16);

测试代码

public class ServiceAA {
 
    public ServiceAA() {
        System.out.println("AA已经创建");
    }
 
    private ServiceBB serviceBB;
 
    public ServiceBB getServiceBB() {
        return serviceBB;
    }
 
    public void setServiceBB(ServiceBB serviceBB) {
        this.serviceBB = serviceBB;
    }
}

public class ServiceBB {
    public ServiceBB() {
        System.out.println("BB已经创建");
    }
    private ServiceAA serviceAA;
 
    public ServiceAA getServiceAA() {
        return serviceAA;
    }
 
    public void setServiceAA(ServiceAA serviceAA) {
        this.serviceAA = serviceAA;
    }
}

流程

• 在上述代码中，ServiceAA 依赖于ServiceBB，同时ServiceBB也依赖于ServiceAA ，各个bean相互依赖，最终形成了闭环，那么spring是如何解决此问题的呢?
• 可以简单理解为spring创建bean分为两个步骤，第一步是创建原始bean，第二步就是对属性进行赋值和初始化等操作。
• 每次创建bean之前都会去缓存中查找是否有当前bean，因为是单例，只能有一个
• 当创建bean serviceAA后，会将其加入三级缓存中，然后需要填充bean的属性了
• 这时候发现需要依赖于bean serviceBB，接下来又去创建serviceBB。重复1-3的流程
• 这时候发现需要依赖于bean serviceAA，发现三级缓存中存在bean serviceAA，所以不需要重复创建。把bean serviceAA注入bean serviceBB
• 这个时候bean serviceBB创建好了，递归继续去为bean serviceAA进行属性赋值。闭环完成

源码

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            try {
                
 
                //初始化剩下的单实例bean
                finishBeanFactoryInitialization(beanFactory);
 
                
            }
 
            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }
 
                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();
 
                // Reset 'active' flag.
                cancelRefresh(ex);
 
                // Propagate exception to caller.
                throw ex;
            }
 
            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        //实例化单实例bean
        beanFactory.preInstantiateSingletons();
    }

@Override
    public void preInstantiateSingletons() throws BeansException {
        
        getBean(beanName);
            
    }

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

protected  T doGetBean(
            final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
 
        final String beanName = transformedBeanName(name);
        Object bean;
 
        //首先查询缓存中是否存在bean，当前为null
        Object sharedInstance = getSingleton(beanName);
        final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory