- 创建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
缓存中。
- 创建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()
方法提前暴露一个原始的代理对象。
- 注入依赖:
在创建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中。
- 初始化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实例都能够得到正确的依赖对象,避免了循环依赖所带来的问题。