Spring的Bean的实例化过程

柔情只为你懂 2022-10-07 06:52 243阅读 0赞

前面已经把Spring的ioc流程分析的很详细了，我们今天就来分析一下spring的Bean的实例化过程。来看下Spring是如何把一个Bean给new出来，并且是如何填充属性的.

进入refresh方法，查看finishBeanFactoryInitialization(beanFactory);

这个方法前面的代码都不是我们分析的重点，直接看最后一行代码:

// Instantiate all remaining (non-lazy-init) singletons.
    		beanFactory.preInstantiateSingletons();

public void preInstantiateSingletons() throws BeansException {
    		if (logger.isDebugEnabled()) {
    			logger.debug("Pre-instantiating singletons in " + this);
    		}
    		//所有bean的名字
    		// 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.
    		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
    		// Trigger initialization of all non-lazy singleton beans...
    		// 触发所有非延迟加载单例beans的初始化，主要步骤为调用getBean
    		for (String beanName : beanNames) {
    			//合并父BeanDefinition
    			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    				if (isFactoryBean(beanName)) {
    					//如果是FactoryBean则加上&
    					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    					if (bean instanceof FactoryBean) {
    						final 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 {
    					getBean(beanName);
    				}
    			}
    		}
    
    		// Trigger post-initialization callback for all applicable beans...
    		for (String beanName : beanNames) {
    			Object singletonInstance = getSingleton(beanName);
    			if (singletonInstance instanceof SmartInitializingSingleton) {
    				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    				if (System.getSecurityManager() != null) {
    					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    						smartSingleton.afterSingletonsInstantiated();
    						return null;
    					}, getAccessControlContext());
    				}
    				else {
    					smartSingleton.afterSingletonsInstantiated();
    				}
    			}
    		}
    	}

稍微的解读一下这段代码:

获取所有的beanName，遍历拿到我们BeanFactory里面的bd，判断是不是factoryBean，如果是的

会走一个factoryBean的逻辑，我们这次不分析factorybean,我们分析普通的bean，所以说会调用getBean,然后调用doGetBean

/**
    	 * 真正实现向IOC容器获取Bean的功能，也是触发依赖注入的地方
    	 * @param name
    	 * @param requiredType
    	 * @param args
    	 * @param typeCheckOnly
    	 * @param <T>
    	 * @return
    	 * @throws BeansException
    	 */
    	@SuppressWarnings("unchecked")
    	protected <T> T doGetBean(
    			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    			throws BeansException {
    
    		String beanName = transformedBeanName(name);
    		Object bean;
    
    		// Eagerly check singleton cache for manually registered singletons.
    		//先从缓存中获取单例bean，对于单例bean，整个IOC容器只创建一次
    		Object sharedInstance = getSingleton(beanName);
    		if (sharedInstance != null && args == null) {
    			if (logger.isDebugEnabled()) {
    				// 如果指定名称的bean在容器中已有单例模式的bean被创建，直接返回已经创建的bean
    				if (isSingletonCurrentlyInCreation(beanName)) {
    					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
    							"' that is not fully initialized yet - a consequence of a circular reference");
    				}
    				else {
    					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
    				}
    			}
    
    			// 获取给定bean的实例对象，主要是完成factorybean的相关处理
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		else {
    			//缓存中没有单例bean
    			//如果我们已经创建此bean实例，
    			//但是由于循环引用的问题导致实例化对象失败
    			if (isPrototypeCurrentlyInCreation(beanName)) {
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    
    			// Check if bean definition exists in this factory.
    			//对ioc容器中是否存在指定名称的BeanDefinition进行检查，首先检查
    			// 能在当前的BeanFactory中获取所需的Bean，如果不能委托当前容器的父类
    			// 去查找，如果还找不到则沿着容器的继承体系向父容器查找 (正常来说，这个parentBeanFactory肯定是null)
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    				// Not found -> check parent.
    				String nameToLookup = originalBeanName(name);
    				if (parentBeanFactory instanceof AbstractBeanFactory) {
    					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
    							nameToLookup, requiredType, args, typeCheckOnly);
    				}
    				else if (args != null) {
    					// Delegation to parent with explicit args.
    					//委派父容器根据根据指定名称和显式的参数查找
    					return (T) parentBeanFactory.getBean(nameToLookup, args);
    				}
    				else {
    					// No args -> delegate to standard getBean method.
    					//委派父容器根据根据指定名称和类型查找
    					return parentBeanFactory.getBean(nameToLookup, requiredType);
    				}
    			}
    
    			// 创建的Bean是否需要进行类型验证，一般不需要
    			if (!typeCheckOnly) {
    				// 像容器标记指定的Bean已经被创建
    				markBeanAsCreated(beanName);
    			}
    
    			try {
    				// 主要解决Bean继承时子类合并父类公共属性问题
    				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// Guarantee initialization of beans that the current bean depends on.
    				// 获取当前Bean依赖的所有Bean
    				String[] dependsOn = mbd.getDependsOn();
    				if (dependsOn != null) {
    					for (String dep : dependsOn) {
    						if (isDependent(beanName, dep)) {
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    						}
    						//递归调用getBean方法，获取当前bean的依赖Bean
    						registerDependentBean(dep, beanName);
    						try {
    							//把被依赖 Bean 注册给当前依赖的 Bean
    							getBean(dep);
    						}
    						catch (NoSuchBeanDefinitionException ex) {
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
    						}
    					}
    				}
    
    				// Create bean instance.
    				if (mbd.isSingleton()) {
    					// 这里使用了一个匿名内部类，创建bean实例对象，并且注册给所依赖的对象
    					sharedInstance = getSingleton(beanName, () -> {
    						try {
    							// 创建一个指定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;
    						}
    					});
    					// 获取给定Bean的实例对象
    					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    				}
    
    				// 如果是原型模式的bean对象
    				else if (mbd.isPrototype()) {
    					// It's a prototype -> create a new instance.
    					Object prototypeInstance = null;
    					try {
    						// 回调 beforePrototypeCreation 方法，默认的功能是注册当前创建的原型对象
    						beforePrototypeCreation(beanName);
    						// 创建bean
    						prototypeInstance = createBean(beanName, mbd, args);
    					}
    					finally {
    						//回调 afterPrototypeCreation 方法，默认的功能告诉 IOC 容器指定 Bean 的原型对象不再创建
    						afterPrototypeCreation(beanName);
    					}
    					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    				}
    
    				//要创建的 Bean 既不是单例模式，也不是原型模式，则根据 Bean 定义资源中
    				//配置的生命周期范围，选择实例化 Bean 的合适方法，这种在 Web 应用程序中
    				//比较常用，如：request、session、application 等生命周期
    				else {
    					String scopeName = mbd.getScope();
    					if (!StringUtils.hasLength(scopeName)) {
    						throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
    					}
    					Scope scope = this.scopes.get(scopeName);
    					if (scope == null) {
    						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
    					}
    					try {
    						Object scopedInstance = scope.get(beanName, () -> {
    							beforePrototypeCreation(beanName);
    							try {
    								return createBean(beanName, mbd, args);
    							}
    							finally {
    								afterPrototypeCreation(beanName);
    							}
    						});
    						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    					}
    					catch (IllegalStateException ex) {
    						throw new BeanCreationException(beanName,
    								"Scope '" + scopeName + "' is not active for the current thread; consider " +
    								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
    								ex);
    					}
    				}
    			}
    			catch (BeansException ex) {
    				cleanupAfterBeanCreationFailure(beanName);
    				throw ex;
    			}
    		}
    
    		// Check if required type matches the type of the actual bean instance.
    		// 对创建的bean实例对象，进行类型检查
    		if (requiredType != null && !requiredType.isInstance(bean)) {
    			try {
    				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
    				if (convertedBean == null) {
    					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    				}
    				return convertedBean;
    			}
    			catch (TypeMismatchException ex) {
    				if (logger.isDebugEnabled()) {
    					logger.debug("Failed to convert bean '" + name + "' to required type '" +
    							ClassUtils.getQualifiedName(requiredType) + "'", ex);
    				}
    				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    			}
    		}
    		return (T) bean;
    	}

这个方法真的很长，我们来慢慢分析一下:

首先

> //先从缓存中获取单例bean，对于单例bean，整个IOC容器只创建一次 Object sharedInstance = getSingleton(beanName);
> 
> 为啥会一上来就先获取一下呢，这个肯定是null啊？先留个疑问

第一次这个sharedInstance肯定是null的，会进入else分支

会执行这个判断：

>     //但是由于循环引用的问题导致实例化对象失败
>     if (isPrototypeCurrentlyInCreation(beanName)) {
>        throw new BeanCurrentlyInCreationException(beanName);
>     }

一直走到一个最重要的方法：

if (mbd.isSingleton()) {
    					// 这里使用了一个匿名内部类，创建bean实例对象，并且注册给所依赖的对象
    					sharedInstance = getSingleton(beanName, () -> {
    						try {
    							// 创建一个指定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;
    						}
    					});
    					// 获取给定Bean的实例对象
    					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    				}

首先会调用getSingleton方法

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    		Assert.notNull(beanName, "Bean name must not be null");
    		synchronized (this.singletonObjects) {
    			Object singletonObject = this.singletonObjects.get(beanName);
    			if (singletonObject == null) {
    				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);
    				boolean newSingleton = 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;
    		}
    	}

首先会从singletonObjects里面去拿，肯定是没有的，然后调用beforeSingletonCreation

protected void beforeSingletonCreation(String beanName) {
    		if (!this.inCreationCheckExclusions.contains(beanName) &&
    				// 把beanName加到这个map里面
    				!this.singletonsCurrentlyInCreation.add(beanName)) {
    			throw new BeanCurrentlyInCreationException(beanName);
    		}
    	}

执行完，会调用createBean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    			throws BeanCreationException {
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Creating instance of bean '" + beanName + "'");
    		}
    		RootBeanDefinition mbdToUse = mbd;
    
    		//确保bean类在这一点上被实际解析，并且
    		//在动态解析类的情况下克隆bean定义
    		//不能存储在共享合并bean定义中。
    
    		//判断需要创建的 Bean 是否可以实例化，即是否可以通过当前的类加载器加
    		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
    			mbdToUse = new RootBeanDefinition(mbd);
    			mbdToUse.setBeanClass(resolvedClass);
    		}
    
    		// Prepare method overrides.
    		try {
    			mbdToUse.prepareMethodOverrides();
    		}
    		
    		try {
    			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    			// 如果Bean配置了初始化前和初始化后的处理器，则试图返回一个需要创建Bean的代理对象  就是调用bean的后置处理器的before方法
    			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    			if (bean != null) {
    				return bean;
    			}
    		}
    		
    		try {
    			//创建bean的入口
    			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    			if (logger.isDebugEnabled()) {
    				logger.debug("Finished creating instance of bean '" + beanName + "'");
    			}
    			return beanInstance;
    		}
    		
    	}

看下这个方法:resolveBeforeInstantiation

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    		Object bean = null;
    		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
    			// Make sure bean class is actually resolved at this point.
    			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    				Class<?> targetType = determineTargetType(beanName, mbd);
    				if (targetType != null) {
    					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
    					if (bean != null) {
    						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
    					}
    				}
    			}
    			mbd.beforeInstantiationResolved = (bean != null);
    		}
    		return bean;
    	}

// 在 bean 初始化前应用后置处理，如果后置处理返回的 bean 不为空，则直接返回

我们这没有做别的操作，这个bean肯定是null的接着往下看

然后调用doCreateBean

/**
    	 *实际创建指定的bean。已进行创建前处理
    	 *此时，例如，检查{@code postprocessinationbeforestinstantiation}回调。
    	 *<p>区分默认bean实例化和
    	 *工厂方法，并自动连接构造函数。
    	 *@param beanName 豆子的名字
    	 *@param mbd bean的合并bean定义
    	 *@param args 用于构造函数或工厂方法调用的显式参数
    	 *@return一个新的bean实例
    	 *如果无法创建bean，@throws BeanCreationException
    	 *@见
    	 *@see#实例化使用工厂方法
    	 *@见#autowireConstructor
    	 */
    	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    			throws BeanCreationException {
    
    		// Instantiate the bean.
    		//BeanWrapper是用来持有创建出来的bean对象的
    		BeanWrapper instanceWrapper = null;
    		// 如果是singleton先把缓存中同名的bean清除
    		if (mbd.isSingleton()) {
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) {
    			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.
    		//调用Postprocess后置处理器
    		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对象，以防循环引用
    		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");
    			}
    			//这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用
    			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    		}
    
    		// Initialize the bean instance.
    		//bean对象的初始化，依赖注入在此触发
    		//这个 exposedObject 在初始化完成之后返回作为依赖注入完成后的 Bean
    		Object exposedObject = bean;
    		try {
    			// 将Bean实例对象封装，并且bean定义中配置的属性赋值给实例对象
    			populateBean(beanName, mbd, instanceWrapper);
    			//初始化bean对象
    			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) {
    			// 获取指定名称的已经注册的单例模式Bean对象
    			Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) {
    				//根据名称获取的已注册的 Bean 和正在实例化的 Bean 是同一个
    				if (exposedObject == bean) {
    					//当前实例化的bean初始化完成
    					exposedObject = earlySingletonReference;
    				}
    				//当前bean依赖其他bean，并且当发生循环引用时不允许新创建实例对象
    				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.
    		//注册完成依赖注入的bean
    		try {
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}

首先创建了一个 BeanWrapper 也就是创建出来的bean对象,

然后调用这个createBeanInstance

/**
    	 *使用适当的实例化策略为指定bean创建新实例：
    	 *工厂方法、构造函数自动连接或简单实例化。
    	 *@param beanName 豆子的名字
    	 *@param mbd bean的bean定义
    	 *@param args 用于构造函数或工厂方法调用的显式参数
    	 *@为新实例返回一个BeanWrapper
    	 *@见#从供应商处获得
    	 *@see#实例化使用工厂方法
    	 *@见#autowireConstructor
    	 *@见
    	 */
    	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);
    
    		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());
    		}
    
    		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    		if (instanceSupplier != null) {
    			return obtainFromSupplier(instanceSupplier, beanName);
    		}
    
    		if (mbd.getFactoryMethodName() != null) {
    			//调用工厂方法实例化
    			return instantiateUsingFactoryMethod(beanName, mbd, args);
    		}
    
    		// Shortcut when re-creating the same bean...
    		//使用容器的自动装配方法进行实例化
    		boolean resolved = false;
    		boolean autowireNecessary = false;
    		if (args == null) {
    			synchronized (mbd.constructorArgumentLock) {
    				if (mbd.resolvedConstructorOrFactoryMethod != null) {
    					resolved = true;
    					autowireNecessary = mbd.constructorArgumentsResolved;
    				}
    			}
    		}
    		if (resolved) {
    			if (autowireNecessary) {
    				//配置了自动装配属性，使用容器的自动装配实例化
    				//容器的自动装配是根据参数类型匹配 Bean 的构造方法
    				return autowireConstructor(beanName, mbd, null, null);
    			}
    			else {
    				//使用默认的无参构造方法实例化
    				return instantiateBean(beanName, mbd);
    			}
    		}
    
    		// Candidate constructors for autowiring?
    		//使用 Bean 的构造方法进行实例化
    		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
    			return autowireConstructor(beanName, mbd, ctors, args);
    		}
    
    		// No special handling: simply use no-arg constructor.
    		//使用默认的无参构造方法实例化
    		return instantiateBean(beanName, mbd);
    	}

因为我们不是一个factoryMethod肯定会走spring的自动装配进行实例化

这个代码就是spring会推断用哪个构造方法，里面需要关注的点很多，有时间单独写一篇博客来分析

Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

因为我们的X类没有指定构造方法，所以说，他肯定是null，会走spring的默认无参构造方法

/**
    	 *使用其默认构造函数实例化给定bean。
    	 *@param beanName 豆子的名字
    	 *@param mbd bean的bean定义
    	 *@为新实例返回一个BeanWrapper
    	 */
    	protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
    		try {
    			Object beanInstance;
    			if (System.getSecurityManager() != null) {
    				//这里是一个匿名内置类，根据实例化策略创建实例对象
    				beanInstance = AccessController.doPrivileged(
    						(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
    						getAccessControlContext());
    			}
    			else {
    				//将实例化的对象封装起来
    				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
    			}
    			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    			initBeanWrapper(bw);
    			return bw;
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    		}
    	}

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    		// Don't override the class with CGLIB if no overrides.
    		//如果bean定义没有方法覆盖，就不需要CGLib父类方法
    		if (!bd.hasMethodOverrides()) {
    			Constructor<?> constructorToUse;
    			synchronized (bd.constructorArgumentLock) {
    				//获取对象的构造方法或工厂方法
    				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
    				//如果没有构造方法且没有工厂方法
    				if (constructorToUse == null) {
    					//使用 JDK 的反射机制，判断要实例化的 Bean 是否是接口
    					final Class<?> clazz = bd.getBeanClass();
    					if (clazz.isInterface()) {
    						throw new BeanInstantiationException(clazz, "Specified class is an interface");
    					}
    					try {
    						if (System.getSecurityManager() != null) {
    							//这里是一个匿名内置类，使用反射机制获取 Bean 的构造方法
    							constructorToUse = AccessController.doPrivileged(
    									(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
    						}
    						else {
    							constructorToUse = clazz.getDeclaredConstructor();
    						}
    						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
    					}
    					catch (Throwable ex) {
    						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
    					}
    				}
    			}
    			//使用 BeanUtils 实例化，通过反射机制调用”构造方法.newInstance(arg)”来进行实例化
    			return BeanUtils.instantiateClass(constructorToUse);
    		}
    		else {
    			// Must generate CGLIB subclass.
    			//使用 CGLib 来实例化对象
    			return instantiateWithMethodInjection(bd, beanName, owner);
    		}
    	}

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
    		Assert.notNull(ctor, "Constructor must not be null");
    		try {
    			ReflectionUtils.makeAccessible(ctor);
    			return (KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
    					KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
    		}
    	}

利用反射就把spring的bean给new出来了，我们的beanWarpper就是一个对象啦

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70][]

回到org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#doCreateBean

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 1][]

这边做了一个很重要的操作(spring循环引用的三级缓存就是用这里面的map的)

//这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用
    			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    
    	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);
    			}
    		}
    	}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 2][]

>     //用于存放完全初始化好的 bean从该缓存中取出的 bean可以直接使用
>     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
>     
>     /** Cache of singleton factories: bean name --> ObjectFactory */
>     //存放 bean工厂对象解决循环依赖
>     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
>     
>     //存放原始的bean对象用于解决循环依赖,注意：存到里面的对象还没有被填充属性
>     /** Cache of early singleton objects: bean name --> bean instance */
>     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
>     
>     /**已经注册的单例bean**/
>     private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

singletonFactories：现在是0
    earlySingletonObjects现在也是0
    registeredSingletons不是0

执行完之后: singletonFactories将会put一个 x对象

registeredSingletons也会新增一个x

![20210616200046949.png][]

后面将会做我们的依赖注入

>     // 将Bean实例对象封装，并且bean定义中配置的属性赋值给实例对象 populateBean(beanName, mbd, instanceWrapper);

/**
    	 *用属性值填充给定BeanWrapper中的bean实例
    	 *从bean定义。
    	 *@param beanName 豆子的名字
    	 *@param mbd bean的bean定义
    	 *@param bw 带有bean实例的BeanWrapper
    	 */
    	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    		if (bw == null) {
    			if (mbd.hasPropertyValues()) {
    				throw new BeanCreationException(
    						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
    			}
    			else {
    				// Skip property population phase for null instance.
    				return;
    			}
    		}
    
    		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
    		// state of the bean before properties are set. This can be used, for example,
    		// to support styles of field injection.
    		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    			for (BeanPostProcessor bp : getBeanPostProcessors()) {
    				if (bp instanceof InstantiationAwareBeanPostProcessor) {
    					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
    						return;
    					}
    				}
    			}
    		}
    
    		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    
    		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    			// Add property values based on autowire by name if applicable.
    			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
    				autowireByName(beanName, mbd, bw, newPvs);
    			}
    			// Add property values based on autowire by type if applicable.
    			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    				autowireByType(beanName, mbd, bw, newPvs);
    			}
    			pvs = newPvs;
    		}
    
    		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
    
    		if (hasInstAwareBpps || needsDepCheck) {
    			if (pvs == null) {
    				pvs = mbd.getPropertyValues();
    			}
    			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    			if (hasInstAwareBpps) {
    				for (BeanPostProcessor bp : getBeanPostProcessors()) {
    					if (bp instanceof InstantiationAwareBeanPostProcessor) {
    						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
    						if (pvs == null) {
    							return;
    						}
    					}
    				}
    			}
    			if (needsDepCheck) {
    				checkDependencies(beanName, mbd, filteredPds, pvs);
    			}
    		}
    
    		if (pvs != null) {
    			applyPropertyValues(beanName, mbd, bw, pvs);
    		}
    	}

上面很多代码对我们来说都不重要，我们来看这行代码

int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    			// Add property values based on autowire by name if applicable.
    			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
    				autowireByName(beanName, mbd, bw, newPvs);
    			}
    			// Add property values based on autowire by type if applicable.
    			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    				autowireByType(beanName, mbd, bw, newPvs);
    			}
    			pvs = newPvs;
    		}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 4][]

接着往下走:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 5][]

我们主要看这个后置处理器AutowiredAnnotationBeanPostProcessor

执行这个方法

public PropertyValues postProcessPropertyValues(
    			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
    
    		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    		try {
    			metadata.inject(bean, beanName, pvs);
    		}
    		return pvs;
    	}

执行inject方法:

@Override
    		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    			Field field = (Field) this.member;
    			Object value;
    			if (this.cached) {
    				value = resolvedCachedArgument(beanName, this.cachedFieldValue);
    			}
    			else {
    				DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
    				desc.setContainingClass(bean.getClass());
    				Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
    				Assert.state(beanFactory != null, "No BeanFactory available");
    				TypeConverter typeConverter = beanFactory.getTypeConverter();
    				try {
    					// 创建当前对象依赖的对象
    					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
    				}
    				catch (BeansException ex) {
    					throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
    				}
    				synchronized (this) {
    					if (!this.cached) {
    						if (value != null || this.required) {
    							this.cachedFieldValue = desc;
    							registerDependentBeans(beanName, autowiredBeanNames);
    							if (autowiredBeanNames.size() == 1) {
    								String autowiredBeanName = autowiredBeanNames.iterator().next();
    								if (beanFactory.containsBean(autowiredBeanName) &&
    										beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
    									this.cachedFieldValue = new ShortcutDependencyDescriptor(
    											desc, autowiredBeanName, field.getType());
    								}
    							}
    						}
    						else {
    							this.cachedFieldValue = null;
    						}
    						this.cached = true;
    					}
    				}
    			}
    			if (value != null) {
    				ReflectionUtils.makeAccessible(field);
    				field.set(bean, value);
    			}
    		}
    	}

在inject里面，会给当前对象依赖的对象赋值,也就是当实例化X的时候，发现X里面注入了Y，将会实例化Y

// 创建当前对象依赖的对象
    					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
    			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    
    		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
    		if (Optional.class == descriptor.getDependencyType()) {
    			return createOptionalDependency(descriptor, requestingBeanName);
    		}
    		else if (ObjectFactory.class == descriptor.getDependencyType() ||
    				ObjectProvider.class == descriptor.getDependencyType()) {
    			return new DependencyObjectProvider(descriptor, requestingBeanName);
    		}
    		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
    			return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
    		}
    		else {
    			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
    					descriptor, requestingBeanName);
    			if (result == null) {
    				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
    			}
    			return result;
    		}
    	}

里面会掉doResolveDependency去实例化依赖的对象

result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);

@Nullable
    	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
    			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    
    		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
    		try {
    			Object shortcut = descriptor.resolveShortcut(this);
    			if (shortcut != null) {
    				return shortcut;
    			}
    
    			Class<?> type = descriptor.getDependencyType();
    			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
    			if (value != null) {
    				if (value instanceof String) {
    					String strVal = resolveEmbeddedValue((String) value);
    					BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
    					value = evaluateBeanDefinitionString(strVal, bd);
    				}
    				TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
    				return (descriptor.getField() != null ?
    						converter.convertIfNecessary(value, type, descriptor.getField()) :
    						converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
    			}
    
    			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
    			if (multipleBeans != null) {
    				return multipleBeans;
    			}
    
    			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) {
    				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);
    		}
    	}

然后调用

instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);

public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
    			throws BeansException {
    
    		return beanFactory.getBean(beanName);
    	}

将会来到getBean,dogetBean  我把这段代码再截图看下，加深下印象

执行完以后，肯定会回到inject方法，我们是从inject方法跳到resolveDependency方法里面的

protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    			Field field = (Field) this.member;
    			Object value;
    			if (this.cached) {
    				value = resolvedCachedArgument(beanName, this.cachedFieldValue);
    			}
    			else {
    				DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
    				desc.setContainingClass(bean.getClass());
    				Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
    				Assert.state(beanFactory != null, "No BeanFactory available");
    				TypeConverter typeConverter = beanFactory.getTypeConverter();
    				try {
    					// 创建当前对象依赖的对象
    					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
    				}
    				catch (BeansException ex) {
    					throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
    				}
    				synchronized (this) {
    					if (!this.cached) {
    						if (value != null || this.required) {
    							this.cachedFieldValue = desc;
    							registerDependentBeans(beanName, autowiredBeanNames);
    							if (autowiredBeanNames.size() == 1) {
    								String autowiredBeanName = autowiredBeanNames.iterator().next();
    								if (beanFactory.containsBean(autowiredBeanName) &&
    										beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
    									this.cachedFieldValue = new ShortcutDependencyDescriptor(
    											desc, autowiredBeanName, field.getType());
    								}
    							}
    						}
    						else {
    							this.cachedFieldValue = null;
    						}
    						this.cached = true;
    					}
    				}
    			}
    			if (value != null) {
    				ReflectionUtils.makeAccessible(field);
    				field.set(bean, value);
    			}
    		}
    	}

再看下这个方法，这时候肯定有个value

if (value != null) {
    				ReflectionUtils.makeAccessible(field);
    				field.set(bean, value);
    			}

![20210622140746443.png][]

X里面注入的Y就会被设置进去了

将会执行这个方法

//初始化bean对象
    exposedObject = initializeBean(beanName, exposedObject, mbd);

执行完以后会添加到singleObjects

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

这个就代表X创建完了，后面肯定会，实例化Y，因为前面是for循环进来的

public void preInstantiateSingletons() throws BeansException {
    		if (logger.isDebugEnabled()) {
    			logger.debug("Pre-instantiating singletons in " + this);
    		}
    		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    		for (String beanName : beanNames) {
    			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    				if (isFactoryBean(beanName)) {
    					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    					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 {
    					getBean(beanName);
    				}
    			}
    		}

我们再分析Y是怎样注入的

流程是一样的，唯一不同的是，我们的Y在实例化的时候已经创建出来了

我们第二次创建Y的时候，doGetBean的时候，

//先从缓存中获取单例bean，对于单例bean，整个IOC容器只创建一次
    Object sharedInstance = getSingleton(beanName);

这里面返回的就不是null了

/**
    	 *返回在给定名称下注册的（原始）单例对象。
    	 *<p>检查已经实例化的单例，并允许
    	 *对当前创建的单例的引用（解析循环引用）。
    	 *@param beanName 要查找的bean的名称
    	 *@param  allowEarlyReference 允许引用是否应该创建早期引用
    	 *@return注册的singleton对象，如果找不到则返回{@code null}
    	 */
    	@Nullable
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    		Object singletonObject = this.singletonObjects.get(beanName);
    		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;
    	}

我们的singletonObjects是有y这个实例的

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 6][]

这段代码也是我们常说的Spring三级缓存，下篇博客将详细讲解spring的循环引用问题

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70]: /images/20221005/a6723c28b19447b588237a6f93a4e2c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 1]: /images/20221005/629c96dadc6d4c40ab3b8bcddbc2f8e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 2]: /images/20221005/4a5d08acb09145908ac2ad6afb658ac4.png
[20210616200046949.png]: /images/20221005/063097e6e6f44d73ba1d0c358257f01a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 3]: /images/20221005/3bef514e7dfd4e4fa6e451a2f34db206.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 4]: /images/20221005/6eb1f52b9abe4831a6f5bb2d47800101.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 5]: /images/20221005/0a97868a7a9a41a8b7232b924101a75b.png
[20210622140746443.png]: /images/20221005/e4ae35cc27db431986e510b07a7e31d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 6]: /images/20221005/a91c295e90264c0daafe2f43e3e4d19c.png