回顾上一篇博客中, 在 AbstractApplicationContext 这个抽象类中, Spring 使用 invokeBeanFactoryPostProcessors(beanFactory); 执行 BeanFactoryPostProcessor, 通过回调 Spring 自己添加的 ConfigurationClassPostProcessor 以及用户添加的 bean 工厂的后置处理器, 完成了包扫描以及对主配置类代理的工作
本篇博文将继续往下跟进
程序入口: 注册 bean 的后置处理器
AbstractApplicationContext 的 registerBeanPostProcessors(beanFactory); 方法
通过方法名字, 见名知意, 注册 bean 的后置处理器, 说白了就是将系统中所有的 bean 的后置处理器统一交给 Spring 的 beanFactory 管理
那么问题来了
什么是 BeanPostProcessor? 有什么作用?
Bean 的后置处理器, 首先来说, 他是 Spring 中抽象出来的一个顶级的接口, 他里面有如下有如下两个方法, 这两个方法的执行时机通过方法的名字也能猜的出, 一个是在构造方法之后, init() 方法之前, 第二个是在 init() 方法之后执行
- public interface BeanPostProcessor {
- @Nullable
- default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
- return bean;
- }
- @Nullable
- default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
- return bean;
- }
- }
大家说它是 Spring 对外提供的拓展点, 也许是因为, 通过实现这个接口, 程序员可以被 Spring 管理的 bean 的生命周期进行插手
这也体现了 AOP 的设计思想, 就比如在 init() 方法执行前后做出不同的动作, 其实就是对 bean 的一种增强
此外 BeanPostProcessor 可以存在多个, 他们会被存储在一个列表中, 然后依次被执行
为什么要注册 BeanPostProcessor?
所谓的注册, 只不过是对当前上下文中所有的 BeanPostProcessor 进行一种集中式管理罢了, 为什么非得这么做呢? 因为上下文中 BeanPostProcessor 的数量不是一成不变的, Spring 为了启动的正常, 需要添加原生的 BeanPostProcessor, 程序员因为自己的需求也会添加不同数量的 bean 的后置处理器, 因此需要这种策略, 将上下文中所有的后置处理器进行统一的管理, 方便回调
源码阅读:
这段代码的逻辑很清楚简明: 首先, 根据类型从当前的上面中取出所有的 BeanPostProcessor 的实现类, 那么问题来了, 当前上下文中有几个呢? 如下图:
这三个中的前两个后置还处理器是在 prepareBeanFactory() 时添加进去的, 第三个是在为主配置类生成代理时传递进去的
紧接着调用 beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false), 结果如下图
前三个处理器是不是很熟悉? 没错, 他们是创建 AnnotationedBeanDefinitionReader 时创建的 6 个 RootBeanDefinition 中 的第 4-5-6 个, 其中的 AutowiredAnnotationBeanPostProcessor 的主要功能是处理 @Autowired 注解, 并且解决了 setter 方式的循环依赖问题, CommonAnnotationBeanPostProcessor 主要处理 @Resource @PostConstructor @PreDestory 注解
RequiredAnnotationBeanPostProcessor 处理 @Required 注解, 上图中的最后一个注解是 ``
在下面的代码中, Spring 开始根据不同的处理器的注解标注情况, 接口的实现情况进行排序处理, 并且又添加了两个后置处理器
- public static void registerBeanPostProcessors(
- ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
- // 根据类型从 beanFactory 中取出所有实现 BeanPostProcessor 接口的实现类的名字
- String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
- int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
- // 这是个内部类, 用来检查是否在 bean 的创建过程中, 经过了所有本来应经过的后置处理器
- beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
- List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
- List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
- List<String> orderedPostProcessorNames = new ArrayList<>();
- List<String> nonOrderedPostProcessorNames = new ArrayList<>();
- // 将添加执行注解, 实现排序接口的 beanPostProcessor 添加到相应的集合中
- for (String ppName : postProcessorNames) {
- if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
- BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
- priorityOrderedPostProcessors.add(pp);
- if (pp instanceof MergedBeanDefinitionPostProcessor) {
- internalPostProcessors.add(pp);
- }
- }
- else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
- orderedPostProcessorNames.add(ppName);
- }
- else {
- nonOrderedPostProcessorNames.add(ppName);
- }
- }
- // 按照优先顺序排序
- sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
- // 批量注册 priorityOrderedPostProcessors 中的 bean 的后置处理器
- registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
- List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
- for (String ppName : orderedPostProcessorNames) {
- BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
- orderedPostProcessors.add(pp);
- if (pp instanceof MergedBeanDefinitionPostProcessor) {
- internalPostProcessors.add(pp);
- }
- }
- // 再次排序, 注册
- sortPostProcessors(orderedPostProcessors, beanFactory);
- registerBeanPostProcessors(beanFactory, orderedPostProcessors);
- // Now, register all regular BeanPostProcessors.
- // todo 现在注册 全部 正常的没有排序的 BeanPostProcessor
- List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
- for (String ppName : nonOrderedPostProcessorNames) {
- BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
- nonOrderedPostProcessors.add(pp);
- if (pp instanceof MergedBeanDefinitionPostProcessor) {
- internalPostProcessors.add(pp);
- }
- }
- // 再次排序, 注册
- registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
- sortPostProcessors(internalPostProcessors, beanFactory);
- // Finally, re-register all internal BeanPostProcessors.
- // 最后注册所有内置的 BeanPostProcessor
- registerBeanPostProcessors(beanFactory, internalPostProcessors);
- // 这里又添加了一个处理器
- beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
- }
beanPostProcessor 全部注册到了 AbstractBeanFactory 中的下面这个字段中
private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
来源: https://www.cnblogs.com/ZhuChangwu/p/11699677.html