本篇阅读思路：

1. 是什么
   
2. 如何使用
   
3. Spring 实现逻辑
   

• BeanFactoryPostProcessor
  
• 是什么
  
• 如何使用
  

• 官方例子：PropertyPlaceholderConfigurer
  
• 使用自定义 BeanFactoryPostProcessor
  

• 在哪注册
  
• 激活 BeanFactoryPostProcessor
  

• 流程图
  
• 代码
  

• 总结
  
• 参考资料
  

前言

首先我们先将 Spring 想像成一个大容器，然后保存了很多 bean 的信息，根据定义：bean 是一个被实例化，组装，并通过 SpringIoC 容器所管理的对象，也可以简单得理解为我们在配置文件配置好元数据， SpringIoC 容器会帮我们对 bean 进行管理，这些对象在使用的时候通过 Spring 取出就能使用。

那么是谁帮这个 Spring 管理呢，那就是 BeanFactory，粗暴点直译为 bean 工厂，但其实它才是承担容器功能的幕后实现者，它是一个接口，提供了获取 bean 、获取别名 Alias 、判断单例、类型是否匹配、是否原型等方法定义，所以需要通过引用，实现具体方法才后才能使用。

回顾完 beanFactory 后，我们再来回顾在前面内容中，看到过很多后处理器 PostProcessor 的代码影子，分别是 BeanFactoryPostProcessor：主体是 BeanFactory， 和 BeanPostProcessor：主体是 Bean，这两者都是 Spring 用来为使用者提供的扩展功能之一。

接下来为了更好的分析和了解使用后处理器，实现扩展功能，一起跟踪源码学习吧~

BeanFactoryPostProcessor

是什么

BeanFactoryPostProcessor 是一个接口，在里面只有一个方法定义：

1. @FunctionalInterface
   
2. publicinterfaceBeanFactoryPostProcessor{
   
3.    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException;
   
4. }
   

定义：是 Spring 对外提供可扩展的接口，能够在容器加载了所有 bean 信息（ AbstractApplicationContext#obtainFreshBeanFactory 方法）之后， bean 实例化之前执行，用来修改 bean 的定义属性。

可以看到，方法参数是 ConfigurableListableBeanFactorybeanFactory ，说明我们可以通过引用该接口，在方法中实现逻辑，对容器中 bean 的定义（配置元数据）进行处理

同时，执行后处理器是有先后顺序的概念，我们可以通过设置 order 属性来控制它们的执行次序，前提是 BeanFactoryPostProcessor 实现了 Order 接口。

下面一起来看下它的如何使用，以及是如何进行注册和执行~

如何使用

官方例子：PropertyPlaceholderConfigurer

这个类是 Spring 容器里自带的后处理器，是用来替换占位符，填充属性到 bean 中。

像我们在 xml 文件中配置了属性值为 ${max.threads}，能够通过它来找到 max.threads 在配置文件对应的值，然后将属性填充到 bean 中。

虽然在 Spring 5 中， PropertyPlaceholderConfigurer 已经打上了不建议使用的标志 @Deprecated，看了文件注释，提示我们去使用 Environment 来设置属性，但我觉得这个后处理器的思想是一样的，所以还是拿它作为例子进行熟悉。

先来看下它的继承体系：

~~忽略它被冷落的下划线标签~~

当 Spring 加载任何实现了 BeanFactoryPostProcessor 接口的 bean 配置时，都会在 bean 工厂载入所有 bean 的配置之后执行 postProcessBeanFactory 方法。

可以看到它引用了 BeanFactoryPostProcessor 接口，在 PropertyResourceConfigurer 父类中实现了 postProcessBeanFactory，在方法中依次调用了合并资源 mergedProps 方法，属性转换 convertProperties 方法和真正修改 beanFactory 中配置元数据的 processProperties(beanFactory,mergedProps) 方法。

因为通过在 PropertyPlaceholderConfigurer 的后处理方法 postProcessBeanFactory， BeanFactory在实例化任何 bean 之前获得配置信息，从而能够正确解析 bean 描述文件中的变量引用。

所以通过后处理器，我们能够对 beanFactory 中的 bean 配置信息在实例化前还有机会进行修改。

题外话：想到之前我遇到全半角空格的配置问题，程序认为全半角空格不是同一个字符，但肉眼却很难察觉，所以感觉可以在加载配置信息时，通过自定义一个后处理，在实例化之前，将全角空格转成半角空格，这样程序比较时都变成统一样式。所以后处理器提供的扩展功能可以让我们对想要处理的 bean 配置信息进行特定修改

使用自定义 BeanFactoryPostProcessor

实现的功能与书中的类似，例如之前西安奔驰汽车维权事件，如果相关网站想要屏蔽这奔驰这两个字，可以通过后处理器进行替换：

1. 配置文件 factory-post-processor.xml

1. <beanid="carPostProcessor"class="context.CarBeanFactoryPostProcessor">
   
2.    <propertyname="obscenties">
   
3.        <!--set 属性-->
   
4.        <set>
   
5.            <value>奔驰</value>
   
6.            <value>特斯拉</value>
   
7.        </set>
   
8.    </property>
   
9. </bean>
   
11. <beanid="car"class="base.factory.bean.Car">
    
12.    <propertyname="price"value="10000"/>
    
13.    <propertyname="brand"value="奔驰"/>
    
14. </bean>
    

2. 后处理器 CarBeanFactoryPostProcessor

1. publicclassCarBeanFactoryPostProcessorimplementsBeanFactoryPostProcessor{
   
3.    /**
   
4.     * 敏感词
   
5.     */
   
6.    privateSet<String> obscenties;
   
8.    @Override
   
9.    publicvoid postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException{
   
10.        // 从 beanFactory 中获取 bean 名字列表
    
11.        String[] beanNames = beanFactory.getBeanDefinitionNames();
    
12.        for(String beanName : beanNames){
    
13.            BeanDefinition definition = beanFactory.getBeanDefinition(beanName);
    
14.            StringValueResolver valueResolver = strVal ->{
    
15.                if(isObscene(strVal))return"*****";
    
16.                return strVal;
    
17.            };
    
18.            BeanDefinitionVisitor visitor =newBeanDefinitionVisitor(valueResolver);
    
19.            // 这一步才是真正处理 bean 的配置信息
    
20.            visitor.visitBeanDefinition(definition);
    
21.        }
    
23.    }
    
25.    /**
    
26.     * 判断 value 是否在敏感词列表中
    
27.     * @param value 值
    
28.     * @return      boolean
    
29.     */
    
30.    privateboolean isObscene(Object value){
    
31.        String potentialObscenity = value.toString().toUpperCase();
    
32.        returnthis.obscenties.contains(potentialObscenity);
    
33.    }
    
34. }
    

3. 启动

1. publicclassBeanFactoryPostProcessorBootstrap{
   
3.    publicstaticvoid main(String[] args){
   
4.        ConfigurableApplicationContext context =newClassPathXmlApplicationContext("factory.bean/factory-post-processor.xml");
   
5.        // 这两行其实可以不写，因为在 refresh() 方法中，调用了一个函数将后处理器执行了，具体请往下看~
   
6.        BeanFactoryPostProcessor beanFactoryPostProcessor =(BeanFactoryPostProcessor) context.getBean("carPostProcessor");
   
7.        beanFactoryPostProcessor.postProcessBeanFactory(context.getBeanFactory());
   
8.        // 输出 ：Car{maxSpeed=0, brand='*****', price=10000.0}，敏感词被替换了
   
9.        System.out.println(context.getBean("car"));
   
10.    }
    
11. }
    

通过上面的演示代码，新增一个自定义实现 BeanFactoryPostProcessor 的后处理器 CarBeanFactoryPostProcessor，在 postProcessBeanFactory 方法中进行逻辑处理，最后通过 visitor.visitBeanDefinition 修改配置信息。

查看输出结果，能发现宝马敏感词已经被屏蔽了，实现了后处理器的逻辑功能~

在哪注册

按照一般套路，后处理器需要有个地方进行注册，然后才能进行执行，通过代码分析，的确在 AbstractApplicationContext 中看到了 beanFactoryPostProcessors 数组列表，但往数组中添加后处理器的方法 addBeanFactoryPostProcessor 只在单元测试包调用了。

这让我很迷惑它到底是在哪里进行注册，直到我看到它的执行方法，原来我们定义的后处理器在 bean 信息加载时就放入注册表中，然后通过 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false) 方法获取后处理器列表遍历执行。

所以前面的 beanFactoryPostProcessors 数组列表，是让我们通过硬编码方法方式，手动添加进去，然后通过 context.refresh() 方法后，再执行硬编码的后处理器

例如下面这个例子

1. publicclassHardCodeBeanFactoryPostProcessorimplementsBeanFactoryPostProcessor{
   
2.    @Override
   
3.    publicvoid postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException{
   
4.        System.out.println("Hard Code BeanFactory Post Processor execute time");
   
5.    }
   
6. }
   
8. // 硬编码 后处理器执行时间
   
9. BeanFactoryPostProcessor hardCodeBeanFactoryPostProcessor =newHardCodeBeanFactoryPostProcessor();
   
10. context.addBeanFactoryPostProcessor(hardCodeBeanFactoryPostProcessor);
    
11. // 更新上下文
    
12. context.refresh();
    
13. // 输出：
    
14. //Hard Code BeanFactory Post Processor execute time
    
15. //Car{maxSpeed=0, brand='*****', price=10000.0}
    
16. System.out.println(context.getBean("car"));
    

激活 BeanFactoryPostProcessor

看完了怎么使用后，我们来分析下 Spring 是如何识别和执行 BeanFactoryPostProcessor，入口方法：

org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors

实际上，委派了 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory,getBeanFactoryPostProcessors()) 代理进行执行。由于代码有点长，所以我画了一个流程图，可以结合流程图来分析代码：