大厂Java二面：Spring循环依赖，烂大街的问题这么答面试官才满意(1)

System.out.println(“（1）调用change前”+a);

change(a);

System.out.println(“（3）调用change后”+a);

}

public static void change(A a){

a= new A();

System.out.println(“（2）change方法内”+a);

}

}

class A{

}

（1）调用change前com.wsjia.ms.controller.A@61064425

（2）change方法内com.wsjia.ms.controller.A@7b1d7fff

（3）调用change后com.wsjia.ms.controller.A@61064425

我承认JAVA中都是值传递。

但此处想要表达的是：引用类型参数，与原引用值共同指向一块内存地址，对对象的修改是相互影响的。

本文姑且叫他引用的传递【我知道你应该懂得什么意思】

2. Bean创建的几个关键点

================

此处只是列出Bean的几个重要的阶段，为了讲清楚循环依赖，具体的在以后专门讲讲Bean的创建。

Spring 创建Bean的过程，大致和对象的初始化有点类似吧。有几个关键的步骤

• createBeanInstance ：实例化，此处要强调的是，Bean的早期引用在此出现了。

• populateBean ： 填充属性，此处我们熟悉的@Autowired属性注入就发生在此处

• initializeBean : 调用一些初始化方法，例如init ,afterPropertiesSet

此外：BeanPostProcessor作为一个扩展接口，会穿插在Bean的创建流程中，留下很多钩子，让我们可以去影响Bean的创建过程。其中最主要的就属AOP代理的创建了。

3. AOP的原理

==========

AOP是以一个

InstantiationAwareBeanPostProcessor类型的BeanPostProcessor,参与到Bean的创建逻辑中，并根据是否需要代理当前Bean，决定是否创建代理对象。

主要逻辑在(BeanPostProcessor)AbstractAutoProxyCreator类中中,有三个重要方法。

//早期bean创建代理用

public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {

Object cacheKey = getCacheKey(bean.getClass(), beanName);

this.earlyProxyReferences.put(cacheKey, bean);

return wrapIfNecessary(bean, beanName, cacheKey);

}

//bean创建代理用

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

if (bean != null) {

Object cacheKey = getCacheKey(bean.getClass(), beanName);

if (this.earlyProxyReferences.remove(cacheKey) != bean) {

return wrapIfNecessary(bean, beanName, cacheKey);

}

}

return bean;

}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {

//创建代理的逻辑

}

当一个Bean创建代理后，我们通过beanname从BeanFactory中获取的就是就是代理的对象的了

4. getBean()返回的是什么？

====================

当我们尝试按name从BeanFactory.getBean(beanname)一个Bean时，返回的一定是A类对应的实例吗？

答案是否， 当A需要需要创建代理对象时，我们getBean 得到是 代理对象的引用。

5. 三个缓存

========

本文暂时只考虑单例的情况

把创建好的Bean缓存起来，这是非常平常的逻辑。

/** Cache of singleton objects: bean name --> bean instance */

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

/** Cache of early singleton objects: bean name --> bean instance */

private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

/** Cache of singleton factories: bean name --> ObjectFactory */

private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap

• singletonObjects：第一级缓存，里面存放的都是创建好的成品Bean。

• earlySingletonObjects : 第二级缓存，里面存放的都是半成品的Bean。

• singletonFactories ：第三级缓存， 不同于前两个存的是 Bean对象引用，此缓存存的bean 工厂对象，也就存的是 专门创建Bean的一个工厂对象。此缓存用于解决循环依赖

这里有个点：我个人认为这么叫这三个缓存更加合适

• singletonObjects：成品缓存

• earlySingletonObjects： 半成品缓存

• singletonFactories ：单例工厂缓存

至于为什么，稍微给我个人理解。

三、解析循环依赖

========

接下来开始讲讲循环依赖

本文只讨论，属性注入的情况。

假设有这么两个类产生了循环依赖。如果解决这个问题？

public class A {

B b;

public A() {

}

}

class B{

@Autowired

A a;

public B() {

}

}

1.一个缓存能解决不？

===========

首先我们先来讨论下这个循环依赖问题

• 从A获取开始，从缓存里查看，没有开始创建A实例，执行构造方法，填充属性时发现需要依赖B，

• 尝试从缓存中获取B。

• 开始创建B实例，执行构造方法，填充属性时，发现需要依赖A，取缓存找A .

• A正在创建没有完成。

• 死结

2.两个缓存能解决不？？

============

不等创建完成，有了引用后，提前放入半成品缓存

• A引用创建后，提前暴露到半成品缓存中

• 依赖B，创建B ，B填充属性时发现依赖A， 先从成品缓存查找，没有,再从半成品缓存查找 取到A的早期引用。

• B顺利走完创建过程, 将B的早期引用从半成品缓存移动到成品缓存

• B创建完成，A获取到B的引用，继续创建。

• A创建完成，将A的早期引用从半成品缓存移动到成品缓存

• 完美解决循环依赖

嗯？ 两个缓存就能解决？？？为啥需要三个缓存？？

3.为啥需要三个缓存

==========

Spring 为啥用三个缓存去解决循环依赖问题？

上面两个缓存的地方，我们只是没有考虑代理的情况。

代理的存在

=====

Bean在创建的最后阶段，会检查是否需要创建代理，如果创建了代理，那么最终返回的就是代理实例的引用。我们通过beanname获取到最终是代理实例的引用

也就是说：上文中，假设A最终会创建代理，提前暴露A的引用， B填充属性时填充的是A的原始对象引用。A最终放入成品库里是代理的引用。那么B中依然是A的早期引用。这种结果最终会与我们的期望的大相径庭了。

怎么办？？？

Spring 是这么做的

============

=======AbstractAutowireCapableBeanFactory.doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)

throws BeanCreationException {

【1】Instantiate the bean.

BeanWrapper instanceWrapper = null;

if (mbd.isSingleton()) {

instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

}

if (instanceWrapper == null) {

instanceWrapper = createBeanInstance(beanName, mbd, args);

}

【早期引用】

final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);

【2】在需要暴露早期引用的条件下

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&

isSingletonCurrentlyInCreation(beanName));

if (earlySingletonExposure) {

【2.1】绑定当前Bean引用到ObjectFactory，注册到三级singletonFactories

addSingletonFactory(beanName, new ObjectFactory() {

【重写getObject】

@Override

public Object getObject() throws BeansException {

return getEarlyBeanReference(beanName, mbd, bean);

}

});

}

}

===AbstractAutowireCapableBeanFactory.doCreateBean—>DefaultSingletonBeanRegistry.getSingleton

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {

synchronized (this.singletonObjects) {

if (!this.singletonObjects.containsKey(beanName)) {

【3】放入到singletonFactories 缓存中，清除其他缓存

this.singletonFactories.put(beanName, singletonFactory);

this.earlySingletonObjects.remove(beanName);

this.registeredSingletons.add(beanName);

}

}

===========AbstractBeanFactory.doGetBean—>DefaultSingletonBeanRegistry.getSingleton

【4】按Beanname取Bean

protected Object getSingleton(String beanName, boolean allowEarlyReference) {

【4.1】先尝试从成品缓存获取

Object singletonObject = this.singletonObjects.get(beanName);

【4.2】成品缓存没有，且正在创建，尝试从半成品缓存获取

if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

synchronized (this.singletonObjects) {

singletonObject = this.earlySingletonObjects.get(beanName);

if (singletonObject == null && allowEarlyReference) {

【4.3】半成品缓存没有，且允许早期引用，尝试从工厂缓存中查找有么此Bean的工厂类存在

ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);

if (singletonFactory != null) {

【4.4】存在，执行getObject获取早期引用，放入到半成品缓存，并将工厂类从工厂缓存中移除

singletonObject = singletonFactory.getObject();

this.earlySingletonObjects.put(beanName, singletonObject);

this.singletonFactories.remove(beanName);

}

}

}

}

return (singletonObject != NULL_OBJECT ? singletonObject : null);

}

注册 ObjectFactory工厂类到工厂缓存： 
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

权威指南-第一本Docker书

引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。

总共包含了：简介、安装Docker、Docker入门、使用Docker镜像和仓库、在测试中使用Docker、使用Docker构建服务、使用Fig编配Docke、使用Docker API、获得帮助和对Docker进行改进等9个章节的知识。

关于阿里内部都在强烈推荐使用的“K8S+Docker学习指南”—《深入浅出Kubernetes：理论+实战》、《权威指南-第一本Docker书》，看完之后两个字形容，爱了爱了！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。

总共包含了：简介、安装Docker、Docker入门、使用Docker镜像和仓库、在测试中使用Docker、使用Docker构建服务、使用Fig编配Docke、使用Docker API、获得帮助和对Docker进行改进等9个章节的知识。

[外链图片转存中…(img-DUPTDgwD-1713626000408)]

[外链图片转存中…(img-5h40ZWrz-1713626000408)]

[外链图片转存中…(img-wPuP3iWC-1713626000408)]

[外链图片转存中…(img-QCldppW3-1713626000409)]

关于阿里内部都在强烈推荐使用的“K8S+Docker学习指南”—《深入浅出Kubernetes：理论+实战》、《权威指南-第一本Docker书》，看完之后两个字形容，爱了爱了！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！