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（）方法就会把第一部创建的对象返回。
5.TestService的属性填充完了。
6.开始再次返回到TestDao中将TestService设置到它本身的属性中。至此循环依赖就解决掉了。
*：通过这个分析其实并不是所有的循环依赖都能解决，我通过上述的过程分析可以看出来，属性之间的依赖是可以解决，构造函数与属性之间的依赖也是可以解决的，构造函数与构造函数之间的依赖是解决不了的。
标签：5.0,String,mbd,beanName,descriptor,bean,源码,null,第二集 来源： https://www.cnblogs.com/kangz/p/14208418.html