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 {@Overridepublic 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 {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");}@Overridepublic 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 {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");}@Overridepublic 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 {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("MyConfigurationPostProcessor1---postProcessBeanFactory");}@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {System.out.println("MyConfigurationPostProcessor1---postProcessBeanDefinitionRegistry");}
}

@Component
public class MyConfigurationPostProcessor2 implements BeanDefinitionRegistryPostProcessor {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {System.out.println("MyConfigurationPostProcessor2---postProcessBeanFactory");}@Overridepublic 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 beanFactoryPostProcessors) {// 因为第一过来的时候 TODO beanFactoryPostProcessors 这个变量不知道什么时候才会传入值，目前看是空集合，有待调试Set processedBeans = new HashSet<>();// beanFactory 实现了 BeanDefinitionRegistry 注册接口，所以这里条件成立if (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;List regularPostProcessors = new ArrayList<>();List 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 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 这个应该是测试代码，只有一个地方调用了，就是 TestinvokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}//=========================================================================================// 这下面的逻辑全部都是调用 BeanFactoryPostProcessor 的 postProcessBeanFactory() 方法//=========================================================================================/** 获取到所有的  BeanFactoryPostProcessor beaFactory后置处理器*/String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);List priorityOrderedPostProcessors = new ArrayList<>();List orderedPostProcessorNames = new ArrayList<>();List 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 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 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 mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256)beanFactory.clearMetadataCache();}

这里特别注意一点，优先级问题，因为我们平时可能扩展的 BeanFactoryPostProcessor 不止一个，所以这里就需要分优先级执行，优先级可以通过 PriorityOrdered 和 Ordered 方法定义优先级。