bean创建流程中的拓展点BeanPostProcessors和循环依赖

ContextLoaderListener 实现ServletContextListener 接口，servlet容器启动后执行
ContextLoaderListener .contextInitialized()>
ContextLoader .initWebApplicationContext()>
ContextLoader .configureAndRefreshWebApplicationContext()>
AbstractApplicationContext .refresh()>
AbstractApplicationContext .finishBeanFactoryInitialization()>
DefaultListableBeanFactory.preInstantiateSingletons(){
for (String beanName : beanNames) getBean(beanName );}>
AbstractBeanFactory.doGetBean()

	protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
		final String beanName = transformedBeanName(name);
		//第一次getSingleton，从singletonObjects取为null，但isSingletonCurrentlyInCreation为false，返回null。
		//如果是创建bean的过程中，因为循环依赖，再次进入doGetBean方法，此时isSingletonCurrentlyInCreation为true。
		//从earlySingletonObjects中获取为空后，调用singletonFactory.getObject()方法获取singletonObject，放入earlySingletonObjects中，并在singletonFactories移除对应beanName的singletonFactory。
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	} else {
		try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				if (mbd.isSingleton()) {
					//第二次调用getSingleton
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							try {
								return createBean(beanName, mbd, args);
							}
							catch (BeansException ex) {
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
	}
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	//第一次getSingleton
	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 != NULL_OBJECT ? singletonObject : null);
	}
	//第二次getSingleton
	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		//先从singletonObjects获取
		Object singletonObject = this.singletonObjects.get(beanName);
		//把beanName添加到singletonsCurrentlyInCreation集合中
		beforeSingletonCreation(beanName);
		//调用singletonFactory.getObject()方法，实质是调AbstractAutowireCapableBeanFactory.createBean()方法
		singletonObject = singletonFactory.getObject();
		newSingleton = true;
		if (newSingleton) {
		//往singletonObjects中put，singletonFactories和earlySingletonObjects中remove对应的beanName
		addSingleton(beanName, singletonObject);
		}
	}
}

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
		RootBeanDefinition mbdToUse = mbd;
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		//第一个BeanPostProcessor扩展点，执行InstantiationAwareBeanPostProcessors的postProcessBeforeInstantiation方法
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		//创建bean
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		return beanInstance;
	}
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {
		BeanWrapper instanceWrapper = null;
		//反射创建，在determineConstructorsFromBeanPostProcessors方法中会执行第二个扩展点
		instanceWrapper = createBeanInstance(beanName, mbd, args);
		//执行MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition流程  
		applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
		//判断是否需要提前暴露单例Bean引用，从而解决循环引用。
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			//主要为了解决循环依赖，往singletonFactories中添加。此时再去执行第一次处的getSingleton能获取到一个未初始化完全的循环依赖的结果
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					//调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference返回一个需要暴露的Bean。当发生循环依赖时，提前进行AOP。
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}
				Object exposedObject = bean;
		try {
			//注入，可能会发生循环引用
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
				//初始化
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}
		try {
			//注册Bean的销毁回调，注册后会触发第九个扩展点，调用DisposableBean的destroy销毁方法。  
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		return exposedObject;
	}
	protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
		//第五个拓展点
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
						break;
				}
			}
		}
	}
		//自动装配
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
		//第六个扩展点
		if (hasInstAwareBpps || needsDepCheck) {
			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);
			}
		}
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
	
	protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
		invokeAwareMethods(beanName, bean);
	//第七个扩展点
		Object wrappedBean = bean;  
		if (mbd == null || !mbd.isSynthetic()) {  
		    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
}  
		try {  
			//执行初始化回调（调用InitializingBean的afterPropertiesSet或自定义的init-method）  
		    invokeInitMethods(beanName, wrappedBean, mbd);  
		} 
		if (mbd == null || !mbd.isSynthetic()) {
			第八个扩展点
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}
	//第一个扩展点
	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;
	}
	//第二个扩展点
	protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(Class<?> beanClass, String beanName)
			throws BeansException {

		if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
					if (ctors != null) {
						return ctors;
					}
				}
			}
		}
		return null;
	}
	//第三个扩展点
	protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}
	//第四个扩展点
	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
					if (exposedObject == null) {
						return null;
					}
				}
			}
		}
		return exposedObject;
	}
}