spring循环依赖缓存问题源码剖析

一、针对循环依赖，使用代码来进行源码跟踪

1.创建实体类A/B,A里面有B，B里面有A，循环依赖

package cycle;

public class A {

	private B b;


	public B getB() {
		return b;
	}

	public void setB(B b) {
		this.b = b;
	}
}

package cycle;

public class B {

	private A a;


	public A getA() {
		return a;
	}

	public void setA(A a) {
		this.a = a;
	}
}

2.创建xml文件，ref相互指向

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean class="cycle.A" id="a">
		<property name="b" ref="b"/>
	</bean>

	<bean class="cycle.B" id="b">
		<property name="a" ref="a"/>
	</bean>
</beans>

3.测试程序

package cycle;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试循环依赖的注入过程
 */
public class DemoDependen {

	public static void main(String[] args) {

		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("cycle.xml");
		A bean = applicationContext.getBean(A.class);
		System.out.println(bean.getB());

		B bean1 = applicationContext.getBean(B.class);
		System.out.println(bean1.getA());



	}
}

二、结合源代码分析

1.创建bean的方法在finishBeanFactoryInitialization(beanFactory)中调用

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		//为上下文初始化类型转换器
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {//conversionService
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no BeanFactoryPostProcessor
		// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		//如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器，主要用于注解值的解析
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		//尽早初始化LoadTimeWeaverAware bean，以便尽早注册转换器
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		//禁止使用临时类加载器进行类型匹配
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		//冻结所有的bean定义，说明注册的bean将不被修改或者进一步的处理
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		//实例化剩下的单例对象
		beanFactory.preInstantiateSingletons();
	}

2.再来看其下的beanFactory.preInstantiateSingletons()实例化方法

public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
	    //将所有的beandefinitionNames属性里面的名字做为数组创建对象
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		//遍历集合，触发所有非延时加载的单例bean的初始化，延时加载的单例不在此处处理
		for (String beanName : beanNames) {
			//合并父类BeanDefinition
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//条件判断：抽象 单例  非懒加载
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//判断是否实现了FactoryBean接口
				if (isFactoryBean(beanName)) {
					//根据&+beanName来获取具体的bean对象
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						//进行类型转化
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						//判断这个FactoryBean是否希望立即初始化
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						//如果希望急切的初始化，则通过beanName获取bean
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {//如果beanName对应Bean不是FactoryBean，只是普通的Bean，则通过beanName获取Bean
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
				smartInitialize.end();
			}
		}
	}

3.接下来看getBean(beanName)，此时beanName为a：

@Override
	public Object getBean(String name) throws BeansException {
		//此方法是实际获取Bean的方法，也是触发依赖注入的方法
		return doGetBean(name, null, null, false);
	}

4.doGetBean(name, null, null, false)方法中调用第一个方法Object sharedInstance = getSingleton(beanName)时，缓存中获取不到值

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// Quick check for existing instance without full singleton lock
		//从单例对象缓存中获取beanName对应的单例对象
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果单例对象缓存中没有，并且该beanName对应的单例对象正在创建中
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			//从早期单例缓存对象中获取单例对象，（之所以称之为早期对象，是因为earlySingletonObjects里的对象
			//都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作）
			singletonObject = this.earlySingletonObjects.get(beanName);
			//如果在早期单例对象缓存中也没有,并且允许创建早期单例对象引用
			if (singletonObject == null && allowEarlyReference) {
				//如果为空，则锁定全局变量，进行处理
				synchronized (this.singletonObjects) {
					// Consistent creation of early reference within full singleton lock
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						singletonObject = this.earlySingletonObjects.get(beanName);
						if (singletonObject == null) {
							//当某些方法需要提前初始化的时候，则会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletonFactoryies
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								singletonObject = singletonFactory.getObject();
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

调用第二个获取缓存方法的sharedInstance = getSingleton(beanName,lamabd())表达式，此时一级缓存singletonObjects中没有值

	            sharedInstance = getSingleton(beanName, () -> {
						try {
							//为给定的合并后的BeanDefinition（和参数）创建一个bean对象
							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;
						}
					});

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		//如果beanName为空，则抛出异常
		Assert.notNull(beanName, "Bean name must not be null");
		//使用单例对象的高速缓存map作为锁，保证线程同步
		synchronized (this.singletonObjects) {
			//从单例对象的高速缓存Map中获取beanName对应的bean对象
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				//如果在destructSingleton中
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				//如果当前日志级别是调试
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
				//创建单例之前的回调，默认实现将单例注册为正在创建
				beforeSingletonCreation(beanName);
				//表示生成了新的单例对象的标记，为false，标识没有生成单例对象
				boolean newSingleton = false;
				//有抑制异常标识，没有为true，有为false
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				//如果没有抑制异常记录
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					//从单例工厂中获取对象
					singletonObject = singletonFactory.getObject();
					//生成了新的单例对象的标识
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					// Has the singleton object implicitly appeared in the meantime ->
					// if yes, proceed with it since the exception indicates that state.
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				catch (BeanCreationException ex) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {//生成了新单例对象，放到缓存中
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

方法singletonObject = singletonFactory.getObject()，调用lambad表达式的方法createBean（）

5.createBean(beanName, mbd, args)：为给定的合并后的BeanDefinition（和参数）创建一个bean对象

@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		//锁定class，根据设置的class属性或者根据className来解析class
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		//进行条件筛选，重新赋值RootBeanDefinition，并设置BeanClass属性
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			//重新创建RootBeanDefinition对象
			mbdToUse = new RootBeanDefinition(mbd);
			//设置beanClass属性值
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		//验证及准备要覆盖的方法lookup-method
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}

		try {
			//实际创建bean的方法
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("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;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

6.Object beanInstance = doCreateBean(beanName, mbdToUse, args)：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		//这个beanWrapper是用来持有创建出来的bean的
		BeanWrapper instanceWrapper = null;
		//获取factoryBean的实例化缓存
		if (mbd.isSingleton()) {
			//如果是单例对象，从factorybean实例缓存中移出当前bean的定义信息
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		//没有就创建
		if (instanceWrapper == null) {
			//根据执行bean使用对象的策略创建对象
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//从包装类中获取原始bean，只是完成了实例化操作，字段值都是空
		Object bean = instanceWrapper.getWrappedInstance();
		//获取bean对象的class属性
		Class<?> beanType = instanceWrapper.getWrappedClass();
		//如果不等于NullBean类型，则修改目标类型
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		//允许beanPostprocesser去修改合并后的beandefinition
		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.
		//判断当前bean是否需要提前曝光，单例&允许循环依赖&当前bean正在创建中，检查循环依赖
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			//为了避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		//初始化bean实例
		Object exposedObject = bean;
		try {
			//对bean进行属性填充，将各个属性值注入，其中，可能存在依赖其他bean的属性，则会递归初始化依赖的bean
			populateBean(beanName, mbd, instanceWrapper);
			//执行初始化逻辑
			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);
			//earlySingletonReference只有在检测到有循环依赖的情况才不为空
			if (earlySingletonReference != null) {
				//如果exposedObject没有在初始化中被改变，也就是没有被增强
				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 {
			//注册bean对象，方便在后续容器销毁时销毁对象
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

7.调用方法instanceWrapper = createBeanInstance(beanName, mbd, args)实例化bean，调用instantiateBean创建bean

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		//确认需要创建的bean实例可以被实例化
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		//确保class不为空，并且访问权限是public
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		//判断当前beandefinition是否包含实例供应器，此处相当于一个回调方法，通过回调方法来创建bean
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		//如果工厂方法不为空，则使用工厂方法初始化策略
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		//一个类可能有多个构造器，所以Spring得根据参数个数，参数类型确认调用的构造器
		//在使用构造器创建实例后，Spring会将解析过后确定下来的构造器或工厂方法放到缓存中，避免再次创建相同bean时再解析
		// Shortcut when re-creating the same bean...
		//标记下，防止创建同一个bean
		boolean resolved = false;
		//是否需要自动装配
		boolean autowireNecessary = false;
		//如果没有参数
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				//因为一个类可能有多个构造器，所以需要根据参数类型确认调用的构造器
				//因为判断过程会比较，所以spring会将解析、确定好的构造函数缓存到RootBeanDefinition的resolvedConstructorOrFactoryMethod中
				//在下次创建相同的bean是，直接从RootBeanDefiniton中的属性resolvedConstructorOrFactoryMethod缓存只获取，避免重复解析
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		//有构造函数或者工厂方法
		if (resolved) {
			//构造器有参数
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {//使用默认构造函数构造
				return instantiateBean(beanName, mbd);
			}
		}

		// Candidate constructors for autowiring?
		//从bean后置处理中为自动装配寻找构造方法，有且仅有一个有参构造方法或者有且仅有@Autowired注解构造
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		/**
		 * 以下情况符合其一即可进入
		 * 1.存在可选构造方法、
		 * 2.自动装配模型为构造函数自动装配
		 * 3.给BeanDefinition设置参数构造值
		 * 4.有参与构造函数列表的参数
		 */
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// Preferred constructors for default construction?
		//找出最合适的构造方法
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			//构造函数自动注入
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		// No special handling: simply use no-arg constructor.
		//使用无参构造函数创建对象，
		return instantiateBean(beanName, mbd);
	}

8.通过addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))方法，把创建的key为beanName，value为singletonFactory的放入三级缓存中。

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		//使用singletonObjects加锁，保证线程安全
		synchronized (this.singletonObjects) {
			//如果单例对象的高速缓存【bean名称-bean实例】没有beanname的对象
			if (!this.singletonObjects.containsKey(beanName)) {
				//将beanName，singletonFactory放到单例工厂高速缓存【beanName-singletonFatory】
				this.singletonFactories.put(beanName, singletonFactory);
				//从早前单例对象的高速缓存【beanname，bean实例】，移出beaName的相关缓存对象
				this.earlySingletonObjects.remove(beanName);
				//将beanName添加已注册的单例集中
				this.registeredSingletons.add(beanName);
			}
		}
	}

9.populateBean(beanName, mbd, instanceWrapper)：对bean进行属性填充，将各个属性值注入，其中，可能存在依赖其他bean的属性，则会递归初始化依赖的bean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (pvs != null) {
			//运用给定的属性值，解决任何运用在这个bean工厂运行时其它bean的引用，必须使用深拷贝，所以我们不会永久的修改这个属性
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
}

applyPropertyValues(beanName, mbd, bw, pvs)：遍历属性给属性赋值，此时beanName是A，属性是B，对属性B进行相关操作

// Create a deep copy, resolving any references for values.
		List<PropertyValue> deepCopy = new ArrayList<>(original.size());
		boolean resolveNecessary = false;
		/**
		 * 遍历属性字段
		 */
		for (PropertyValue pv : original) {
			if (pv.isConverted()) {
				deepCopy.add(pv);
			}
			else {
				//获取属性的名字
				String propertyName = pv.getName();
				//获取未进类型转化的值
				Object originalValue = pv.getValue();
				//AutowiredPropertyMarker.INSTANCE自动生成标记的规范实例
				if (originalValue == AutowiredPropertyMarker.INSTANCE) {
					Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
					if (writeMethod == null) {
						throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
					}
					originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
				}

				/**
				 * 调用此方法
				 */
				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
				Object convertedValue = resolvedValue;
				boolean convertible = bw.isWritableProperty(propertyName) &&
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
				if (convertible) {
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
				}
				// Possibly store converted value in merged bean definition,
				// in order to avoid re-conversion for every created bean instance.
				if (resolvedValue == originalValue) {
					if (convertible) {
						pv.setConvertedValue(convertedValue);
					}
					deepCopy.add(pv);
				}
				else if (convertible && originalValue instanceof TypedStringValue &&
						!((TypedStringValue) originalValue).isDynamic() &&
						!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
					pv.setConvertedValue(convertedValue);
					deepCopy.add(pv);
				}
				else {
					resolveNecessary = true;
					deepCopy.add(new PropertyValue(pv, convertedValue));
				}
			}
		}

调用Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue)，B的值类型为RuntimeBeanReference，所以此方法中这个判断成立

	if (value instanceof RuntimeBeanReference) {//是这个类型
			RuntimeBeanReference ref = (RuntimeBeanReference) value;
			return resolveReference(argName, ref);//调用此方法
		}

调用resolveReference(argName, ref)处理，程序执行的是bean = this.beanFactory.getBean(resolvedName)，又回到第3不getBean方法中，此时beanName为B

@Nullable
	private Object resolveReference(Object argName, RuntimeBeanReference ref) {
		try {
			Object bean;
			Class<?> beanType = ref.getBeanType();
			if (ref.isToParent()) {
				BeanFactory parent = this.beanFactory.getParentBeanFactory();
				if (parent == null) {
					throw new BeanCreationException(
							this.beanDefinition.getResourceDescription(), this.beanName,
							"Cannot resolve reference to bean " + ref +
									" in parent factory: no parent factory available");
				}
				if (beanType != null) {
					bean = parent.getBean(beanType);
				}
				else {
					bean = parent.getBean(String.valueOf(doEvaluate(ref.getBeanName())));
				}
			}
			else {
				String resolvedName;
				if (beanType != null) {
					NamedBeanHolder<?> namedBean = this.beanFactory.resolveNamedBean(beanType);
					bean = namedBean.getBeanInstance();
					resolvedName = namedBean.getBeanName();
				}
				else {
					resolvedName = String.valueOf(doEvaluate(ref.getBeanName()));
					/**
					 * 再次调用getBean方法回去了
					 */
					bean = this.beanFactory.getBean(resolvedName);
				}
				this.beanFactory.registerDependentBean(resolvedName, this.beanName);
			}
			if (bean instanceof NullBean) {
				bean = null;
			}
			return bean;
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					this.beanDefinition.getResourceDescription(), this.beanName,
					"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
		}
	}

10.beanName为B，通过getBean（beanName）-》doGetBean(name, null, null, false)-》Object sharedInstance = getSingleton(beanName)也是获取不到缓存值-》

getSingleton(beanName,lambad（））方法中，Object singletonObject = this.singletonObjects.get(beanName)缓存中依然没有值-》createBean(beanName, mbd, args)-》

Object beanInstance = doCreateBean(beanName, mbdToUse, args)-》instanceWrapper = createBeanInstance(beanName, mbd, args)创建bean对象-》

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))新建的B添加到三级缓存中-》populateBean(beanName, mbd, instanceWrapper)给B对象填充属性-》applyPropertyValues(beanName, mbd, bw, pvs)给B对象填充属性值-》遍历B对象的参数，给每个参数赋值Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue)，此时的参数为A-》 resolveReference(argName, ref)处理属性-》再次回到bean = this.beanFactory.getBean(resolvedName)调用getBean方法，此时的参数变为A

到目前为止，入口为创建A，A的lamabd标识保存到三级缓存中，给A属性赋值时，有依赖B，然后一样的流程创建B对象，把B对象的lambd表达式存到三级缓存中，给B属性赋值时，有依赖A，跳转到创建A的getBean方法。

11.beanName为A，通过getBean（beanName）-》doGetBean(name, null, null, false)-》Object sharedInstance = getSingleton(beanName)从三级缓存中获取到值，放入到二级缓存中，移出三级缓存中的A

ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								singletonObject = singletonFactory.getObject();
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}

-》beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);返回对象A的实例-》返回doGetBean(name, null, null, false)-》返回getBean（beanName）-》返回this.beanFactory.getBean(resolvedName)-》返回resolveReference(argName, ref)-》返回Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue)获取到B对象的属性A值-》bw.setPropertyValues(new MutablePropertyValues(deepCopy))使用深拷贝给B对象的a属性赋值-》返回applyPropertyValues(beanName, mbd, bw, pvs)-》返回populateBean(beanName, mbd, instanceWrapper)

此时B的属性a已经赋上值，三级缓存中存放着B的lambda标识式，二级缓存中存放着A的办成品对象（未初始化）

12.设置完B的属性a后，执行方法doCreateBean（）下的判断方法

if (earlySingletonExposure) {
			//从缓存中获取具体对象
			Object earlySingletonReference = getSingleton(beanName, false);
			//earlySingletonReference只有在检测到有循环依赖的情况才不为空
			if (earlySingletonReference != null) {
				//如果exposedObject没有在初始化中被改变，也就是没有被增强
				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.");
					}
				}
			}
		}

此时的beanName还是B，B的创建还没有结束。Object earlySingletonReference = getSingleton(beanName, false)方法，缓存查询不到数据，此时B对应的单例对象不是正在创建中，不符合条件返回空

@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// Quick check for existing instance without full singleton lock
		//从单例对象缓存中获取beanName对应的单例对象
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果单例对象缓存中没有，并且该beanName对应的单例对象正在创建中
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			//从早期单例缓存对象中获取单例对象，（之所以称之为早期对象，是因为earlySingletonObjects里的对象
			//都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作）
			singletonObject = this.earlySingletonObjects.get(beanName);
			//如果在早期单例对象缓存中也没有,并且允许创建早期单例对象引用
			if (singletonObject == null && allowEarlyReference) {
				//如果为空，则锁定全局变量，进行处理
				synchronized (this.singletonObjects) {
					// Consistent creation of early reference within full singleton lock
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						singletonObject = this.earlySingletonObjects.get(beanName);
						if (singletonObject == null) {
							//当某些方法需要提前初始化的时候，则会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletonFactoryies
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								singletonObject = singletonFactory.getObject();
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

-》返回Object beanInstance = doCreateBean(beanName, mbdToUse, args)-》返回return createBean(beanName, mbd, args);-》返回

singletonObject = singletonFactory.getObject()-》执行其下的方法

if (newSingleton) {//生成了新单例对象，放到缓存中
					addSingleton(beanName, singletonObject);
				}

-》把当前B对象放到一级缓存中，移出二三级的B对象，singletonObject是组织完B的属性A的对象，此处B对象不存在于二级对象中，此时的B对象是一个完成的对象

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

至此，一级缓存中存放着完整的B对象，二级缓存中存放着半成品A（未初始化），三级对象移出完A和B

-》返回getSingleton(beanName，lamabd（））表达式方法-》返回doGetBean(name, null, null, false)-》返回bean = this.beanFactory.getBean(resolvedName)-》返回

resolveReference(argName, ref);-》返回Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue)

此时已经返回到设置A属性，遍历属性集合时，传递B出去的方法了，所以此时beanName为A,已经获取到属性b的值了-》

通过bw.setPropertyValues(new MutablePropertyValues(deepCopy));给A的属性B赋上值，此时二级缓存中的A对象的属性B也被赋上值

-》返回applyPropertyValues(beanName, mbd, bw, pvs)-》返回populateBean(beanName, mbd, instanceWrapper)赋值属性的方法-》

此时操作的beanName为A，调用方法Object earlySingletonReference = getSingleton(beanName, false);从二级缓存中获取到A对象

-》返回Object beanInstance = doCreateBean(beanName, mbdToUse, args);-》返回getSingleton(beanName，lamabd（））表达式方法-》返回

singletonObject = singletonFactory.getObject()-》执行其下的方法addSingleton(beanName, singletonObject)

		if (newSingleton) {//生成了新单例对象，放到缓存中
					addSingleton(beanName, singletonObject);
				}

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

此时beanName为A，把A对象放到一级缓存中，移出二三级级的A对象，此时三级对象中没有A对象。至此A中注入了B，B中注入了A，一级缓存中存放成品A、B、二三级缓存没有存放AB

13.实例化初始化完A之后，preInstantiateSingletons方法再操作B，但是从一级缓存中直接获取到B，不进行相关操作了

三.创建流程截图

四.先总结缓存的一些相关知识点

1.三级缓存中分别保存的对象有

（1）一级缓存singletonObjects：成品对象（实例化、初始化）；

（2）二级缓存earlySingletonObjects：半成品对象（实例化，未初始化）

（3）三级缓存singletonFactories：lambda标识式

2.不能只有一级缓存，因为成品和半成品对象会放到一起，在进行对象获取的时候有可能获取到半成品对象，这样的对象是没法使用的

3.只有二级缓存的时候修改下getSingleton（）方法，也可以解决循环依赖的问题，但是添加aop的实现之后，报错,This means that said other beans do not use the final version of the bean没有使用最终版本的bean对象

4.三级缓存作用：容器中，对象都是单例的，意味着根据名称只能获取一个对象的值，此时同时存在两个对象的话，使用的时候无法判断应该取哪一个。也无法确认什么时候会调用当前对象，是在其他对象的执行过程中来进行调用的，而不是人为指定的，所以必须要保证容器中任何时候都只有一个对象供外部调用，所以在三级缓存中，完成了代理对象替换非代理对象的工作，确定返回的是唯一的对象；三级缓存是为了解决在aop代理过程中产生的循环依赖问题，如果没有aop的话，二级缓存足矣解决循环依赖问题