spring源码阅读（二）--ioc容器加载（五）--invokeBeanFactoryPostProcessors（）

前面我们讲解了postProcessBeanFactory(beanFactory); 是spring留给我们的扩展点，该扩展点是一个bean工厂的后置处理器，那么这些bean工厂会给我们带来什么要的威力呢，下面开始关于invokeBeanFactoryPostProcessors()的源码分析

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		//委托给PostProcessorRegistrationDelegate去调用
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// 判断工厂中是否存在名字包含loadTimeWeaver的bean，如果存在将会将临时的类加载器进行set，并且添加bean的后置处理器，
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

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

		//如果存在BeanDefinitionRegistryPostProcessors，先调用BeanDefinitionRegistryPostProcessors方法
		Set<String> processedBeans = new HashSet<>();
		//如果bean工厂实现了BeanDefinitionRegistry，我们创建的工厂是DefaultListableBeanFactory，
		// 根据类图可以得知是肯定实现了BeanDefinitionRegistry的，这段逻辑主要是吧后置处理器全部找出来
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					//开始调用postProcessBeanDefinitionRegistry方法
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					//将调用过的处理器存入registryProcessors
					registryProcessors.add(registryProcessor);
				}
				else {
					//没有实现的BeanDefinitionRegistryPostProcessor也会加入到处理过的registryProcessors
					regularPostProcessors.add(postProcessor);
				}
			}


			//不要在这里初始化工厂bean，我们需要保留所有的普通bean
			//让bean工厂后置处理器去调用没有初始化的bean
			//独立的BeanDefinitionRegistryPostProcessors实现
			//诸如PriorityOrdered，Ordered此类的
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			//首先，调用实现了PriorityOrdered的BeanDefinitionRegistryPostProcessors
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					//根据名称和类型获取bean，并加入到当前需要调用的容器中currentRegistryProcessors，
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//同时也将处理过的bean加入到processedBeans集合中去
					processedBeans.add(ppName);
				}
			}
			//对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//把他加入到用于保存的registryProcessors中
			registryProcessors.addAll(currentRegistryProcessors);
			//调用它的后置处理器
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			//调用完之后，马上clear掉
			currentRegistryProcessors.clear();

			//其次，开始调用实现了Ordered的BeanDefinitionRegistryPostProcessors
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			//排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//将已经调用过的也存在的registryProcessors
			registryProcessors.addAll(currentRegistryProcessors);
			//开始挨个调用
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			//清空掉容器，方便下次使用
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			//最后，开始调用其他的BeanDefinitionRegistryPostProcessors，知道没有其他的处理器出现为止（处理所有的后置处理器）
			//核心调用逻辑
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				//查出所有实现了BeanDefinitionRegistryPostProcessor接口的bean名称
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					//前面的逻辑中，已经对实现了PriorityOrdered和Ordered的bean都处理过了，因此通过processedBeans过滤，processedBeans中没有的才会在此处理
					if (!processedBeans.contains(ppName)) {
						//根据名称和类型获取bean，并加入到currentRegistryProcessors，
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						//把需要调用的bean的名称放到processedBeans
						processedBeans.add(ppName);
						//跳出循环
						reiterate = true;
					}
				}
				//排序
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				//将已经调用过的也存在的registryProcessors
				registryProcessors.addAll(currentRegistryProcessors);
				//开始挨个调用
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				//清空掉容器
				currentRegistryProcessors.clear();
			}

			// 现在，开始调用所有处理过的处理器的回调
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

以上就是invokeBeanFactoryPostProcessors源码部分的解读，这里主要允许我们通过代码的方式注册bean定义，允许对已注册的bean定义进行获取，删除，修改等

参考博客：https://blog.youkuaiyun.com/v123411739/article/details/87741251（感谢博主的无私奉献）