深度分析什麼是迴圈依賴？Spring是如何解決迴圈依賴的？
阿新 • • 發佈：2021-01-07
什麼是迴圈依賴？
顧名思義，迴圈依賴就是A依賴B，B又依賴A，兩者之間的依賴關係形成了一個圓環，通常是由於不正確的編碼所導致。Spring只能解決屬性迴圈依賴問題，不能解決建構函式迴圈依賴問題，因為這個問題無解。
接下來我們首先寫一個Demo來演示Spring是如何處理屬性迴圈依賴問題的。
Talk is cheap. Show me the code
第一步：定義一個類ComponentA，其有一個私有屬性componentB。
package com.tech.ioc; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; /** * @author 君戰 * **/ @Component public class ComponentA { @Autowired private ComponentB componentB; public void say(){ componentB.say(); } }
第二步：定義一個類ComponentB，其依賴ComponentA。並定義一個say方法便於列印資料。
package com.tech.ioc; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; /** * @author 君戰 * **/ @Component public class ComponentB { @Autowired private ComponentA componentA; public void say(){ System.out.println("componentA field " + componentA); System.out.println(this.getClass().getName() + " -----> say()"); } }
第三步：重點，編寫一個類-SimpleContainer，模仿Spring底層處理迴圈依賴。如果理解這個程式碼，再去看Spring處理迴圈依賴的邏輯就會很簡單。
package com.tech.ioc; import java.beans.Introspector; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * 演示Spring中迴圈依賴是如何處理的，只是個簡版，真實的Spring依賴處理遠比這個複雜。 * 但大體思路都相同。另外這個Demo很多情況都未考慮，例如執行緒安全問題，僅供參考。 * @author 君戰 * * **/ public class SimpleContainer { /*** * 用於存放完全初始化好的Bean，Bean處於可狀態 * 這個Map定義和Spring中一級快取命名一致 * */ private Map<String, Object> singletonObjects = new ConcurrentHashMap<>(); /*** * 用於存放剛創建出來的Bean，其屬性還沒有處理，因此存放在該快取中的Bean還不可用。 * 這個Map定義和Spring中三級快取命名一致 * */ private final Map<String, Object> singletonFactories = new HashMap<>(16); public static void main(String[] args) { SimpleContainer container = new SimpleContainer(); ComponentA componentA = container.getBean(ComponentA.class); componentA.say(); } public <T> T getBean(Class<T> beanClass) { String beanName = this.getBeanName(beanClass); // 首先根據beanName從快取中獲取Bean例項 Object bean = this.getSingleton(beanName); if (bean == null) { // 如果未獲取到Bean例項，則建立Bean例項 return createBean(beanClass, beanName); } return (T) bean; } /*** * 從一級快取和二級快取中根據beanName來獲取Bean例項，可能為空 * */ private Object getSingleton(String beanName) { // 首先嚐試從一級快取中獲取 Object instance = singletonObjects.get(beanName); if (instance == null) { // Spring 之所以能解決迴圈依賴問題，也是靠著這個singletonFactories instance = singletonFactories.get(beanName); } return instance; } /*** * 建立指定Class的例項，返回完全狀態的Bean(屬性可用) * * */ private <T> T createBean(Class<T> beanClass, String beanName) { try { Constructor<T> constructor = beanClass.getDeclaredConstructor(); T instance = constructor.newInstance(); // 先將剛建立好的例項存放到三級快取中，如果沒有這一步，Spring 也無法解決三級快取 singletonFactories.put(beanName, instance); Field[] fields = beanClass.getDeclaredFields(); for (Field field : fields) { Class<?> fieldType = field.getType(); field.setAccessible(true); // 精髓是這裡又呼叫了getBean方法，例如正在處理ComponentA.componentB屬性， // 執行到這裡時就會去例項化ComponentB。因為在getBean方法首先去查快取， // 而一級快取和三級快取中沒有ComponentB例項資料，所以又會呼叫到當前方法， // 而在處理ComponentB.componentA屬性時，又去呼叫getBean方法去快取中查詢， // 因為在前面我們將ComponentA例項放入到了三級快取，因此可以找到。 // 所以ComponentB的例項化結束，方法出棧，返回到例項化ComponentA的方法棧中， // 這時ComponentB已經初始化完成，因此ComponentA.componentB屬性賦值成功！ field.set(instance, this.getBean(fieldType)); } // 最後再將初始化好的Bean設定到一級快取中。 singletonObjects.put(beanName, instance); return instance; } catch (Exception e) { e.printStackTrace(); } throw new IllegalArgumentException(); } /** * 將類名小寫作為beanName，Spring底層實現和這個差不多，也是使用javaBeans的 * {@linkplain Introspector#decapitalize(String)} **/ private String getBeanName(Class<?> clazz) { String clazzName = clazz.getName(); int index = clazzName.lastIndexOf("."); String className = clazzName.substring(index); return Introspector.decapitalize(className); } }
如果各位同學已經閱讀並理解上面的程式碼，那麼接下來我們就進行真實的Spring處理迴圈依賴問題原始碼分析，相信再閱讀起來就會很容易。
底層原始碼分析
分析從AbstractBeanFactory的doGetBean方法著手。可以看到在該方法首先呼叫transformedBeanName(其實就是處理BeanName問題)，和我們自己寫的getBeanName方法作用是一樣的，但Spring考慮的遠比這個複雜，因為有FactoryBean、別名問題。
// AbstractBeanFactory#doGetBean
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
// ！！！重點是這裡，首先從快取中beanName來獲取對應的Bean。
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 執行到這裡說明快取中存在指定beanName的Bean例項，getObjectForBeanInstance是用來處理獲取到的Bean是FactoryBean問題
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
else {
try {
// 刪除與本次分析無關程式碼....
// 如果是單例Bean，則通過呼叫createBean方法進行建立
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
return (T) bean;
}
getSingleton方法存在過載方法，這裡呼叫的是過載的getSingleton方法，注意這裡傳遞的boolean引數值為true，因為該值決定了是否允許曝光早期Bean。
// DefaultSingletonBeanRegistry#getSingleton
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
// DefaultSingletonBeanRegistry#getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 首先從一級快取中獲取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 如果一級快取中未獲取到，再從二級快取中獲取
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果未從二級快取中獲取到並且allowEarlyReference值為true(前面傳的為true)
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
//Double Check
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 最後嘗試去三級快取中獲取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 儲存到二級快取
this.earlySingletonObjects.put(beanName, singletonObject);
// 從三級快取中移除
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
ok，看完Spring是如何從快取中獲取Bean例項後，那再看看creatBean方法是如何建立Bean的
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// 刪除與本次分析無關的程式碼...
try {// createBean方法底層是通過呼叫doCreateBean來完成Bean建立的。
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
// AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 建立Bean例項
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
// 如果允許當前Bean早期曝光。只要Bean是單例的並且allowCircularReferences 屬性為true(預設為true)
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 這裡呼叫了addSingletonFactory方法將剛建立好的Bean儲存到了三級快取中。
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 刪除與本次分析無關的程式碼.....
Object exposedObject = bean;
try {// Bean屬性填充
populateBean(beanName, mbd, instanceWrapper);
// 初始化Bean，熟知的Aware介面、InitializingBean介面.....都是在這裡呼叫
exposedObject = initializeBean(beanName, exposedObject, mbd);
} catch (Throwable ex) {
}
// 刪除與本次分析無關的程式碼.....
return exposedObject;
}
先分析addSingletonFactory方法，因為在該方法中將Bean儲存到了三級快取中。
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
// 如果一級快取中不存在指定beanName的key
if (!this.singletonObjects.containsKey(beanName)) {
// 將剛建立好的Bean示例儲存到三級快取中
this.singletonFactories.put(beanName, singletonFactory);
// 從二級快取中移除。
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
處理Bean的依賴注入是由populateBean方法完成的，但整個執行鏈路太長了，這裡就不展開講了，只說下IoC容器在處理依賴時是如何一步一步呼叫到getBean方法的，這樣就和我們自己寫的處理欄位注入的邏輯對上了。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 刪除與本次分析無關程式碼...
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 遍歷所有已註冊的BeanPostProcessor介面實現類，如果實現類是InstantiationAwareBeanPostProcessor介面型別的，呼叫其postProcessProperties方法。
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
// 刪除與本次分析無關程式碼...
pvs = pvsToUse;
}
}
// 刪除與本次分析無關程式碼...
}
}
在Spring 中，@Autowired註解是由AutowiredAnnotationBeanPostProcessor類處理，而@Resource註解是由CommonAnnotationBeanPostProcessor類處理，這兩個類都實現了InstantiationAwareBeanPostProcessor介面，都是在覆寫的postProcessProperties方法中完成了依賴注入。這裡我們就分析@Autowired註解的處理。
// AutowiredAnnotationBeanPostProcessor#postProcessProperties
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 根據beanName以及bean的class去查詢Bean的依賴元資料-InjectionMetadata
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {// 呼叫inject方法
metadata.inject(bean, beanName, pvs);
} catch (BeanCreationException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
在InjectionMetadata的inject方法中，獲取當前Bean所有需要處理的依賴元素(InjectedElement)，這是一個集合，遍歷該集合，呼叫每一個依賴注入元素的inject方法。
// InjectionMetadata#inject
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
// 獲取當前Bean所有的依賴注入元素(可能是方法，也可能是欄位)
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
// 如果當前Bean的依賴注入項不為空，遍歷該依賴注入元素
for (InjectedElement element : elementsToIterate) {
// 呼叫每一個依賴注入元素的inject方法。
element.inject(target, beanName, pvs);
}
}
}
在AutowiredAnnotationBeanPostProcessor類中定義了兩個內部類-AutowiredFieldElement、AutowiredMethodElement繼承自InjectedElement，它們分別對應欄位注入和方法注入。
以大家常用的欄位注入為例，在AutowiredFieldElement的inject方法中，首先判斷當前欄位是否已經被處理過，如果已經被處理過直接走快取，否則呼叫BeanFactory的resolveDependency方法來處理依賴。
// AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {// 如果當前欄位已經被處理過，直接從快取中獲取
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
} else {
// 構建依賴描述符
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {// 呼叫BeanFactory的resolveDependency來解析依賴
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
} catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
// 刪除與本次分析無關程式碼....
}
if (value != null) {
// 通過反射來對屬性進行賦值
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
}
在DefaultListableBeanFactory實現的resolveDependency方法，最終還是呼叫doResolveDependency方法來完成依賴解析的功能。在Spring原始碼中，如果存在do什麼什麼方法，那麼該方法才是真正幹活的方法。
// DefaultListableBeanFactory#resolveDependency
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
// .....
// 如果在欄位(方法)上添加了@Lazy註解，那麼在這裡將不會真正的去解析依賴
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
// 如果新增@Lazy註解，那麼則呼叫doResolveDependency方法來解析依賴
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
// DefaultListableBeanFactory#doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//.....
try {
// 根據名稱以及型別查詢合適的依賴
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {// 如果未找到相關依賴
if (isRequired(descriptor)) { // 如果該依賴是必須的(@Aautowired的required屬性)，直接丟擲異常
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
// 如果查詢到的依賴多於一個，例如某個介面存在多個實現類，並且多個實現類都註冊到IoC容器中。
if (matchingBeans.size() > 1) {// 決定使用哪一個實現類，@Primary等方式都是在這裡完成
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
} else {
return null;
}
}
instanceCandidate = matchingBeans.get(autowiredBeanName);
} else {
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
// 如果查詢到的依賴是某個類的Class(通常如此)，而不是例項，
//呼叫描述符的方法來根據型別resolveCandidate方法來獲取該型別的例項。
if (instanceCandidate instanceof Class) {
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
//...
}
在依賴描述符的resolveCandidate方法中，是通過呼叫BeanFactory 的getBean方法來完成所依賴Bean例項的獲取。
// DependencyDescriptor#resolveCandidate
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
throws BeansException {
return beanFactory.getBean(beanName);
}
而在getBean方法實現中，依然是通過呼叫doGetBean方法來完成。這也和我們自己寫的依賴處理基本一致，只不過我們自己寫的比較簡單，而Spring要考慮和處理的場景複雜，因此程式碼比較繁雜，但大體思路都是一樣的。
// AbstractBeanFactory#getBean
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
重點是前面我們寫的處理迴圈依賴的Demo，如果理解那個程式碼，再看Spring的迴圈依賴處理，就會發現很簡單。
總結
迴圈依賴就是指兩個Bean之間存在相互引用關係，例如A依賴B，B又依賴A，但Spring只能解決屬性迴圈依賴，不能解決建構函式迴圈依賴，這種場景也無法解決。
Spring解決迴圈依賴的關鍵就是在處理Bean的屬性依賴時，先將Bean存到三級快取中，當存在迴圈依賴時，從三級快取中獲取到相關Bean，然後從三級快取中移除，存入到二級快取中。
什麼是迴圈依賴？
顧名思義，迴圈依賴就是A依賴B，B又依賴A，兩者之間的依賴關係形成了一個圓環，通常是由於不正確的編碼所導致。Spring只能解決屬性迴圈依賴問題，不能解決建構函式迴圈依賴問題，因為這個問題無解。
接下來我們首先寫一個Demo來演示Spring是如何處理屬性迴圈依賴問題的。
Talk is cheap. Show me the code
第一步：定義一個類ComponentA，其有一個私有屬性componentB。
package com.tech.ioc;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* @author 君戰
* **/
@Component
public class ComponentA {
@Autowired
private ComponentB componentB;
public void say(){
componentB.say();
}
}
第二步：定義一個類ComponentB，其依賴ComponentA。並定義一個say方法便於列印資料。
package com.tech.ioc;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* @author 君戰
* **/
@Component
public class ComponentB {
@Autowired
private ComponentA componentA;
public void say(){
System.out.println("componentA field " + componentA);
System.out.println(this.getClass().getName() + " -----> say()");
}
}
第三步：重點，編寫一個類-SimpleContainer，模仿Spring底層處理迴圈依賴。如果理解這個程式碼，再去看Spring處理迴圈依賴的邏輯就會很簡單。
package com.tech.ioc;
import java.beans.Introspector;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 演示Spring中迴圈依賴是如何處理的，只是個簡版，真實的Spring依賴處理遠比這個複雜。
* 但大體思路都相同。另外這個Demo很多情況都未考慮，例如執行緒安全問題，僅供參考。
* @author 君戰
*
* **/
public class SimpleContainer {
/***
* 用於存放完全初始化好的Bean，Bean處於可狀態
* 這個Map定義和Spring中一級快取命名一致
* */
private Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
/***
* 用於存放剛創建出來的Bean，其屬性還沒有處理，因此存放在該快取中的Bean還不可用。
* 這個Map定義和Spring中三級快取命名一致
* */
private final Map<String, Object> singletonFactories = new HashMap<>(16);
public static void main(String[] args) {
SimpleContainer container = new SimpleContainer();
ComponentA componentA = container.getBean(ComponentA.class);
componentA.say();
}
public <T> T getBean(Class<T> beanClass) {
String beanName = this.getBeanName(beanClass);
// 首先根據beanName從快取中獲取Bean例項
Object bean = this.getSingleton(beanName);
if (bean == null) {
// 如果未獲取到Bean例項，則建立Bean例項
return createBean(beanClass, beanName);
}
return (T) bean;
}
/***
* 從一級快取和二級快取中根據beanName來獲取Bean例項，可能為空
* */
private Object getSingleton(String beanName) {
// 首先嚐試從一級快取中獲取
Object instance = singletonObjects.get(beanName);
if (instance == null) { // Spring 之所以能解決迴圈依賴問題，也是靠著這個singletonFactories
instance = singletonFactories.get(beanName);
}
return instance;
}
/***
* 建立指定Class的例項，返回完全狀態的Bean(屬性可用)
*
* */
private <T> T createBean(Class<T> beanClass, String beanName) {
try {
Constructor<T> constructor = beanClass.getDeclaredConstructor();
T instance = constructor.newInstance();
// 先將剛建立好的例項存放到三級快取中，如果沒有這一步，Spring 也無法解決三級快取
singletonFactories.put(beanName, instance);
Field[] fields = beanClass.getDeclaredFields();
for (Field field : fields) {
Class<?> fieldType = field.getType();
field.setAccessible(true);
// 精髓是這裡又呼叫了getBean方法，例如正在處理ComponentA.componentB屬性，
// 執行到這裡時就會去例項化ComponentB。因為在getBean方法首先去查快取，
// 而一級快取和三級快取中沒有ComponentB例項資料，所以又會呼叫到當前方法，
// 而在處理ComponentB.componentA屬性時，又去呼叫getBean方法去快取中查詢，
// 因為在前面我們將ComponentA例項放入到了三級快取，因此可以找到。
// 所以ComponentB的例項化結束，方法出棧，返回到例項化ComponentA的方法棧中，
// 這時ComponentB已經初始化完成，因此ComponentA.componentB屬性賦值成功！
field.set(instance, this.getBean(fieldType));
}
// 最後再將初始化好的Bean設定到一級快取中。
singletonObjects.put(beanName, instance);
return instance;
} catch (Exception e) {
e.printStackTrace();
}
throw new IllegalArgumentException();
}
/**
* 將類名小寫作為beanName，Spring底層實現和這個差不多，也是使用javaBeans的
* {@linkplain Introspector#decapitalize(String)}
**/
private String getBeanName(Class<?> clazz) {
String clazzName = clazz.getName();
int index = clazzName.lastIndexOf(".");
String className = clazzName.substring(index);
return Introspector.decapitalize(className);
}
}
如果各位同學已經閱讀並理解上面的程式碼，那麼接下來我們就進行真實的Spring處理迴圈依賴問題原始碼分析，相信再閱讀起來就會很容易。
底層原始碼分析
分析從AbstractBeanFactory的doGetBean方法著手。可以看到在該方法首先呼叫transformedBeanName(其實就是處理BeanName問題)，和我們自己寫的getBeanName方法作用是一樣的，但Spring考慮的遠比這個複雜，因為有FactoryBean、別名問題。
// AbstractBeanFactory#doGetBean
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
// ！！！重點是這裡，首先從快取中beanName來獲取對應的Bean。
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 執行到這裡說明快取中存在指定beanName的Bean例項，getObjectForBeanInstance是用來處理獲取到的Bean是FactoryBean問題
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
else {
try {
// 刪除與本次分析無關程式碼....
// 如果是單例Bean，則通過呼叫createBean方法進行建立
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
return (T) bean;
}
getSingleton方法存在過載方法，這裡呼叫的是過載的getSingleton方法，注意這裡傳遞的boolean引數值為true，因為該值決定了是否允許曝光早期Bean。
// DefaultSingletonBeanRegistry#getSingleton
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
// DefaultSingletonBeanRegistry#getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 首先從一級快取中獲取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 如果一級快取中未獲取到，再從二級快取中獲取
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果未從二級快取中獲取到並且allowEarlyReference值為true(前面傳的為true)
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
//Double Check
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 最後嘗試去三級快取中獲取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 儲存到二級快取
this.earlySingletonObjects.put(beanName, singletonObject);
// 從三級快取中移除
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
ok，看完Spring是如何從快取中獲取Bean例項後，那再看看creatBean方法是如何建立Bean的
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// 刪除與本次分析無關的程式碼...
try {// createBean方法底層是通過呼叫doCreateBean來完成Bean建立的。
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
// AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 建立Bean例項
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
// 如果允許當前Bean早期曝光。只要Bean是單例的並且allowCircularReferences 屬性為true(預設為true)
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 這裡呼叫了addSingletonFactory方法將剛建立好的Bean儲存到了三級快取中。
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 刪除與本次分析無關的程式碼.....
Object exposedObject = bean;
try {// Bean屬性填充
populateBean(beanName, mbd, instanceWrapper);
// 初始化Bean，熟知的Aware介面、InitializingBean介面.....都是在這裡呼叫
exposedObject = initializeBean(beanName, exposedObject, mbd);
} catch (Throwable ex) {
}
// 刪除與本次分析無關的程式碼.....
return exposedObject;
}
先分析addSingletonFactory方法，因為在該方法中將Bean儲存到了三級快取中。
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
// 如果一級快取中不存在指定beanName的key
if (!this.singletonObjects.containsKey(beanName)) {
// 將剛建立好的Bean示例儲存到三級快取中
this.singletonFactories.put(beanName, singletonFactory);
// 從二級快取中移除。
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
處理Bean的依賴注入是由populateBean方法完成的，但整個執行鏈路太長了，這裡就不展開講了，只說下IoC容器在處理依賴時是如何一步一步呼叫到getBean方法的，這樣就和我們自己寫的處理欄位注入的邏輯對上了。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 刪除與本次分析無關程式碼...
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 遍歷所有已註冊的BeanPostProcessor介面實現類，如果實現類是InstantiationAwareBeanPostProcessor介面型別的，呼叫其postProcessProperties方法。
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
// 刪除與本次分析無關程式碼...
pvs = pvsToUse;
}
}
// 刪除與本次分析無關程式碼...
}
}
在Spring 中，@Autowired註解是由AutowiredAnnotationBeanPostProcessor類處理，而@Resource註解是由CommonAnnotationBeanPostProcessor類處理，這兩個類都實現了InstantiationAwareBeanPostProcessor介面，都是在覆寫的postProcessProperties方法中完成了依賴注入。這裡我們就分析@Autowired註解的處理。
// AutowiredAnnotationBeanPostProcessor#postProcessProperties
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 根據beanName以及bean的class去查詢Bean的依賴元資料-InjectionMetadata
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {// 呼叫inject方法
metadata.inject(bean, beanName, pvs);
} catch (BeanCreationException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
在InjectionMetadata的inject方法中，獲取當前Bean所有需要處理的依賴元素(InjectedElement)，這是一個集合，遍歷該集合，呼叫每一個依賴注入元素的inject方法。
// InjectionMetadata#inject
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
// 獲取當前Bean所有的依賴注入元素(可能是方法，也可能是欄位)
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
// 如果當前Bean的依賴注入項不為空，遍歷該依賴注入元素
for (InjectedElement element : elementsToIterate) {
// 呼叫每一個依賴注入元素的inject方法。
element.inject(target, beanName, pvs);
}
}
}
在AutowiredAnnotationBeanPostProcessor類中定義了兩個內部類-AutowiredFieldElement、AutowiredMethodElement繼承自InjectedElement，它們分別對應欄位注入和方法注入。
[圖片上傳中...(image-20be56-1610010542040-0)]
以大家常用的欄位注入為例，在AutowiredFieldElement的inject方法中，首先判斷當前欄位是否已經被處理過，如果已經被處理過直接走快取，否則呼叫BeanFactory的resolveDependency方法來處理依賴。
// AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {// 如果當前欄位已經被處理過，直接從快取中獲取
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
} else {
// 構建依賴描述符
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {// 呼叫BeanFactory的resolveDependency來解析依賴
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
} catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
// 刪除與本次分析無關程式碼....
}
if (value != null) {
// 通過反射來對屬性進行賦值
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
}
在DefaultListableBeanFactory實現的resolveDependency方法，最終還是呼叫doResolveDependency方法來完成依賴解析的功能。在Spring原始碼中，如果存在do什麼什麼方法，那麼該方法才是真正幹活的方法。
// DefaultListableBeanFactory#resolveDependency
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
// .....
// 如果在欄位(方法)上添加了@Lazy註解，那麼在這裡將不會真正的去解析依賴
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
// 如果新增@Lazy註解，那麼則呼叫doResolveDependency方法來解析依賴
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
// DefaultListableBeanFactory#doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//.....
try {
// 根據名稱以及型別查詢合適的依賴
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {// 如果未找到相關依賴
if (isRequired(descriptor)) { // 如果該依賴是必須的(@Aautowired的required屬性)，直接丟擲異常
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
// 如果查詢到的依賴多於一個，例如某個介面存在多個實現類，並且多個實現類都註冊到IoC容器中。
if (matchingBeans.size() > 1) {// 決定使用哪一個實現類，@Primary等方式都是在這裡完成
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
} else {
return null;
}
}
instanceCandidate = matchingBeans.get(autowiredBeanName);
} else {
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
// 如果查詢到的依賴是某個類的Class(通常如此)，而不是例項，
//呼叫描述符的方法來根據型別resolveCandidate方法來獲取該型別的例項。
if (instanceCandidate instanceof Class) {
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
//...
}
在依賴描述符的resolveCandidate方法中，是通過呼叫BeanFactory 的getBean方法來完成所依賴Bean例項的獲取。
// DependencyDescriptor#resolveCandidate
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
throws BeansException {
return beanFactory.getBean(beanName);
}
而在getBean方法實現中，依然是通過呼叫doGetBean方法來完成。這也和我們自己寫的依賴處理基本一致，只不過我們自己寫的比較簡單，而Spring要考慮和處理的場景複雜，因此程式碼比較繁雜，但大體思路都是一樣的。
// AbstractBeanFactory#getBean
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
重點是前面我們寫的處理迴圈依賴的Demo，如果理解那個程式碼，再看Spring的迴圈依賴處理，就會發現很簡單。
總結
迴圈依賴就是指兩個Bean之間存在相互引用關係，例如A依賴B，B又依賴A，但Spring只能解決屬性迴圈依賴，不能解決建構函式迴圈依賴，這種場景也無法解決。
Spring解決迴圈依賴的關鍵就是在處理Bean的屬性依賴時，先將Bean存到三級快取中，當存在迴圈依賴時，從三級快取中獲取到相關Bean，然後從三級快取中移除，存入到二級快取中。
歡迎關注公眾號：前程有光，領取一線大廠Java面試題總結+各知識點學習思維導+一份300頁pdf文件的Java核心知識點總結！