BeanFactoryPostProcessor 作用
BeanFactoryPostProcessor 和该子类 BeanDefinitionRegistryPostProcessor 作用于 BeanDefinition 解析之后，Bean 实例化之前，所以我们可以在 BeanDefinition 定义好了之后做一些修改，从而影响 Bean 的实例化。
源码如下
BeanFactoryPostProcessor 类定义的方法中我们可以获取到 BeanFactory，有了这个工厂自然而然就可以干很多事情啦，比如去修改它的默认配置：
// 对 bean 工厂的进一步后置增强，这个接口会暴露出工厂，有了工厂自然而然就可以干很多事情啦
@FunctionalInterface
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
比如我们去修改 BeanFactory 中的两个默认属性：是否允许循环依赖，是否允许 BeanDefinition 覆盖（当我们注解和 xml 同时存在并且 beanName 还是相同，是否支持 BeanDefinition 的覆盖）
@Component
public class MyConfigurationPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof DefaultListableBeanFactory) {
DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;
defaultListableBeanFactory.setAllowCircularReferences(false);
defaultListableBeanFactory.setAllowBeanDefinitionOverriding(false);
}
}
}
BeanDefinitionRegistryPostProcessor 类继承了 BeanFactoryPostProcessor 类，扩展了方法，让我们可以更轻松的获取到 BeanDefinitionRegistry 注册器，这样我们就可以利用这个类去额外注册一些其他的 BeanDefinition，也可以对 BeanDefinition 做一些删除、修改等操作
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}
比如我们现在有一个实体类，但是没有标注 @Component 注解，那么肯定是不能被 @ComponentScan 扫描到的，此时我们可以通过这个方法就可以手动讲该实体交给 Spring 管理。
实体类如下：
public class ProcessorEntity {
private String name = "ABC";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
注意实体类没有标注 @Component 注解，并且属性默认值是 ABC，然后通过 BeanDefinitionRegistryPostProcessor 进行注册该实体类，并且还要修改属性的默认值，修改成"小明"，如下：
@Component
public class MyConfigurationPostProcessor1 implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry");
GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
genericBeanDefinition.setBeanClass(ProcessorEntity.class);
MutablePropertyValues propertyValues = genericBeanDefinition.getPropertyValues();
// 修改 ProcessorEntity 类中 name 属性默认值
propertyValues.addPropertyValue("name","小明");
// 然后再将 BeanDefinition 注册到 BeanFactory 容器中
registry.registerBeanDefinition("processorEntity",genericBeanDefinition);
}
}
测试类如下：
public class TestBeanScanner {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(ScannerConfig.class);
ProcessorEntity processorEntity = context.getBean("processorEntity", ProcessorEntity.class);
System.out.println("processorEntity = " + processorEntity+",name="+processorEntity.getName());
}
}
输出结果如下：
MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry
MyConfigurationPostProcessor1---postProcessBeanFactory
processorEntity = com.gwm.bean221207.processors.ProcessorEntity@346d61be,name=小明
发现也是可以获取到 ProcessorEntity 类的实例。
然后我们继续利用这个方法，来扫描我们自定义注解修饰的类。
自定义注解如下：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyServiceAnno {
String value() default "";
}
实体类如下：
@MyServiceAnno
public class TestAnnoService {
private String userName = "张老三";
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
}
然后借助 Spring 的包扫描器 ClassPathBeanDefinitionScanner 进行扫描，此时我们的 MyConfigurationPostProcessor1 就有点类似于简化版的 ConfigurationClassPostProcessor 后置处理器，都是在 postProcessBeanDefinitionRegistry() 方法中进行操作的，都实现了接口 BeanDefinitionRegistryPostProcessor ，只不过 Spring 提供内置的扫描功能比较全面，我们做的比较简陋而已，就只模拟扫描自定义注解，代码如下：
@Component
public class MyConfigurationPostProcessor1 implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry");
GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
genericBeanDefinition.setBeanClass(ProcessorEntity.class);
MutablePropertyValues propertyValues = genericBeanDefinition.getPropertyValues();
// 修改 ProcessorEntity 类中 name 属性默认值
propertyValues.addPropertyValue("name","小明");
// 然后再将 BeanDefinition 注册到 BeanFactory 容器中
registry.registerBeanDefinition("processorEntity",genericBeanDefinition);
// 直接把 Spring 的类路径扫描器拿过来用用
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry);
// 添加过滤条件：自定义的注解修饰的类
scanner.addIncludeFilter(new AnnotationTypeFilter(MyServiceAnno.class));
// 开始自动扫描然后封装 ScannedBeanDefinition，然后注册到容器
scanner.scan("com.gwm.anno");
}
}
输出结果如下：
MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry
MyConfigurationPostProcessor1---postProcessBeanFactory
testAnnoService = com.gwm.anno.TestAnnoService@747edf66,userName=张老三
processorEntity = com.gwm.bean221207.processors.ProcessorEntity@346d61be,name=小明
那么以上两个接口中的方法在哪里被调用呢，这里举例说明其中的一处调用。为了更好地展示效果，这里直接我们直接输出日志。
定义两个 Processor 都实现 BeanDefinitionRegistryPostProcessor 接口，代码如下：
@Component
public class MyConfigurationPostProcessor1 implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry");
}
}
@Component
public class MyConfigurationPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("MyConfigurationPostProcessor2---postProcessBeanFactory");
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("MyConfigurationPostProcessor2---postProcessBeanDefinitionRegistry");
}
}
输出结果：
MyConfigurationPostProcessor2---postProcessBeanDefinitionRegistry
MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry
MyConfigurationPostProcessor2---postProcessBeanFactory
MyConfigurationPostProcessor1---postProcessBeanFactory
debug 跟踪源码，发现调用的地方在下面这段代码中，源码如下：
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 因为第一过来的时候 TODO beanFactoryPostProcessors 这个变量不知道什么时候才会传入值，目前看是空集合，有待调试
Set<String> processedBeans = new HashSet<>();
// beanFactory 实现了 BeanDefinitionRegistry 注册接口，所以这里条件成立
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);
}
}
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
/**
* 获取所有实现了 BeanDefinitionRegistryPostProcessor 接口的子类
* 并且判断是否还实现了 PriorityOrdered 权重接口，如果实现了则优先回调该类的 postProcessBeanDefinitionRegistry() 方法
* 目前看如果是以注解方式启动，Spring 其中有一个内置类实现了该接口，就是 ConfigurationClassPostProcessor 该配置类是在
* 外面的 this() 构造函数中直接把 BeanDefinition 注册到了 BeanDefinitionMap 容器中,其中还有 @AutowiredPostProcessor
* 所以这里优先调用的是这个扫描后置处理类的方法，然后去调用 doScan() 扫描其他组件
* 所以下面如果在重新调用这个 getBeanNamesForType() 方法，可能就会多出很多的子类了
* 因为 ConfigurationClassPostProcessor 后之类已经把所有的类扫描进来了
*/
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 是否实现了 PriorityOrdered 排序接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 调用 getBean() 直接实例化这个子类
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 记录一下当前已经执行过的 Processor，避免重复调用
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
/**
* 循环回调 BeanDefinitionRegistryPostProcessor 所有实现子类的方法
* 目前这里看只会回调到 ConfigurationClassPostProcessor 子类中的方法
* 这个类回调到 doScan() 扫描其他组件，然后注册到 BeanDefinitionMap 容器中，所以下面在执行 getBeanNamesForType()
* 方法时肯定会多出很多 BeanDefinitionRegistryPostProcessor 的子类实现
*/
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();
/**
* 再次去检索一下 BeanDefinitionRegistryPostProcessor 接口的实现子类，此时应该是会更多或者是一样
* 此时如果我们扩展了这个接口，比较交给了 Spring 管理，那么这里肯定是能够扫描出来的
* 如果还实现了 Ordered 接口的话，那么下面这段代码就会会调用方法 postProcessBeanDefinitionRegistry()
*/
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 是否实现了 Ordered 排序接口
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 调用 getBean() 直接实例化这个子类
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 记录一下当前已经执行过的 Processor，避免重复调用
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
/**
* 执行过的就不会再回调了，因为 processedBeans 标记好了哪些执行过的，这里会回调我们自己扩展的 Processor 子类
*/
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();
/**
* 最后，再次检索 BeanDefinitionRegistryPostProcessor，然后处理没有实现 PriorityOrdered、Ordered 接口的子类实现
*/
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
/**
* 此处会通过 getBean() 去创建好这个后置处理器 Bean
*/
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
/** 调用 postProcessBeanDefinitionRegistry() 方法 */
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
currentRegistryProcessors.clear();
}
/**
* 上面一大段逻辑都是去调用 BeanDefinitionRegistryPostProcessor 类子类的 postProcessBeanDefinitionRegistry()
* 的注册方法。
* 最后在调用 BeanDefinitionRegistryPostProcessor 从父类继承过来的 postProcessBeanFactory() 方法
*/
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
/**
* 一般这里是没有值的，无需注重
* 调用从入参中传入过来的 BeanDefinitionRegistryPostProcessor 对象的方法
*/
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// TODO 这个应该是测试代码，只有一个地方调用了，就是 Test
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
//=========================================================================================
// 这下面的逻辑全部都是调用 BeanFactoryPostProcessor 的 postProcessBeanFactory() 方法
//=========================================================================================
/** 获取到所有的 BeanFactoryPostProcessor beaFactory后置处理器*/
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
/**
* processedBeans 如果是执行过的 bean 后置处理器，就直接跳过 skip 不再处理
* 注意虽然代码会走到这些面，但是因为这里的 processedBeans 会拦截处理过的 BeanFactoryPostProcessor
* 这个细节注意哟
**/
if (processedBeans.contains(ppName)) {
// ...do nothing...
}
// 判断你是否实现了 PriorityOrdered 接口，实现这个接口可以将后置处理进行排序执行
// 其中 Ordered 数值越小优先级越高
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 判断你是否实现了注解方式的优先级，和 PriorityOrdered 接口功能是一样的
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
// 就上述两种处理器，其他的都是普通的 bean 工厂后置处理器
nonOrderedPostProcessorNames.add(ppName);
}
}
// gwm_tag: 最先调用实现了 PriorityOrdered 接口的 beanFactoryPostProcessor 处理器
// 处理器进行排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 开始调用实现了 PriorityOrdered 接口的 bean 工厂处理器的 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 处理器进行排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// gwm_tag: 第二调用实现了 Ordered 注解的 bean 工厂后置处理器的 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// gwm_tag: 最后才是调用普通的 bean 工厂后置处理器的 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 最后清空缓存就是这个 Map 而已： Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256)
beanFactory.clearMetadataCache();
}
这里特别注意一点，优先级问题，因为我们平时可能扩展的 BeanFactoryPostProcessor 不止一个，所以这里就需要分优先级执行，优先级可以通过 PriorityOrdered 和 Ordered 方法定义优先级。