Spring，三级缓存，循环依赖问题看这篇就够了！

测试的Springboot版本: 2.6.4禁止了循环依赖但是可以通过application.yml开启哈哈Lazy注解解决循环依赖情况一只有简单属性关系的循环依赖涉及的Bean:ASerivce及其实现类ASerivceImplBSerivce及其实现类BSerivceImplcom.example.demo.service.AServicepackage com.example.demo.service; public interface AService { void zaWaLuDo(); }com.example.demo.service.impl.AServiceImplpackage com.example.demo.service.impl; import com.example.demo.service.AService; import com.example.demo.service.BService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; Service public class AServiceImpl implements AService { Autowired public BService bService; Override public void zaWaLuDo(){ System.out.println(ToKiOToMaLei!); } }com.example.demo.service.BServicepackage com.example.demo.service; public interface BService { }com.example.demo.service.impl.BServiceImplpackage com.example.demo.service.impl; import com.example.demo.service.AService; import com.example.demo.service.BService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; Service public class BServiceImpl implements BService { Autowired public AService aService; }此时ASerivce和BService构成循环依赖的关系测试类com.example.demo.service.AServiceTestpackage com.example.demo.service; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; SpringBootTest class AServiceTest { Autowired AService aService; Test public void test(){ aService.zaWaLuDo(); } }此时运行test方法将会报错java.lang.IllegalStateException: Failed to load ApplicationContext at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:132) at org.springframework.test.context.support.DefaultTestContext.getApplicationContext(DefaultTestContext.java:124) at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.injectDependencies(DependencyInjectionTestExecutionListener.java:118) at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.prepareTestInstance(DependencyInjectionTestExecutionListener.java:83) at org.springframework.boot.test.autoconfigure.SpringBootDependencyInjectionTestExecutionListener.prepareTestInstance(SpringBootDependencyInjectionTestExecutionListener.java:43) at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:248) at org.springframework.test.context.junit.jupiter.SpringExtension.postProcessTestInstance(SpringExtension.java:138) at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeTestInstancePostProcessors$8(ClassBasedTestDescriptor.java:363) at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.executeAndMaskThrowable(ClassBasedTestDescriptor.java:368) at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeTestInstancePostProcessors$9(ClassBasedTestDescriptor.java:363) ......省略..... Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name AServiceImpl: Unsatisfied dependency expressed through field bService; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name BServiceImpl: Unsatisfied dependency expressed through field aService; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name AServiceImpl: Requested bean is currently in creation: Is there an unresolvable circular reference? at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.resolveFieldValue(AutowiredAnnotationBeanPostProcessor.java:659) at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:639) at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:119)最重要的一句应该是美观处理过 Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name AServiceImpl: Unsatisfied dependency expressed through field bService; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name BServiceImpl: Unsatisfied dependency expressed through field aService; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name AServiceImpl: Requested bean is currently in creation: Is there an unresolvable circular reference?Spring提醒我们可能存在circular reference就是大名鼎鼎的循环依赖。解决办法在其中任意一个属性注入Autowired上加入懒加载Lazy即可跑通比如在AService的实现类中加入package com.example.demo.service.impl; import com.example.demo.service.AService; import com.example.demo.service.BService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; Service public class AServiceImpl implements AService { Autowired Lazy //懒加载 public BService bService; Override public void zaWaLuDo(){ System.out.println(ToKiOToMaLei!); } }此时运行测试方法test()的运行结果就是ToKiOToMaLei!说明aService.zaWaLuDo()方法执行成功源码分析参考https://www.zhihu.com/question/438247718主要是靠Spring中人为定义的三级缓存有关org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)第一级缓存**MapString, Object singletonObjects**第一级缓存的作用用于存储单例模式下创建的Bean实例已经创建完毕。该缓存是对外使用的指的就是使用Spring框架的程序员。存储什么数据Kbean的名称Vbean的实例对象, 或者说“成品”对象有代理对象则指的是代理对象已经创建完毕第二级缓存**MapString, Object earlySingletonObjects**第二级缓存的作用用于存储单例模式下创建的Bean实例该Bean被提前暴露的引用,该Bean还在创建中。该缓存是对内使用的指的就是Spring框架内部逻辑使用该缓存。存储的数据Kbean的名称Vbean的实例对象“半成品”对象有代理对象则指的是代理对象该Bean还在创建中第三级缓存**MapString, ObjectFactory? singletonFactories**第三级缓存的作用通过ObjectFactory对象来存储单例模式下提前暴露的Bean实例的引用正在创建中。该缓存是对内使用的指的就是Spring框架内部逻辑使用该缓存。此缓存是解决循环依赖最大的功臣存储什么数据Kbean的名称VObjectFactory该对象持有提前暴露的bean的引用一、注入AService时首先进入org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean:// Create bean instance. if (mbd.isSingleton()) { sharedInstance getSingleton(beanName, () - { try { return createBean(beanName, mbd, args); } ... }看看getSingleton方法的原型org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory?)public Object getSingleton(String beanName, ObjectFactory? singletonFactory)所以此时doGetBean方法会进入lambda方法中的调用createBean方法来得到一个ObjectFactory接着我们进入到org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory的doCreateBean方法, 打上断点看看当beanNameAServiceImpl的时候先根据反射创建了一个Object类的AServiceImpl的bean里面的BService为nullprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, Nullable Object[] args){ ...省略... Object bean instanceWrapper.getWrappedInstance(); //ASericeImpl4686 Class? beanType instanceWrapper.getWrappedClass(); //beanType class com.example.demo.service.impl.AServiceImpl ...省略... }判断该bean是否已经被提前暴露protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Nullable Object[] args) throws BeanCreationException { ...省略... //判断该bean是否已经被提前暴露 //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)); //如果是就调用addSingletonFactory方法 if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace(Eagerly caching bean beanName to allow for resolving potential circular references); } addSingletonFactory(beanName, () - getEarlyBeanReference(beanName, mbd, bean)); } ...省略... }若没有被提前暴露就进入到语句// Initialize the bean instance. Object exposedObject bean; try { //调用populateBean方法后AService中的BService属性就不再是null而是一个$Proxy4981$ //应该是个代理的对象解决注入的燃眉之急 populateBean(beanName, mbd, instanceWrapper); //做一些初始化的操作 exposedObject initializeBean(beanName, exposedObject, mbd); }将该bean暴露// Register bean as disposable. try { registerDisposableBeanIfNecessary(beanName, bean, mbd); }接着就将其返回return exposedObject;此时exposedObject对象里的bService还是$Proxy$二、回到org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean方法if (mbd.isSingleton()) { sharedInstance getSingleton(beanName, () - { try { //这时候回到了这里lambda表达式会得到上面的exposedObject return createBean(beanName, mbd, args); }此时会回到getSingleton方法中进入getSingleton方法内部try { //其中的singletonFactory调用getObject就是lambda表达式返回的exposedObject也就是里面的bService还是$Proxy$ singletonObject singletonFactory.getObject(); //标记为新的单例bean newSingleton true; }最后我们看看this.singletonObjects中的AService可以看到用bService中注入了一个神秘的$Proxy$然后写入了一级缓存中经调试后发现是在getSingleton方法中调用addSingleton方法写入的这时候二级、三级缓存全程都没写入过数据。if (newSingleton) { addSingleton(beanName, singletonObject); }三、回到test()方法Test public void test(){ aService.zaWaLuDo(); }此时aService中的bService还是个Proxy$这时候继续就会正常执行aService.zaWaLuDo_()_程序正常结束。总结下就是这种情况下aService会由doCreateBean方法创建而bService是某种代理的东西存在其中。四、我们改写一下两个Service使AService需要调用BService的方法AServiceImplpackage com.example.demo.service.impl; import com.example.demo.service.AService; import com.example.demo.service.BService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; Service public class AServiceImpl implements AService { Autowired Lazy public BService bService; Override public void zaWaLuDo(){ System.out.println(ToKiOToMaLei!); bService.starPuLaXin(); } }BServiceImplpackage com.example.demo.service.impl; import com.example.demo.service.AService; import com.example.demo.service.BService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; Service public class BServiceImpl implements BService { Autowired public AService aService; Override public void starPuLaXin() { System.out.println(Za WaLuDo!); } }我们先在执行aServuce,zaWaLuDo()之前打个断点看看此时的aService是什么情况可以看到跟上面的情况是一样的。这个时候我们在org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)方法打个断点看看这时候会进入org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean方法执行// Eagerly check singleton cache for manually registered singletons. Object sharedInstance getSingleton(beanName);sharedInstance是这样的里面的bService还是一个$Proxy$我们一直调试到getBean方法结束他最终会进入到jdk代理org.springframework.aop.framework.JdkDynamicAopProxy中执行方法//方法参数 Object[] argsToUse AopProxyUtils.adaptArgumentsIfNecessary(method, args); //target根据参数argsToUse执行方法method的结果 retVal AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);于是就会执行结果ToKiOToMaLei! Za WaLuDo!五、研究一下aService和bService的注入过程二者都会进入doCreateBean方法aService会入上面的过程一样被创建我们研究一下bService的创建过程当执行到:try { populateBean(beanName, mbd, instanceWrapper); exposedObject initializeBean(beanName, exposedObject, mbd); }执行完populateBean方法exposedObject(即将成型的bService)就被注入了aService但是这个aService中的bService实际上还只是个$Proxy$在接下来的过程中aService中的bService一直都还只是个$Proxy$就像bService中的aService也一直都还是个$Proxy$所以可以推断这种情况下Spring不关心二者是否真的存了个“成品”对象只是有个“半成品”对象利用通过jdk动态代理AOP执行bService的方法而已, 最终会到org.springframework.aop.framework.JdkDynamicAopProxy#invoke中执行bService的方法.情况二构造器注入循环依赖示例com.example.demo.service.CServicepackage com.example.demo.service; public interface CService { void goldExperience(); }com.example.demo.service.DServicepackage com.example.demo.service; public interface DService { }com.example.demo.service.impl.CServiceImplpackage com.example.demo.service.impl; import com.example.demo.service.CService; import com.example.demo.service.DService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; Service public class CServiceImpl implements CService { private DService dService; Autowired public CServiceImpl(DService dService) { this.dService dService; } Override public void goldExperience() { System.out.println(MUDAMUDAMUDAMUDA!!!!); } }com.example.demo.service.impl.DServiceImplpackage com.example.demo.service.impl; import com.example.demo.service.CService; import com.example.demo.service.DService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; Service public class DServiceImpl implements DService { private CService cService; Autowired public DServiceImpl(CService cService) { this.cService cService; } }com.example.demo.service.CServiceTestpackage com.example.demo.service; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import static org.junit.jupiter.api.Assertions.*; SpringBootTest class CServiceTest { Autowired CService cService; Test public void test(){ cService.goldExperience(); } }运行测试方法同样报循环依赖的错误。解决方法在参数里添加Lazy方法package com.example.demo.service.impl; import com.example.demo.service.CService; import com.example.demo.service.DService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; Service public class CServiceImpl implements CService { private DService dService; Autowired public CServiceImpl(Lazy DService dService) { //参数上添加了Lazy方法 this.dService dService; } Override public void goldExperience() { System.out.println(MUDAMUDAMUDAMUDA!!!!); } }源码分析跟情况一一样也是通过注入一个假的对象解决将代码改成情况一的调用dService的方法也是通过jdk动态代理AOP解决。Springboot解决循环依赖的源码阅读在application.yml中开启:spring: main: allow-circular-references: true我们先调试一下看看发现cService中的dService是货真价实的我们尝试调试看看能不能搞清楚Springboot到底是怎么注入的在老地方org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)打个断点研究一下dService是怎么做的Override public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); }一直调试到org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor才终于有点眉目:if (value ! null) { ReflectionUtils.makeAccessible(field); field.set(bean, value); }此时的各变量是这样的field.set(bean, value)方法内部是getFieldAccessor_(_obj_)_.set_(_obj, value_)_;后面的set_(_obj, value_)_就是已编译好的字节码了执行下一步后dService中缺乏的cService就有东西了所以可以推测是一个写入过程。我们看看其巨长无比的调用栈在这句所在的inject方法头部打个注解看看有没有头绪cService是从哪来的重新启动一下当创建dService时会进入到该方法体初始的时候value啥也没有接着会进到... value resolveFieldValue(field, bean, beanName); //进入本句 ... if (value ! null) { ReflectionUtils.makeAccessible(field); field.set(bean, value); }一直调用到org.springframework.beans.factory.config.DependencyDescriptor#resolveCandidate方法public Object resolveCandidate(String beanName, Class? requiredType, BeanFactory beanFactory) throws BeansException { return beanFactory.getBean(beanName); //beanNameCServiceImpl }此时由进入到了老朋友org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)方法中返回了一个CServiceImpl对象给上面的resolveFieldValue(field, bean, beanName);接着就进入到field.set(bean, value);中将其注入那么神奇的事情肯定是发生在beanFactory.getBean(beanName);中老办法再打个断点回到取CServiceImpl对象的时候看看接着他会进入老朋友org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)方法中我们step into在执行完Object sharedInstance getSingleton(beanName)后就有了CServiceImpl对象只不过他的dService还是null:protected T T doGetBean( String name, Nullable ClassT requiredType, Nullable Object[] args, boolean typeCheckOnly) throws BeansException { String beanName transformedBeanName(name); Object beanInstance; // Eagerly check singleton cache for manually registered singletons. Object sharedInstance getSingleton(beanName); ....最后还是会field.set(bean, value);给dService先注入。看到这里感觉非常混乱感觉还是按那幅图来看吧在创建cService调用doCreateBean方法执行了addSingletonFactory{ addSingletonFactory(beanName, () - getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject bean; try { populateBean(beanName, mbd, instanceWrapper); exposedObject initializeBean(beanName, exposedObject, mbd); }三级缓存this.singletonFactories 中便存入了“半成品”对象的自己cService执行到populateBean的时候旋即进入到了dService的doCreateBeandService通过addSingletonFactory也往三级缓存this.singletonFactories 中便存入了“半成品”对象的自己此时c、d都在三级缓存this.singletonFactories里当dService执行了下一句即populateBean之后cService从三级缓存换入到了二级缓存this.earlySingletonObjects此时其内部的dService为空到这一步我们再理清一下调用链dService执行到getSingleton后// Create bean instance. if (mbd.isSingleton()) { sharedInstance getSingleton(beanName, () - { try { return createBean(beanName, mbd, args); }在getSingleton内部执行了addSingleton_(_beanName, singletonObject_)_之后便把自己写入了三级缓存this.singletonObjects中并把半成品的cService注入到自己中形如之后就回到了cService-populateBean的执行最终去到了field.set_(_bean, value_)_中此时bean为cService, value为dService内部的cService的dService仍未空执行完之后就链接上了神奇待cService -populateBean执行结束后回到cService - doGetBean的执行进行完cService - getSingleton后二级缓存this.earlySingletonObjects中的cService也移入了一级缓存this.singletonObjects之中此时基本上解决了循环引用的问题。总结一下我们认为一个对象的创建可分为两步实例化可认为是一个在内存中划分空间的过程初始化为该对象的属性赋值的过程cService在创建的时候先只进行了实例化此时是一个“半成品”对象写入三级缓存中存储旋即进行其所需要的dService对象的创建而dService会进行实例化之后也将“半成品”的自己写入三级缓存中此时cService会尝试进行初始化为属性赋值他需要写入dService但事实上会为dService赋值为null然后写入二级缓存此时的cService仍然是个“半成品”。接着又回到dService的创建这时候他也会进行一个初始化将二级队列中的完成了“假”的初始化的“半成品”对象cService给自己所需的属性注入完成了初始化过程并写入了一级缓存。然后就回到了cService还在进行中的创建过程这个时候cService是个“假”的“半成品”在二级缓存而dService是个真的成品他确实拥有了cService对象。cService这时候也会将一级缓存中的dService一个真正完成了初始化的对象注入到自己的属性中这个时候二者终于完成了互相注入cService也完成了初始化进入了一级缓存循环依赖得以解决。为什么需要三级缓存我大概总结了一下流程可以看出互相依赖的两个对象有三种状态只有“存在”没有内部的“半成品”形态一对象注入了“半成品”形态一对象的“半成品”形态二对象注入了“半成品”形态二对象的完全体“成品”对象因有客观上有三种状态的对象所以才利用三级缓存来分别存储比较科学的说明如下三级缓存singletonObjects一级缓存 Cache of singleton objects bean name -- bean instance。 存放完整对象。earlySingletonObjects二级缓存 Cache of early singleton objects bean name -- bean instance 提前曝光的BEAN缓存。 存放半成品对象。singletonFactories三级缓存 Cache of singleton factories bean name -- ObjectFactory。需要的对象被代理时就必须使用三级缓存否则二级就够了。解决循环依赖中存在aop的问题 存放 lambda 表达式和对象名称的映射。