无处不在的扩展点BeanPostProcessor

无处不在的扩展点BeanPostProcessor

    在spring创建bean的过程中，多次出现了BeanPostProcessor的身影，它们是怎么来的，可以怎么用？本文就对spring中的BeanPostProcessor做个总结。

    

public interface BeanPostProcessor {
	
	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

	
	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

     如上所示，BeanPostProcessor接口中其实才定义了两个方法，这两个方法分别在invokeInitMethods的前后调用。还记得invokeInitMethods吗，它回调了bean的afterPropertiesSet方法以及bean的initMethod。除了最基本的BeanPostProcessor，spring中还定义一些扩展的BeanPostProcessor。有MergedBeanDefinitionPostProcessor，它只增加了一个方法在bean实例化之后马上执行。

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {

	void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);

}

   InstantiationAwareBeanPostProcessor，它扩展了三个方法，分别在实例化之前、实例化之后依赖注入之前、依赖解析之后而注入之前执行。另外，还有SmartInstantiationAwareBeanPostProcessor、DestructionAwareBeanPostProcessor。

    

     这些BeanPostProcessor各司其职，在bean的整个生命周期的各个阶段发挥着不同的作用，使我们可以在bean的生命周期的每个阶段都可以做一些准备工作或后期处理。讲到这里不得不赞叹spring的强大，spring设计的巧妙。正是由于这些BeanPostProcessor，给我们留出了充足的扩展点，我们才可以以插件式的形式在扩展点植入我们自己的逻辑。对于没有自己写过BeanPostProcessor的同学，只是在配置文件中加入了一些标签就有了对应的BeanPostProcessor，那么这些BeanPostProcessor是怎么来的呢?这要从spring上下文的建立，也就是ApplicationContext的初始化说起，在AbstractApplicationContext的refresh方法中创建了BeanFactory并且对其进行了配置，其中就包括向BeanFactory中注册bean的后置处理器BeanPostProcessor。见如下两个方法：

	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			if (isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		OrderComparator.sort(priorityOrderedPostProcessors);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		OrderComparator.sort(orderedPostProcessors);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// Now, register all regular BeanPostProcessors.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		OrderComparator.sort(internalPostProcessors);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector());
	}

	private void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

		for (BeanPostProcessor postProcessor : postProcessors) {
			beanFactory.addBeanPostProcessor(postProcessor);
		}
	}

  正是由于ApplicationContext对BeanFactory的增强，使我们在使用ApplicationContext的时候不必关系一些细节就可以获得拥有强大功能的容器。既然 ApplicationContext的BeanPostProcessor 也是直接从Beanfactory中获取的，那么这些BeanPostProcessor 到底是哪里注册到BeanFactory中去的呢？如果不是你自己注册的，那么肯定就是配置文件中的一些标签中引入的了，比如context:component-scan。