简单回顾一下上一篇文章，是在BeanFacroty创建完之后，可以通过Editor和EditorRegistrar实现对类属性的自定义扩展，以及忽略要自动装配的Aware接口。
本篇帖子会顺着refresh()主流程方法接着向下执行。在讲invokeBeanFactoryPostProcessors方法的具体逻辑之前，先简单介绍BeanFactoryPostProcessor接口和整个invokeBeanFactoryPostProcessors方法的执行流程。
refresh
java
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
/**
* 前戏，做容器刷新前的准备工作
* 1、设置容器的启动时间
* 2、设置活跃状态为true
* 3、设置关闭状态为false
* 4、获取Environment对象，并加载当前系统的属性值到Environment对象中
* 5、准备监听器和事件的集合对象，默认为空的集合
*/
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 创建容器对象：DefaultListableBeanFactory
// 加载xml配置文件的属性值到当前工厂中，最重要的就是BeanDefinition
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// beanFactory的准备工作，对各种属性进行填充
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 子类覆盖方法做额外的处理，此处我们自己一般不做任何扩展工作，但是可以查看web中的代码，是有具体实现的
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 调用各种beanFactory处理器
invokeBeanFactoryPostProcessors(beanFactory);
}
}
}
java
@FunctionalInterface
public interface BeanFactoryPostProcessor {
/**
* Modify the application context's internal bean factory after its standard
* initialization. All bean definitions will have been loaded, but no beans
* will have been instantiated yet. This allows for overriding or adding
* properties even to eager-initializing beans.
* @param beanFactory the bean factory used by the application context
* @throws org.springframework.beans.BeansException in case of errors
*/
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
/**
* Modify the application context's internal bean definition registry after its
* standard initialization. All regular bean definitions will have been loaded,
* but no beans will have been instantiated yet. This allows for adding further
* bean definitions before the next post-processing phase kicks in.
* @param registry the bean definition registry used by the application context
* @throws org.springframework.beans.BeansException in case of errors
*/
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}BFPP和BDRPP
根据上面的流程图以及代码块可以看出BFPP和BDRPP的关系，其中BFPP类中只有一个postProcessBeanFactory()方法，而BDRPP中只有postProcessBeanDefinitionRegistry()方法，因为是继承的关系，所以所有实现BDRPP接口的类，也会有postProcessBeanFactory()方法。
而BFPP和BDRPP其中有一个很重要的区别就在于，它们两个方法接收的参数不同，其中BFPP接收BeanFactory参数，针对整个BeanFactory做操作，而BDRPP接收的参数是BeanDefinitionRegistry（可以理解是对Definition做一些正删改查的操作）。
BeanDefinitionRegistry
java
public interface BeanDefinitionRegistry extends AliasRegistry {
/**
* 注册BeanDefinition到注册表
*
* Register a new bean definition with this registry.
* Must support RootBeanDefinition and ChildBeanDefinition.
* @param beanName the name of the bean instance to register
* @param beanDefinition definition of the bean instance to register
* @throws BeanDefinitionStoreException if the BeanDefinition is invalid
* @throws BeanDefinitionOverrideException if there is already a BeanDefinition
* for the specified bean name and we are not allowed to override it
* @see GenericBeanDefinition
* @see RootBeanDefinition
* @see ChildBeanDefinition
*/
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
/**
* 移除注册表中beanName的BeanDefinition
*
* Remove the BeanDefinition for the given name.
* @param beanName the name of the bean instance to register
* @throws NoSuchBeanDefinitionException if there is no such bean definition
*/
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
/**
* 获取注册表中beanName的BeanDefinition
*
* Return the BeanDefinition for the given bean name.
* @param beanName name of the bean to find a definition for
* @return the BeanDefinition for the given name (never {@code null})
* @throws NoSuchBeanDefinitionException if there is no such bean definition
*/
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
/**
* 检查此注册表是否包含具有给定名称的BeanDefinition
*
* Check if this registry contains a bean definition with the given name.
* @param beanName the name of the bean to look for
* @return if this registry contains a bean definition with the given name
*/
boolean containsBeanDefinition(String beanName);
/**
* 返回此注册表中定义的所有bean的名称
*
* Return the names of all beans defined in this registry.
* @return the names of all beans defined in this registry,
* or an empty array if none defined
*/
String[] getBeanDefinitionNames();
/**
* 返回注册表中定义的bean的数目
*
* Return the number of beans defined in the registry.
* @return the number of beans defined in the registry
*/
int getBeanDefinitionCount();
/**
* 确定给定bean名称是否已在该注册表中使用
*
* Determine whether the given bean name is already in use within this registry,
* i.e. whether there is a local bean or alias registered under this name.
* @param beanName the name to check
* @return whether the given bean name is already in use
*/
boolean isBeanNameInUse(String beanName);
}接口的作用和整体的执行流程已经介绍完成，下面看看invokeBeanFactoryPostProcessors方法的具体执行逻辑。
invokeBeanFactoryPostProcessors
主要是调用delegate中的同名invokeBeanFactoryPostProcessors方法，对BaenFactory中和自定义注册进来的BFPP的实现类进行处理。
其中getBeanFactoryPostProcessors()是如果类继承了AbstractApplicationContext后，可以有add方法自行注册BeanFactoryPostProcessor。处理时也会先处理这部分的BFPP。
invokeBeanFactoryPostProcessors
java
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 获取到当前应用程序上下文的beanFactoryPostProcessors变量的值，并且实例化调用执行所有已经注册的beanFactoryPostProcessor
// 默认情况下，通过getBeanFactoryPostProcessors()来获取已经注册的BFPP，但是默认是空的
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}AbstractApplicationContext
如果想要自己注册进来，要实现AbstractApplicationContext并调用addBeanFactoryPostProcessor方法将自定义BFPP实现类加进来，就可以get到。
java
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
@Override
public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
this.beanFactoryPostProcessors.add(postProcessor);
}
/**
* Return the list of BeanFactoryPostProcessors that will get applied
* to the internal BeanFactory.
*/
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}
//删除其他代码
} 具体处理逻辑
如最开始图片中标注的处理流程一样，
- 处理过的BFPP都放入processedBeans集合，避免后续重复执行。
- 先遍历beanFactoryPostProcessors中BDRPP类型的，并直接调用postProcessBeanDefinitionRegistry进行逻辑处理。非BDRPP类型放入regularPostProcessors集合，后续统一处理。
- 找到BeanFactory中BDRPP类型，并根据PriorityOrdered，Order进行优先级排序，最后再执行没有优先级的。
- 因为继承了BDRPP的肯定也会有BFPP中的方法，所以还会统一处理执行BDRPP中的postProcessBeanFactory方法。
- 执行完BeanFactory中的BDRPP类型后，再查找BeanFactory中BFPP类型，同样按照PriorityOrdered，Order进行优先级排序。并执行postProcessBeanFactory方法。
java
class PostProcessorRegistrationDelegate {
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
//所有已经执行过BFPP的存储在processedBeans，防止重复执行
Set<String> processedBeans = new HashSet<String>();
//判断beanFactory是否属于BeanDefinitionRegistry类型，默认的beanFactory是DefaultListableBeanFactory，
//实现了BeanDefinitionRegistry 所以为true
if (beanFactory instanceof BeanDefinitionRegistry) {
//强制类型转换
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
//存放BFPP类型的集合
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
//存放BDRPP类型的集合
List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
new LinkedList<BeanDefinitionRegistryPostProcessor>();
//优先处理入参中的beanFactoryPostProcessors,遍历所有beanFactoryPostProcessors，
//并将参数中的BFPP和BDRPP区分开
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
//如果是BDRPP类型
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryPostProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
//直接调用BDRPP中的postProcessBeanDefinitionRegistry具体方法进行处理
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
//放入registryPostProcessors集合中
registryPostProcessors.add(registryPostProcessor);
}
else {
//否则，只是普通的BeanFactoryPostProcessor，则放入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.
//根据type获取BeanFactory中所有类型为BDRPP的postProcessorNames
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
//将实现了BDRPP和priorityOrder接口的类放入该集合
List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
//如果是PriorityOrdered类型的
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//放入priorityOrderedPostProcessors集合
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//放入processedBeans集合，避免重复执行
processedBeans.add(ppName);
}
}
//按照优先级进行排序
OrderComparator.sort(priorityOrderedPostProcessors);
//添加到registryPostProcessors中
registryPostProcessors.addAll(priorityOrderedPostProcessors);
//遍历priorityOrderedPostProcessors集合，执行postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
//再次获取BDRPP类型的所有postProcessorNames
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//实现了Order接口的BeanDefinitionRegistryPostProcessor放入该集合
List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
//如果是没执行过，并且实现了Order接口的
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
//放到Order集合中
orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//放入processedBeans集合，避免重复执行
processedBeans.add(ppName);
}
}
//按照优先级排序
OrderComparator.sort(orderedPostProcessors);
//放入registryPostProcessors集合
registryPostProcessors.addAll(orderedPostProcessors);
//遍历orderedPostProcessors集合，执行postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
//找出所有实现了BDRPP接口的类
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//跳过执行过BDRPP的类
if (!processedBeans.contains(ppName)) {
//根据name获取实例
BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
//添加到registryPostProcessors集合中
registryPostProcessors.add(pp);
//添加到processedBeans集合中
processedBeans.add(ppName);
//直接执行BDRPP
pp.postProcessBeanDefinitionRegistry(registry);
reiterate = true;
}
}
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
//遍历registryPostProcessors和regularPostProcessors中有所的bean，
//执行BFPP接口postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
//如果beanFactory不属于BeanDefinitionRegistry，直接执行具体方法
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
//到这为止，入参的beanFactoryPostProcessors和BeanFactory中BDRPP类型的方法已经全部处理完成
//后面开始都是操作BFPP类型
//到这位置
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
//找到所有实现BeanFactoryPostProcessor的类
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
//依次声明priorityOrderedPostProcessors、orderedPostProcessorNames和nonOrderedPostProcessorNames分别用来存放对应
//实现了priorityOrdered、ordered和没实现排序接口的类
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
//遍历所有postProcessorNames，将没执行过的BFPP方法的类放入对应集合中。
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.
//按照优先级进行排序，并执行具体的BFPP方法
OrderComparator.sort(priorityOrderedPostProcessors);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
OrderComparator.sort(orderedPostProcessors);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}看完上面这段源码之后，不知道大家有没有这样的一个疑问，为什么重复代码较多？每次都要根据类型重新获取String[] postProcessorNames，第一次获取后，根据postProcessorNames按照PriorityOrdered和Order进行优先级排序、分组执行不行么？
是因为在执行BDRPP的方法postProcessBeanDefinitionRegistry时，有可能会有新增的额外的BDRPP的类，每次都重新获取，能避免BDRPP类执行的不完全。