Spring扩展点之BeanFactoryPostProcessor：彻底搞懂原理以及使用场景【源码分析】
spring框架流行了这么多年，地位至今不被动摇，除了spring全家桶的生态之外，它给开发者的提供的扩展也是值得一提的。那么今天就来聊聊Spring扩展点之BeanFactoryPostProcessor。
这个扩展点是发生在bean实例化之前，BeanDefinition读取完之后。所以我们在这里可以获取到BeanDefinition，以改变他默认的实例化方式。
由于文章内容是基于源码角度来讲的，考虑到有些朋友不需要看的如此的深入，所以在此贴出其简单的使用方式：加上@Component注解，使其加入到spring容器中，他会自动识别并在适当位置调用。
@Component
public class BeanFactoryPostProcessorExtension implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
// 获取指定的beanDefinition，这里操作bean定义的属性是最合适不过的
BeanDefinition personDefinition = beanFactory.getBeanDefinition("person");
System.out.println(personDefinition);
// 这里建议不要调用getBean来获取某个类的实例进行一些操作，因为这里get的话，他可能还没有进行属性赋值
}
}
后面就进行深度分析了，不感兴趣的朋友可以直接跳过，有上面的使用方式已满足日常开发需求。
首先来贴一张图：
这是spring工作的大致流程图，其中标蓝色的部分为今天要讲的重点。
首先我们来看入口类AnnotationConfigApplicationContext的构造函数：
/**
* 创建一个新的AnnotationConfigApplicationContext，从给定的组件类派生bean定义并自动刷新上下文。
*
* @param componentClasses 一个或者多个组件
* {@link Configuration @Configuration} classes
*/
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
// 调用空参构造函数，初始化对应的解析器：注解bean定义解读器和类路径下bean定义扫描器
this();
/**
* 注册组件，主要工作就是解析注解生成bean定义对象{@link org.springframework.beans.factory.config.BeanDefinition}，
* ban定义的子类是：{@link AnnotatedGenericBeanDefinition}
* 加入的其map中{@link org.springframework.beans.factory.support.DefaultListableBeanFactory.beanDefinitionMap}
*/
register(componentClasses);
// 刷新上下文，调用父类的refresh核心方法
refresh();
}
调用this()：也就是另一个构造函数，主要是初始化扫描器，用来扫描bean的。
register() ：主要是注册bean，通过扫描器扫描出bean的一些信息，然封装成BeanDefinition对象，存放在DefaultListableBeanFactory.beanDefinitionMap中，其中key为bean的名称。
refresh()：刷新上下文。
接下来我们看refresh()方法：
@Override
public void refresh() throws BeansException, IllegalStateException {
// 同步锁，防止出现线程安全问题
// 此方法很多地方都对线程安全做了动作
// 专门new了一个Object对象来当做锁
synchronized (this.startupShutdownMonitor) {
// 准备刷新此上下文
/**
* 1、设置刷新开始时间
* 2、分别设置closed和active（这两个是atomic并发包下面的，防止并发修改值错乱），
* 3、调用用户自定义的初始化property资源
* 4、验证比传属性：ConfigurablePropertyResolver接口中可以设置必传属性.
* 如果我们需要设置比传属性的话，可以监听SpringApplicationRunListeners.
* 并且覆盖他的environmentPrepared方法，此方法传入ConfigurableEnvironment 作为参数，然后对其进行设置
* 5、重置本地的程序侦听器
*/
prepareRefresh();
// 告诉子类刷新内部bean工厂。
// obtain：获得
// 获取刷新的bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 准备BeanFactory以供在此上下文中使用
prepareBeanFactory(beanFactory);
try {
/**
* 允许在上下文子类中对bean工厂进行后处理。
* 这里如果只是spring单独的项目的话，spring是无需对其处理的，
* 这里提供了一个对bean工厂进行的一个扩展点
* 如果需要扩展，那么就可以覆盖
* {@link AbstractApplicationContext#postProcessBeanFactory(org.springframework.beans.factory.config.ConfigurableListableBeanFactory)}
* 方法，向其加入一些自定义的BeanFactory后置处理器
*/
postProcessBeanFactory(beanFactory);
/**
* 在上下文中调用注册为bean的工厂处理器。
* invoke：调用
* 调用BeanFactory注册的后置处理器
*/
invokeBeanFactoryPostProcessors(beanFactory);
System.out.println("======执行完了BeanFactory的后置处理器方法======");
/**
* 注册bean的后置处理器
* 注意：这里的思路和beanFactory的后置处理器思想一样，
* {@link BeanPostProcessor} ：bean后置处理器的接口
*/
registerBeanPostProcessors(beanFactory);
// 初始化此上下文的消息源。
initMessageSource();
// 为此上下文初始化事件多宿主。
initApplicationEventMulticaster();
// 初始化特定上下文子类中的其他特殊bean。
onRefresh();
// 检查侦听器bean并注册它们。
registerListeners();
// 完成一些没有被实例化的bean， 并且创建其实例和属性填充
finishBeanFactoryInitialization(beanFactory);
// 最后一步：发布相应的事件。
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 销毁已经创建的单实例以避免悬空资源。
destroyBeans();
// 重置“活动”标志。
cancelRefresh(ex);
// 将异常传播到调用方。
throw ex;
}
finally {
// 重置Spring核心中的公共内省缓存，因为我们可能不再需要单例bean的元数据了。。。
resetCommonCaches();
}
}
}
其中invokeBeanFactoryPostProcessors就是执行我们自定义的beanFactory后置处理器的方法了，在此方法的前面，可以看到，前面还没有做啥事情，可以看出，这里的扩展还是比较早的扩展。
然后继续看invokeBeanFactoryPostProcessors的方法体：抛开了不重要的
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 这里获取所有注册进入的beanFactory，然后调用其后处理器方法
PostProcessorRegistrationDelegate
.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// ...
}
可以看到他将执行BeanFactory后置处理器方法的工作委派给了PostProcessorRegistrationDelegate。
然后调用getBeanFactoryPostProcessors获取所有的后置处理器，
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}
由于这里面的后置处理器是AbstractApplicationContext#beanFactoryPostProcessors的一个属性，这里可以通过编程的方式向其添加后置处理器，而我们自己配置的那种是加入到spring容器中的，所以这里返回的并不包含我们自定义的后置处理器。
然后继续看委派的执行器里面的方法体：
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 根据：BeanFactoryPostProcessor类型，从所有bean定义中获取类名，因为bean定义已经扫描过了，所以这里能够拿到
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class,
true, false);
for (String ppName : postProcessorNames) {
// 如果已经存在了，那么这里没有做任何事情，就不添加进去额
if (processedBeans.contains(ppName)) {
// 跳过——已经在上面的第一阶段处理
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 如果存在PriorityOrdered，它的优先级是最高的
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 如果指定了顺序的
orderedPostProcessorNames.add(ppName);
}
else {
// 如果没有指定顺序的
nonOrderedPostProcessorNames.add(ppName);
}
}
}
// 一波排序之后...
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}
从这里就可以看到，我们只要实现了BeanFactoryPostProcessor接口，并且将其实现类加入到spring容器当中，他就会在这个位置来解析我们自定义的BeanFactory，并且下面会执行方法。
spring很多的扩展都是通过这样的方式来提供给我们开发者的。
循环调用其方法：
private static void invokeBeanFactoryPostProcessors(
Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
// 实际调用的在这里。
for (BeanFactoryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanFactory(beanFactory);
}
}
到此其原理已经大致讲完，那么这个扩展点spring提供出来给我们干什么的呢，有什么用呢?
是否ConfigurableListableBeanFactory的api我们都可以使用呢？
接下来我们看看BeanFactoryPostProcessor上面的注释：
import org.springframework.beans.BeansException;
/**
* 工厂钩子：也可以叫做工厂的回调，
* 允许自定义修改应用程序上下文的bean定义，调整上下文底层bean工厂的bean属性值。
*
* 对于覆盖在应用程序上下文中配置的bean属性的系统管理员的自定义配置文件非常有用。
*
* 请参阅{@link PropertyResourceConfigurer}及其具体实现，以了解解决这种配置需求的开箱即用解决方案。
* PropertyResourceConfigurer：也是一个工厂的后置处理器，
*
* 一个{@code BeanFactoryPostProcessor}可以与bean定义交互并修改bean定义，
* 但从不与bean实例交互。这样做可能会导致过早的bean实例化，破坏容器并导致意外的副作用。{@link BeanPostProcessor}。
* 这里说可以与bean的定义进行交互，但是不要和bean的实例进行交互，如果要和bean的实例进行交互，
* 建议使用BeanPostProcessor扩展点
*
* 注册：
* {@code ApplicationContext}自动检测其bean定义中的{@code BeanFactoryPostProcessor} bean，
* 并在创建任何其他bean之前应用它们。一个{@code BeanFactoryPostProcessor}.
* 也可以通过程序注册一个{@code ConfigurableApplicationContext}。
* 这里讲spring应用会自动检测BeanFactoryPostProcessor，并且在创建bean之前应用他们，
* 同时也可以通过程序来注册他们。
*
* 排序：
* 1、自定检测到的bean会按照ordered和PriorityOrdered进行排序
* 2、对于编程的方式注册的后置处理器，他会按照注册的顺序进行排序,
* 如果实现了order接口，也会被忽略：底层是一个list，编程的方式就是add
*
*/
@FunctionalInterface
public interface BeanFactoryPostProcessor {
/**
* BeanFactory后置处理器:
*
* 在标准初始化之后修改应用程序上下文的内部bean工厂。
* 所有bean定义都已加载，但还没有实例化bean。这允许覆盖或添加属性，甚至可以在快速初始化bean中。
* 此后置处理器所在的阶段为bean定义获取之后，bean实例化之前，这里可以对其bean工厂进行改造，
* 方法：{@link ConfigurableListableBeanFactory#getBeanDefinition(java.lang.String)}
* 可以获取指定的bean定义，返回其bean定义的对象，如果想要扩展，可以对其进行修改
* bean实例化就是通过bean定义的信息进行实例化的
*/
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
这些后置处理器，他会在所有bean实例化之前进行应用，主要是提供给开发者去修改bean定义，以达到bean实例的生成按照自己的方式来生成。这里不建议调用getBean方法，使其bean过早的实例化，这可能会破坏容器并导致意外的副作用。它的执行顺序可以按照Order来指定：order数字越大，优先级越低。
比如：
@Component
@Order(1)
public class BeanFactoryPostProcessorExtension implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
// ...
}
}
上面既然说到了能够修改bean定义，那么我们就要研究一下这个bean定义（BeanDefinition）：
那么我们就可以修改他的全限定类名，scope，是否懒加载，所依赖的类名等…
当然具体需要更多的信息，可以看具体BeanDefinition的实现类。