白话理解什么是Spring循环依赖
我们知道Spring IOC是指的容器来负责创建Bean并负责处理Bean之间的依赖关系，比如有如下两个类A、B：
@Component
public class A
@Autowired
private B b;
@Component
public class B
站在容器的角度，发现A依赖B，直接先创建B然后创建A，把B实例赋值给A的成员变量b，完事儿。
但如果是下面一种循环依赖的情况，按照上面的逻辑就不可行了：
循环依赖
@Component
public class A
@Autowired
private B b;
@Component
public class B
@Autowired
private C c;
@Component
public class C
@Autowired
private A a;
A依赖B、B依赖C、C又依赖A
如果你是容器，尼玛到底该先创建谁？？
解决思路
创建一个类实例之前，先去一个全局的缓存Map里看下是否有这个类的实例，如果有则说明已经创建过、直接返回，如果没有则创建。
创建类实例的对应的属性的实例、并赋值给成员变量。递归。
创建A的实例，加入缓存Map，遍历A的属性，发现B需要创建，创建B的实例也加入缓存，遍历B的属性发现需要创建C，创建C的实例，遍历C的属性发现需要创建A的实例，但是A实例已经在缓存了、直接赋值。循环结束。
下面按照上面的思路，写下代码模拟循环依赖的解决：
package com.wangan.cyclicdependency;
public class A {
public B b;
}
public class B {
public C c;
}
public class C {
public A a;
}
package com.wangan.cyclicdependency;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
/**
* 模拟简单循环依赖解决
* */
public class TestCyclicDependency {
private static Map<String, Object> beanCache = new HashMap<>();
public static void main(String[] args) throws Exception {
String[] beanDefinations = {"com.wangan.cyclicdependency.A",
"com.wangan.cyclicdependency.B",
"com.wangan.cyclicdependency.C"};
for(String beanName : beanDefinations) {
getBean(beanName);
}
A a = (A) beanCache.get("com.wangan.cyclicdependency.A");
B b = (B) beanCache.get("com.wangan.cyclicdependency.B");
C c = (C) beanCache.get("com.wangan.cyclicdependency.C");
System.out.println(a.b);
System.out.println(b.c);
System.out.println(c.a);
System.out.println(a.b==b);
System.out.println(b.c==c);
System.out.println(c.a==a);
}
public static Object getBean(String beanName) throws Exception {
if(beanCache.containsKey(beanName)) {
return beanCache.get(beanName);
}else {
Object bean = Class.forName(beanName).newInstance();
beanCache.put(beanName, bean);
Field[] fields = bean.getClass().getFields();
for(Field f : fields) {
String typeClassName = f.getType().getName();
f.setAccessible(true);
f.set(bean, getBean(typeClassName));
}
return bean;
}
}
}
Spring中的循环依赖问题
先对于我们上面的简单例子，Spring要面对的问题要复杂一些，即要实现AOP，相对于我们上面使用了1个Map来作为缓存来暂存Bean，Spring使用了3个Map形成所谓的“三级缓存”。
DefaultSingletonBeanRegistry.java，继承关系是DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory extends AbstractBeanFactory extends FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry （吐槽一下，所以说Spring的源代码为什么难读，瞅瞅这继承的关系有多深）
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
singletonObjects是1级缓存，就是所谓的单例池，存放经过代理的且经过初始化的完整的Bean。earlySingletonObjects是2级缓存，存放实例化之后、且经过代理的Bean，但是还没有初始化（也就是属性还没填充）。singletonFactories是3级缓存，存放用实例化后的Bean对象封装成的工厂对象，如果有AOP则这个工厂对象getObject直接返回原实例化对象、如果启用了AOP那么这个工厂对象返回的就是加了AOP切面的动态代理对象。
下面我们还是用代码模拟一下，以加深理解：
互相依赖的两个类，A和B：
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Data
public class A {
@Autowired
private B b;
public A() {
log.info("A初始化");
}
public void helloA() {
log.info("hello A");
}
}
@Slf4j
@Data
public class B {
@Autowired
private A a;
public B() {
log.info("B初始化");
}
public void helloB() {
log.info("hello B");
}
}
DefaultSingletonBeanRegistry
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.util.Assert;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class DefaultSingletonBeanRegistry {
//1级缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//2级缓存
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
//3级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
this.singletonsCurrentlyInCreation.add(beanName);
boolean newSingleton = false;
singletonObject = singletonFactory.getObject();
newSingleton = true;
this.singletonsCurrentlyInCreation.remove(beanName);
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
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);
}
}
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);
}
}
}
protected void removeSingleton(String beanName) {
synchronized (this.singletonObjects) {
this.singletonObjects.remove(beanName);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
//this.registeredSingletons.remove(beanName);
}
}
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
}
BeanFactory，继承BeanRegistry：
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.support.RootBeanDefinition;
public class DefaultListenableBeanFactory extends DefaultSingletonBeanRegistry{
private final Map<String, RootBeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
public void registerBeanDefinition(String beanName, RootBeanDefinition beanDefinition) {
this.beanDefinitionMap.put(beanName, beanDefinition);
}
public Object getBean(String beanName) {
return doGetBean(beanName);
}
private Object doGetBean(String beanName) {
Object bean;
Object sharedInstance = getSingleton (beanName, true);
if(sharedInstance != null) {
return sharedInstance;
}else {
RootBeanDefinition beanDefinition = this.beanDefinitionMap.get(beanName);
bean = getSingleton(beanName, () -> {
return doCreateBean(beanName, beanDefinition);
});
}
return bean;
}
//创建Bean
private Object doCreateBean(String beanName, RootBeanDefinition beanDefinition) {
Object bean = createBeanInstance(beanName, beanDefinition);
//如果beanName正在创建中，而本次doCreateBean又创建，说明出现了循环依赖现象，则把它放入3级缓存里
boolean earlySingletonExposure = this.isSingletonCurrentlyInCreation(beanName);
if(earlySingletonExposure) {
this.addSingletonFactory(beanName, ()->bean);
}
Object exposedObject = bean;
//属性赋值
populateBean(beanName, beanDefinition, bean);
if(earlySingletonExposure) {
Object earlySingletonReference = getSingleton (beanName, false);
if(earlySingletonReference != null)
exposedObject = earlySingletonReference;
}
return exposedObject;
}
//实例化
private Object createBeanInstance(String beanName, RootBeanDefinition beanDefinition) {
Constructor<Object> constructor;
try {
constructor = (Constructor<Object>) beanDefinition.getBeanClass().getDeclaredConstructor();
constructor.setAccessible(true);
return constructor.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
//属性填充
private void populateBean(String beanName, RootBeanDefinition beanDefinition, Object beanInstance) {
Field[] fields = beanDefinition.getBeanClass().getDeclaredFields();
Arrays.stream(fields).forEach(field -> {
Autowired autowired = field.getAnnotation(Autowired.class);
if(null != autowired) {
Object beanField = this.getBean(field.getName());
field.setAccessible(true);
try {
field.set(beanInstance, beanField);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
});
}
}
测试：
public class CyclicDependencyTest {
public static void main(String[] args) {
RootBeanDefinition beanDefinitionA = new RootBeanDefinition();
beanDefinitionA.setBeanClass(A.class);
RootBeanDefinition beanDefinitionB = new RootBeanDefinition();
beanDefinitionB.setBeanClass(B.class);
DefaultListenableBeanFactory beanFactory = new DefaultListenableBeanFactory();
beanFactory.registerBeanDefinition("a", beanDefinitionA);
beanFactory.registerBeanDefinition("b", beanDefinitionB);
A a = (A) beanFactory.getBean("a");
a.getB().helloB();
B b = (B) beanFactory.getBean("b");
b.getA().helloA();
}
}
输出：
[2021-11-28 12:09:32] [ INFO ] [main] [codeline:16] - A初始化
[2021-11-28 12:09:32] [ INFO ] [main] [codeline:16] - B初始化
[2021-11-28 12:09:32] [ INFO ] [main] [codeline:20] - hello B
[2021-11-28 12:09:32] [ INFO ] [main] [codeline:20] - hello A
参考
https://mp.weixin.qq.com/s/kS0K5P4FdF3v-fiIjGIvvQ 感谢这个aobing小兄弟，闻道有先后，从他写的和整理的材料里理顺了不少思路
