Spring IoC的细节--initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd)

AbstractAutowireCapableBeanFactory：

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

		//实例化Bean
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			//创建实例  重点
			instanceWrapper = createBeanInstance(beanName, mbd, args);  //代码1
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		//允许post-processors修改合并后的BeanDefinition
		//加锁，保证原子性操作
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					//执行post-processors
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				//设置post-processors的执行标识
				mbd.postProcessed = true;
			}
		}

		//缓存单例以便处理循环引用，即使是像BeanFactoryAware这样的生命周期接口触发的
		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));
		}

		//初始化Bean实例
		Object exposedObject = bean;
		try {
			
			//注入过程  重点
			populateBean(beanName, mbd, instanceWrapper); //代码2
			// 将会执行Bean的初始化  
			// 将会触发postProcessBeforeInitialization和postProcessAfterInitialization
			exposedObject = initializeBean(beanName, exposedObject, mbd);  //代码3
		}
		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);
					//获取当前Bean所依赖的其他Bean
					for (String dependentBean : dependentBeans) {
						//对依赖Bean进行类型检查
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						...
					}
				}
			}
		}


		//注册完成依赖注入的Bean
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

代码3，将触发Bean的初始化操作，其为Bean实例对象添加BeanPostProcessor后置处理器的入口。

AbstractAutowireCapableBeanFactory：

	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		//JDK安全验证
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			//设置beanName、ClassLoader、BeanFactory等
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			//初始化前应用BeanPostProcessor的前置通知方法
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); //代码4
		}

		try {
			//调用配置了init-method的方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			//初始化后应用BeanPostProcessor的后置通知方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); //代码5
		}

		return wrappedBean;
	}

代码4和代码5分别会触发Bean初始化注册的BeanPostProcessor事件，执行前置通知后后置通知。
BeanPostProcessor的其中一个子类实现为AdvisorAdapterRegistrationManager ，其主要的作用为容器中管理的Bean注册一个面向切面编程的通知适配器，以便在Spring容器为所管理的Bean进行面向切面编程时提供方便，其源码如下：

// 为容器中管理的Bean注册一个面向切面编程的通知适配器
public class AdvisorAdapterRegistrationManager implements BeanPostProcessor {

	// 容器中负责管理切面通知适配器注册的对象
	private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();


	/**
	 * Specify the AdvisorAdapterRegistry to register AdvisorAdapter beans with.
	 * Default is the global AdvisorAdapterRegistry.
	 * @see GlobalAdvisorAdapterRegistry
	 */
	public void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry) {
		this.advisorAdapterRegistry = advisorAdapterRegistry;
	}


	@Override
	// BeanPostProcessor在Bean对象初始化前的操作
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// 没有做任何操作，直接返回容器创建的Bean对象
		return bean;
	}

	@Override
	// BeanPostProcessor在Bean对象初始化后的操作
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if (bean instanceof AdvisorAdapter){
			// 如果容器创建的Bean实例对象是一个切面通知适配器，则向容器的注册
			this.advisorAdapterRegistry.registerAdvisorAdapter((AdvisorAdapter) bean);
		}
		return bean;
	}

}