Spring——BeanPostProcessors (bean的后置处理器)

BeanPostProcessors

bean的后置处理器

1. BeanPostProcessors 注册（ registerBeanPostProcessors(beanFactory);方法）

在refresh()的 invokeBeanFactoryPostProcessors(beanFactory)中;所有的bean已经被注册到BeanDefintionMap中，但是只有BeanFactory的后置处理器进行了对象创建的工作。bean的后置处理器还没有进行。所有在registerBeanPostProcessors(beanFactory);中完成bean的后置处理器的对象创建工作。 Bean的后置处理器也分为两种：一种是Spring自带的后置处理器，一种是我们自定义的后置处理器
查看registerBeanPostProcessors(beanFactory);方法

// 这个方法开始注册后置处理器
public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		// 根据接口类型获取全部的bean后置处理器的名称。
		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.
		// 此处可以看出支持排序，创建几个排序集合。用于装不同顺序的beanpost的后置处理器。跟BeanFactoryPost的后置处理器一样。
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		// 此处创建的内部bean的后置处理器集合。专门用于存放MergedBeanDefinitionPostProcessor的。
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		// 也是排序集合
		List<String> orderedPostProcessorNames = new ArrayList<>();
		// 也是排序集合
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		// 编译全部。
		for (String ppName : postProcessorNames) {
			// // 先遍历，找出优先级最高的，实现PriorityOrdered.class接口的。
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 创建对象。
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				// 添加到此集合中
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			// 实现Ordered.class接口的，优先级第二。
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			// 添加到此集合中，但是不创建对象。
				orderedPostProcessorNames.add(ppName);
			}
			else {
			// 没有实现排序接口的最后添加到此集合中，，但是不创建对象。
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		// 首先进行排序工作。针对实现了PriorityOrdered接口的，优先级最高的。
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 优先注册PriorityOrdered接口的实现类。其实就是添加到beanPostProcessors中。
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		// 接下来针对实现了Ordered接口的进行对象的创建工作。
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			// 如果有实现MergedBeanDefinitionPostProcessor这个接口的，添加到internalPostProcessors这个集合中。
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		// 排序。
		sortPostProcessors(orderedPostProcessors, beanFactory);
		// 注册.
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// Now, register all regular BeanPostProcessors.
		// 最后创建没有排序的bean的后置处理器对象。。
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			// 如果有实现MergedBeanDefinitionPostProcessor这个接口的，添加到internalPostProcessors这个集合中。
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		// 注册
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		// 最后排序internal BeanPostProcessors集合注册
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		// 添加一个ApplicationListenerDetector后置处理器。
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

通过以上代码可以看出，主要的逻辑是创建了bean的后置处理器对象，然后添加到beanPostProcessorsMap集合中。当然也支持排序接口。

2. BeanPostProcessors 调用（ registerBeanPostProcessors(beanFactory);方法）

Spring在创建对象的时候经理了三次过程，实例化，属性赋值，初始化，针对每一次过程都有处理器来进行处理。

2.1 第一次调用（实例化之前）调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation方法。

在 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation 方法中。

此方法传入的参数为Class<?> beanClass, String beanName 。返回值bean，说明此时bean还没有被创建出来。如果我们实现了这个接口交给我自己来创建bean。如果我们创建了bean，后续针对bean的一切行为都终止。并且直接调用bean初始化后置处理器，说明实现此接口，bean的生命周期全盘由我们来控制

2.2 第二次调用（实例化之前，选择构造方法）调用SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors方法。

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance 方法中。

此方法参数为Class<?> beanClass, String beanName，返回值为Constructor<?>[]
此时代码已经进去到开始实例化对象的逻辑中了。既然是实例化对象，肯定要确认构造方法。此接口就是让我们自己来确定实例化对象执行的构造方法。不回去影响后续的调用

2.3 第三次调用（实例后之后，属性注入之前）调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition方法。

在 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean 方法中。

参数为 RootBeanDefinition beanDefinition, Class<?> beanType, String beanName 。无返回值。此方法的作用就是在实例化之后，属性注入之前针对BeanDefinition进行一些定制化的修改

2.4 第四次调用（实例后之后，属性注入之前）调用org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference方法。

在 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean方法中。

参数为 Object bean, String beanName 返回值为Object，此方法主要值解决循环依赖的问题，同样是在属性注入之前

2.5 第五次调用（实例后之后，属性注入之前）调用InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation方法。

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean 方法中。

参数为Object bean, String beanName，返回值boolean。此方法的返回值可以选择当前的对象是否需要注入，或者根据条件觉得是否需要注入？

2.6 第六次调用（可以进行属性的注入）调用InstantiationAwareBeanPostProcessor.postProcessProperties或者postProcessPropertyValues（已过时）方法。

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean 方法中。

参数PropertyValues pvs, Object bean, String beanName ，返回值PropertyValues。在这里进行属性的注入

2.7 第七次调用（属性注入后，初始化之前）调用BeanPostProcessor.postProcessBeforeInitialization。

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition) 方法中。

参数 Object bean, String beanName，返回值Object。此方法是在放在执行初始化函数的时候，针对对象进行修改，如果返回的null，后续的方法调用就不会走了

2.8 第八次调用（初始化之后）调用BeanPostProcessor.postProcessAfterInitialization。

在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)方法中。

参数Object bean, String beanName，此方法是在调用初始化之后进针对对象进行一些操作