文章内容来源:拉勾教育Java高薪训练营8期
知识的获取,来源于输出!这是我在拉勾教育Java高薪训练营8期学习后的一个总结与分享,选取spring的循环依赖处理这一知识点做总结,因为我觉得它涵盖spring创建bean的流程,既梳理了循环依赖,也能对bean的创建流程进行一个回顾。
1.谈谈在拉勾教育训练营的学习感受
1.1 报名学习初衷
技术遇到瓶颈,目前的工作技术对技术提升难度大,给自己一个提升于与学习的机会
1.2 学习方式
直播+录播,有班主任负责学习事务,导师负责指导学习
1.3 学习感受
老师讲课能够由浅入深,有深度也有广度,跟着老师学下来。对相对复杂的知识也能掌握(如框架源码),最终能够手写实现核心逻辑
1.4 老师
班主任认真负责,经常我们监督学习和服务同学们,导师也是有问必答,帮助同学学习、解惑
2.spring循环依赖处理机制
2.1 什么是循环依赖
循环依赖就是指对象之间的相互引用,通俗来讲,就是两个或者两个以上的对象互相持有对方的引用,用代码表示就是:
public class LagouBean {
private ItBean itBean;
...
}
public class ItBean {
private LagouBean lagouBean;
...
}
在开发中使用spring时,对象一般都是交给spring来创建和管理,就像下面这样:
<bean id="lagouBean" class="com.lagou.edu.LagouBean">
<property name="ItBean" ref="itBean"/>
</bean>
<bean id="itBean" class="com.lagou.edu.ItBean">
<property name="LagouBean" ref="lagouBean"/>
</bean>
如上两个类,在创建LagouBean的时候发现它依赖了ItBean,于是要先去创建ItBean,这时候发现ItBean又依赖了LagouBean,此时又要去创建LagouBean,好像陷入了一种死循环...但在使用spring的时候,发现它并不会进入死循环导致程序异常,反而能够正常创建对象供程序调用,那么它是如何处理的?
2.2 spring如何处理循环依赖
经过翻阅spring创建bean部分的源码得知,spring处理循环依赖的核心思想是基于java的引用传递,获得对象的引用时,属性是可以延后设置的。利用这一特性,spring在创建对象时,先不设置其属性,实例化后提前暴露到容器中,提供给其他对象引用。
所以创建LagouBean时,实例化后立即暴露到容器中,然后填充属性,此时发现它依赖了ItBean,则先去创建ItBean,ItBean实例化后也会提前暴露,后填充属性,此时发现ItBean依赖了LagouBean,因为LagouBean提前已经暴露出来了,就可以从容器中取到完成ItBean的创建,ItBean创建完成,填充到LagouBean完成创建。
spring为了完成这一过程,采用了三级缓存机制,对象的提前暴露就是将创建的对象事先放入缓存之中。在org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
类中,定义了这三个缓存:
Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
Map<String, Object> earlySingletonObjects = new HashMap<>(16);
- singletonObjects:一级缓存,存放创建完成的单例对象,是完完整整的对象,经历了实例化、属性填充、后置处理等一系列步骤后创建的对象
- singletonFactories:三级缓存,存放的是将实例化后的bean包装成的ObjectFactory
- earlySingletonObjects:二级缓存,存放的是提前暴露的bean,未填充属性,但是已经可以被其他对象引用了,这里bean的获取主要是调用三级缓存中存放的ObjectFactory的getObject()方法创建
综上,spring处理循环依赖的思想主要基于java引用传递,采用三级缓存机制,将对象仅实例化后提前暴露存放至缓存中,使得依赖它的对象可以获取其引用完成创建,然后进行属性填充、初始化等操作,最后完成对象的创建。附上一张学习时的图方便理解:
3.spring循环依赖处理源码解析
经过上一部分的大致分析,这部分将对源码进行一个解读,深入了解一下spring处理循环依赖的整个流程,写了如下一段测试代码:
public void testIoC() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
System.out.println(lagouBean);
}
3.1 容器初始化源码解析
如上面的测试代码,使用了ClassPathXmlApplicationContext容器作为测试对象,通过代码调试跟踪,最开始调用了ClassPathXmlApplicationContext的构造方法,方法内部调用了org.springframework.context.support.AbstractApplicationContext#refresh()
来完成容器的创建
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)throws BeansException {
//初始化父类
super(parent);
//设置配置信息
setConfigLocations(configLocations);
//完成容器的初始化
if (refresh) {
refresh();
}
}
在refresh()
方法的核心就是完成BeanFactory的创建,加载beandefition,然后进行bean的创建
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//创建beanfactory,加载beandefition注册到beandefiitoRegisty
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//初始化bean,填充属性,初始化方法调用..
finishBeanFactoryInitialization(beanFactory);
}
}
在finishBeanFactoryInitialization()
方法中,调用了org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons()
方法
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//实例化所有非延迟加载的bean
beanFactory.preInstantiateSingletons();
}
preInstantiateSingletons()
中调用了org.springframework.beans.factory.support.AbstractBeanFactory#getBean(String name)
方法,Bean的创建流程就是从这里开始的,getBean()自调用了doGetBean()
方法,开始真正创建bean了
3.2 获取对象doGetBean方法解析
protected <T> T doGetBean() throws BeansException {
Object bean;
//标记:1
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
try {
if (mbd.isSingleton()) {
//标记:2
sharedInstance = getSingleton(beanName, () -> {
// 创建单例Bean的主要方法,返回的bean是完整的
return createBean(beanName, mbd, args);
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
}
}
return (T) bean;
}
doGetBean()
方法的主要逻辑为:
- 根据beanName尝试从缓存中取对象LagouBean
- 取到就返回对应的实例
- 未取到,则进行bean的创建
其中重点标记处:
- 标记1: 调用
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(String beanName)
方法,尝试从缓存中取对象 - 标记2: 判断如果要创建的对象是单例对象,调用getSingleton的重载方法
getSingleton(String beanName, ObjectFactory<?> singletonFactory)
进行对象的创建,它的内部,有两段重点代码:
//标记:2-1
singletonObject = singletonFactory.getObject();
//标记:2-2
addSingleton(beanName, singletonObject);
- 标记2-1: 从上面的标记2中可以看出singletonFactory.getObject()调用的是方法
createBean(beanName, mbd, args)
返回最终创建的对象 - 标记2-2: 新创建的bean添加到【一级缓存】中,以后getBean的时候就可以直接获取了,源码如下:
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 将新创建的bean添加到一级缓存中
this.singletonObjects.put(beanName, singletonObject);
// 从其他缓存中移除相关的bean
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
}
}
3.3 创建对象doCreateBean源码解析
上面说到创建对象的方法在createBean(beanName, mbd, args)
,内部调用了org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
方法,其内部逻辑分为5大步,这里将其拆开来剖析:
3.3.1 实例化对象
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
// 调用无参构造实例化Bean
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 实例化后的Bean对象,这里获取到的是一个原始对象,即没有进行属性填充的对象
final Object bean = instanceWrapper.getWrappedInstance();
}
这部分的主要逻辑就是调用无参构造实例化,拿到一个原始的Bean
3.3.2 将原始对象放入三级缓存
protected Object doCreateBean() {
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
}
- earlySingletonExposure:是否”提前暴露“原始对象的引用,如果需要提前暴露单例bean,则将该bean工厂放入【三级缓存】中
- 方法
addSingletonFactory
则是将原始对象包装成ObjectFactory放入三级缓存,源码如下:
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
//向三级缓存里添加ObjectFactory
this.singletonFactories.put(beanName, singletonFactory);
}
}
}
- 匿名内部方法
getEarlyBeanReference
是SmartInstantiationAwareBeanPostProcessor接口的的一个默认方法,实现这个方法的只有org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
这个类,实现逻辑为:
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean);
return wrapIfNecessary(bean, beanName, cacheKey);
}
它内部自调用了方法 wrapIfNecessary
:
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// Create proxy if we have advice.
if (specificInterceptors != DO_NOT_PROXY) {
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
return proxy;
}
return bean;
}
这个方法关键点在 createProxy
,顾名思义它是为bean创建代理对象的,所以它的整个逻辑就是,如果当前bean需要创建代理对象,那么它返回的就是代理对象,否则返回原始对象。
那么getEarlyBeanReference
在什么时候调用的?
还记得在3.2章节讲述doGetBean
方法时提到首先会从缓存中尝试获取bean吗?如下:
protected <T> T doGetBean() throws BeansException {
Object sharedInstance = getSingleton(beanName);
}
调用的getSingleton
方法就是尝试从缓存中获取bean,这里来看一下它的源码:
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从 singletonObjects 获取实例,singletonObjects 中的实例都是准备好的 bean 实例,可以直接使用
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从二级缓存中获取单例bean
singletonObject = this.earlySingletonObjects.get(beanName);
// allowEarlyReference :表示是否允许从singletonFactories中通过getObject拿到对象
if (singletonObject == null && allowEarlyReference) {
// 从三级缓存中获取单例bean,并移动到二级缓存
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 通过单例工厂获取单例bean
singletonObject = singletonFactory.getObject();
// 从三级缓存移动到了二级缓存,并移除singletonFactory
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
可以看到,从三级缓存获取对象时,调用了singletonFactory.getObject()
,这里最终调用的就是匿名内部方法getEarlyBeanReference
。
所以可以说三级缓存的功效就是,在bean放入【二级代理】之前,通过ObjectFactory为当前bean创建代理对象(如果需要的话),保证别的bean引用它时是一个代理对象。
3.3.3 属性填充
经过上一小节的分析可知:
- 原始对象已经创建成功
- 原始对象包装成ObjectFactory放入了三级缓存
接下来,就是对bean进行属性填充了
protected Object doCreateBean() {
...
populateBean(beanName, mbd, instanceWrapper);
...
}
属性填充调用了populateBean
方法,它最终调用了 applyPropertyValues
进行属性填充:
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
//获取依赖的bean
String propertyName = pv.getName();
Object originalValue = pv.getValue();
//获取依赖的对象
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
}
}
方法applyPropertyValues
内部遍历处理依赖,获取依赖的bean,调用org.springframework.beans.factory.support.BeanDefinitionValueResolver#resolveValueIfNecessary
方法去获取被依赖的对象:
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
if (value instanceof RuntimeBeanReference) {
RuntimeBeanReference ref = (RuntimeBeanReference) value;
return resolveReference(argName, ref);
}
}
方法内部又自调用了resolveValueIfNecessary
方法:
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
//获取或创建依赖对象
bean = this.beanFactory.getBean(refName);
return bean;
}
方法 resolveReference
根据获取的beanName调用beanFactory的getBean
方法去获取依赖的bean,此时如果bean还未被创建,则会走一遍创建bean的流程,之后拿到依赖的bean,进行属性填充。
以文章开头的LagouBean与ItBean为例,说明一下整个流程:
(1)首先尝试从缓存中获取LagouBean,发现没有,则创建LagouBean,实例化后,放入三级缓存
(2)为LagouBean填充属性,发现依赖了ItBean
(3)创建ItBean,实例化后,放入三级缓存
(4)为ItBean填充属性,发现依赖了LagouBean,于是尝试从缓存中获取LagouBean
(5)发现LagouBean在三级缓存中,则调用对应的objectFactory.getObject()
拿到对象LagouBean(如果LagouBean需要创建代理,也是在这一步完成的)
(6)拿到对象LagouBean后移动到二级缓存,可供其他对象引用了,ItBean也因此可以完成属性填充,初始化,完成创建,最后放入一级缓存,返回给LagouBean
(7) LagouBean拿到ItBean,继续走填充流程,直到填充完毕,创建完成,放入一级缓存,到此LagouBean就可以使用了,解决了循环依赖问题
通过上述流程发现,如果LagouBean 与ItBean都需要创建代理对象,LagouBean的代理对象的创建在第(5)可完成,因为ItBean的创建在LagouBean的属性填充过程中,创建完直接放入了一级缓存,没有走二级缓存,ItBean的代理对象好像并没有创建的地方,那么spring如何保证LagouBean最终依赖的是ItBean的代理对象呢?其实ItBean的代理对象发生在bean初始化这一步,它在属性填充之后执行。
3.3.4 初始化
初始化就是给创建好的bean做后置处理,就像创建了一个人,populateBean
就是给人填充各种五脏六腑,血肉...初始化就是给人穿上外衣,如下图源码所示,initializeBean
方法就是对bean进行初始化
protected Object doCreateBean() {
//填充属性(依赖注入)
populateBean(beanName, mbd, instanceWrapper);
//调用初始化方法,完成bean的初始化操作
exposedObject = initializeBean(beanName, exposedObject, mbd);
return exposedObject;
}
initializeBean
方法做了4个动作,如下
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
invokeAwareMethods(beanName, bean);
Object wrappedBean = bean;
//before
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//触发初始化方法的调用
invokeInitMethods(beanName, wrappedBean, mbd);
//after
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}
-
invokeAwareMethods
方法主要给bean设置beanName,beanfactory,applicationContext -
applyBeanPostProcessorsBeforeInitialization
指预初始化方法,内部比较简单 -
invokeInitMethods
方法做了两件事:一个是调⽤InitializingBean
的afterPropertiesSet⽅法,一个是调用自定义的init方法
protected void invokeInitMethods() {
//调用InitializingBean的afterPropertiesSet()
((InitializingBean) bean).afterPropertiesSet();
//调用自定义的init方法
invokeCustomInitMethod(beanName, bean, mbd);
}
-
applyBeanPostProcessorsAfterInitialization
后初始化方法,它内部调用了接口org.springframework.beans.factory.config. BeanPostProcessor
的postProcessAfterInitialization
方法,这个方法的实现类为org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
,它的源码如下,有两个重要的方法:
public abstract class AbstractAutoProxyCreator{
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
//放进缓存earlyProxyReferences里,bean此时是原始对象,标记该对象是否被循环依赖
this.earlyProxyReferences.put(cacheKey, bean);
//创建代理对象
return wrapIfNecessary(bean, beanName, cacheKey);
}
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// remove方法返回记录的bean
// 若被循环引用了,说明执行了getEarlyBeanReference方法,remove返回值是==bean的
// 若没被循环引用,getEarlyBeanReference没执行 remove方法返回null,所以就进入创建代理对象步骤
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
}
在3.3.2章节中讲过,getEarlyBeanReference
是处理循环依赖的关键方法,它的执行要先于postProcessAfterInitialization
,功能就是创建好代理对象,最终放入二级缓存,提前暴露代理对象的引用。
postProcessAfterInitialization
方法执行在处理循环依赖之后,所以先进行判断有没有被循环引用过,没有循环引用过,则会创建它的代理对象返回。
所以,前文中所说的ItBean没有被循环引用,如果它需要创建代理对象的话,在postProcessAfterInitialization
这里就会去创建它的代理对象。最终保证依赖ItBean的类也能拿到它的代理对象引用。
到此,循环依赖处理也就讲述结束了。最后附上一张我自己手绘的图方便理解:
4.spring循环依赖常见问题总结
1.作用域为prototype的 bean对象支持循环依赖处理吗?
不支持。prototype的 bean存在循环引用的话会直接跑出异常org.springframework.beans.factory.BeanCurrentlyInCreationException
,spring解决循环依赖的核心思想就是基于java的引用对bean缓存,提前曝光给其他对象引用,对于prototype类型的每次请求都会创建一个bean,循环引用太多了的话,无法进行缓存处理,也就无法提前曝光引用。
2.如果构造器注入方式也有循环依赖情况,支持吗?
不支持。spring处理循环依赖的核心思想是基于java的引用传递,提前实例化好bean进行曝光。实例化bean需要调用构造器,存在循环依赖的情况时,会无法实例化提前曝光,所以构造器的循环依赖无法解决。
3.二级缓存能解决循环依赖吗?
- 没有AOP的情况下,二级缓存能解决循环依赖
- 有AOP的情况下,就无法解决了,因为注入到其他bean里的要是一个代理对象,如果只有二级缓存,那么注入到其他bean里的就有可能是个原始对象。这里有人说Bean 在实例化后就完成 代理对象的创建不就解决问题了吗?这样的话,其实连二级缓存都不需要了,一个缓存就够了,里面又处理原始对象,又处理代理对象,又要完成初始化等,这么想想就不是很优雅,也违背了单一原则,使用三级缓存各司其职,也体现了spring在设计上的优雅。