【Spring】循环依赖问题处理分析

1. 创建Bean对象：
   在Spring容器启动时，会解析配置文件或注解，将Bean定义信息转换为BeanDefinition对象，并注册到BeanFactory中。当应用程序需要获取一个Bean对象时，Spring会调用DefaultSingletonBeanRegistry中的getSingleton()方法来获取Bean实例。在此方法中，首先会尝试从singletonObjects缓存中获取Bean实例。如果缓存中不存在该Bean实例，则执行后续步骤。

源码分析：
在DefaultSingletonBeanRegistry中的getSingleton()方法中，首先尝试从缓存中获取Bean实例：

public Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从缓存中获取Bean实例
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果缓存中不存在Bean实例，则需要创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 从earlySingletonObjects或singletonFactories中获取Bean实例
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
                // 通过ObjectFactory创建Bean实例
                singletonObject = singletonFactory.getObject();
                // 将创建的Bean实例存储到earlySingletonObjects中
                this.earlySingletonObjects.put(beanName, singletonObject);
                // 从singletonFactories中移除相应的ObjectFactory
                this.singletonFactories.remove(beanName);
            }
        }
    }
    return singletonObject;
}

可以看到，如果缓存中不存在该Bean实例，并且检测到当前正在创建该Bean实例的过程中，Spring会尝试从earlySingletonObjects（存放提前暴露的原始代理对象）或singletonFactories（存放ObjectFactory）中获取Bean实例。如果可以获取到Bean实例，就会将其存入earlySingletonObjects缓存中。

2. 创建Bean实例：
   在创建Bean实例时，Spring会调用AbstractAutowireCapableBeanFactory中的doCreateBean()方法。在该方法中，会执行Bean的实例化、依赖注入和初始化等操作。

源码分析：
在doCreateBean()方法中，Spring首先会创建Bean实例，然后进行依赖注入和初始化。如果检测到循环依赖，会提前暴露一个还不完整的Bean实例，并存储在earlySingletonObjects缓存中，以供其他依赖该Bean的对象进行依赖注入。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 1. 创建Bean实例
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);

    // 检测循环依赖，提前暴露一个原始的代理对象
    Object exposedObject = getSingleton(beanName, false);
    if (exposedObject != null) {
        return exposedObject;
    }

    // 2. 初始化BeanWrapper
    populateBean(beanName, mbd, instanceWrapper);

    // 3. 初始化Bean
    Object bean = initializeBean(beanName, instanceWrapper.getWrappedInstance(), mbd);

    // ...

    return bean;
}

可以看到，如果检测到循环依赖，会通过getSingleton()方法提前暴露一个原始的代理对象。

3. 注入依赖：
   在创建Bean实例后，Spring会调用AbstractAutowireCapableBeanFactory中的populateBean()方法进行依赖注入。在这个过程中，Spring会检查Bean中的依赖关系，并通过反射将依赖注入到Bean中。

源码分析：
在populateBean()方法中，Spring会通过调用AutowireUtils的autowireByName()方法来自动注入依赖。

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    // ...

    // 3. 注入依赖
    AutowireUtils.autowireByName(beanName, bw, this);

    // ...
}

autowireByName()方法负责处理自动注入，它会遍历Bean中的属性，根据属性的名称和容器中的Bean名称进行匹配，并通过反射机制将依赖注入到Bean中。

4. 初始化Bean：
   在依赖注入完成后，Spring会调用AbstractAutowireCapableBeanFactory中的initializeBean()方法对Bean进行初始化。这个方法会触发Bean的初始化回调方法，并最终返回完全初始化的Bean实例。

源码分析：
在initializeBean()方法中，Spring会按照一定的顺序调用Bean的初始化回调方法，并在调用前后执行BeanPostProcessor的相应方法。

protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
    // ...

    // 4. 初始化Bean
    invokeAwareMethods(beanName, bean);
    applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    invokeInitMethods(beanName, bean, mbd);
    applyBeanPostProcessorsAfterInitialization(bean, beanName);

    // ...

    return wrappedBean;
}

在调用applyBeanPostProcessorsBeforeInitialization()方法之前，会首先调用invokeAwareMethods()方法，完成例如BeanNameAware等接口的处理。然后，先执行BeanPostProcessor的postProcessBeforeInitialization()方法，再执行Bean的初始化方法（例如带有@PostConstruct注解的方法），最后再执行BeanPostProcessor的postProcessAfterInitialization()方法。

通过以上四个步骤，Spring能够解决循环依赖的问题。三级缓存的使用确保了在依赖注入过程中，每个Bean实例都能够得到正确的依赖对象，避免了循环依赖所带来的问题。