介紹
先說一下什么是回圈依賴，Spring在初始化A的時候需要注入B，而初始化B的時候需要注入A，在Spring啟動后這2個Bean都要被初始化完成
Spring的回圈依賴有兩種場景
- 構造器的回圈依賴
- 屬性的回圈依賴
構造器的回圈依賴，可以在建構式中使用@Lazy注解延遲加載，在注入依賴時，先注入代理物件，當首次使用時再創建物件完成注入
屬性的回圈依賴主要是通過3個map來解決的
構造器的回圈依賴
@Component
public class ConstructorA {
private ConstructorB constructorB;
@Autowired
public ConstructorA(ConstructorB constructorB) {
this.constructorB = constructorB;
}
}
@Component
public class ConstructorB {
private ConstructorA constructorA;
@Autowired
public ConstructorB(ConstructorA constructorA) {
this.constructorA = constructorA;
}
}
@Configuration
@ComponentScan("com.javashitang.dependency.constructor")
public class ConstructorConfig {
}
public class ConstructorMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(ConstructorConfig.class);
System.out.println(context.getBean(ConstructorA.class));
System.out.println(context.getBean(ConstructorB.class));
}
}
運行ConstructorMain的main方法的時候會在第一行就報例外，說明Spring沒辦法初始化所有的Bean，即上面這種形式的回圈依賴Spring無法解決，
我們可以在ConstructorA或者ConstructorB建構式的引數上加上@Lazy注解就可以解決
@Autowired
public ConstructorB(@Lazy ConstructorA constructorA) {
this.constructorA = constructorA;
}
因為我們主要關注屬性的回圈依賴，構造器的回圈依賴就不做過多分析了
屬性的回圈依賴
先演示一下什么是屬性的回圈依賴
@Component
public class FieldA {
@Autowired
private FieldB fieldB;
}
@Component
public class FieldB {
@Autowired
private FieldA fieldA;
}
@Configuration
@ComponentScan("com.javashitang.dependency.field")
public class FieldConfig {
}
public class FieldMain {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(FieldConfig.class);
// com.javashitang.dependency.field.FieldA@3aa9e816
System.out.println(context.getBean(FieldA.class));
// com.javashitang.dependency.field.FieldB@17d99928
System.out.println(context.getBean(FieldB.class));
}
}
Spring容器正常啟動，能獲取到FieldA和FieldB這2個Bean
屬性的回圈依賴在面試中還是經常被問到的，總體來說也不復雜，但是涉及到Spring Bean的初始化程序，所以感覺比較復雜，我寫個demo演示一下整個程序
Spring的Bean的初始化程序其實比較復雜，為了方便理解Demo，我就把Spring Bean的初始化程序分為2部分
- bean的實體化程序，即呼叫建構式將物件創建出來
- bean的初始化程序，即填充bean的各種屬性
bean初始化程序完畢，則bean就能被正常創建出來了
下面開始寫Demo，ObjectFactory介面用來生產Bean，和Spring中定義的介面一樣
public interface ObjectFactory<T> {
T getObject();
}
public class DependencyDemo {
// 初始化完畢的Bean
private final Map<String, Object> singletonObjects =
new ConcurrentHashMap<>(256);
// 正在初始化的Bean對應的工廠，此時物件已經被實體化
private final Map<String, ObjectFactory<?>> singletonFactories =
new HashMap<>(16);
// 存放正在初始化的Bean，物件還沒有被實體化之前就放進來了
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
public <T> T getBean(Class<T> beanClass) throws Exception {
// 類名為Bean的名字
String beanName = beanClass.getSimpleName();
// 已經初始化好了，或者正在初始化
Object initObj = getSingleton(beanName, true);
if (initObj != null) {
return (T) initObj;
}
// bean正在被初始化
singletonsCurrentlyInCreation.add(beanName);
// 實體化bean
Object object = beanClass.getDeclaredConstructor().newInstance();
singletonFactories.put(beanName, () -> {
return object;
});
// 開始初始化bean，即填充屬性
Field[] fields = object.getClass().getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
// 獲取需要注入欄位的class
Class<?> fieldClass = field.getType();
field.set(object, getBean(fieldClass));
}
// 初始化完畢
singletonObjects.put(beanName, object);
singletonsCurrentlyInCreation.remove(beanName);
return (T) object;
}
/**
* allowEarlyReference引數的含義是Spring是否允許回圈依賴，默認為true
* 所以當allowEarlyReference設定為false的時候，當專案存在回圈依賴，會啟動失敗
*/
public Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null
&& isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory =
this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
}
}
}
}
return singletonObject;
}
/**
* 判斷bean是否正在被初始化
*/
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
}
測驗一波
public static void main(String[] args) throws Exception {
DependencyDemo dependencyDemo = new DependencyDemo();
// 假裝掃描出來的物件
Class[] classes = {A.class, B.class};
// 假裝專案初始化所有bean
for (Class aClass : classes) {
dependencyDemo.getBean(aClass);
}
// true
System.out.println(
dependencyDemo.getBean(B.class).getA() == dependencyDemo.getBean(A.class));
// true
System.out.println(
dependencyDemo.getBean(A.class).getB() == dependencyDemo.getBean(B.class));
}
是不是很簡單？我們只用了2個map就搞定了Spring的回圈依賴
2個Map就能搞定回圈依賴，那為什么Spring要用3個Map呢？
原因其實也很簡單，當我們從singletonFactories中根據BeanName獲取相應的ObjectFactory，然后呼叫getObject()這個方法回傳對應的Bean，在我們的例子中
ObjectFactory的實作很簡單哈，就是將實體化好的物件直接回傳，但是在Spring中就沒有這么簡單了，執行程序比較復雜，為了避免每次拿到ObjectFactory然后呼叫getObject()，我們直接把ObjectFactory創建的物件快取起來不就行了，這樣就能提高效率了
比如A依賴B和C，B和C又依賴A，如果不做快取那么初始化B和C都會呼叫A對應的ObjectFactory的getObject()方法，如果做快取只需要B或者C呼叫一次即可，
知道了思路，我們把上面的代碼改一波，加個快取，
public class DependencyDemo {
// 初始化完畢的Bean
private final Map<String, Object> singletonObjects =
new ConcurrentHashMap<>(256);
// 正在初始化的Bean對應的工廠，此時物件已經被實體化
private final Map<String, ObjectFactory<?>> singletonFactories =
new HashMap<>(16);
// 快取Bean對應的工廠生產好的Bean
private final Map<String, Object> earlySingletonObjects =
new HashMap<>(16);
// 存放正在初始化的Bean，物件還沒有被實體化之前就放進來了
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
public <T> T getBean(Class<T> beanClass) throws Exception {
// 類名為Bean的名字
String beanName = beanClass.getSimpleName();
// 已經初始化好了，或者正在初始化
Object initObj = getSingleton(beanName, true);
if (initObj != null) {
return (T) initObj;
}
// bean正在被初始化
singletonsCurrentlyInCreation.add(beanName);
// 實體化bean
Object object = beanClass.getDeclaredConstructor().newInstance();
singletonFactories.put(beanName, () -> {
return object;
});
// 開始初始化bean，即填充屬性
Field[] fields = object.getClass().getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
// 獲取需要注入欄位的class
Class<?> fieldClass = field.getType();
field.set(object, getBean(fieldClass));
}
singletonObjects.put(beanName, object);
singletonsCurrentlyInCreation.remove(beanName);
earlySingletonObjects.remove(beanName);
return (T) object;
}
/**
* allowEarlyReference引數的含義是Spring是否允許回圈依賴，默認為true
*/
public 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;
}
}
我們寫的getSingleton的實作和org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)的實作一模一樣，這個方法幾乎所有分析Spring回圈依賴的文章都會提到，這次你明白作業原理是什么了把
總結一波
- 拿bean的時候先從singletonObjects（一級快取）中獲取
- 如果獲取不到，并且物件正在創建中，就從earlySingletonObjects（二級快取）中獲取
- 如果還是獲取不到就從singletonFactories（三級快取）中獲取，然后將獲取到的物件放到earlySingletonObjects（二級快取）中，并且將bean對應的singletonFactories（三級快取）清除
- bean初始化完畢，放到singletonObjects（一級快取）中，將bean對應的earlySingletonObjects（二級快取）清除
歡迎關注
參考博客
[1]https://mp.weixin.qq.com/s/gBr3UfC1HRcw4U-ZMmtRaQ
[2]https://mp.weixin.qq.com/s/5mwkgJB7GyLdKDgzijyvXw
比較詳細
[1]https://zhuanlan.zhihu.com/p/84267654
[2]https://juejin.im/post/5c98a7b4f265da60ee12e9b2
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/158879.html
標籤：Java