Spring循环依赖底层实现原理深度剖析

@Component
public class A {
    private B b;
    public A(B b) {
        this.b = b;
    }
}
@Component
public class B {
    private A a;
    public B(A a) {
        this.a = a;
    }
}
复制代码

// AbstractApplicationContext.java
public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext, DisposableBean {
    public void refresh() throws BeansException, IllegalStateException {
        // 创建 BeanFactory，并通过 BeanFactoryPostProcessor 对 BeanFactory 进行处理
        refreshBeanFactory();
        // 通过 BeanDefinitionReader 将 Bean 的定义信息读取到 BeanFactory 中，并注册到 BeanDefinitionMap 中
        // 然后，通过 DefaultListableBeanFactory 中的 preInstantiateSingletons() 方法创建 Bean 实例
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        // ...
        // 创建 Bean 的过程是由 getBean() 方法触发的
        // 在 getBean() 方法中，会先检查 singletonObjects 缓存中是否存在该 Bean 的实例
        // 如果存在，直接返回该实例；否则继续创建该 Bean 的实例
        beanFactory.getBean(beanName);
        // ...
    }
}
// DefaultListableBeanFactory.java
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry {
    public Object getBean(String name) throws BeansException {
        // ...
        // 先检查 singletonObjects 缓存中是否存在该 Bean 的实例
        // 如果存在，直接返回该实例；否则继续创建该 Bean 的实例
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null) {
            // ...
            return null;
        }
        // ...
        // 创建该 Bean 的半成品对象，并将其存储在 earlySingletonObjects 缓存中
        // 然后，继续创建该 Bean 所依赖的其他 Bean
        // 当所有的 Bean 都被创建完成后，会调用 BeanPostProcessor 的 postProcessAfterInitialization() 方法
        // 将所有标记为“当前正在创建的 Bean”的半成品对象转化为完整的 Bean 对象，并存储在 singletonObjects 缓存中
        createBean(beanName, mbd, args);
        // ...
    }
    protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
        // ...
        // 创建该 Bean 的半成品对象，并将其存储在 earlySingletonObjects 缓存中
        Object beanInstance = doCreateBean(beanName, mbd, args);
        // ...
        // 调用 BeanPostProcessor 的 postProcessAfterInitialization() 方法
        // 将所有标记为“当前正在创建的 Bean”的半成品对象转化为完整的 Bean 对象，并存储在 singletonObjects 缓存中
        // 在 postProcessAfterInitialization() 方法中，会检查该 Bean 是否存在循环依赖的问题
        Object exposedObject = bean;
        if (mbd.isSingleton()) {
            // ...
            // 将该 Bean 存储在 singletonObjects 缓存中
            addSingleton(beanName, singletonObject);
            // ...
        }
        // ...
    }
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
        // ...
        // 如果创建依赖的 Bean 时发现循环依赖的问题
        // 会先将该 Bean 的工厂方法存储在 singletonFactories 缓存中，以便在创建其他 Bean 时使用
        if (mbd.isPrototype()) {
            // ...
        } else {
            // ...
            // 如果存在循环依赖的问题
            if (isSingletonCurrentlyInCreation(beanName)) {
                // 先从 singletonFactories 缓存中获取该 Bean 的工厂方法
                ObjectFactory<?> singletonFactory = singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // ...
                    // 将该 Bean 存储在 singletonObjects 缓存中
                    addSingleton(beanName, singletonObject);
                    // ...
                }
            }
            // ...
        }
        // ...
    }
    protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        // ...
        // 在对属性进行赋值的过程中，如果发现循环依赖的问题
        // 会先将该 Bean 的工厂方法存储在 singletonFactories 缓存中
        if (hasInstantiationAwareBeanPostProcessors()) {
            for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
                // 如果该 Bean 存在循环依赖的问题
                // 则先将该 Bean 的工厂方法存储在 singletonFactories 缓存中
                // 然后，将该 Bean 标记为“当前正在创建的 Bean”
                // 最后，调用 BeanPostProcessor 的 postProcessBeforeInstantiation() 方法
                // 创建该 Bean 的工厂方法，并将其存储在 singletonFactories 缓存中
                // 在 postProcessBeforeInstantiation() 方法中，会返回该 Bean 的工厂方法
                // 以便在创建其他 Bean 时使用
                Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    // ...
                    // 将该 Bean 的工厂方法存储在 singletonFactories 缓存中
                    singletonFactories.put(beanName, () -> result);
                    // ...
                    return result;
                }
            }
        }
        // ...
    }
    protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        // ...
        // 在对属性进行赋值的过程中，如果发现循环依赖的问题
        // 会先将该 Bean 的工厂方法存储在 singletonFactories 缓存中
        if (hasInstantiationAwareBeanPostProcessors()) {
            for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
                // ...
                // 如果该 Bean 存在循环依赖的问题
                // 则先将该 Bean 的工厂方法存储在 singletonFactories 缓存中
                // 然后，将该 Bean 标记为“当前正在创建的 Bean”
                // 最后，调用 BeanPostProcessor 的 postProcessPropertyValues() 方法
                // 对该 Bean 的属性进行赋值，并返回新的 PropertyValues 对象
                // 在 postProcessPropertyValues() 方法中，会检查该 Bean 是否存在循环依赖的问题
                PropertyValues pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bean, beanName);
                if (pvsToUse == null) {
                    // ...
                } else {
                    // ...
                    pvs = pvsToUse;
                }
            }
        }
        // ...
    }
}
复制代码