refresh之invokeBeanFactoryPostProcessors

invokeBeanFactoryPostProcessors翻译过来就是执行beanDefinition后置处理器的意思，所以这个方法就是bean定义的扩展点了，第一篇已经介绍过了后置处理器的相关概念，下面先介绍几个属性

1. regularPostProcessors：用来存放BeanFactoryPostProcessor
2. registryProcessors：用来存放BeanDefinitionRegistryPostProcessor
3. currentRegistryProcessors：临时变量，也是装载BeanDefinitionRegistryPostProcessor，因为这里有一个优先级的概念，所以分别处理放入这个集合，优先级处理后统一放入registryProcessors
4. processedBeans：前面说了这里有一个分级处理的概念，所以这个是用来记录已经处理过的后置处理器的名字，避免重复

public static void invokeBeanFactoryPostProcessors(
	 ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor>
			beanFactoryPostProcessors) {
		
		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set<String> processedBeans = new HashSet<>();
		
		//beanFactory是DefaultListableBeanFactory，是BeanDefinitionRegistry的实现类，所以肯定满足if
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			
			 //regularPostProcessors 用来存放BeanFactoryPostProcessor，
			 List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			
			 //registryProcessors 用来存放BeanDefinitionRegistryPostProcessor
			 //BeanDefinitionRegistryPostProcessor扩展了BeanFactoryPostProcessor
			 List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
			
			 // 循环传进来的beanFactoryPostProcessors，正常情况下，beanFactoryPostProcessors肯定没有数据
			 // 因为beanFactoryPostProcessors是获得手动添加的，而不是spring扫描的
			 // 只有手动调用annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX)才会有数据
			 for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				 // 判断postProcessor是不是BeanDefinitionRegistryPostProcessor，因为BeanDefinitionRegistryPostProcesso
				
				 // 扩展了BeanFactoryPostProcessor，所以这里先要判断是不是BeanDefinitionRegistryPostProcessor
				 // 是的话，直接执行postProcessBeanDefinitionRegistry方法，然后把对象装到registryProcessors里面去
				 if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					 BeanDefinitionRegistryPostProcessor registryProcessor =
							 (BeanDefinitionRegistryPostProcessor) postProcessor;
					 registryProcessor.postProcessBeanDefinitionRegistry(registry);
					 registryProcessors.add(registryProcessor);
					 }
				
				 else {//不是的话，就装到regularPostProcessors
					 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.
			 //一个临时变量，用来装载BeanDefinitionRegistryPostProcessor
			 //BeanDefinitionRegistry继承了PostProcessorBeanFactoryPostProcessor
			 List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
			
			 // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			 // 获得实现BeanDefinitionRegistryPostProcessor接口的类的BeanName:org.springframework.context.annotation.internalConfigurationAnnotationProcessor
			 // 并且装入数组postProcessorNames，我理解一般情况下，只会找到一个
			 // 这里又有一个坑，为什么我自己创建了一个实现BeanDefinitionRegistryPostProcessor接口的类，也打上了@Component注解
			 // 配置类也加上了@Component注解，但是这里却没有拿到
			 // 因为直到这一步，Spring还没有去扫描，扫描是在ConfigurationClassPostProcessor类中完成的，也就是下面的第一个
			 // invokeBeanDefinitionRegistryPostProcessors方法
			 String[] postProcessorNames =
					 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			
			 for (String ppName : postProcessorNames) {
				 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					 //获得ConfigurationClassPostProcessor类，并且放到currentRegistryProcessors
					 //ConfigurationClassPostProcessor是很重要的一个类，它实现了BeanDefinitionRegistryPostProcessor接口
					 //BeanDefinitionRegistryPostProcessor接口又实现了BeanFactoryPostProcessor接口
					 //ConfigurationClassPostProcessor是极其重要的类
					 //里面执行了扫描Bean，Import，ImportResouce等各种操作
					 //用来处理配置类（有两种情况 一种是传统意义上的配置类，一种是普通的bean）的各种逻辑
					 currentRegistryProcessors.add(beanFactory.getBean(ppName,
							BeanDefinitionRegistryPostProcessor.class));
					 //把name放到processedBeans，后续会根据这个集合来判断处理器是否已经被执行过了
					 processedBeans.add(ppName);
					 }
				 }
			
			 //处理排序
			 sortPostProcessors(currentRegistryProcessors, beanFactory);
			
			 //合并Processors，为什么要合并，因为registryProcessors是装载BeanDefinitionRegistryPostProcessor的
			 //一开始的时候，spring只会执行BeanDefinitionRegistryPostProcessor独有的方法
			 //而不会执行BeanDefinitionRegistryPostProcessor父类的方法，即BeanFactoryProcessor的方法
			 //所以这里需要把处理器放入一个集合中，后续统一执行父类的方法
			 registryProcessors.addAll(currentRegistryProcessors);
			
			 //可以理解为执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法
			 //Spring热插播的体现，像ConfigurationClassPostProcessor就相当于一个组件，Spring很多事情就是交给组件去管理
			 //如果不想用这个组件，直接把注册组件的那一步去掉就可以
			 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			
			 //因为currentRegistryProcessors是一个临时变量，所以需要清除
			 currentRegistryProcessors.clear();
			
			 // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			 // 再次根据BeanDefinitionRegistryPostProcessor获得BeanName，看这个BeanName是否已经被执行过了，有没有实现ered接口
			 // 如果没有被执行过，也实现了Ordered接口的话，把对象推送到currentRegistryProcessors，名称推送到processedns
			 // 如果没有实现Ordered接口的话，这里不把数据加到currentRegistryProcessors，processedBeans中，后续再做处理
			 // 这里才可以获得我们定义的实现了BeanDefinitionRegistryPostProcessor的Bean
			 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);
			
			 //合并Processors
			 registryProcessors.addAll(currentRegistryProcessors);
			
			 //执行我们自定义的BeanDefinitionRegistryPostProcessor
			 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			
			 //清空临时变量
			 currentRegistryProcessors.clear();
			
			 // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			 // 上面的代码是执行了实现了Ordered接口的BeanDefinitionRegistryPostProcessor，
			 // 下面的代码就是执行没有实现Ordered接口的BeanDefinitionRegistryPostProcessor
			 boolean reiterate = true;
			 while (reiterate) {
				 reiterate = false;
				 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				 for (String ppName : postProcessorNames) {
					 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.
			 //registryProcessors集合装载BeanDefinitionRegistryPostProcessor
			 //上面的代码是执行子类独有的方法，这里需要再把父类的方法也执行一次
			 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			
			 //regularPostProcessors装载BeanFactoryPostProcessor，执行BeanFactoryPostProcessor的方法
			 //但是regularPostProcessors一般情况下，是不会有数据的，只有在外面手动添加BeanFactoryPostProcessor，才会有数据
			 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
			 }
		
		 else {
			 // Invoke factory processors registered with the context instance.
			 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
			 }
		
		 // Do not initialize FactoryBeans here: We need to leave all regular beans
		 // uninitialized to let the bean factory post‐processors apply to them!
		 //找到BeanFactoryPostProcessor实现类的BeanName数组
		 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<>();
		 //循环BeanName数组
		 for (String ppName : postProcessorNames) {
			 //如果这个Bean被执行过了，跳过
			 if (processedBeans.contains(ppName)) {
				161 // skip ‐ already processed in first phase above
				162 }
			 //如果实现了PriorityOrdered接口，加入到priorityOrderedPostProcessors
			 else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
				 }
			 //如果实现了Ordered接口，加入到orderedPostProcessorNames
			 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				 orderedPostProcessorNames.add(ppName);
				 }
			 //如果既没有实现PriorityOrdered，也没有实现Ordered。加入到nonOrderedPostProcessorNames
			 else {
				 nonOrderedPostProcessorNames.add(ppName);
				 }
			 }
		
		 //排序处理priorityOrderedPostProcessors，即实现了PriorityOrdered接口的BeanFactoryPostProcessor
		 // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		 //执行priorityOrderedPostProcessors
		 invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
		
		 //执行实现了Ordered接口的BeanFactoryPostProcessor
		 // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		 List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		 for (String postProcessorName : orderedPostProcessorNames) {
			 orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
			 }
		 sortPostProcessors(orderedPostProcessors, beanFactory);
		 invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
		
		 // 执行既没有实现PriorityOrdered接口，也没有实现Ordered接口的BeanFactoryPostProcessor
		 // Finally, invoke all other BeanFactoryPostProcessors.
		 List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		 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();
	}

主要是分了4个级别处理

1. 处理手动调用annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX)的后置处理器
2. 处理实现了PriorityOrdered优先级的后置处理器
3. 处理实现了Ordered优先级的后置处理器
4. 其他后置处理器
   
   其中用于解析配置类的ConfigurationClasspostprocessor类图如图所示，它继承了PriorityOrdered和BeanDefinitionRegistryPostProcessor，解析配置类就是在它重写的postProcessBeanDefinitionRegistry方法的processConfigBeanDefinitions(registry);
   

	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);
//头痛的地方。救命。开始解析配置类
		processConfigBeanDefinitions(registry);
	}