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

前置知识

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

    /** 一级缓存，存放经历完整生命周期的bean*/
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
 
    /** 三级缓存，存放FactoryBean */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
 
    /** 二级缓存，存放刚刚创建出来还未进行属性赋值的bean */
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(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;
    }
}

    <bean id="serviceAA" class="org.song.circularDepend.ServiceAA" >
        <property name="serviceBB" ref="serviceBB"/>
    </bean>
 
    <bean id="serviceBB" class="org.song.circularDepend.ServiceBB">
        <property name="serviceAA" ref="serviceAA"/>
    </bean>

流程

• 在上述代码中，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> T doGetBean(
            final String name, final Class<T> 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<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                //创建bean
                                return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {
                                destroySingleton(beanName);
                                throw ex;
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //一级缓存中是否存在当前bean(serviceAA)，此时为null
        //isSingletonCurrentlyInCreation(beanName)，当前bean是否被标记为
        //正在创建，返回false，所以后续不执行，直接返回null
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    beforeSingletonCreation(beanName);
                
    singletonObject = singletonFactory.getObject();
                
    addSingleton(beanName, singletonObject);
                
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

protected void beforeSingletonCreation(String beanName) {
        //将当前正在创建的bean serviceAA 标记为正在创建中，添加到集合singletonsCurrentlyInCreation中
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        //开始真正的创建bean service AA
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        
        return beanInstance;
    }

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
            throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
            //用反射创建初始bean serviceAA，源码部分略过
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        //当前为true
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            //如果一级缓存中没有当前bean，就将当前bean放入三级缓存
            addSingletonFactory(beanName, new ObjectFactory<Object>() {
                @Override
                public Object getObject() throws BeansException {
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }
        // 初始化bean
        Object exposedObject = bean;
        //为当前bean serviceAA赋值
            populateBean(beanName, mbd, instanceWrapper);
        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
            }
                
        return exposedObject;
    }

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        //将当前bean serviceAA放入三级缓存，key为beanname value为创建该bean的工厂
        synchronized (this.singletonObjects) {
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        //获取当前bean sercieAA所有的属性
        PropertyValues pvs = mbd.getPropertyValues();
        //......对属性的解析等操作略过
 
        //开始注入属性
        applyPropertyValues(beanName, mbd, bw, pvs);
    }

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    
   //封装所有属性的集合，略过
    List<PropertyValue> original;
 
    for (PropertyValue pv : original) {
        String propertyName = pv.getName(); 
        Object originalValue = pv.getValue();
        //解析引用类型的属性
        Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
    }
    //应用属性过程略过
}

public Object resolveValueIfNecessary(Object argName, Object value) {
        //判断是否是运行时bean引用
        if (value instanceof RuntimeBeanReference) {
            RuntimeBeanReference ref = (RuntimeBeanReference) value;
            //解析此引用 service BB
            return resolveReference(argName, ref);
        }

private Object resolveReference(Object argName, RuntimeBeanReference ref) {
 
    String refName = ref.getBeanName();
    refName = String.valueOf(doEvaluate(refName));
    //开始递归调用getbean方法，当前bean为serviceBB
    Object bean = this.beanFactory.getBean(refName);
 
}

• 此时serviceBB开始递归调用getBean()方法，开始重复上述流程，关注流程第五步。此时bean serviceBB实例化完成，并且开始为属性赋值，发现有一个属性为serviceAA。于是尝试获取serviceAA。
• 进入this.beanFactory.getBean()方法。进入doGetBean()方法。后进入getSingleton(String beanName, boolean allowEarlyReference)

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //一级缓存中是否存在当前bean(serviceAA)，此时为null
        //isSingletonCurrentlyInCreation(beanName)，当前bean是否被标记为
        //正在创建，当前为true，进入判断
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                //判断二级缓存中是否有bean serviceAA，当前返回null
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                //通过beanname获得了之前在三级缓存中添加的创建serviceAA的工厂方法
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        //此时singletonObject指向之前实例化完成的serviceAA对象
                        singletonObject = singletonFactory.getObject();
                        //将serviceAA添加到二级缓存中，并从三级缓存中删除
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

• 此时serviceBB的属性赋值完毕，serviceBB的populateBean方法执行结束。其属性service AA指向还未执行完成populateBean()方法的bean serviceAA，等待后续的递归返回。

protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            //将serviceBB放入一级缓存
            this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
            //从三级缓存，二级缓存中删除
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

• 此时serviceBB创建完毕。递归返回继续还未属性赋值完成的bean serviceAA。调用 addSingleton()方法，同上将bean serviceAA放入一级缓存

总结

欢迎关注公众号：前程有光，领取一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java核心知识点总结！