SpringIoC源码：createBean（下）-创新互联

• Spring源码系列：
• • 前言
  • 正文
  • 方法1：initializeBean
  • 方法2：invokeAwareMethods
  • 方法3：applyBeanPostProcessorsBeforeInitialization
  • 方法4：invokeInitMethods
  • 方法5：invokeCustomInitMethod
  • 方法6：applyBeanPostProcessorsAfterInitialization
  • 方法7：registerDisposableBeanIfNecessary
  • 方法8：requiresDestruction
  • 方法9：hasDestroyMethod
  • 方法10：hasApplicableProcessors
  • 总结

Spring IOC源码：简单易懂的Spring IOC 思路介绍
Spring IOC源码：核心流程介绍
Spring IOC源码：ApplicationContext刷新前准备工作
Spring IOC源码：obtainFreshBeanFactory 详解（上）
Spring IOC源码：obtainFreshBeanFactory 详解（中）
Spring IOC源码：obtainFreshBeanFactory 详解（下）
Spring IOC源码：＜context:component-scan＞源码详解
Spring IOC源码：invokeBeanFactoryPostProcessors 后置处理器详解
Spring IOC源码：registerBeanPostProcessors 详解
Spring IOC源码：实例化前的准备工作
Spring IOC源码：finishBeanFactoryInitialization详解
Spring IoC源码：getBean 详解
Spring IoC源码：createBean（ 上）
Spring IoC源码：createBean（ 中）
Spring IoC源码：createBean（ 下）
Spring IoC源码：finishRefresh 完成刷新详解

上篇文章讲解了实例化后，初始化属性注入过程中属性值的解析过程及其注入过程，本篇继续讲解doCreateBean流程中属性注入后的其它流程，即对bean实例进行初始化。

populateBean方法执行完成后，开始初始化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) {	//创建Bean实例，通过策略进行创建，如果选择有参构造或无参构造
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//获取当前实例对象
		final Object bean = instanceWrapper.getWrappedInstance();
		//当前实例的Calss对象
		ClassbeanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {	//设置当前bean定义信息的目标类型
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {	if (!mbd.postProcessed) {		try {//执行MergedBeanDefinitionPostProcessor类型后置处理器的postProcessMergedBeanDefinition方法，
					//如@Autowire注解，就是通过该后置处理器进行解析
					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.
		//如果是单例，允许循环依赖，并且beanName正在创建中
		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 {	//初始化过程，进行属性注入。该过程递归创建其依赖的属性。如果A中有B，B中有C，则创建B跟C。
			populateBean(beanName, mbd, instanceWrapper);
			//该过程执行后置处理器的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) {	//从缓存中获取，因为上面我们将其添加到三级缓存中，从三级缓存中获取会调用FactoryObject对象的getObject方法，可能会触发AOP代理。返回代理对象
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {		//如果bean对象还是原来的，则将三级缓存中获取的对象赋值过去
				if (exposedObject == bean) {exposedObject = earlySingletonReference;
				}
				//如果exposedObject在initializeBean方法中被增强 && 不允许在循环引用的情况下使用注入原始bean实例
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {//	获取依赖当前beanName的所有bean名称
					String[] dependentBeans = getDependentBeans(beanName);
					SetactualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					//尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
					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，执行销毁操作的有三种：自定义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