Spring源码之启动过程（二）—— invokeBeanFactoryPostProcessors()方法解析

        Spring在启动的时候，在实例化之前在AbstractApplicationContext.refresh()中会执行invokeBeanFactoryPostProcessors()。

        在前面的BeanFactory准备好之后，执行该方法，负责激活各种 BeanFactory 处理器，以及两个核心接口BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口的调用：        

• BeanDefinitionRegistryPostProcessor
• BeanFactoryPostProcessor
• ConfigurationClassPostProcessor

        它会往AbstractBeanFactory中的beanPostProcessors属性（一个List）中放置各种类型的BeanPostProcessor对象。

BeanFactoryPostProcessor是BeanFactory的后置处理器

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		// 在这里拿到了ConfigurationClassPostProcessor的实例，然后调用beanFactory.getBean()方法
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

        getBeanFactoryPostProcessors()方法获取的是我们手动添加进去的BeanFactoryPostProcessor，例如：

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ScanBean.class);
applicationContext.addBeanFactoryPostProcessor(new KieasarBeanFactoryPostProcessor());

         接下来，进入PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()：

// 参数beanFactory就是之前创建好的BeanFactory
	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set<String> processedBeans = new HashSet<>();

		// 处理实现BeanDefinitionRegistry接口的情况
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			// beanFactoryPostProcessors一般情况下是空的，除非手动调用容器的addBeanFactoryPostProcessor()方法添加
			// beanFactoryPostProcessors包含了普通的BeanFactoryPostProcessor对象和BeanDefinitionRegistryPostProcessor对象
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				// 如果是BeanDefinitionRegistryPostProcessor对象，会强制转换，并执行postProcessBeanDefinitionRegistry()方法
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// Do not initialize FactoryBeans here: We need to leave all regular beans
			// uninitialized to let the bean factory post-processors apply to them!
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// 执行扫描处理的BeanDefinitionRegistryPostProcessor：

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			// 获取实现了BeanDefinitionRegistryPostProcessor接口的所有类的BeanDefinition对象的beanName
			// 1.最先调用的是实现了PriorityOrdered接口的所有BeanDefinitionRegistryPostProcessor中的postProcessBeanDefinitionRegistry()方法
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 判断是否实现了排序接口PriorityOrdered
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					// 通过上面拿到BeanDefinitionRegistryPostProcessor类型的name获取实例，调用beanFactory.getBean()方法
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			// 升序排序，就是用List中的sort排序，通过Comparator来进行
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			// 之前只有一个实例，基于注解的扫描是由@ComponentScan触发的，这个注解的解析是ConfigurationClassPostProcessor做的，有了ConfigurationClassPostProcessor才有后续类的收集、注册（先执行）；
			// 但基于xml配置的自定义标签是先扫描的，把所有注解的类变成BeanDefinition，然后再注册组件，再执行ConfigurationClassPostProcessor类（后执行）。
			// 调用之后，拿到ConfigurationClassPostProcessor实例后在这里调用BeanDefinitionRegistryPostProcessor类的postProcessBeanDefinitionRegistry(registry);
			// 会注册进来多个实例
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			// 2.在getBeanNamesForType()方法中拿到被ConfigurationClassPostProcessor获取到的多个BeanDefinitionRegistryPostProcessor实例
			// 然后调用实现了Ordered接口的所有BeanDefinitionRegistryPostProcessor
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 如果之前已经拿到了，就不重复获取了，并判断是否是实现的Ordered接口
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			// 调用过程，拿到实例后在这里调用BeanDefinitionRegistryPostProcessor接口实现类的postProcessBeanDefinitionRegistry(registry);
			// 会注册进来多个实例
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			// 3.最后调用的是没实现排序接口的、所有实现BeanDefinitionRegistryPostProcessor接口中的postProcessBeanDefinitionRegistry的方法
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					// 忽略之前执行过的PostProcessor
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			// 执行完BeanDefinitionRegistryPostprocessor的postProcessBeanDefinitionRegistry()方法后，再执行BeanDefinitionRegistryPostprocessor的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

			// 执行手动添加的普通BeanFactoryPostProcessor的postProcessBeanFactory()方法
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// 执行扫描出来的普通BeanFactoryPostProcessor

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		// 进行分类
		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);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
	}

       进入PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法：

       1. 调用BeanDefinitionRegistryPostProcessor接口的执行是在实例化之前，可以完成BeanDefinition的注册和修改：

• 实现PriorityOrdered接口；
• 实现Ordered接口；
• 实际是对其实现类中postProcessBeanDefinitionRegistry()方法的调用，完成对BeanDefinition的新增、修改。

private static void invokeBeanDefinitionRegistryPostProcessors(
      Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

   for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
      // 实际是对其实现类中postProcessBeanDefinitionRegistry()方法的调用，完成对BeanDefinition的新增、修改；
      postProcessor.postProcessBeanDefinitionRegistry(registry);
   }
}

        主要是对其实现类中postProcessBeanDefinitionRegistry()方法的调用，完成对BeanDefinition的新增、修改。 

      2. 调用BeanFactoryPostProcessor接口：

• 实现PriorityOrdered接口；
• 实现Ordered接口；
• 两个接口都没实现；
• 实际完成了对其实现类中postProcessBeanFactory方法的调用。

private static void invokeBeanFactoryPostProcessors(
      Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

   for (BeanFactoryPostProcessor postProcessor : postProcessors) {
      // 调用它的postProcessBeanFactory方法
      postProcessor.postProcessBeanFactory(beanFactory);
   }
}

        执行对其实现类中postProcessBeanFactory()方法的调用。

        对上面代码的理解：获取 BeanDefinitionRegistry 对象，获取到这个对象就可以获取这个对象中注册的所有 BeanDefinition 对象，拥有了这个对象就可以对里面所有 BeanDefinition 对象的修改和新增操作。

        调用所有实现了BeanDefinitionRegistryPostProcessor接口中的两个方法，执行过程完成。

        总结一下，invokeBeanFactoryPostProcessors()方法执行逻辑：

        1. 执行通过ApplicationContext添加进来的BeanDefinitionRegistryPostProcessor的
postProcessBeanDefinitionRegistry()方法；
        2. 执行BeanFactory中实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的
postProcessBeanDefinitionRegistry()方法；
        3. 执行BeanFactory中实现了Ordered接口的BeanDefinitionRegistryPostProcessor的
postProcessBeanDefinitionRegistry()方法；
        4. 执行BeanFactory中其他的BeanDefinitionRegistryPostProcessor的
postProcessBeanDefinitionRegistry()方法；
        5. 执行上面所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法；
        6. 执行通过ApplicationContext添加进来的BeanFactoryPostProcessor的
postProcessBeanFactory()方法；
        7. 执行BeanFactory中实现了PriorityOrdered接口的BeanFactoryPostProcessor的
postProcessBeanFactory()方法；
        8. 执行BeanFactory中实现了Ordered接口的BeanFactoryPostProcessor的
postProcessBeanFactory()方法;
        9. 执行BeanFactory中其他的BeanFactoryPostProcessor的postProcessBeanFactory()方法。

        BeanDefinitionRegistryPostProcessor接口应用：

/**
 * @Classname BeanPro
 * @Description BeanDefinitionRegistryPostProcessor接口案例
 * @Author Kieasar
 * Date 2021/5/13 20:17
 * Version 1.0
 */
@Component
public class BeanPro implements BeanDefinitionRegistryPostProcessor, PriorityOrdered, Ordered {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        //查询BeanDefinition
        final String[] beanDefinitionNames = registry.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            BeanDefinition beanDefinition = registry.getBeanDefinition(beanDefinitionName);
            System.out.println(beanDefinition);
        }
        // 新建一个beanDefinition
        GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
        genericBeanDefinition.setBeanClass(BeanDefinitionBean.class);
        MutablePropertyValues propertyValues = genericBeanDefinition.getPropertyValues();
        // 将BeanDefinitionBean中name之前的test修改为Kieasar
        propertyValues.add("name", "Kieasar");
        // 然后注册到Spring容器中
        registry.registerBeanDefinition("beanDefinitionBean", genericBeanDefinition);

        // 新建一个扫描器
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry);
        //需要过滤的注解
        scanner.addIncludeFilter(new AnnotationTypeFilter(MyService.class));
        // 指定扫描的包
        scanner.scan("com.enjoy.Kieasar.customBean");

    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        String[] beanDefinitionNames = registry.getBeanDefinitionNames();

        DefaultListableBeanFactory beanFactory1 = (DefaultListableBeanFactory) beanFactory;
        // 是否允许BeanDefinition名称重复
        beanFactory1.setAllowBeanDefinitionOverriding(true);
        // 是否允许循环依赖
        beanFactory1.setAllowCircularReferences(true);
        // 是否允许未经包装的注入报错（多重循环依赖报错、多重切面存在循环依赖的报错）
        beanFactory1.setAllowRawInjectionDespiteWrapping(true);
    }

    @Override
    public int getOrder() {
        return 0;
    }
}