spring源码--IOC容器的实现:BeanFatory后置处理

当BeanFatory解析完资源文件并将bean的信息注册进BeanFatory之后，spring接下来对BeanFactory做了统一的后置处理，el表达式的解析，以及基于@Configuration等注解的bean的解析注册也是在这期间发生的。

public void refresh() throws BeansException, IllegalStateException {
   	synchronized (this.startupShutdownMonitor) {
   
   		prepareRefresh();
   		
   		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
   		//解析并注册bean
   		prepareBeanFactory(beanFactory);

   		try {
   			//beanfactory的后置操作，主要是容器的公共操作
   			postProcessBeanFactory(beanFactory);
   			//调用实现 BeanFactoryPostProcessor接口的后置处理器
   			invokeBeanFactoryPostProcessors(beanFactory);

   			registerBeanPostProcessors(beanFactory);

   			initMessageSource();

   			initApplicationEventMulticaster();

   			onRefresh();
   			
   			registerListeners();

   			finishBeanFactoryInitialization(beanFactory);

   			finishRefresh();
   		}

   		catch (BeansException ex) {
   			if (logger.isWarnEnabled()) {
   				logger.warn("Exception encountered during context initialization - " +
   						"cancelling refresh attempt: " + ex);
   			}

   			// Destroy already created singletons to avoid dangling resources.
   			destroyBeans();

   			// Reset 'active' flag.
   			cancelRefresh(ex);

   			// Propagate exception to caller.
   			throw ex;
   		}

   		finally {
   			// Reset common introspection caches in Spring's core, since we
   			// might not ever need metadata for singleton beans anymore...
   			resetCommonCaches();
   		}
   	}
   }

postProcessBeanFactory(beanFactory)在不同的容器中有不同的实现，我们以web容器的基类org.springframework.web.context.support.AbstractRefreshableWebApplicationContext来看西安在这个方法中都做了些什么

@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
	beanFactory.ignoreDependencyInterface(ServletContextAware.class);
	beanFactory.ignoreDependencyInterface(ServletConfigAware.class);

	WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
	WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}

可以看到主要是注册BeanFactoryPostProcessor，以及忽略web相关接口的依赖注入。这里只做注册，而真正调用后置处理器的操作是在
invokeBeanFactoryPostProcessors(beanFactory);

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	}

getBeanFactoryPostProcessors()获取到容器内部已经实例化的BeanFactoryPostProcessor，但是对于ClassPathXmlApplicationContext来说，这里获取到的是null。

进入PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors方法

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// 1.调用BeanDefinitionRegistryPostProcessors
		Set<String> processedBeans = new HashSet<String>();

		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
					new LinkedList<BeanDefinitionRegistryPostProcessor>();
			
			//1.1 从方法传入的 beanFactoryPostProcessors 中取出 BeanDefinitionRegistryPostProcessors 并调用postProcessBeanDefinitionRegistry后置处理方法。
			//并按照是否是BeanDefinitionRegistryPostProcessor的实现类分为 registryPostProcessors 和 regularPostProcessors
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
					registryPostProcessors.add(registryPostProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			//1.2 获取BeanFatory中注册的BeanDefinitionRegistryPostProcessors
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

			// 1.3 挑选出实现 PriorityOrdered接口的的后置处理器，排序，并调用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry后置处理方法。PriorityOrdered表明这些处理器的优先级很高，需要优先调用
			List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
			registryPostProcessors.addAll(priorityOrderedPostProcessors);
			invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);

			// 1.4 挑选出实现 Ordered接口的的后置处理器，排序，并调用并调用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry后置处理方法。Ordered表明这些处理器需要按照顺序调用，优先级比实现PriorityOrdered的后置处理器低
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(beanFactory, orderedPostProcessors);
			registryPostProcessors.addAll(orderedPostProcessors);
			invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);

			// 1.5 最后调用其他 BeanDefinitionRegistryPostProcessors的后置处理方法
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
						registryPostProcessors.add(pp);
						processedBeans.add(ppName);
						pp.postProcessBeanDefinitionRegistry(registry);
						reiterate = true;
					}
				}
			}

			// 1.6 调用 BeanDefinitionRegistryPostProcessor 的 方法postProcessBeanFactory
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			// 1.7 调用 BeanFactoryPostProcessors的 postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {

			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// 2.1 获取BeanFatory中注册的BeanFactoryPostProcessors
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// 2.2将BeanFactoryPostProcessors按照优先级分开
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 2.3调用实现PriorityOrdered 接口优先级最高的BeanFactoryPostProcessors
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// 2.4调用实现Ordered 接口优先级最高的BeanFactoryPostProcessors
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(beanFactory, orderedPostProcessors);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// 2.5调用其他的BeanFactoryPostProcessors
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// 2.6 清除缓存
		beanFactory.clearMetadataCache();
	}

BeanDefinitionRegistryPostProcessor 是 BeanFactoryPostProcessor 的子接口，BeanDefinitionRegistryPostProcessor 比 BeanFactoryPostProcessor 多了
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException; 方法

PriorityOrdered 是 Ordered的子接口，这里spring视实现了PriorityOrdered 的BeanDefinitionRegistryPostProcessor 和BeanFactoryPostProcessor 的接口优先级更高。