第3レベルのキャッシュは、Beanの作成プロセスにおける循環依存関係を解決します
1.循環依存とは何ですか？
つまり、AはBに依存し、BはCに依存し、CはAに依存します。このような問題により、Aはインスタンス化されたときに完了しません。
循環依存の分類：
-
コンストラクターの循環依存
この状況は解決できません。コンストラクターを介してインスタンス化する必要があるため、コンストラクターを呼び出さないことは不可能であり、依存関係の発生を回避することは不可能です。この時点でスローされ
BeanCurrentlyInCreationExceptionます。 -
セッター循環依存。すでにインスタンス化されているBeanは、インスタンス化と初期化を分離することにより、事前に公開できます。
Springは、セッターの場合にのみ、シングルトンBeanの循環依存問題を解決できます。
/** Cache of singleton objects: bean name --> bean instance */ //一级缓存，存放成品对象
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** Cache of singleton factories: bean name --> ObjectFactory *///三级缓存，存放函数式接口，完成代理对象的覆盖
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name --> bean instance *///二级缓存，存放半成品对象
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
private final Set<String> registeredSingletons = new LinkedHashSet<>(256); //已经创建成功的单例
2.循環依存の分析
プログラム実行のプロセスに従って、Springが循環依存をどのように解決するかを分析します。
Spring構成ファイルをロードする過程で、refreshメソッドがトリガーされることがわかっています。明確：
AbstractBeanFactory#refresh()#finishBeanFactoryInitialization(beanFactory)で、合格します
getBean(beanName)メソッドはオブジェクトの作成を完了します。これが呼び出しdoGetBeanです。これは最初にgetSingleton(beanName)メソッド。
//getSingleton(beanName) 调用的实际方法
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//首先从一级缓存 singletonObjects 中获取成品对象
Object singletonObject = this.singletonObjects.get(beanName);
//一级缓存为 null 且 bean 正在创建（循环依赖发生了，则触发二级缓存）
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//二级缓存中获取半成品对象
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
//三级缓存中获取接口方法对象
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
//如果存在三级缓存，则将其加入二级缓存，再移除三级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
最初の作成のオブジェクトはなく、nullが直接返されます。この時点で、BeanはトリガーgetSingletonの。
getSingletonインターフェイスパラメータメソッド：ここでのインターフェイスパラメータはL3キャッシュです。現時点ではL3キャッシュはありませんので、作成してcreateBean作成ください。このメソッドではが呼び出されます
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
//多例的处理逻辑，直接 createBean
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
getSingletonインターフェイスパラメータメソッド：ここでのインターフェイスパラメータはL3キャッシュです。現時点ではL3キャッシュはありませんので、作成してcreateBean作成ください。
第3レベルのキャッシュがインターフェイスメソッドを格納する理由を考えてみてください。1つはこのプロパティを使用してBeanを作成することであり、もう1つは拡張機能です。
その後、彼はBeanを正常に作成でき、Beanが依存している場合は、getEarlyBeanReferenceを介してプロキシBean作成操作を実行できます。このプロセスは、作成されたBeanをプロキシBeanでオーバーライドします。
//通过 ObjectFactory 获取实例
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//一级缓存中获取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
beforeSingletonCreation(beanName);//标记创建中
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//从三级缓存中获取，此时三级缓存不存在，所以会去创建一个
//此时会回调到 createBean#doCreateBean#createBeanInstance
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
//.....
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
//触发创建操作后，此处执行三级缓存机制（将 B 加入）
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
添付ファイル：3レベルのキャッシュメカニズム：
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject); //加入一级缓存
this.singletonFactories.remove(beanName); //移除三级缓存
this.earlySingletonObjects.remove(beanName); //移除二级缓存
this.registeredSingletons.add(beanName); //标记已创建
}
}
Beanが作成された後、プロパティの割り当て中に循環依存が発生します。たとえば、Aを作成するプロセスでは、インスタンスBに移動する必要があります。Bが存在しない場合は、Bを作成する必要があります。Bを作成した後、属性割り当て用にAを作成する必要があります。このとき、BがAを作成すると、最初に2番目のレベルのキャッシュに移動して半完成のAを取得し、Aの2番目のインスタンスをスキップします。Bは半製品Aを取得した後、作成を完了します。つまり、Aはまだ半製品であり、属性の割り当てがまだないため、Bにはaがあり、aにはbがnullです。
Bが作成されると、Aが作成されます。
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//earlySingletonExposure 只有当支持循环依赖，才使用三级缓存，解决代理问题
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper); //填充属性，循环依赖发生
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
//....
if (earlySingletonExposure) {
//尝试从缓冲中获取
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
//这里需要说明的是，getEarlyBeanReference 是一个实现 aop 的增强方法,代理对象
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
//如果存在 BeanPostProcessors，需要代理，则生成代理对象
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
//拿到代理 bean 并覆盖，SmartInstantiationAwareBeanPostProcessor 会在实例化过程中进行增强操作
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
//轮询初始化 bean，但此时 bean 尚未实例化要知道
// Trigger initialization of all non-lazy singleton beans...
下一步轮询 bean，是否实现了 SmartInitializingSingleton 的增强操作
// Trigger post-initialization callback for all applicable beans...
要約する
循環依存の問題を解決するために、第2レベルのキャッシュを実装できます。
L3キャッシュを使用すると、プロキシBeanの問題を解決できます。
Awareインターフェースが実装され、そのsetxxxAwareメソッドが書き直されている限り、そのプロパティはオブジェクトを介して取得できます。
動的プロキシの撤回：傍受の強化@lookup