什么是回圈依賴？
顧名思義，回圈依賴就是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，它們分別對應欄位注入和方法注入，
// 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)) { // 如果該依賴是必須的(例如@Autowired的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，然后從三級快取中移除，存入到二級快取中，最后初始化完畢后存入到一級快取中，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/246165.html
標籤：java
下一篇：海龜畫圖全解--值得你一看！