• Spring源碼系列：
• • 前言
  • 正文
  • 方法1：initializeBean
  • 方法2：invokeAwareMethods
  • 方法3：applyBeanPostProcessorsBeforeInitialization
  • 方法4：invokeInitMethods
  • 方法5：invokeCustomInitMethod
  • 方法6：applyBeanPostProcessorsAfterInitialization
  • 方法7：registerDisposableBeanIfNecessary
  • 方法8：requiresDestruction
  • 方法9：hasDestroyMethod
  • 方法10：hasApplicableProcessors
  • 總結(jié)

Spring IOC源碼：簡單易懂的Spring IOC 思路介紹
Spring IOC源碼：核心流程介紹
Spring IOC源碼：ApplicationContext刷新前準(zhǔn)備工作
Spring IOC源碼：obtainFreshBeanFactory 詳解（上）
Spring IOC源碼：obtainFreshBeanFactory 詳解（中）
Spring IOC源碼：obtainFreshBeanFactory 詳解（下）
Spring IOC源碼：＜context:component-scan＞源碼詳解
Spring IOC源碼：invokeBeanFactoryPostProcessors 后置處理器詳解
Spring IOC源碼：registerBeanPostProcessors 詳解
Spring IOC源碼：實例化前的準(zhǔn)備工作
Spring IOC源碼：finishBeanFactoryInitialization詳解
Spring IoC源碼：getBean 詳解
Spring IoC源碼：createBean（ 上）
Spring IoC源碼：createBean（ 中）
Spring IoC源碼：createBean（ 下）
Spring IoC源碼：finishRefresh 完成刷新詳解

上篇文章講解了實例化后，初始化屬性注入過程中屬性值的解析過程及其注入過程，本篇繼續(xù)講解doCreateBean流程中屬性注入后的其它流程，即對bean實例進(jìn)行初始化。

populateBean方法執(zhí)行完成后，開始初始化bean。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {//如果是單例并且是FactoryBean則嘗試移除
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {	//創(chuàng)建Bean實例，通過策略進(jìn)行創(chuàng)建，如果選擇有參構(gòu)造或無參構(gòu)造
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//獲取當(dāng)前實例對象
		final Object bean = instanceWrapper.getWrappedInstance();
		//當(dāng)前實例的Calss對象
		ClassbeanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {	//設(shè)置當(dāng)前bean定義信息的目標(biāo)類型
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {	if (!mbd.postProcessed) {		try {//執(zhí)行MergedBeanDefinitionPostProcessor類型后置處理器的postProcessMergedBeanDefinition方法，
					//如@Autowire注解，就是通過該后置處理器進(jìn)行解析
					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.
		//如果是單例，允許循環(huán)依賴，并且beanName正在創(chuàng)建中
		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");
			}
			//包裝成FactoryObject對象，并添加到三級緩存中
			addSingletonFactory(beanName, () ->getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {	//初始化過程，進(jìn)行屬性注入。該過程遞歸創(chuàng)建其依賴的屬性。如果A中有B，B中有C，則創(chuàng)建B跟C。
			populateBean(beanName, mbd, instanceWrapper);
			//該過程執(zhí)行后置處理器的before方法，bean的init方法，后置處理器的after方法，可能會生成新的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) {	//從緩存中獲取，因為上面我們將其添加到三級緩存中，從三級緩存中獲取會調(diào)用FactoryObject對象的getObject方法，可能會觸發(fā)AOP代理。返回代理對象
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {		//如果bean對象還是原來的，則將三級緩存中獲取的對象賦值過去
				if (exposedObject == bean) {exposedObject = earlySingletonReference;
				}
				//如果exposedObject在initializeBean方法中被增強 && 不允許在循環(huán)引用的情況下使用注入原始bean實例
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {//	獲取依賴當(dāng)前beanName的所有bean名稱
					String[] dependentBeans = getDependentBeans(beanName);
					SetactualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					//嘗試移除這些bean的實例，因為這些bean依賴的bean已經(jīng)被增強了，他們依賴的bean相當(dāng)于臟數(shù)據(jù)
					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 " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {	//注冊用于銷毀的bean，執(zhí)行銷毀操作的有三種：自定義destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {	throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

initializeBean(beanName, exposedObject, mbd)，見方法1詳解

registerDisposableBeanIfNecessary(beanName, bean, mbd)，見方法7詳解

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {if (System.getSecurityManager() != null) {	AccessController.doPrivileged((PrivilegedAction