Spring中PostProcessorRegistrationDelegate类中beanFactory.getBeanNamesForType()的4次调用

Bertha 。 2022-03-20 06:46 78阅读 0赞

[基于PostProcessorRegistrationDelegate类的示例][PostProcessorRegistrationDelegate]

以下是PostProcessorRegistrationDelegate类中invokeBeanFactoryPostProcessors()这个方法的源码：

public static void invokeBeanFactoryPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { 
    
    		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
    		Set<String> processedBeans = new HashSet<>();
    
    		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;
    					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<>();
    
    			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
    			String[] postProcessorNames =
    					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    			for (String ppName : postProcessorNames) { 
    				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
    					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    					processedBeans.add(ppName);
    				}
    			}
    			sortPostProcessors(currentRegistryProcessors, beanFactory);
    			registryProcessors.addAll(currentRegistryProcessors);
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    			currentRegistryProcessors.clear();
    
    			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
    			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.addAll(currentRegistryProcessors);
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    			currentRegistryProcessors.clear();
    
    			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    			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.
    			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    			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!
    		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<>();
    		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<>();
    		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();
    	}

从如上源码中不难看出，beanFactory.getBeanNamesForType()这个方法有调用过4次，对于这4次调用 ，他们的作用是干嘛的? 为什么要这样做? 下面做一个简单的解译：

*  1.对于这4次调用 ，首先有3次，是在一个 if 判断语句中运行的，从如下判断

if (beanFactory instanceof BeanDefinitionRegistry) {

可以看出，如果实现了 **BeanDefinitionRegistry** 这个接口，则会优先执行，并且需要调用 3 次beanFactory.getBeanNamesForType()这个方法。

> 为什么需要调用 3 次呢？

是因为可能设置过 Bean 的执行优先级顺序。  
可能当前 Bean 实现了 PriorityOrdered 或是 Ordered 接口，来指定当前 Bean 的调用顺序。

**Bean 的优先执行顺序如下：**

1.  如果 Bean 实现了 PriorityOrdered 接口，则最优先执行
2.  若是两个 Bean 同时指定了 PriorityOrdered 接口，则根据指定的 order 值的大小来确定谁优先调用，即

public int getOrder() { 
    	return 0;
    }

的返回结果。谁的值越小，谁优先调用。

1.  如果 Bean 实现了 Ordered 接口，则为第二优先级调用
2.  或是有两个 Bean 同时实现了 Ordered 接口，同样根据指定的 order 值的大小来确认，谁小谁先调用。
3.  如果 Bean 没有实现以上两上接口（PriorityOrdered 和 Ordered），则当前 Bean 最后调用。

从这 3 次调用的顺序来看，按照如下代码的作用来说：

if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

如果当前Bean实现了 **PriorityOrdered** 这个接口，则当前 Bean 会被最优先调用。

invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

如果当前 Bean 实现了 Ordered 接口，则当前 Bean 会被作为第二优先级调用：

if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { 
       //.....
    }
    //执行调用当前 Bean
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

如果当前 Bean 以上两个接口都没有实现，则最后再调用

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();
    }

而在以上 3 次调用的 if 判断语句之外，还会再次调用一次，这是为什么呢？

首先，我们需要了解一下，为什么要做如下这个判断：

if (beanFactory instanceof BeanDefinitionRegistry) {

**BeanDefinitionRegistry** 这个接口的作用是什么呢？  
从它的语意上来看，这个接口主要是做 Bean 定义注册的，相当于是去做添加 Bean 的。

这个 if 判断语句之后的处理，主要是做 BeanFactory 实例化之后的一些增强，如下代码不难看出：

String[] postProcessorNames =
    				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

从整个 Bean 的操作顺序来看，应该是优先处理完所有的 Bean ，然后再处理 BeanFactory 相关的处理。  
这是没什么问题的，而且也应该是这样。

*  2.那么现在的主要问题就是，为什么这里会调用 4 次beanFactory.getBeanNamesForType() 这个呢？

前面 3 次都是获取 BeanDefinitionRigistoryPostProcessor 相关的 Bean 的名称。

String[] postProcessorNames =
    					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

这里为什么需要获取 3 次呢？

是因为针对 3 种优先级别的 Bean，都会分别去调用，去执行。而这些执行过程中，可能会影响到 Bean 的数量，可能会添加一些新的 Bean 进来。

对于实现了 PriorityOrdered 接口的 Bean:

// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
    //获取 BeanDefinitionRegistryPostProcessor 这种类型的 Bean 集合
    String[] postProcessorNames =
    	beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    for (String ppName : postProcessorNames) { 
    	if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
    		currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    		processedBeans.add(ppName);
    	}
    }
    sortPostProcessors(currentRegistryProcessors, beanFactory);
    registryProcessors.addAll(currentRegistryProcessors);
    //执行这些 Bean
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    currentRegistryProcessors.clear();

对于实现了 Ordered 接口的 Bean:

// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
    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.addAll(currentRegistryProcessors);
    //执行这些 Bean
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    currentRegistryProcessors.clear();

对于以上两个接口都没有实现了 Bean:

// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    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);
    	//执行这些 Bean
    	invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    	currentRegistryProcessors.clear();
    }

所有，执行一次之后，都需要重新获取一次全新的 Bean 集合。

而最后，若是PriorityOrdered 和 Ordered 两个接口都没有实现的 Bean，这里为什么需要一个 **while** 循环呢？

原因是因为，若是执行过一次BeanDefinitionRegistryPostProcessor 之后，都有可能会影响 Bean 的数量，可能会添加一些的 Bean 实例进来，所以需要循环去再次获取，直到没有新的 Bean 实例添加为止。

*  3.而最后基于 BeanFactory 的处理，不需要以上 3 次处理，是因为，对 BeanFactory 做的增强，是不会影响到 BeanDefinition 的，也就是说，不会添加新的 Bean 实例进来，Bean 的个数已经固定了。

所以只做一次获取BeanFactoryPostProcessor的集合就可以了。

但从如下代码来看：

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<>();
    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<>();
    for (String postProcessorName : nonOrderedPostProcessorNames) { 
    	nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

对于 BeanFactoryPostProcessor 的处理也是有优先执行顺序的。  
和之前 BeanDefinitionRegistryPostProcessor 一样，实现了 PriorityOrdered 接口的 Bean 最优先执行，实现了 Ordered 接口的第二优先执行，然后以上两个接口都没有实现的 Bean 最后执行。

终上所述：  
这 4 次调用，有 3 次是针对 BeanDefinitionRegistryPostProcessor 执行的，而仅有一次是针对 BeanFactoryPostProcessor 执行的。

BeanDefinitionRegistryPostProcessor 可能会影响 BeanDefinition， 添加一些新的 Bean 实例进来。而针对 3 种执行优先顺序 Bean 来说，这 3 种是分别执行的，执行一次都有可能会影响 BeanDefinition，所以每次执行之前都需要重新调用 beanFactory.getBeanNamesForType() 获取一次全新的 Bean 集合，所以调用了 3 次。

而 BeanFactoryPostProcessor 是不会影响 BeanDefinition 的。所以只需要调用一次 beanFactory.getBeanNamesForType() 获取全新的 Bean 集合就可以了。

但针对实现了 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 接口的 Bean 内部都是有执行顺序的，实现了 PriorityOrdered 接口的最优先，实现了 Ordered 接口的第二优先，以上两个接口都没有实现的，最后执行。

[PostProcessorRegistrationDelegate]: https://blog.csdn.net/hsl0530hsl/article/details/87004348