Spring循环依赖

已于 2025-04-06 13:36:18 修改
阅读量1.9k 收藏 48
点赞数 37
CC 4.0 BY-SA版权
分类专栏： # spring源码 文章标签： spring java
于 2025-04-06 13:23:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40463629/article/details/147012675

文章目录

循环依赖是什么？

循环依赖，其实就是循环引用，就是两个或者两个以上的 Bean 互相引用对方，最终形成一个闭环，如 A 依赖 B，B 依赖 C，C 依赖 A。

Spring中三大循环依赖场景

Spring 只处理单例 Bean 的循环依赖，原型模式的 Bean 如果存在循环依赖直接抛出异常，单例 Bean 的循环依赖的场景有两种：

  1. 构造器注入出现循环依赖
  2. 字段（或 Setter）注入出现循环依赖

对于构造器注入出现缓存依赖，Spring 是无法解决的，因为当前 Bean 还未实例化，无法提前暴露对象，所以只能抛出异常。

构造器注入循环依赖

@Service
public class A {
    public A(B b) {
    }
}
@Service
public class B {
    public B(A a) {
    }
}

结果：项目启动失败抛出异常BeanCurrentlyInCreationException

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:339)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:215)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199)

field属性注入（setter方法注入）循环依赖

这种方式是我们最最最最为常用的依赖注入方式（所以猜都能猜到它肯定不会有问题啦）：

@Service
public class A {
    @Autowired
    private B b;
}

@Service
public class B {
    @Autowired
    private A a;
}

结果：项目启动成功，能够正常work

prototype field属性注入循环依赖

prototype在平时使用情况较少，但是也并不是不会使用到，因此此种方式也需要引起重视。

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Service
public class A {
    @Autowired
    private B b;
}

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Service
public class B {
    @Autowired
    private A a;
}

结果：需要注意的是本例中启动时是不会报错的（因为非单例Bean默认不会初始化，而是使用时才会初始化），所以很简单咱们只需要手动getBean()或者在一个单例Bean内@Autowired一下它即可

// 在单例Bean内注入
@Autowired
private A a;

这样子启动就报错：

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'mytest.TestSpringBean': Unsatisfied dependency expressed through field 'a'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'a': Unsatisfied dependency expressed through field 'b'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'b': Unsatisfied dependency expressed through field 'a'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?

	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:596)
	at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:90)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessProperties(AutowiredAnnotationBeanPostProcessor.java:374)

循环依赖原理

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	...
	// 从上至下 分表代表这“三级缓存”
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 二级缓存
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 三级缓存
	...
	
	/** Names of beans that are currently in creation. */
	// 这个缓存也十分重要：它表示bean创建过程中都会在里面呆着~
	// 它在Bean开始创建时放值，创建完成时会将其移出~
	private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/** Names of beans that have already been created at least once. */
	// 当这个Bean被创建完成后，会标记为这个 注意：这里是set集合 不会重复
	// 至少被创建了一次的  都会放进这里~~~~
	private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
	// ...
}

首先，我需要明确这三个缓存的作用：
一级缓存（singletonObjects）​：存储已经完全初始化好的单例Bean。
二级缓存（earlySingletonObjects）​：存储早期的Bean引用，这些Bean已经实例化但尚未完成初始化（如属性填充）。
三级缓存（singletonFactories）​：存储Bean的ObjectFactory，用于创建早期的Bean实例。

在这里插入图片描述

以上面A、B类使用属性field注入循环依赖的例子为例，对整个流程做文字步骤总结如下：

  1. 使用context.getBean(A.class)，旨在获取容器内的单例A(若A不存在，就会走A这个Bean的创建流程)，显然初次获取A是不存在的，因此走A的创建之路~
  2. 实例化A（注意此处仅仅是实例化），并将它放进缓存（此时A已经实例化完成，已经可以被引用了）
  3. 初始化A：@Autowired依赖注入B（此时需要去容器内获取B）
  4. 为了完成依赖注入B，会通过getBean(B)去容器内找B。但此时B在容器内不存在，就走向B的创建之路~
  5. 实例化B，并将其放入缓存。（此时B也能够被引用了）
  6. 初始化B，@Autowired依赖注入A（此时需要去容器内获取A）
  7. 此处重要：初始化B时会调用getBean(A)去容器内找到A，上面我们已经说过了此时候因为A已经实例化完成了并且放进了缓存里，所以这个时候去看缓存里是已经存在A的引用了的，所以getBean(A)能够正常返回
  8. B初始化成功（此时已经注入A成功了，已成功持有A的引用了），return（注意此处return相当于是返回最上面的getBean(B)这句代码，回到了初始化A的流程中~）。
  9. 因为B实例已经成功返回了，因此最终A也初始化成功
  10. 到此，B持有的已经是初始化完成的A，A持有的也是初始化完成的B

尝试从缓存中获取单例 Bean

在这里插入图片描述

在AbstractBeanFactory刚开始初始化bean的时候，会先调用getSingleton方法，首先会从缓存中尝试获取对象，对应代码段：

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
	// ...
    // 先从缓存（仅缓存单例 Bean ）中获取 Bean 对象，这里缓存指的是 3 个 Map
    // 缓存中也可能是正在初始化的 Bean，可以避免循环依赖注入引起的问题
    Object sharedInstance = getSingleton(beanName);
	// ...
}

// DefaultSingletonBeanRegistry.java

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


protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 尝试从一级缓存singletonObjects获取Bean：如果找到了就直接返回，否则进入后续处理。
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果一级缓存中不存在，且当前 beanName 正在创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 对 singletonObjects 加锁
        synchronized (this.singletonObjects) {
            // 从二级缓存earlySingletonObjects获取Bean：如果存在，则直接返回，避免重复创建。
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果二级缓存earlySingletonObjects中不存在，且允许提前创建
            if (singletonObject == null && allowEarlyReference) {
                // 则从三级缓存singletonFactories获取ObjectFactory，并通过它创建Bean实例
                // 然后将该实例放入二级缓存，并从三级缓存移除对应的ObjectFactory。
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                // 如果从三级缓存singletonFactories中存在对应的对象，则进行下面的处理
                if (singletonFactory != null) {
                    // 调用 ObjectFactory#getOject() 方法，获取目标 Bean 对象（早期半成品）
                    singletonObject = singletonFactory.getObject();
                    // 将目标对象放入二级 Map
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 从三级 Map移除 beanName
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    // 返回从缓存中获取的对象
    return singletonObject;
}

这里的缓存指的就是上面三个 Map 对象：

  • singletonObjects（一级 Map）：里面保存了所有已经初始化好的单例 Bean，也就是会保存 Spring IoC 容器中所有单例的 Spring Bean
  • earlySingletonObjects（二级 Map），里面会保存从 三级 Map 获取到的正在初始化的 Bean
  • singletonFactories（三级 Map），里面保存了正在初始化的 Bean 对应的ObjectFactory实现类，调用其getObject()方法返回正在初始化的 Bean 对象（仅实例化还没完全初始化好）

getSingleton()从缓存里获取单例对象步骤分析可知，Spring解决循环依赖的诀窍：就在于singletonFactories这个三级缓存。这个Cache里面都是ObjectFactory，它是解决问题的关键。

初始化Bean

会进入getSingleton的另外一个重载方法getSingleton(beanName, singletonFactory)。

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
	// ...
    if (mbd.isSingleton()) { // 单例模式
        /*
         * 创建 Bean，成功创建则进行缓存，并移除缓存的早期对象
         * 创建过程实际调用的下面这个 `createBean(...)` 方法
         */
        sharedInstance = getSingleton(beanName,
                // ObjectFactory 实现类
                () -> {
                    try {
                        // 【核心】 创建 Bean
                        return createBean(beanName, mbd, args);
                    } catch (BeansException ex) {
                        // 如果创建过程出现异常，则显式地从缓存中删除当前 Bean 相关信息
                        // 在单例模式下为了解决循环依赖，创建过程会缓存早期对象，这里需要进行删除
                        destroySingleton(beanName);
                        throw ex;
                    }
        });
        // <9.1.2> 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
        // 否则，调用 FactoryBean#getObject() 获取目标对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
	// ...
}

AbstractAutowireCapableBeanFactory的doCreateBean方法中提前暴露当前 Bean，在获取到实例对象后，如果是单例模式，则提前暴露这个实例对象，对应代码段：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
	// ...
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
		// ...
		// 创建Bean对象，并且将对象包裹在BeanWrapper 中
		instanceWrapper = createBeanInstance(beanName, mbd, args);
		// 再从Wrapper中把Bean原始对象（非代理~~~）  这个时候这个Bean就有地址值了，就能被引用了~~~
		// 注意：此处是原始对象，这点非常的重要
		final Object bean = instanceWrapper.getWrappedInstance();
		// ...
		// earlySingletonExposure 用于表示是否”提前暴露“原始对象的引用，用于解决循环依赖。
		// mbd.isSingleton()仅对单例Bean处理循环依赖（原型Bean不支持循环依赖）
		// this.allowCircularReferences是否允许循环依赖（默认true，可通过配置关闭）。
		// isSingletonCurrentlyInCreation(beanName)判断当前单例bean是否正在被创建，在前面已经标记过
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
			}
			// 重点：在这里往三级缓存singletonFactories中放进一个ObjectFactory
			// getEarlyBeanReference的作用：调用SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference()这个方法  否则啥都不做
			// 也就是给调用者个机会，自己去实现暴露这个bean的应用的逻辑~~~
			// 比如在getEarlyBeanReference()里可以实现AOP的逻辑~~~  参考自动代理创建器AbstractAutoProxyCreator  实现了这个方法来创建代理对象
			// 若不需要执行AOP的逻辑，直接返回Bean
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		Object exposedObject = bean; //exposedObject 是最终返回的对象
		...
		// 填充属于，解决@Autowired依赖~
		populateBean(beanName, mbd, instanceWrapper);
		// 执行初始化回调方法们~~~
		exposedObject = initializeBean(beanName, exposedObject, mbd);
		
		// earlySingletonExposure：如果你的bean允许被早期暴露出去 也就是说可以被循环引用  那这里就会进行检查
		// 此段代码非常重要~~~~~但大多数人都忽略了它
		if (earlySingletonExposure) {
			// 此时一级缓存肯定还没数据，但是呢此时候二级缓存earlySingletonObjects也没数据
			//注意，注意：第二参数为false  表示不会再去三级缓存里查了~~~

			// 此处非常巧妙的一点：：：因为上面各式各样的实例化、初始化的后置处理器都执行了，如果你在上面执行了这一句
			//  ((ConfigurableListableBeanFactory)this.beanFactory).registerSingleton(beanName, bean);
			// 那么此处得到的earlySingletonReference 的引用最终会是你手动放进去的Bean最终返回，完美的实现了"偷天换日" 特别适合中间件的设计
			// 我们知道，执行完此doCreateBean后执行addSingleton()  其实就是把自己再添加一次  **再一次强调，完美实现偷天换日**
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
			
				// 这个意思是如果经过了initializeBean()后，exposedObject还是木有变，那就可以大胆放心的返回了
				// initializeBean会调用后置处理器，这个时候可以生成一个代理对象，那这个时候它哥俩就不会相等了 走else去判断吧
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				} 

				// allowRawInjectionDespiteWrapping这个值默认是false
				// hasDependentBean：若它有依赖的bean 那就需要继续校验了~~~(若没有依赖的 就放过它~)
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					// 拿到它所依赖的Bean们~~~~ 下面会遍历一个一个的去看~~
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					
					// 一个个检查它所以Bean
					// removeSingletonIfCreatedForTypeCheckOnly这个放见下面  在AbstractBeanFactory里面
					// 简单的说，它如果判断到该dependentBean并没有在创建中的了的情况下,那就把它从所有缓存中移除~~~  并且返回true
					// 否则（比如确实在创建中） 那就返回false 进入我们的if里面~  表示所谓的真正依赖
					//（解释：就是真的需要依赖它先实例化，才能实例化自己的依赖）
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}

					// 若存在真正依赖，那就报错（不要等到内存移除你才报错，那是非常不友好的） 
					// 这个异常是BeanCurrentlyInCreationException，报错日志也稍微留意一下，方便定位错误~~~~
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}
		
		return exposedObject;
	}

	// 虽然是remove方法 但是它的返回值也非常重要
	// 该方法唯一调用的地方就是循环依赖的最后检查处~~~~~
	protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName) {
		// 如果这个bean不在创建中  比如是ForTypeCheckOnly的  那就移除掉
		if (!this.alreadyCreated.contains(beanName)) {
			removeSingleton(beanName);
			return true;
		}
		else {
			return false;
		}
	}

}

设置三级缓存

BeanA走到这里，会在三级缓存中暴露一个BeanA的ObjectFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
	// ...
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
		// ...
		// earlySingletonExposure 用于表示是否”提前暴露“原始对象的引用，用于解决循环依赖。
		// mbd.isSingleton()仅对单例Bean处理循环依赖（原型Bean不支持循环依赖）
		// this.allowCircularReferences是否允许循环依赖（默认true，可通过配置关闭）。
		// isSingletonCurrentlyInCreation(beanName)判断当前单例bean是否正在被创建，在前面已经标记过
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
			}
			// 重点：在这里往三级缓存singletonFactories中放进一个ObjectFactory
			// getEarlyBeanReference的作用：调用SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference()这个方法  否则啥都不做
			// 也就是给调用者个机会，自己去实现暴露这个bean的应用的逻辑~~~
			// 比如在getEarlyBeanReference()里可以实现AOP的逻辑~~~  参考自动代理创建器AbstractAutoProxyCreator  实现了这个方法来创建代理对象
			// 若不需要执行AOP的逻辑，直接返回Bean
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		Object exposedObject = bean; //exposedObject 是最终返回的对象
		...
	}
}

通过 Lambda 表达式创建一个ObjectFactory实现类，如下：

// AbstractAutowireCapableBeanFactory.java
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    // RootBeanDefinition 不是用户定义的（由 Spring 解析出来的）
    if (!mbd.isSynthetic() 
        && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

它实际上就是调用了SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference，而真正实现了这个方法的后置处理器只有AbstractAutoProxyCreator，与Aop相关。

SmartInstantiationAwareBeanPostProcessor

然后调用addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory)方法，如下：

// DefaultSingletonBeanRegistry.java
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

可以看到会往singletonFactories集合（三级 Map）中添加当前beanName和singletonFactory（ObjectFactory实现类）的映射关系；
从earlySingletonObjects集合（二级 Map）中移除当前beanName；
往registeredSingletons集合（已注册的 Bean 的名称集合）中添加当前beanName。

升级二级缓存

AbstractAutowireCapableBeanFactory的populateBean方法中会解析BeanA的依赖，发现需要BeanB，然后再次调用getBean方法，构造BeanB，对应代码段：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
	// ...
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
		// ...
		// 填充属于，解决@Autowired依赖~
		populateBean(beanName, mbd, instanceWrapper);
		// ...
	}
}

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
		@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
	// ...
	if (instanceCandidate instanceof Class) {
		//创建这个依赖对象，进行getBean操作
		instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
	}
	// ...
}

public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
		throws BeansException {
	return beanFactory.getBean(beanName);
}

具体看AutowiredAnnotationBeanPostProcessor源码解析

然后BeanB在初始化过程中走到populateBean方法，调用getBean方法去获取BeanA。

因为此时BeanA已经在三级缓存中了，调用getSingleton方法就会将BeanA从三级缓存升级到二级缓存，并用来构造BeanB。

在AbstractBeanFactory刚开始初始化bean的时候，会先调用getSingleton方法，首先会从缓存中尝试获取对象，对应代码段：

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
	// ...
    // 先从缓存（仅缓存单例 Bean ）中获取 Bean 对象，这里缓存指的是 3 个 Map
    // 缓存中也可能是正在初始化的 Bean，可以避免循环依赖注入引起的问题
    Object sharedInstance = getSingleton(beanName);
	// ...
}

// DefaultSingletonBeanRegistry.java

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


protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 尝试从一级缓存singletonObjects获取Bean：如果找到了就直接返回，否则进入后续处理。
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果一级缓存中不存在，且当前 beanName 正在创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 对 singletonObjects 加锁
        synchronized (this.singletonObjects) {
            // 从二级缓存earlySingletonObjects获取Bean：如果存在，则直接返回，避免重复创建。
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果二级缓存earlySingletonObjects中不存在，且允许提前创建
            if (singletonObject == null && allowEarlyReference) {
                // 则从三级缓存singletonFactories获取ObjectFactory，并通过它创建Bean实例
                // 然后将该实例放入二级缓存，并从三级缓存移除对应的ObjectFactory。
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                // 如果从三级缓存singletonFactories中存在对应的对象，则进行下面的处理
                if (singletonFactory != null) {
                    // 调用 ObjectFactory#getOject() 方法，获取目标 Bean 对象（早期半成品）
                    singletonObject = singletonFactory.getObject();
                    // 将目标对象放入二级 Map
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 从三级 Map移除 beanName
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    // 返回从缓存中获取的对象
    return singletonObject;
}

升级一级缓存

会进入getSingleton的另外一个重载方法getSingleton(beanName, singletonFactory)。

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
	// ...
    if (mbd.isSingleton()) { // 单例模式
        /*
         * 创建 Bean，成功创建则进行缓存，并移除缓存的早期对象
         * 创建过程实际调用的下面这个 `createBean(...)` 方法
         */
        sharedInstance = getSingleton(beanName,
                // ObjectFactory 实现类
                () -> {
                    try {
                        // 【核心】 创建 Bean
                        return createBean(beanName, mbd, args);
                    } catch (BeansException ex) {
                        // 如果创建过程出现异常，则显式地从缓存中删除当前 Bean 相关信息
                        // 在单例模式下为了解决循环依赖，创建过程会缓存早期对象，这里需要进行删除
                        destroySingleton(beanName);
                        throw ex;
                    }
        });
        // <9.1.2> 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
        // 否则，调用 FactoryBean#getObject() 获取目标对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
	// ...
}

在createBean创建ObjectFactory后，getSingleton会调用singletonFactory.getObject()创建一个Bean后添加到一级缓存singletonObjects中

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	// ...
    try {
        // 上游传入的lambda在这里会被执行，调用createBean方法创建一个Bean后返回
        singletonObject = singletonFactory.getObject();
        newSingleton = true;
    }
    // ...
    // 省略catch异常处理
    // ...
    finally {
        if (recordSuppressedExceptions) {
            this.suppressedExceptions = null;
        }
        // 创建完成后将对应的beanName从singletonsCurrentlyInCreation移除
        afterSingletonCreation(beanName);
    }
    if (newSingleton) {
        // 添加到一级缓存singletonObjects中
        addSingleton(beanName, singletonObject);
    }
    // ...
    return singletonObject;
}

在完全初始化好一个单例 Bean 后，会缓存起来，如下：

// DefaultSingletonBeanRegistry.java
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);
    }
}

往singletonObjects（一级 Map）存放当前单例 Bean，同时从singletonFactories（三级 Map）和earlySingletonObjects（二级 Map）中移除

【微服务】spring 循环依赖问题深入解析
congge_study的博客
09-05 3681
spring 循环依赖问题深入解析
spring源码系列（一）——spring循环引用
热门推荐
java_lyvee的专栏
09-30 7万+
spring循环依赖如何解的？
Spring循环引用
一个有深度的博客
08-19 2476
1. AOP注解执行顺序 注：springBoot 的版本是2.3.3.RELEASE，Spring版本5.2.8.RELEASE。 正常情况(执行顺序)： 异常情况(执行顺序)： @Around @Around ⬇ ⬇ @Before
Spring中的循环引用
最新发布
Very_a的博客
05-14 415
循环依赖发生在两个或两个以上的bean互相持有对方，形成闭环。一级缓存：单例池，缓存已完成初始化的bean对象。二级缓存：缓存尚未完成生命周期的早期bean对象。，用于创建bean对象。
spring循环引用
civil的专栏
05-06 510
当spring的bean存在循环引用时，有的情况下会报错，而有的情况下不会。影响是否会报错的因素是：1.属性是通过构造方法传递值还是通过setter传递值。2.属性是否是单例的。下面解释了四种情况、是否会报错、报错或不报错的原因。 前置知识 不论是singleton还是prototype，在创建的过程中都会有一个xxxCurrentlyInCreation的Set对象，这个Set中存放的key表示正在创建的对象，但是还没有创建完成。在对象new之前先检查这个Set中没有要创建的key，然后把要创建的对象的k
Spring 循环依赖
程序猿进阶
10-09 9568
三级缓存中的对象工厂可以确保在需要时创建代理对象，并将其放入二级缓存，从而确保代理对象可以在循环依赖中正确地被引用。时，它需要立即解析所有的构造函数参数，这会导致循环依赖问题。的代理对象来解决循环依赖问题。但从设计和架构的角度来看，尽量避免循环依赖是更好的做法。在需要时延迟创建早期引用，而不是立即创建。可能无法正确地创建代理对象，因为代理对象的创建依赖于完整的。的完全初始化的实例后，完成自身初始化，并放入一级缓存。的引用，所以最终拿到的是一个完整的。的初始化，从而解决循环依赖问题。
简单了解Spring循环依赖解决过程
08-25
Spring 循环依赖解决过程详解 Spring 框架中循环依赖是一个常见的问题，它指的是两个或多个 Bean 之间存在的相互依赖关系，例如 A 依赖 B，B 依赖 A，这种情况下，Spring 需要解决这个循环依赖关系，以便正确地实例...
Spring循环依赖的解决办法,你真的懂了吗
08-19
Spring循环依赖的解决办法 Spring框架中，循环依赖是指两个或多个Bean相互引用，形成一个环。这篇文章主要介绍了Spring循环依赖的解决办法。在Spring中，循环依赖可以分为两种场景：构造器的循环依赖和属性的循环...
Spring的循环引用
qq_43578058的博客
01-01 859
循环引用问题
spring的循环依赖
weixin_49107940的博客
04-21 448
spring的循环依赖
Spring源码 （一）Spring循环引用
github_38935808的博客
06-04 235
spring源码（一）spring循环引用Spring在默认情况下是支持循环引用的Spring的循环依赖可以关闭循环依赖无非就是属性注入两个相关概念spring bean的生命周期经历步骤spring大概在什么时候实例化bean的spring bean实例化的过程理论：源码验证：新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可
再谈Spring的循环引用
immort.L 的博客
03-02 556
1. 前言 我之前有一篇文章，也是谈的Spring的循环引用(文章链接)。文章中有我翻看源码的见解，其实那篇文章只是说了循环引用的一部分，并没有阐述“为什么需要三个级别的缓存才可以”，如果按照我上一个文章来看，貌似用两级缓存就足以解决了循环引用的问题。但是我上一个文章，只是说了普通的情况，也就是说，普通的循环引用的情况。普通的循环引用的话，直接使用两个级别的缓存的确可以解决。那么什么情况下，两个的缓存不能解决呢？ 其实这个文章好久之前都写好了。只是时间问题，没有分享出来。 这里分享出来我的见解，欢迎指正。
Spring中解决循环引用
欣淡定的博客
04-11 2669
目录 一、前言 二、源码分析 1.getBean(String name)方法 2.getSingleton(beanName)方法 3.getSingleton(String beanName, ObjectFactory singletonFactory)方法 4.createBean(beanName, mbd, args)方法 5.addSingletonFactory(beanName, singletonFactory)方法 6.addSingleton(be...
理解Spring循环引用（循环依赖）
轻松囧的专栏
08-16 1万+
test
Spring 循环依赖解决方案
sinat_34814635的博客
11-24 2万+
循环依赖就是循环引用，就是两个或多个Bean相互之间的持有对方，比如A引用B，B引用C，C引用A，则它们最终反映为一个环。结论先行：1.构造器循环依赖----初始化失败2.field属性注入循环依赖----初始化成功3.field属性注入循环依赖（prototype）----初始化失败现象总结：同样对于循环依赖的场景，构造器注入和prototype类型的属性注入都会初始化Bean失败。因为@Service默认是单例的，所以单例的属性注入是可以成功的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值