spring中bean的循环依赖细节描述

🕗 发布于 2025-01-19 23:23 spring java

首先，循环依赖不是一件好事，设计上几乎不会这么设计。但是总有时候要碰到一起奇怪的循环依赖。

spring bean循环依赖之所以能实现，也是有条件的，构造函数的依赖显然不行。而bean生命周期的实例化和属性设置是分阶段的，所以能够解决循环依赖。

测试代码

a 依赖 b (a有代理)
b 依赖 a, c
c 依赖 a

附测试代码：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class A {
    @Autowired
    B b;

    public A() {
        System.out.println("A()");
    }

    public void say(){
        System.out.println("say A");
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


@Service
public class B {

    @Autowired
    A a;

    @Autowired
    C c;

    public B() {
        System.out.println("B()");
    }

    public void sayAC() {
        System.out.println("A:" + a + ",C:" + c);
    }

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class C {

    @Autowired
    A a;

    public C() {
        System.out.println("C()");
    }

}

代理A的方法

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Service;

@Aspect
@Service
public class LogAspect {
    @Before("execution(public * com.aop.dependency..*.say(..))")
    public void before() {
        System.out.println("... before say...");
    }

}

测试

@EnableAspectJAutoProxy
@Configuration
@ComponentScan("com.aop.dependency")
public class ConfigOne {
}

@Test 
public void test() throws Exception {
       ApplicationContext ctx =
               new AnnotationConfigApplicationContext(ConfigOne.class);

A a = (A) ctx.getBean("a");
a.say();

((AnnotationConfigApplicationContext) ctx).close();
}

debug循环依赖逻辑

在这里插入图片描述

doGetBean方法和其第一句的getSingleton(beanName, true)方法

bean获取逻辑在：org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean中

其中第一个方法就是getSingleton(beanName, true)，如下，有几个级别的缓存map获取

最后的实例缓存：org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#singletonObjects
早期实例缓存：org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#earlySingletonObjects
lambda表达式的工厂缓存：org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#singletonFactories

/**
 * Return the (raw) singleton object registered under the given name.
 * <p>Checks already instantiated singletons and also allows for an early
 * reference to a currently created singleton (resolving a circular reference).
 * @param beanName the name of the bean to look for
 * @param allowEarlyReference whether early references should be created or not
 * @return the registered singleton object, or {@code null} if none found
 */
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
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;
}

bean “a” 第一次getBean的时候执行了哪些操作

可以看到做了如下的一些操作和缓存

标记自己在创建中
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#singletonsCurrentlyInCreation
实例化对象并缓存到org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#factoryBeanInstanceCache中
添加了singletonFactorie的lambda表达式,即所谓的第3级缓存

问题1: singletonFactory的lambda表达式什么时候缓存的

在第一次getBean"a"的时候，生命周期里面添加的

在这里插入图片描述

lambda表达式为：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#getEarlyBeanReference

/**
 * Obtain a reference for early access to the specified bean,
 * typically for the purpose of resolving a circular reference.
 * @param beanName the name of the bean (for error handling purposes)
 * @param mbd the merged bean definition for the bean
 * @param bean the raw bean instance
 * @return the object to expose as bean reference
 */
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}

补充问题2：怎么执行到doCreateBean生命周期方法的

如下图，也用了一个lambda表达式执行
在这里插入图片描述

/**
 * Return the (raw) singleton object registered under the given name,
 * creating and registering a new one if none registered yet.
 * @param beanName the name of the bean
 * @param singletonFactory the ObjectFactory to lazily create the singleton
 * with, if necessary
 * @return the registered singleton object
 */
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 {
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}

先进行标记是在创建中
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#singletonsCurrentlyInCreation

然后执行singletonFactory.getObject();即开始执行lambda表达式得到bean实例

接着会判断是否FactoryBean

最后的对象则加入到singletonObjects缓存中，并清除其它缓存

/**
 * Add the given singleton object to the singleton cache of this factory.
 * <p>To be called for eager registration of singletons.
 * @param beanName the name of the bean
 * @param singletonObject the singleton object
 */
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);
}
}

所以不要混乱了

“a” 到 “b” 到 “a” ，“a”第二次doGetBean

第二次执行因为已经缓存了singletonFactorie，所以要执行lamdb表达了

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}

从方法命名可以看到是得到一个早期对象，执行完成后会发现已经是一个代理对象了，因为本例中bean"a"是使用了aop的, （代码中称为sharedInstance）

在这里插入图片描述

且第二次执行不会执行doCreateBean生命周期方法了

而是对早期对象执行org.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance方法并返回

"b"到“c”到“b”, "b"第二次doGetBean

如果没有代理，可以发现"b"还是"b"
在这里插入图片描述

“a”到“b”(“a”, “c”) 到“c” 到“a”, "a"第三次doGetBean

第三次的时候，注解从earlySingletonObjects早期对象缓存取出来

最后"c",“b”,"a"都完成自己的生命周期

早期对象是什么？

是自己或者自己的代理（如果有aop）
且代理逻辑只会执行一次

对于spring的了解，我们也应该知道BeanPostProcessor是实现bean代理的关键，而getEarlyBeanReference确实如此

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}

有代理如何执行？

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getEarlyBeanReference

在这里插入图片描述
可以看到也会有缓存的

@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
this.earlyProxyReferences.add(cacheKey);
}
return wrapIfNecessary(bean, beanName, cacheKey);
}

代理关键执行则是在org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary方法中

在这里插入图片描述

总结循环依赖实现依靠什么

依靠实例化和属性依赖注入是分开的
依赖各种缓存和逻辑标记，绝不是网上说的只记住三级缓存那么简单。可以看到实例化出来的raw bean要缓存的，代理出来的早期对象也要缓存的…

所以回答这个问题，需要更加细致一些。

最后可以看到spring bean循环依赖是有条件的，过程是复杂的；工作中不要用了，自己也会绕晕，看到其它人写了，最好改下设计。

原文地址：https://blog.csdn.net/qq_26437925/article/details/145224918

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：深入解析 Spring AI 系列：分析 Spring AI 可观测性
下一篇：MuJoCo仿真中的两轮平衡小车项目【问题集合】

语言模型的价值定位与技术突破：从信息处理到创新认知
当前语言模型的核心价值主要体现在信息综合与处理能力上，用户友好的交互界面是其成功关键。在模型计算机制方面，推理能力的实现包括chain-of-thought和自适应计算两种范式，而内部计算过程研究将成
阅读更多2025-01-21
Python绘制数据地图-MovingPandas
是一个用于时空数据分析的 Python 库，它扩展了 Pandas 和 GeoPandas，使得处理和分析带有时间戳的地理数据变得更加方便。请注意，这个示例非常基础，只是简单地绘制了每个时间点的位置。
阅读更多2025-01-21
《数字图像处理（面向新工科的电工电子信息基础课程系列教材）》重印变更的彩插
禹晶、肖创柏、廖庆敏《数字图像处理（面向新工科的电工电子信息基础课程系列教材）》第一次重印变更的彩插
阅读更多2025-01-21
Redis-HyperLogLog
是Redis的高级数据结构，它在做的时候非常有用，每个HyperLogLog的键可以计算接近2^64不同元素的基数，而大小只需要12KB。目前只支持3个命令，PFADDPFCOUNTPFMERGE。底
阅读更多2025-01-21
SpringBoot集成 jakarta mail 实现发送邮件
3、如上示例只验证了简单内容的邮件，也支持附件、HTML内容、抄送等邮件。2、MailAccount实例配置。验证结果：皆成功收到邮件。
阅读更多2025-01-21
gitlab使用多数据库
如果现有的gitlabhq_production已经有了ci的相关数据，那么就通过停止puma/rails服务，然后备份gitlabhq_production库，在将备份的sql写入到gitlabhq
阅读更多2025-01-21
基于springboot+thymeleaf+Redis仿知乎网站问答项目源码
基于springboot+thymeleaf+Redis仿知乎网站问答项目源码，可以作为毕业设计项目参考学习按照需要一定动手能力发文章，发视频，发想法，提问回答，注册登录开发环境使用技术：spring
阅读更多2025-01-21
JavaWeb开发学习笔记——MySQL
跟着黑马程序员学习MySQL注意，以下笔记中[]中都是可省略内容，如果不省略，那么直接写即可，不带[]
阅读更多2025-01-21
CycleGAN - CycleGAN网络：无监督图像到图像转换的生成对抗网络
CycleGAN是一种基于生成对抗网络（GAN）的无监督学习模型，旨在解决没有成对图像数据的图像到图像转换问题。其核心思想是通过引入循环一致性损失来确保生成的图像在转换回原始域时，能够保持与输入图像相
阅读更多2025-01-21
IF=58.7|肠-脑-肝轴新突破
本研究通过多组学联合分析，发现HE与患者粪便中的R.gnavus通过PDC及其代谢物PEA有关，提升了人们对HE发病机制的了解，为HE的治疗和预防策略开辟了新的途径。
阅读更多2025-01-21

spring中bean的循环依赖细节描述

目录

测试代码

debug循环依赖逻辑

doGetBean方法和其第一句的getSingleton(beanName, true)方法

bean “a” 第一次getBean的时候执行了哪些操作

问题1: singletonFactory的lambda表达式什么时候缓存的

补充问题2：怎么执行到doCreateBean生命周期方法的

“a” 到 “b” 到 “a” ，“a”第二次doGetBean

"b"到“c”到“b”, "b"第二次doGetBean

“a”到“b”(“a”, “c”) 到“c” 到“a”, "a"第三次doGetBean

最后"c",“b”,"a"都完成自己的生命周期

早期对象是什么？

有代理如何执行？

总结循环依赖实现依靠什么

相关文章