spring 5.0.21.BUILD-SNAPSHOT源码解读，第二集(Spring循环依赖解决方案)
1.老办法，代码放在码云：
https://gitee.com/rich_lz/spring_kz 所属分支：springReferDepends；
2.循环依赖代码演示：
@Repository public class TestDao {
/**
*
*dao层依赖TestService
*/
@Autowired private TestService testservice; public String sayHello(String name){ System.out.println("接口调用==>"+name); return name; } }
@Service(value = "TestService") public class TestService {
/**
*TestService 又依赖TestDao
*
**/
@Autowired private TestDao testDao; @Autowired TestService(TestDao testDao){ this.testDao = testDao; } public String test(String name){ return testDao.sayHello(name); } }
3.代码调试：
通过第一集的内容，我们大概了解到spring先要加载bean，然后再实例化，那么我们很容易就想到发生循环依赖肯定是在实例化的过程中，那么我们就很容易的找到我们需要调试的地方了，AbstractApplicationContext.refresh()
这个方法中一共有11个方法，真正实例化bean的地方是在 finishBeanFactoryInitialization(beanFactory); 内，通过源码跟踪定位到DefaultListableBeanFactory.preInstantiateSingletons()。
@Override public void preInstantiateSingletons() throws BeansException { if (logger.isDebugEnabled()) { logger.debug("Pre-instantiating singletons in " + this); } // 获取到所有已经定义好，并且放到list集合中的bean. List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 这个bean不是抽象的，是单例，不是懒加载。 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
//实现FactoryBean接口的bean. if (bean instanceof FactoryBean) { FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged( (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else {
//核心方法，普通定义的bean。 getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }
4.再打开getBean方法再往下跟会发现调用的事AbstractBeanFactory.doGetBean()方法：
/** * 开始实例化bean. */ // Create bean instance. if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try {
//回调，会调用AbstractAutowireCapableBeanFactory的createBean方法。 return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); }
5.接着再次进入到createBean方法中.
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } ............
try {//开始创建bean Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isDebugEnabled()) { logger.debug("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { // A previously detected exception with proper bean creation context already, // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. throw ex; } }
6.又进入到doCreateBean方法(这个方法很重要)：
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { //第1步，实例化对象，根据构造函数实例化对象。 instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } /** * 根据是否是单例，是否允许循环依赖，当前对象是否在创建 三个条件。 * 目的是将已经实例化的对象（还没有初始化）放入到一个对外可识别的容器中。 */ // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isDebugEnabled()) { logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } /** * 将已经实例化的对象放入到singletonFactories,registeredSingletons 中。 */ addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { //第二步，填充属性，解决依赖问题。 populateBean(beanName, mbd, instanceWrapper); //调用initmethod方法，初始化。 exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
7.上述代码中有几个方法很重要： createBeanInstance，创建实例对象，就是调用构造函数，代码如下：
return BeanUtils.instantiateClass(constructorToUse);
初始化对象完毕之后，只是在内存中分配了一块空地儿，对象中的属性全部都是null。
8.那么接下来就需要进入到populateBean填充属性的方法中了，注意在填充属性之前，实例化之后，会做一个操作，将刚才实例化的TestDao(半成品只有内存空间，没有属性值)放到三级缓存中：
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); } } }
9.这个时候才会填充刚才已经实例化好的Testdao对象,进入到populateBean方法中，主要代码如下：
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { //获取bean的后置处理器，对已经实例化的bean做处理。if (hasInstAwareBpps) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { /** * AutowiredAnnotationBeanPostProcessor 后置处理器处理属性依赖。 */ InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvs == null) { return; } } } }
10.这个时候再次进入到 postProcessPropertyValues 方法中发现进入到 InjectionMetadata的inject方法中，我们不妨先看看调用这个方法之前传入的参数：
11.参数中的bean中的属性testservice依然为null,说明此时还没有注入，那么我们调试再进入到inject中，进入到这个方法中：
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable { Collection<InjectedElement> checkedElements = this.checkedElements; Collection<InjectedElement> elementsToIterate = (checkedElements != null ? checkedElements : this.injectedElements);
//获取到这个对象的所填充属性。 if (!elementsToIterate.isEmpty()) { for (InjectedElement element : elementsToIterate) { if (logger.isDebugEnabled()) { logger.debug("Processing injected element of bean '" + beanName + "': " + element); } element.inject(target, beanName, pvs); } } }
12. 通过上述接入可以看到TestDao 已经实例化，现在已经获取到他的一个属性类型为Testservice.
再次接着走入到 element.inject(target, beanName, pvs)方法中:
@Override @Nullable public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException { ........else { Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary( descriptor, requestingBeanName); if (result == null) {//开始处理依赖 result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter); } return result; } }
13.需要再次的进入到： doResolveDependency中:
@Nullable public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException { //开始处理依赖，处理基本类型，像Array,Map,Collection, Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter); if (multipleBeans != null) { return multipleBeans; } //根据属性匹配看有没有匹配的bean. Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor); if (matchingBeans.isEmpty()) { if (isRequired(descriptor)) { raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor); } return null; } String autowiredBeanName; Object instanceCandidate; if (matchingBeans.size() > 1) { autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor); if (autowiredBeanName == null) { if (isRequired(descriptor) || !indicatesMultipleBeans(type)) { return descriptor.resolveNotUnique(type, matchingBeans); } else { // In case of an optional Collection/Map, silently ignore a non-unique case: // possibly it was meant to be an empty collection of multiple regular beans // (before 4.3 in particular when we didn't even look for collection beans). 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); } if (instanceCandidate instanceof Class) { //根据类型寻找daoBean定义之后，开始实例化这个bean. instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this); } Object result = instanceCandidate; if (result instanceof NullBean) { if (isRequired(descriptor)) { raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor); } result = null; } if (!ClassUtils.isAssignableValue(type, result)) { throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass()); } return result; } finally { ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint); } }
14.我们注意到 findAutowireCandidates 这个方法好像是跟注解有关系的，先通过表达式看下结果：
15.通过返回结果值看到时一个TestService 的class类，很明显这个方法是根据我传入的参数名称，从bean定义的容器中返回一个class对象，调试进去：
protected Map<String, Object> findAutowireCandidates( @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
//这里根据传入的beanName = TestDao, requireType =com.audaque.learn.srvice.TestService
//直接找到TestService这个bean.
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors( this, requiredType, true, descriptor.isEager()); Map<String, Object> result = new LinkedHashMap<>(candidateNames.length); for (String candidate : candidateNames) { if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) { addCandidateEntry(result, candidate, descriptor, requiredType); } } if (result.isEmpty() && !indicatesMultipleBeans(requiredType)) { // Consider fallback matches if the first pass failed to find anything... DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch(); for (String candidate : candidateNames) { if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor)) { addCandidateEntry(result, candidate, descriptor, requiredType); } } if (result.isEmpty()) { // Consider self references as a final pass... // but in the case of a dependency collection, not the very same bean itself. for (String candidate : candidateNames) { if (isSelfReference(beanName, candidate) && (!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) && isAutowireCandidate(candidate, fallbackDescriptor)) { addCandidateEntry(result, candidate, descriptor, requiredType); } } } } return result; }
16.这个方法主要代码就是第一行的
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());从bean定义的容器中获取指定类型的bean.
17.通过看参数返回值，发现已经返回了我们需要的testSerivce的定义对象，其实这里就是这个testService的beandefinition.
那么接下来已经获取到属性对应的bean定义信息了，那么就需要去实例化这个属性的bean了，代码会跳转到 descriptor.resolveCandidate这个方法中，
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) throws BeansException { //别看只有一行代码，要了我的命，在这里再去实例化Testservice,流程跟实例化Testdao一样。 return beanFactory.getBean(beanName); }
18.在通过一圈的调试，截图发现神奇的问题：
先市实例化TestDao依赖TestService，那么会去实例化TestService，但是TestService中又依赖TestDao 的属性，但是现在截图中的效果是，TestService中的TestDao有值，但是TestDao中的属性值依然为空，说明在testservice实例化中已经从我们上边的某个地方获取到了TestDao,哈哈哈，是不是很神奇，写了半天了，才到了见证奇迹的时候了，其实我在第八步骤的时候，就有埋下伏笔的，在实例化TestDao 的时候，已经提前将这个半成品暴露出去了，那么在实例化Testservice的TestDao中获取，会从这个把这个半成品放到TestService 的testdao 属性上，不信？，代码如下：
protected Object getSingleton(String beanName, boolean allowEarlyReference) { Object singletonObject = this.singletonObjects.get(beanName);
//判断这个bean是否正在创建。 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; }
再结合第8步，是不是瞬间明白了？哈哈哈，不过没明白也没关系，我再来重新梳理一遍。
TestService依赖TestDao ,TestDao依赖TestService.
1.实例化TestDao，会调用getSingleton()，此时第一次调用返回空，那么就去实例化，并把返回结果TestDao放到三级缓存中，也就是singletonFactories中，并标注这个testDao的bean正在创建。
2.再去填充属性，发现有一个类型为TestService的属性，那么就会去实例化TestService这个对象。
3.实例化TestService这个对象，同样调用getSingleton()返回空，那么也要去实例化一个TestService对象，并把它放到singletonFactories三级缓存。
4.再去寻找TestService依赖的Testdao,这个时候调用getSingleton（），由于在第一步骤的时候已经放到缓存中，并且当前的属性testDao是在创建中，所有getSingleton（）方法就会把第一部创建的对象返回，并将三级缓存的对象提升到二级缓存
earlySingletonObjects中。
5.TestService的属性填充完了。
6.开始再次返回到TestDao中将TestService设置到它本身的属性中。至此循环依赖就解决掉了。
*：通过这个分析其实并不是所有的循环依赖都能解决，我通过上述的过程分析可以看出来，属性之间的依赖是可以解决，构造函数与属性之间的依赖也是可以解决的，构造函数与构造函数之间的依赖是解决不了的。
道生一,一生二,二生三,三生万物。
