@Autowired为何能解决循环依赖

最新推荐文章于 2025-03-30 10:00:10 发布
最新推荐文章于 2025-03-30 10:00:10 发布
阅读量2.1k 收藏 3
点赞数 3
分类专栏： java 文章标签： java
原文链接：https://blog.csdn.net/scientificCommunity/article/details/109220092
版权

文章目录

@Autowired的what&how

在spring框架下，我们可以通过@Autowired注解对属性或者方法参数进行标注，当spring ioc容器初始化时，会帮我们从容器中拿到对应的实例进行注入

什么是循环依赖

假如现在有两个Bean如下所示

public class BeanA {
    @Autowired
    private BeanB beanB;
}

public class BeanB {
@Autowired
private BeanA beanA;
}

    然后我们通过annotationConfigApplicationContext#register将两个bean的信息注入到容器中，最后通过refresh进行容器到初始化操作

    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
        annotationConfigApplicationContext.register(Bean1.class);
        annotationConfigApplicationContext.register(Bean2.class);
        annotationConfigApplicationContext.refresh();
    }

      可以看到A跟B互相依赖，试着想象：当容器先初始化beanA时，必然要对属性beanB进行赋值，这个时候容器中还没有beanB，那么势必会触发beanB的初始化流程，而beanB初始化的完成也需要对属性beanA赋值，但beanA还未初始化完成，这里就产生了所谓的循环依赖。

      spring如何解决循环依赖

      这里有一个很关键的属性：

      public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	/** Cache of singleton factories: bean name to ObjectFactory. */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}

        key是beanName，value是一个对象工厂，我们点进去看一下

        public interface ObjectFactory<T> {

        T <span class="token function">getObject</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">throws</span> BeansException<span class="token punctuation">;</span>

        }

          其实这里的getObject()就是最终解决循环依赖所调用的方法。
          那么程序是怎样执行到这的呢？
          我们先从bean的创建入手
          如果容器还未实例化bean，那么就会走到这里

          protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		BeanWrapper instanceWrapper = null;
		if (instanceWrapper == null) {
			//实例化bean，如果@Autowired加在构造方法上，
			//那么就会在这里完成注入
			//因为下面的回调还未注册，所以这里无法解决循环依赖
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

          	<span class="token keyword">final</span> Object bean <span class="token operator">=</span> instanceWrapper<span class="token punctuation">.</span><span class="token function">getWrappedInstance</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
	
	<span class="token keyword">boolean</span> earlySingletonExposure <span class="token operator">=</span> <span class="token punctuation">(</span>mbd<span class="token punctuation">.</span><span class="token function">isSingleton</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">&amp;&amp;</span> <span class="token keyword">this</span><span class="token punctuation">.</span>allowCircularReferences <span class="token operator">&amp;&amp;</span>
			<span class="token function">isSingletonCurrentlyInCreation</span><span class="token punctuation">(</span>beanName<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
	<span class="token keyword">if</span> <span class="token punctuation">(</span>earlySingletonExposure<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
		<span class="token keyword">if</span> <span class="token punctuation">(</span>logger<span class="token punctuation">.</span><span class="token function">isTraceEnabled</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
			logger<span class="token punctuation">.</span><span class="token function">trace</span><span class="token punctuation">(</span><span class="token string">"Eagerly caching bean '"</span> <span class="token operator">+</span> beanName <span class="token operator">+</span>
					<span class="token string">"' to allow for resolving potential circular references"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
		<span class="token punctuation">}</span>
		<span class="token comment">//往单例工厂(之前说的singletonFactories)中添加一个</span>
		<span class="token comment">//ObjectFactory的匿名实现作为回调，</span>
		<span class="token function">addSingletonFactory</span><span class="token punctuation">(</span>beanName<span class="token punctuation">,</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">-</span><span class="token operator">&gt;</span> <span class="token function">getEarlyBeanReference</span><span class="token punctuation">(</span>beanName<span class="token punctuation">,</span> mbd<span class="token punctuation">,</span> bean<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
		
		<span class="token comment">//属性赋值，处理@Autowired(非构造方法)</span>
		<span class="token function">populateBean</span><span class="token punctuation">(</span>beanName<span class="token punctuation">,</span> mbd<span class="token punctuation">,</span> instanceWrapper<span class="token punctuation">)</span><span class="token punctuation">;</span>
	<span class="token punctuation">}</span>

            这里我们发现，在实例化bean跟对属性赋值之间有一个addSingletonFactory的操作，作用是注册一个可以获取当前正在创建的bean的一个回调

            	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		synchronized (this.singletonObjects) {
			if (!this.singletonObjects.containsKey(beanName)) {
				this.singletonFactories.put(beanName, singletonFactory);
			}
		}
	}

              进入回调，发现回调默认返回的就是bean本身

              	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;
	}

              <span class="token keyword">default</span> Object <span class="token function">getEarlyBeanReference</span><span class="token punctuation">(</span>Object bean<span class="token punctuation">,</span> String beanName<span class="token punctuation">)</span> <span class="token keyword">throws</span> BeansException <span class="token punctuation">{<!-- --></span>
	<span class="token comment">//	返回bean本身</span>
	<span class="token keyword">return</span> bean<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
              • ok，这里得出一个结论，即使bean未初始化完成，spring也提供了方法来获取这个bean的实例。
                如果应用到我们上面的栗子中来就是：
                1. beanA实例化完成
                2. 添加获取beanA的回调到singletonFactories
                3. 调用populateBean，处理@Autowired，注入beanB

                因为beanB还未创建，那么势必会进入创建beanB的流程，当beanB也走到populateBean时，也需要完成beanA的注入，这时就会尝试从beanFactory中获取beanA，这里最终会进到
                AbstractBeanFactory的doGetBean中

                	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

                	<span class="token keyword">final</span> String beanName <span class="token operator">=</span> <span class="token function">transformedBeanName</span><span class="token punctuation">(</span>name<span class="token punctuation">)</span><span class="token punctuation">;</span>
	Object bean<span class="token punctuation">;</span>

	<span class="token comment">// Eagerly check singleton cache for manually registered singletons.</span>
	Object sharedInstance <span class="token operator">=</span> <span class="token function">getSingleton</span><span class="token punctuation">(</span>beanName<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

                这里很关键，我们进入getSingleton(beanName)

                	public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}

                <span class="token keyword">protected</span> Object <span class="token function">getSingleton</span><span class="token punctuation">(</span>String beanName<span class="token punctuation">,</span> <span class="token keyword">boolean</span> allowEarlyReference<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
	Object singletonObject <span class="token operator">=</span> <span class="token keyword">this</span><span class="token punctuation">.</span>singletonObjects<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span>beanName<span class="token punctuation">)</span><span class="token punctuation">;</span>
	<span class="token keyword">if</span> <span class="token punctuation">(</span>singletonObject <span class="token operator">==</span> null <span class="token operator">&amp;&amp;</span> <span class="token function">isSingletonCurrentlyInCreation</span><span class="token punctuation">(</span>beanName<span class="token punctuation">)</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
		<span class="token keyword">synchronized</span> <span class="token punctuation">(</span><span class="token keyword">this</span><span class="token punctuation">.</span>singletonObjects<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
			singletonObject <span class="token operator">=</span> <span class="token keyword">this</span><span class="token punctuation">.</span>earlySingletonObjects<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span>beanName<span class="token punctuation">)</span><span class="token punctuation">;</span>
			<span class="token keyword">if</span> <span class="token punctuation">(</span>singletonObject <span class="token operator">==</span> null <span class="token operator">&amp;&amp;</span> allowEarlyReference<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
				<span class="token comment">//拿到之前注册的单例工厂对象</span>
				ObjectFactory<span class="token operator">&lt;</span><span class="token operator">?</span><span class="token operator">&gt;</span> singletonFactory <span class="token operator">=</span> <span class="token keyword">this</span><span class="token punctuation">.</span>singletonFactories<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span>beanName<span class="token punctuation">)</span><span class="token punctuation">;</span>
				<span class="token keyword">if</span> <span class="token punctuation">(</span>singletonFactory <span class="token operator">!=</span> null<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
				    <span class="token comment">//调用之前注册的回调</span>
					singletonObject <span class="token operator">=</span> singletonFactory<span class="token punctuation">.</span><span class="token function">getObject</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
					<span class="token keyword">this</span><span class="token punctuation">.</span>earlySingletonObjects<span class="token punctuation">.</span><span class="token function">put</span><span class="token punctuation">(</span>beanName<span class="token punctuation">,</span> singletonObject<span class="token punctuation">)</span><span class="token punctuation">;</span>
					<span class="token keyword">this</span><span class="token punctuation">.</span>singletonFactories<span class="token punctuation">.</span><span class="token function">remove</span><span class="token punctuation">(</span>beanName<span class="token punctuation">)</span><span class="token punctuation">;</span>
				<span class="token punctuation">}</span>
			<span class="token punctuation">}</span>
		<span class="token punctuation">}</span>
	<span class="token punctuation">}</span>
	<span class="token keyword">return</span> singletonObject<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

                  当beanB走到这里时通过beanA的beanName获取beanA，首先会尝试从singletonObjects中获取，这里肯定获取不到，因为singletonObjects的put操作是在bean初始化完成之后。所以只能通过调用之前注册的回调singletonFactory.getObject()来获取beanA。
                  那么到此beanA注入到beanB的顺利完成，当beanB初始化完成之后，其实beanA的getBean()也就返回了beanB的引用，到此beanA也可以顺利完成依赖注入。

                  Spring源码解读之@Autowired如何解决循环依赖
                  scientificCommunity的博客
                  10-22 7533
                  文章目录@Autowired的what&how什么是循环依赖spring如何解决循环依赖 @Autowired的what&how 在spring框架下，我们可以通过@Autowired注解对属性或者方法参数进行标注，当spring ioc容器初始化时，会帮我们从容器中拿到对应的实例进行注入 什么是循环依赖 加入现在有两个Bean如下所示 public class BeanA { @Autowired private BeanB beanB; } public class B
                  springboot解决@Autowired注入service时出现循环依赖问题
                  翱翔-蓝天
                  02-22 2764
                  ChatGPT:Spring推荐使用构造器注入来解决依赖问题，因为它可以保证所需的依赖在对象创建时就完全初始化。但是，如果两个Bean相互依赖，即使是通过构造器注入也无法解决循环依赖的问题。这种情况下，你可能需要重新考虑你的设计。在某些情况下，你可以通过将注解与注解结合使用来解决循环依赖的问题。注解确保Bean在首次使用时才被创建，而不是在启动时就创建。例如，如果有两个服务和相互依赖，你可以在其中一个服务中使用注解来延迟依赖的注入： 3. 分解循环依赖 循环依赖通常是设计上的缺陷。你可以通过重新设计应用的架
                  《Spring 框架必知必会：@Autowired 依赖注入的底层原理与场景实践》​
                  最新发布
                  2401_83923080的博客
                  03-30 1134
                  `@Autowired` 是 Spring 框架中用于实现 **依赖注入（Dependency Injection, DI）** 的核心注解之一。它的核心作用是自动装配 Bean，简化代码中对依赖对象的显式获取和管理。以下是详细解析： --- ### **一、核心作用** 1. **自动注入依赖** 自动查找匹配的 Bean 并注入到目标对象中，无需手动通过 `new` 或 `ApplicationContext.getBean()` 创建对象。 2. **降低耦合** 通过依赖注入
                  spring使用@Autowired @Lazy 注解 解决循环依赖
                  mischen520的博客
                  12-21 2319
                  业务代码是在spring的事务中引入了自身的依赖，导致自己调用自己的时候通过@Autowired是进行引入，但是查询发现这个service被其他的controller层调用，而其他的controller层调用的这个代码又引起了循环依赖，所以导致项目启动报错。在 Spring 容器中，当我们需要使用某个类的时候，如果这个类需要依赖于其他类，在使用 @Autowired 注解的情况下，Spring 就会自动查找并注入所需的依赖。定位问题原因，发现是spring的循环依赖问题。那么，什么是循环依赖呢？
                  手把手教你解决循环依赖，一步一步地来窥探出三级缓存的奥秘
                  阳阳的博客
                  10-03 3917
                  先不去管Spring中的循环依赖，我们先实现一个自定义注解，来模拟@Autowired的功能。 一、自定义注解模拟@Autowired 自定义Load注解，被该注解标识的字段，将会进行自动注入 /** * @author qcy * @create 2021/10/02 13:31:20 */ //只用在字段上 @Target(ElementType.FIELD) //运行时有效，这样可以通过反射解析注解 @Retention(RetentionPolicy.RUNTIME) public @
                  循环依赖问题场景和解决方案
                  洛笙的博客
                  01-11 551
                  场景2:使用 @RequiredArgsConstructor注入bean,配置也增加 spring.main.allow-circular-references=true了，但还是出现了循环依赖问题，项目启动失败?循环依赖产生,所以Spring框架采用三级缓存解决掉了循环依赖问题，Spring三级缓存具体怎么解决的不在本章做过多描述。Spring循环依赖发生原因：A类注入B类,B类注入A类,导致bean在初始化时，循环注入，导致谁都无法成功注入成功，如下图。或者yaml文件增加。
                  学习感悟，以及Spring中的循环依赖是如何解决的
                  weixin_61789925的博客
                  09-26 349
                  循环依赖的定义很容易理解，假如有两个类：Demo01,Demo02,@Component}}@Component}}}可以看到，Demo01和Demo02互相依赖了对方，如果这样测试会发生什么呢@Test}}在进行测试的时候，会弹出这样的报错：意思是在 Demo01需要通过构造函数注入的Demo02实例（或者Demo02中声明的Bean），而Demo02需要通过构造函数注入的 Demo01的实例（或者 Demo01中声明的Bean）。
                  循环依赖-Autowired方式
                  只作为个人备忘录
                  06-04 768
                  @Autowired方式 例子 @Component public class TestA { @Autowired private TestB testB; } @Component public class TestB { @Autowired private TestA testA; } TestA开始，AbstractBeanFactory.doGetBean方法开始分析，getSingleton一级缓存获取beanName，结果null protected
                  Intellij IDEA如何去掉@Autowired 注入警告的方法
                  08-19
                  首先，让我们了解为什么Intellij IDEA会显示红色告警。当我们在Service层注入Mybatis的Mapper时，我们通常会使用@Autowired 自动注入。但是，这时候Intellij IDEA会显示红色告警，提示不能自动注入。这是因为IDEA...
                  Spring依赖注入推荐使用构造函数注入而非@Autowired
                  谷哥的小弟
                  09-30 1369
                  在Spring框架中，依赖注入（Dependency Injection, DI）是实现组件之间松耦合的关键技术。Spring支持多种依赖注入方式，其中构造函数注入和基于@Autowired注解的注入是两种常见的方法。然而，Spring官方以及许多经验丰富的开发者更倾向于推荐使用构造函数注入。接下来，我们将详细解释为什么构造函数注入是更好的选择，以及它与@Autowired注解注入之间的主要区别。
                  @Autowired(required=false)注入注意的问题
                  热门推荐
                  static_coder的博客
                  03-16 12万+
                  1、前言在使用spring开发过程中，我们基本上都是使用@Autowired这个注解，用来注入已有的bean。但是有些时候，会注入失败。当我们加上参数（required=false）就能解决。今天整理一个我在实际开发中的例子2、required属性@Autowired(required=true)：当使用@Autowired注解的时候，其实默认就是@Autowired(required=true)...
                  基于SpringBoot构造器注入循环依赖及解决方式
                  09-16
                  主要介绍了基于SpringBoot构造器注入循环依赖及解决方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
                  Springboot循环依赖
                  qq_42443497的博客
                  12-03 566
                  ……
                  Spring源码学习--Bean对象循环依赖问题解决（四）
                  井底之蛙
                  07-05 6336
                  循环依赖就是N个类相互嵌套引用，如果通过new对象的方式产生循环依赖的话会导致程序内存溢出报错，接下来我们了解一下spring是如何解决循环依赖问题。第一种：prototype原型bean循环依赖对于原型bean的初始化过程中不论是通过构造器参数循环依赖还是通过setXxx方法产生循环依赖，Spring都会直接报错处理。AbstractBeanFactory.doGetBean()方法：if (i
                  【Spring】Spring是如何解决循环依赖问题的
                  weixin_45325628的博客
                  03-12 1456
                  不过要注意，构造器注入的循环依赖是无法解决的，因为构造器注入需要先完成实例化，而实例化的时候就需要依赖的Bean已经存在。需要提醒他们在遇到循环依赖时，检查异常信息，确定是哪种类型的循环依赖，以及Spring是否支持解决。总结一下，回答中需要涵盖：三级缓存机制、处理流程（实例化、提前暴露引用）、构造器注入和原型Bean的限制，以及如何避免循环依赖的建议。另外，Spring只能解决单例作用域的Bean的循环依赖。首先，我得回忆一下循环依赖的定义，就是两个或多个Bean相互依赖，比如A依赖B，B又依赖A。
                  Spring之Bean自注入问题之@Autowired进来的Bean为null ＜=== 循环依赖大致处理过程
                  Be_insighted的博客
                  11-24 3033
                  使用spring事务时，需要调用自身的其他方法，通常使用自注入解决问题。这种方式处理起来简单方便，如果自注入后再要用这个bean中注入的其他bean，会报空指针异常！ @Autowired field方式注入，属性注入 @Resource 和 @Autowired的区别： 都是用来自动装配的，都放在属性字段上 @Autowired 通过byType的方式实现，而且必须要求这个对象存在！【常用】 @Resource 默认通过byname的方式实现，如果找不到名字，则通过byTyp...
                  @Autowired @Lazy 注解 解决循环依赖
                  Dyson_HQ的博客
                  02-28 4761
                  项目报错This is often the result of over-eager type matching 　　今天启动项目时报错：org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name ‘colorController’: Unsatisfied dependency expressed through field ‘jobService’; nested exce
                  Spring对循环依赖注入的处理
                  Brucelwl的博客
                  08-08 783
                  默认单实例情况下，通过字段循环依赖不会报错，可以互相依赖 @Component public class BeanA { private static final Logger logger = LoggerFactory.getLogger(BeanA.class); @Autowired private BeanB beanB; public void print() { logger.info("hello springboot !"); }
                  spring避免循环依赖
                  qq_27886773的博客
                  09-15 689
                  spring避免循环依赖： 参见数《Spring源码深度解析》，第98页 什么是循环依赖，例如A引用B，B引用C，C引用A。 1.如果通过构造器注入构成的循环依赖，这种情况下是没有办法解决的。例如如下配置： <bean id="A" class="A"> <constructor-arg index="0" ref="B"> </bean> <...
                  @Autowired如何解决循环依赖
                  09-20
                  @Autowired注解可以用来自动装配Bean，但在某些情况下，可能会出现循环依赖的问题。循环依赖是指两个或多个Bean之间相互依赖，无法正确实例化的情况。 为了解决循环依赖，Spring提供了三种解决方案： 1. Setter注入：使用setter方法而不是构造函数进行依赖注入。这样可以先创建Bean对象，然后再注入依赖。 2. 构造函数注入：使用构造函数进行依赖注入，并且使用@Qualifier注解来指定Bean的名称，以确保正确的依赖注入顺序。 3. 使用@Lazy注解：将Bean的初始化过程延迟到第一次使用时。这样可以避免循环依赖的问题，在需要使用Bean时再进行初始化。 如果以上方法都无法解决循环依赖的问题，可以考虑通过改变设计来消除循环依赖，或者使用代理模式等其他解决方案。
                  评论 1
                  添加红包

                  请填写红包祝福语或标题

                  个

                  红包个数最小为10个

                  元

                  红包金额最低5元

                  当前余额3.43元 前往充值 >
                  需支付：10.00元
                  成就一亿技术人!
                  领取后你会自动成为博主和红包主的粉丝 规则
                  hope_wisdom
                  发出的红包
                  实付元
                  使用余额支付
                  点击重新获取
                  扫码支付
                  钱包余额 0

                  抵扣说明：

                  1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
                  2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

                  余额充值