spring框架流行了这么多年，地位至今不被动摇，除了spring全家桶的生态之外，它给开发者的提供的扩展也是值得一提的。那么今天就来聊聊Spring扩展点之BeanFactoryPostProcessor。

这个扩展点是发生在bean实例化之前，BeanDefinition读取完之后。所以我们在这里可以获取到BeanDefinition，以改变他默认的实例化方式。

由于文章内容是基于源码角度来讲的，考虑到有些朋友不需要看的如此的深入，所以在此贴出其简单的使用方式：加上@Component注解，使其加入到spring容器中，他会自动识别并在适当位置调用。

@Component
public class BeanFactoryPostProcessorExtension implements BeanFactoryPostProcessor {@Overridepublic 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()方法：

@Overridepublic 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 {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {// ...}
}

上面既然说到了能够修改bean定义，那么我们就要研究一下这个bean定义（BeanDefinition）：

那么我们就可以修改他的全限定类名，scope，是否懒加载，所依赖的类名等…
当然具体需要更多的信息，可以看具体BeanDefinition的实现类。