Spring容器如何处理循环依赖的原理
推荐阅读:
这套Github上40K+star学习笔记,可以帮你搞定95%以上的Java面试
毫不夸张的说,这份SpringBoot学习指南能处理你遇到的98%的问题
给跪了!这套万人期待的 SQL 成神之路PDF,终于开源了
最近看源码在研究相似如下配置的循环依赖是怎样处理的?
1 <bean id="a" class="com.project.demo.A" scope="singleton">2 <property name="b" ref="b"/>3 </bean>4 <bean id="b" class="com.project.demo.B" scope="singleton">5 <property name="a" ref="a"/>6 </bean>说明:
1、Spring容器处理循环依赖的问题配置类必需是单例模式scope=”singleton”才支持,假如是scope=”prototype”是无法处理循环依赖的。
2、Spring容器处理循环依赖主要依靠三级缓存机制
2.1 一级缓存使用的map: private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
2.2 二级缓存使用的map: private final Map<String, Object> earlySingletonObjects = new HashMap(16);
2.3 三级缓存使用的map: private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
3、Spring容器处理循环依赖简洁概述主要有四大流程方法:获取对象 getSingleton()、 创立对象(实例化) doCreateBean()、填充属性(初始化) populateBean()、返回对象 addSingleton()
在系统启动获取配置文件后,程序是依次读取并加载的,所以上面配置文件代码,先实例化a对象,而后初始化a对象给a增加b属性,再实例化b对象,最后初始化b对象给增加属性a.
那么在代码执行过程中,先调用getSingleton()方法,我们查看源码
@Nullable public Object getSingleton(String beanName) { // 调用下方重载方法 return this.getSingleton(beanName, true); } @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 先从一级缓存中获取a对象的实例 Object singletonObject = this.singletonObjects.get(beanName); // 假如从一级缓存中获取不到a对象,那么检查该对象能否正在被创立,假如正在被创立,则进入if循环中 if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) { synchronized(this.singletonObjects) { // 从二级缓存中获取该对象 singletonObject = this.earlySingletonObjects.get(beanName); // 假如二级缓存中无法获取该对象,那么肯定会进入如下if方法,由于allowEarlyReference传过来的时候就是true if (singletonObject == null && allowEarlyReference) { // 从三级缓存中获取该对象 ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName); if (singletonFactory != null) { // 假如获取到了该对象,就将三级缓存中的对象放到二级缓存中,并且将三级缓存中的对象删除 singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } return singletonObject; }从三面的源码发现,假如a第一次获取,那么第9行的if语句为false,将直接放回为null,这时回到创立对象doCreateBean()方法,该方法使用反射的方式生成a对象,并且该对象在三级缓存中,对象生成后就需要对a对象进行属性填充:
1 protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { 2 // 省略多行代码,大致就是调用各种方法,通过反射创立对象 3 try { 4 // a对象创立完成,调用属性填充方法,对a进行属性填充 5 this.populateBean(beanName, mbd, instanceWrapper); 6 exposedObject = this.initializeBean(beanName, exposedObject, mbd); 7 } catch (Throwable var18) { 8 if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) { 9 throw (BeanCreationException)var18;10 }11 12 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);13 }14 15 if (earlySingletonExposure) {16 Object earlySingletonReference = this.getSingleton(beanName, false);17 if (earlySingletonReference != null) {18 // 省略多行代码19 }20 }22 // 省略多行代码23 }在上面代码doCreateBean()方法中先创立a对象,创立完成后会调用this.populateBean(beanName, mbd, instanceWrapper)方法对a进行属性填出,这个时候会获取配置文件中所有<bean id=”a”>里面的所有属性,发现会存在一个b属性,下面贴出部分源码
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { if (mbd.hasPropertyValues()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance"); } } else { boolean continueWithPropertyPopulation = true; if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) { // 删除大量代码 } if (continueWithPropertyPopulation) { // 删除大量源代码,applyPropertyValues方法中beanName为a,pvs为状态各种属性的PropertyValues对象,pvs就装有b这个属性 if (pvs != null) { this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs); } } } }继续跟进applyPropertyValues方法的源码
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { if (!pvs.isEmpty()) { if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) { ((BeanWrapperImpl)bw).setSecurityContext(this.getAccessControlContext()); } MutablePropertyValues mpvs = null; List original; if (pvs instanceof MutablePropertyValues) { // 省略大量代码 } else { original = Arrays.asList(pvs.getPropertyValues()); } // 省略大量代码 大致过程是将属性对象pvs 转化成original List对象,而后在使用迭代器在下面进行迭代 Iterator var11 = original.iterator(); while(true) { while(var11.hasNext()) { PropertyValue pv = (PropertyValue)var11.next(); if (pv.isConverted()) { deepCopy.add(pv); } else { String propertyName = pv.getName(); Object originalValue = pv.getValue(); // 通过下面方法处理依赖的b,整个方法在迭代器中,外层在while(true)中,可能有多个属性,循环直到所有属性都处理了就return;或者者抛出异常 Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); // 省略大量代码 } } if (mpvs != null && !resolveNecessary) { mpvs.setConverted(); } try { bw.setPropertyValues(new MutablePropertyValues(deepCopy)); return; } catch (BeansException var19) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", var19); } } } }继续跟进上面红色方法
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) { if (value instanceof RuntimeBeanReference) { RuntimeBeanReference ref = (RuntimeBeanReference)value; return this.resolveReference(argName, ref); } else if (value instanceof RuntimeBeanNameReference) { // 省略多行代码 } // 省略多行代码 }继续跟进红色部分的代码
private Object resolveReference(Object argName, RuntimeBeanReference ref) { try { String refName = ref.getBeanName(); refName = String.valueOf(this.doEvaluate(refName)); Object bean; if (ref.isToParent()) { // 省略多行代码 } else { // 通过refName的值b又去工厂找b对象 bean = this.beanFactory.getBean(refName); this.beanFactory.registerDependentBean(refName, this.beanName); } // 省略多行代码 return bean; } catch (BeansException var5) { throw new BeanCreationException(this.beanDefinition.getResourceDescription(), this.beanName, "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, var5); } }1 public Object getBean(String name) throws BeansException {2 return this.doGetBean(name, (Class)null, (Object[])null, false);3 } protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { String beanName = this.transformedBeanName(name); // 跟了这么就,最终表明在实例化a对象后,在装载a的属性b时,会经过各种校验最终到getSingleton(),及先获取b对象,假如b对象不存在则会对b完成创立的过程 Object sharedInstance = this.getSingleton(beanName); // 省略多行代码 }上面整个过程概括:在检测到需要实例化a时,先去获取a对象,看a能否已经存在,获取去先从一级缓存中获取,假如没有并且假如a也没有正在实例化,那么直接返回null,表明获取不到a对象,那么此时调用doCreateBean()方法完成对a对象的实例化过程(通过反射创立a对象),并且将创立的a对象放在三级缓存中
而后继续执行doCreateBean中的populateBean()方法完成对a进行初始化即增加属性b,经过少量列校验,最终又会调用getSingleton()方法来获取b对象,同样会返回null
这个时候就会去执行doCreateBean()方法创立b对象,同样过反射创立b,当b对象创立完成时也会存放在三级缓存中,在实例化b对象完成,而后继续执行doCreateBean中的populateBean()方法,也需要初始化b对象,填充b的属性
这时发现b对象的属性是a,同样再次通过getSingleton()方法获取a,获取a的过程如第一个源码部分,先从一级缓存中获取,获取不到,而后判断a正在创立中,而后就从二级、三级缓存中获取,最终在三级缓存中获取到了a,并且将三级缓存中的a对象放到二级缓存中,并将删除三级缓存中的a,此时b对象初始化也完成。
在a对象初始化的流程中,将b对象也实例化和初始化了,在b的初始化过程中,将a从三级缓存移到了二级缓存中,当b初始化完成后继续向下执行,会执行到addSingleton(),查看源码
protected void addSingleton(String beanName, Object singletonObject) { synchronized(this.singletonObjects) { // 将b加入到1级缓存 this.singletonObjects.put(beanName, singletonObject); // 将b从三级缓存中删除 this.singletonFactories.remove(beanName); // 将b从二级缓存中删除(b在二级缓存中没有,即空删除) this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } }从上面代码可以看出来,并创立完成并且初始化后,会将B从三级缓存中直接放到一级缓存中,并且删除三级缓存中的数据。
所有b工作做完后返回到a初始化属性b的代码
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // 省略大量代码 try { // 完成a对于属性b的检查装配工作后返回到方法populateBean(),继续向下执行 this.populateBean(beanName, mbd, instanceWrapper); exposedObject = this.initializeBean(beanName, exposedObject, mbd); } catch (Throwable var18) { if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) { throw (BeanCreationException)var18; } throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18); } if (earlySingletonExposure) { // a执行到该方法getSingleton(),这里面会将a从二级缓存中取出来 Object earlySingletonReference = this.getSingleton(beanName, false); if (earlySingletonReference != null) { // 省略大量代码 } } // 省略大量代码 }继续执行,最终也会到addSingleton()方法,将a也加入一级缓存,并且从二级缓存中删除a。
这样a和b两个循环依赖的bean都被放入到一级缓存中。
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » Spring容器如何处理循环依赖的原理