BeanFactoryPostProcessor 后置处理器的执行顺序

BeanFactoryPostProcessor有两种形式被spring执行，优先级不相同

BeanDefinitionRegistryPostProcessor（对应BeanDefinitionRegistry接口，管理bean元数据）实现了BeanFactoryPostProcessor接口
#postProcessBeanDefinitionRegistry（自己独有的方法）
#postProcessBeanFactory（BeanFactoryPostProcessor的方法）
BeanFactoryPostProcessor（对应BeanFactory接口，管理bean对象）
#postProcessBeanFactory
注：会不会执行BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry还需要看BeanFactory实现类是否实现BeanDefinitionRegistry，没有实现则不执行

执行顺序，优先级由高到低依次为：

1. BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry（spring 直接new出来的后置处理器，没有交给容器管理的）
2. BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry（自定义的实现类，并实现PriorityOrdered接口，同等级还会进行排序）
3. BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry（自定义的实现类，并实现Ordered接口，同等级还会进行排序）
4. BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry（自定义的实现类）
5. BeanDefinitionRegistryPostProcessor#postProcessBeanFactory（因为在前面1，2，3，4步的时候，已经排序放入一个list了，所以这里按1，2，3，4步的顺序执行后置处理器）
   ====================================上面BeanDefinitionRegistryPostProcessor
   ====================================下面BeanFactoryPostProcessor
6. BeanFactoryPostProcessor#postProcessBeanFactory（spring 直接new出来的后置处理器，没有交给容器管理的）
7. BeanFactoryPostProcessor#postProcessBeanFactory（实现PriorityOrdered接口，同等级还会进行排序）
8. BeanFactoryPostProcessor#postProcessBeanFactory（实现Ordered接口，同等级还会进行排序）
9. BeanFactoryPostProcessor#postProcessBeanFactory

如果只看自定义的后置处理器的执行顺序，由高到低依次为：

1. BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
2. BeanDefinitionRegistryPostProcessor#postProcessBeanFactory
3. BeanFactoryPostProcessor#postProcessBeanFactory
   注：同种类型的后置处理器，实现PriorityOrdered接口的优先级高于实现Ordered接口的，没有实现排序接口的优先级最低

这里补充一点BeanPostProcessor的坑（BeanPostProcessor与上面一样，都是使用PriorityOrdered/Ordered实现优先级的）

结论：BeanPostProcessor不会处理优先级大于等于的BeanPostProcessor
1、实现PriorityOrdered，不会被BeanPostProcessor处理
因为此时BeanFactory中没有BeanPostProcessor，所以在getBean的时候，不会经过BeanPostProcessor处理
当都实例化结束，会注册到BeanFactory，供getBean时使用（只包含PriorityOrdered）
2、实现Ordered，只会被实现PriorityOrdered的BeanPostProcessor处理
因为此时BeanFactory中只有实现PriorityOrdered的BeanPostProcessor，所以在getBean的时候，被这部分BeanPostProcessor处理
当都实例化结束，会注册到BeanFactory，供getBean时使用（包含PriorityOrdered/Ordered）
3、没有实现PriorityOrdered 或 Ordered，会被实现PriorityOrdered的BeanPostProcessor处理
因为此时BeanFactory中包含了指定优先级的BeanPostProcessor，所以在getBean的时候，被指定优先级的BeanPostProcessor处理
当都实例化结束，会注册到BeanFactory，供getBean时使用（包含PriorityOrdered/Ordered，还有没有指定优先级的BeanPostProcessor）
4、后面通过getBean，就会被所有BeanPostProcessor处理了

例子：
AOP是通过AbstractAutoProxyCreator实现的，该类实现了BeanPostProcessor，同时也通过Ordered实现优先级（AOP的后置处理器是最低优先级的）
在AbstractAutoProxyCreator中有一个interceptorNames属性，可以对所有AOP代理类再加一层切面，但是需要手动对这个属性设置值
自定义BeanPostProcessor，同时也通过Ordered指定高优先级，发现interceptorNames为空，也就是不生效，后面更改为PriorityOrdered，interceptorNames有值了

具体执行顺序看PostProcessorRegistrationDelegate 类

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

		//存储自定义的BeanDefinitionRegistryPostProcessors 实现类
		//并且是已经执行过postProcessBeanFactory方法的
		Set<String> processedBeans = new HashSet<>();

		if (beanFactory instanceof BeanDefinitionRegistry) {
   
   
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			//存储spring容器直接new出来的BeanFactoryPostProcessor（没有给容器管理）
			List