多语言网站如何开发,郑州西区做网站,网络营销概念是什么,浙江省住房和城乡建设厅电话目录 什么是循环依赖
凡是Java的循环依赖都会有问题#xff1f;
为什么Spring循环依赖会有问题#xff1f;
Spring解决循环依赖问题的思路#xff1f;
设置二级缓存对象池
方案一直接将实例化对象放入早期对象池
方案一缺点
方案二-将实例化对象处理AOP后放入早期对象…目录 什么是循环依赖
凡是Java的循环依赖都会有问题
为什么Spring循环依赖会有问题
Spring解决循环依赖问题的思路
设置二级缓存对象池
方案一直接将实例化对象放入早期对象池
方案一缺点
方案二-将实例化对象处理AOP后放入早期对象池
方案二-缺点
设置三级缓存对象池
Spring解决循环依赖源码解析 什么是循环依赖
对象A依赖对象B对象B依赖对象A这是一种常见且正常的依赖关系。 Java原生创建对象循环依赖不会有问题
通过Java直接创建对象并不会产生问题因为Java创建的只需要实例化后就是一个完整的对象循环依赖时只需将所有的对象都先实例化再处理依赖关系。
publc class A{public B b;
}
publc class B{public A a;
}
public class Test{public static void main(String[] args){A a new A();B b new B();a.b b;b.a a;}
}
为什么Spring循环依赖会有问题
spring创建的bean对象不只是简单的实例化还要经历属性注入初始化前初始化初始化后等过程只有经历完这个过程才是一个完整的bean。要了解spring生命周期可以参考这篇博文
一句话解释处理依赖关系时由于bean没有经历完完整的生命周期还不是一个完整的bean导致有循环依赖关系的bean都陷入等待对方完成状态而无法继续向后执行。请参考下面的流程图感受下
ABean创建--依赖了B属性--触发BBean创建---B依赖了A属性---需要ABean但ABean还在创建过程中 Spring解决循环依赖问题的思路
设置二级缓存对象池
方案一直接将实例化对象放入早期对象池
最简单的思路就是在类似于普通对象创建的方式在实例化后有一个原始的对象池在判断单例池中是否有bean对象时若无则从原始对象池中获取可以解决上诉问题 方案一缺点
如果A的原始对象注入给B的属性之后在初始化后阶段A的原始对象进行了AOP产生了一个代理对象对于A而言它的Bean对象其实应该是AOP之后的代理对象而B的a属性对应的并不是AOP之后的代理对象这就产生了冲突
方案二-将实例化对象处理AOP后放入早期对象池
放入早期对象池前对实例化后对象A处理若有AOP则放入代理对象A,若无AOP,则放入原始对象如下图所示 方案二-缺点
但是在实例化后直接处理对象A将代理对象或原始对象放入对象原始池这种方式对所有对象的创建过程都起作用而没有循环依赖的对象创建过程无需将AOP过程前置所以这个时机不合适
设置三级缓存对象池
Spring为了解决非循环依赖的对象不进行AOP前置使采用函数式编程方式在实例化后先缓存一个对象工厂函数此时不执行内部逻辑待从原始对象池中获取对象时才真正获取到对象工厂去调用函数获取早期对象存放到二级缓存对象池中即早期对象池
三级缓存对象池的作用
1.单例对象池(singletonObjects中)缓存的是经历过完整生命周期后对象
2.早期对象池(earlySingletonObjects)缓存的是没有经历过完整生命周期的对象实例化后原始对象或者实例化后的代理对象
3.对象工厂(singletonFactories)缓存的是对象工厂对象工厂中定义了创建早期对象的函数
三者的创建时机获取时机如下流程图 Spring解决循环依赖源码解析
查看获取属性对象时源码也可知获取对象时先从单例池中获取对象获取不到从早期对象池中获取对象若仍获取不到则从对象工厂中获取对象bean的对象工厂创建早期对象存入早期对象池中并且该对象工厂从对象工厂池中删除。
Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) {// Quick check for existing instance without full singleton lockObject singletonObject this.singletonObjects.get(beanName);if (singletonObject null isSingletonCurrentlyInCreation(beanName)) {singletonObject this.earlySingletonObjects.get(beanName);if (singletonObject null allowEarlyReference) {synchronized (this.singletonObjects) {// Consistent creation of early reference within full singleton locksingletonObject this.singletonObjects.get(beanName);if (singletonObject null) {singletonObject this.earlySingletonObjects.get(beanName);if (singletonObject null) {ObjectFactory? singletonFactory this.singletonFactories.get(beanName);if (singletonFactory ! null) {singletonObject singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}}}return singletonObject;}
对象工厂调用getObject()时实际调用的就是
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#getEarlyBeanReference
会遍历所有实现了SmartInstantiationAwareBeanPostProcessor的类调用getEarlyBeanReference获取bean
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {Object exposedObject bean;if (!mbd.isSynthetic() hasInstantiationAwareBeanPostProcessors()) {for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {exposedObject bp.getEarlyBeanReference(exposedObject, beanName);}}return exposedObject;}
SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference会直接获取到原始bean
public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {/*** Obtain a reference for early access to the specified bean,* typically for the purpose of resolving a circular reference.* pThis callback gives post-processors a chance to expose a wrapper* early - that is, before the target bean instance is fully initialized.* The exposed object should be equivalent to the what* {link #postProcessBeforeInitialization} / {link #postProcessAfterInitialization}* would expose otherwise. Note that the object returned by this method will* be used as bean reference unless the post-processor returns a different* wrapper from said post-process callbacks. In other words: Those post-process* callbacks may either eventually expose the same reference or alternatively* return the raw bean instance from those subsequent callbacks (if the wrapper* for the affected bean has been built for a call to this method already,* it will be exposes as final bean reference by default).* pThe default implementation returns the given {code bean} as-is.* param bean the raw bean instance* param beanName the name of the bean* return the object to expose as bean reference* (typically with the passed-in bean instance as default)* throws org.springframework.beans.BeansException in case of errors*/default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {return bean;}}
但是spring提供了AbstractAutoProxyCreator实现了SmartInstantiationAwareBeanPostProcessor重写了getEarlyBeanReference方法若开启了代理那会直接执行AbstractAutoProxyCreator的getEarlyBeanReference获取代理后的对象
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupportimplements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware{
// 提前进行AOPOverridepublic Object getEarlyBeanReference(Object bean, String beanName) {Object cacheKey getCacheKey(bean.getClass(), beanName);this.earlyProxyReferences.put(cacheKey, bean);return wrapIfNecessary(bean, beanName, cacheKey);}
}
