面试题 Spring bean 循环依赖解决方案以及三级缓存讲解

文章目录

- Spring bean 循环依赖
- - 1.1 什么是循环依赖
  - 1.2 Spring循环依赖几种情况
- 什么是三级缓存到底是什么东西，三级缓存做了什么？
- - 三级缓存源码讲解

Spring bean 循环依赖

1.1 什么是循环依赖

当面试官问到你给我讲一下什么是循环依赖吧，该如何回答可以参考一下话术

spring的循环依赖就是在代码中接口互相调用产生的情况列入接口a引用接口b 接口b引用接口a 形成一种闭环的引用关系，而不是指循环调用

循环调用：

循环调用是指方法之间的互相调用，形成一个闭环。如果没有适当的终止条件，这种调用会导致无限循环，最终可能导致栈溢出（StackOverflowError）或其他运行时错误。

1.2 Spring循环依赖几种情况

在Spring框架中，Bean的循环依赖主要可以分为以下几种情况：

构造器参数循环依赖：
当两个Bean通过构造器参数互相依赖时，Spring无法解决这种依赖。这是因为在创建任何一个Bean之前都需要另一个Bean已经创建完毕，这会导致创建过程陷入死锁状态。在这种情况下，Spring将会抛出BeanCurrentlyInCreationException异常。

在这里插入图片描述

setter方式单例循环依赖：
如果两个单例（singleton）模式的Bean通过setter方法互相依赖，Spring可以通过在Bean创建过程中提前暴露一个还未完全初始化的Bean实例来解决循环依赖。具体来说，当一个Bean的构造器执行完毕后，它会被暂时放入一个称为"singleton cache"的缓存中。如果此时另一个正在创建的Bean请求依赖于这个Bean，那么Spring就会提供这个部分创建好的Bean实例。
setter方式原型循环依赖：
对于原型（prototype）模式的Bean，Spring同样不能解决循环依赖问题。因为原型模式下的Bean每次获取都会创建一个新的实例，所以提前暴露部分创建好的实例策略并不适用。因此，对于原型模式的Bean，应该避免出现循环依赖的情况。这个补充一下我都在类上加了@Scope(“prototype”) 没有截图到

在这里插入图片描述

// 可以使用@Lazy 解决循环依赖问题

此外，还有一些其他的策略可以帮助解决或避免循环依赖，比如：

使用@Lazy注解来延迟加载Bean，但这通常用于解决某些特定情况下的循环依赖，而不是通用解决方案。

spring自身其中构造器循环依赖是无法解决的，当循环依赖通过构造器注入的时候，无论这些bean是单例作用域还是原型原型都会报错，spring自身无法解决只能是通过在构造器参里面加@Lazy注解然后调用接口才可以用。
在这里插入图片描述

面试官可能要问了，难道我要在所有的构造器上加@Lazy注解吗？
可以直接告诉他你想在哪里面构造器参数里面加@Lazy注解都可以

在这里插入图片描述

如果都不加就该报错了。类使用构造器循环依赖也可以使用@Lazy

Spring框架中的Bean循环依赖通常指的是两个或多个Bean之间相互依赖的情况。当这种情况发生时，Spring启动的时候容器会创建这些Bean，由于循环依赖形成了圆形的顺时针请求都无法获取到结果导致都无法创建成功。如果只在一个构造器参数上加上@Lazy注解，这实际上意味着Spring将把该Bean设置为懒加载模式。
所以bean引用该懒加载的只需要知道有这样一个Bean存在即可，而不需要立即实例化它。这样就解决了spring循环依赖的问题

重新设计Bean之间的依赖关系，尽可能地消除循环依赖。
还有网上说使用@DependsOn注解来明确指定Bean的初始化顺序能解决spring bean循环依赖问题，我经过各种尝试始终没有成功。我对@DependsOn的理解就是保证了bean的加载顺序，如果要解决循环依赖问题有点悬，我的理解是虽然我指定a首先加载，但是在加载过程中是要是要知道b的bean的，此时b的bean并没有创建好，a也无法创建成功。目前我没有找到一个demo代码能够证明spring的@DependsOn能够解决循环依赖问题。如果有能证明的例子或者答案请告诉我，我进行改正，谢谢（爱你木木哒）

什么是三级缓存到底是什么东西，三级缓存做了什么？

首先我个人面试过程中很少有问道三级缓存，我也是看面试题，但是也是对三级缓存狗屁不懂。
那到底是什么呢，是我要写的代码还是底层代码呢，最初我是真的不知道。也是在最近我刷面试题，到底什么是三级缓存我产生了质疑和疑问，就开始网上各种找资料，发现大家要嘛照搬，要嘛只是说一下什么是三级缓存还是没有告诉我什么是三级缓存，甚至很少的文章能告诉我到底是不是我要写的代码！在经过我的不断的整理与调查也算是有了自己的一套的理解，我就分享给大家，让不知道的人看到我这篇文章也能知道！

三级缓存源码讲解

首先说明spring循环依赖的三级缓存是spring底层帮我们实现的，意思就是底层源码

在这里插入图片描述

当对象之间存在相互依赖关系，形成一个闭环列如a接口里面引用了b，b里面又引用了a接口

这是三级缓存源码
在这里插入图片描述

源码讲解

首先我们要搞清楚什么情况下才会需要三级缓存

全局查找文件：AbstractAutowireCapableBeanFactory源码类

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {

	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) { // 如果是单例Bean
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); // 尝试从缓存中获取实例
	}
	if (instanceWrapper == null) { // 如果没有找到，则创建一个新的Bean实例
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = instanceWrapper.getWrappedInstance(); // 获取实例化的Bean
	Class<?> beanType = instanceWrapper.getWrappedClass(); // 获取Bean的类型
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType; // 设置Bean的目标类型
	}

	// 允许Bean定义后处理器修改合并后的Bean定义
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); // 应用Bean定义后处理器
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex); // 抛出异常
			}
			mbd.postProcessed = true; // 标记为已处理
		}
	}

	// 为了能够解决循环引用问题，尽早地缓存单例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"); // 记录日志
		}
		//三级缓存的bean从这里添加
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); // 添加单例工厂
	}

	// 初始化Bean实例
	Object exposedObject = bean; // 默认暴露的Bean对象就是原始Bean对象
	try {
		populateBean(beanName, mbd, instanceWrapper); // 填充Bean属性
		exposedObject = initializeBean(beanName, exposedObject, mbd); // 初始化Bean
	}
	catch (Throwable ex) {
		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
			throw (BeanCreationException) ex; // 抛出异常
		}
		else {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); // 抛出异常
		}
	}

	if (earlySingletonExposure) { // 如果之前进行了早期暴露
		Object earlySingletonReference = getSingleton(beanName, false); // 获取单例引用，在这里才是进入了三级缓存方法源码内
		if (earlySingletonReference != null) { // 如果存在单例引用
			if (exposedObject == bean) { // 替换暴露的对象
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { // 验证依赖关系
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				for (String dependentBean : dependentBeans) {
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) { // 如果存在依赖Bean
					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."); // 抛出异常
				}
			}
		}
	}

	// 注册可销毁的Bean
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd); // 注册可销毁的Bean
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); // 抛出异常
	}

	return exposedObject; // 返回初始化后的Bean
}

Spring源码三级缓存的定义

// 一级缓存
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);

一级缓存
这个缓存用于存储已经完全初始化完成的单例Bean。一旦一个Bean被初始化并且所有的生命周期回调都已完成，它就会被放入这个缓存中。之后，任何对该Bean的请求都将直接从这个缓存中获取，而不需要再次初始化。
二级缓存
这个缓存用于存储那些尚未完全初始化但已经实例化完成的单例Bean。它主要用于解决循环依赖的问题。当Spring检测到两个单例Bean之间存在循环依赖时，它会在初始化过程中将这些Bean暂时存储在这个缓存中，以便其他Bean可以访问到一个尚未完全初始化的版本。
三级缓存
这个缓存用于存储单例Bean的工厂函数。当Spring开始创建一个单例Bean时，它会首先创建一个工厂函数，并将该工厂函数存储在这个缓存中。这样做是为了在初始化过程中，如果其他Bean请求这个尚未完全初始化的Bean，Spring可以通过这个工厂函数返回一个临时的、部分初始化的Bean实例。

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从一级缓存中获取单例Bean
    Object singletonObject = this.singletonObjects.get(beanName);
    
    // 如果一级缓存中没有找到，并且当前Bean正在创建过程中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 同步访问二级缓存和三级缓存
        synchronized (this.singletonObjects) {
            // 再次检查二级缓存
            singletonObject = this.earlySingletonObjects.get(beanName);
            
            // 如果二级缓存中也没有找到，并且允许提前引用
            if (singletonObject == null && allowEarlyReference) {
                // 从三级缓存中获取单例Bean的工厂
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                
                // 如果找到了工厂
                if (singletonFactory != null) {
                    // 使用工厂创建Bean实例
                    singletonObject = singletonFactory.getObject();
                    
                    // 将新创建的Bean实例放入二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    
                    // 从三级缓存中移除工厂
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    
    // 返回找到的单例Bean实例
    return singletonObject;
}