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

客官°小女子只卖身不卖艺 2023-10-04 10:16 46阅读 0赞

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

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));
    				}
    			}
    		}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70][]

调用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的办成品对象（未初始化）**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 2][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 3][]

\-》返回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也被赋上值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 4][]

\-》返回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);
    				}

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 5][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 6][]

三.创建流程截图

![format_png][]

![20210409225818293.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 7][]

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

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的话，二级缓存足矣解决循环依赖问题

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210410105344744.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2021041012084668.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2021041012093331.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210410122653259.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210410132756652.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210410133836730.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210410134127924.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H,size_16,color_FFFFFF,t_70
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy90cEVJTGxFbHNrTFpWeDlYSUN0SGtjTnhMeE1nMFR1WHlQaWJFWDRSaWNqZE9ldzNDM3F3d3hHbVJFcXc0c1dpYTRYdXNmQkZmajdseENrMjFHN3ZPVFR6Zy82NDA?x-oss-process=image/format,png
[20210409225818293.png]: https://img-blog.csdnimg.cn/20210409225818293.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210410125945417.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pIQU5HTElaRU5H,size_16,color_FFFFFF,t_70