Spring IoC源码学习：registerBeanPostProcessors 详解

向右看齐 2023-10-18 14:51 101阅读 0赞

> 微信搜索【程序员囧辉】，关注这个坚持分享技术干货的程序员。

**目录**

Spring IoC源码学习全系列

前言

概述

正文

registerBeanPostProcessors

代码块1：registerBeanPostProcessors

代码块2：registerBeanPostProcessors

代码块3：beanFactory.addBeanPostProcessor

基本使用

总结

--------------------

## Spring IoC源码学习全系列 ##

[小白也看得懂的 Spring IoC 核心流程介绍][Spring IoC]

[Spring IoC][Spring IoC 1][源码学习][Link 1][：总览][Spring IoC 1]

[Spring IoC][Spring IoC 2][源码学习][Link 1][：ApplicationContext 刷新前的配置][Spring IoC 2]

[Spring IoC][Spring IoC 3][源码学习][Link 1][：obtainFreshBeanFactory详解][Spring IoC 3]

[Spring IoC][Spring IoC 4][源码学习][Link 1][：parseDefaultElement详解][Spring IoC 4]

[Spring IoC][Spring IoC 5][源码学习][Link 1][：parseCustomElement详解][Spring IoC 5]

[Spring IoC源码学习：context:component-scan 节点详解][Spring IoC_context_component-scan]

[Spring IoC][Spring IoC 6][源码学习][Link 1][：invokeBeanFactoryPostProcessors详解][Spring IoC 6]

[Spring IoC][Spring IoC 7][源码学习][Link 1][：registerBeanPostProcessors详解][Spring IoC 7]

[Spring IoC][Spring IoC 8][源码学习][Link 1][：finishBeanFactoryInitialization详解][Spring IoC 8]

[Spring IoC][Spring IoC 9][源码学习][Link 1][：getBean详解][Spring IoC 9]

[Spring IoC][Spring IoC 10][源码学习][Link 1][：createBean详解（上）][Spring IoC 10]

[Spring IoC][Spring IoC 11][源码学习][Link 1][：createBean详解（下）][Spring IoC 11]

[Spring IoC源码学习：@Autowire 详解][Link 1]

[Spring IoC源码学习：finishRefresh 详解][Spring IoC_finishRefresh]

## 前言 ##

在 [Spring IoC：invokeBeanFactoryPostProcessors解析][Spring IoC 6] 中我们介绍了 invokeBeanFactoryPostProcessors 方法，而本文将介绍另一个类似的方法——registerBeanPostProcessors。

invokeBeanFactoryPostProcessors 方法主要用于处理 BeanFactoryPostProcessor 接口，而 registerBeanPostProcessors 方法主要用于处理 BeanPostProcessor 接口。BeanFactoryPostProcessor 和 BeanPostProcessor，相信大家很容易从命名看出来这两个接口“长得很像”。BeanFactoryPostProcessor 是针对 BeanFactory 的扩展，主要用在 bean 实例化之前，读取 bean 的定义，并可以修改它。BeanPostProcessor 是针对 bean 的扩展，主要用在 bean 实例化之后，执行初始化方法前后，允许开发者对 bean 实例进行修改。

## 概述 ##

本方法会注册所有的 BeanPostProcessor，将所有实现了 BeanPostProcessor 接口的类加载到 BeanFactory 中。

BeanPostProcessor 接口是 Spring 初始化 bean 时对外暴露的扩展点，Spring IoC 容器允许 BeanPostProcessor 在容器初始化 bean 的前后，添加自己的逻辑处理。在 registerBeanPostProcessors 方法只是注册到 BeanFactory 中，具体调用是在 bean 初始化的时候。

具体的：在所有 bean 实例化时，执行初始化方法前会调用所有 BeanPostProcessor 的 postProcessBeforeInitialization 方法，在执行初始化方法后会调用所有 BeanPostProcessor 的 postProcessAfterInitialization 方法。

## 正文 ##

首先我们回到 AbstractApplicationContext.refresh() 方法，找到代码：registerBeanPostProcessors(beanFactory)，单击该行代码跳转到具体的实现。

### registerBeanPostProcessors ###

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // 1.注册BeanPostProcessor
        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    }

1.注册 BeanPostProcessor，**见代码块1详解**。

### 代码块1：registerBeanPostProcessors ###

public static void registerBeanPostProcessors(
            ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    
        // 1.找出所有实现BeanPostProcessor接口的类
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
        // Register BeanPostProcessorChecker that logs an info message when
        // a bean is created during BeanPostProcessor instantiation, i.e. when
        // a bean is not eligible for getting processed by all BeanPostProcessors.
        // BeanPostProcessor的目标计数
        int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
        // 2.添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
        beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
        // Separate between BeanPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        // 3.定义不同的变量用于区分: 实现PriorityOrdered接口的BeanPostProcessor、实现Ordered接口的BeanPostProcessor、普通BeanPostProcessor
        // 3.1 priorityOrderedPostProcessors: 用于存放实现PriorityOrdered接口的BeanPostProcessor
        List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
        // 3.2 internalPostProcessors: 用于存放Spring内部的BeanPostProcessor
        List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
        // 3.3 orderedPostProcessorNames: 用于存放实现Ordered接口的BeanPostProcessor的beanName
        List<String> orderedPostProcessorNames = new ArrayList<String>();
        // 3.4 nonOrderedPostProcessorNames: 用于存放普通BeanPostProcessor的beanName
        List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
        // 4.遍历postProcessorNames, 将BeanPostProcessors按3.1 - 3.4定义的变量区分开
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 4.1 如果ppName对应的Bean实例实现了PriorityOrdered接口, 则拿到ppName对应的Bean实例并添加到priorityOrderedPostProcessors
                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                priorityOrderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                    // 4.2 如果ppName对应的Bean实例也实现了MergedBeanDefinitionPostProcessor接口,
                    // 则将ppName对应的Bean实例添加到internalPostProcessors
                    internalPostProcessors.add(pp);
                }
            }
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                // 4.3 如果ppName对应的Bean实例没有实现PriorityOrdered接口, 但是实现了Ordered接口, 则将ppName添加到orderedPostProcessorNames
                orderedPostProcessorNames.add(ppName);
            }
            else {
                // 4.4 否则, 将ppName添加到nonOrderedPostProcessorNames
                nonOrderedPostProcessorNames.add(ppName);
            }
        }
    
        // First, register the BeanPostProcessors that implement PriorityOrdered.
        // 5.首先, 注册实现PriorityOrdered接口的BeanPostProcessors
        // 5.1 对priorityOrderedPostProcessors进行排序
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        // 5.2 注册priorityOrderedPostProcessors
        registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    
        // Next, register the BeanPostProcessors that implement Ordered.
        // 6.接下来, 注册实现Ordered接口的BeanPostProcessors
        List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
        for (String ppName : orderedPostProcessorNames) {
            // 6.1 拿到ppName对应的BeanPostProcessor实例对象
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            // 6.2 将ppName对应的BeanPostProcessor实例对象添加到orderedPostProcessors, 准备执行注册
            orderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                // 6.3 如果ppName对应的Bean实例也实现了MergedBeanDefinitionPostProcessor接口,
                // 则将ppName对应的Bean实例添加到internalPostProcessors
                internalPostProcessors.add(pp);
            }
        }
        // 6.4 对orderedPostProcessors进行排序
        sortPostProcessors(orderedPostProcessors, beanFactory);
        // 6.5 注册orderedPostProcessors
        registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    
        // Now, register all regular BeanPostProcessors.
        // 7.注册所有常规的BeanPostProcessors（过程与6类似）
        List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
        for (String ppName : nonOrderedPostProcessorNames) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            nonOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    
        // Finally, re-register all internal BeanPostProcessors.
        // 8.最后, 重新注册所有内部BeanPostProcessors（相当于内部的BeanPostProcessor会被移到处理器链的末尾）
        // 8.1 对internalPostProcessors进行排序
        sortPostProcessors(internalPostProcessors, beanFactory);
        // 8.2注册internalPostProcessors
        registerBeanPostProcessors(beanFactory, internalPostProcessors);
    
        // Re-register post-processor for detecting inner beans as ApplicationListeners,
        // moving it to the end of the processor chain (for picking up proxies etc).
        // 9.重新注册ApplicationListenerDetector（跟8类似，主要是为了移动到处理器链的末尾）
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    }

5.1 对 priorityOrderedPostProcessors进行排序，在 [Spring IoC：invokeBeanFactoryPostProcessors解析][Spring IoC 6] **代码中3**已经解析过。

5.2 注册 priorityOrderedPostProcessors，**见代码块2详解**。

### 代码块2：registerBeanPostProcessors ###

private static void registerBeanPostProcessors(
            ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
        // 1.遍历postProcessors
        for (BeanPostProcessor postProcessor : postProcessors) {
            // 2.将PostProcessor添加到BeanFactory中的beanPostProcessors缓存
            beanFactory.addBeanPostProcessor(postProcessor);
        }
    }

2.将 PostProcessor 添加到 BeanFactory 中的 beanPostProcessors 缓存，**见代码块3详解**。

### 代码块3：beanFactory.addBeanPostProcessor ###

@Override
    public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
        Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
        // 1.如果beanPostProcessor已经存在则移除（可以起到排序的效果，beanPostProcessor可能本来在前面，移除再添加，则变到最后面）
        this.beanPostProcessors.remove(beanPostProcessor);
        // 2.将beanPostProcessor添加到beanPostProcessors缓存
        this.beanPostProcessors.add(beanPostProcessor);
        if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
            // 3.如果beanPostProcessor是InstantiationAwareBeanPostProcessor, 则将hasInstantiationAwareBeanPostProcessors设置为true,
            // 该变量用于指示beanFactory是否已注册过InstantiationAwareBeanPostProcessors
            this.hasInstantiationAwareBeanPostProcessors = true;
        }
        if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
            // 4.如果beanPostProcessor是DestructionAwareBeanPostProcessor, 则将hasInstantiationAwareBeanPostProcessors设置为true,
            // 该变量用于指示beanFactory是否已注册过DestructionAwareBeanPostProcessor
            this.hasDestructionAwareBeanPostProcessors = true;
        }
    }

该方法作用就是将 BeanPostProcessor 添加到 beanPostProcessors 缓存，这边的先移除再添加，主要是起一个排序的作用。而 hasInstantiationAwareBeanPostProcessors 和 hasDestructionAwareBeanPostProcessors 变量用于指示 beanFactory 是否已注册过 InstantiationAwareBeanPostProcessors 和 DestructionAwareBeanPostProcessor，在之后的 IoC 创建过程会用到这两个变量，这边先有个印象。

## 基本使用 ##

使用方法比较简单，新建一个类实现 BeanPostProcessor 接口，并将该类注册到 Spring IoC 容器中。

package com.joonwhee.open.demo.spring;
    
    import com.joonwhee.open.demo.service.UserService;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    import org.springframework.core.PriorityOrdered;
    
    /**
     * @author joonwhee
     * @date 2019/2/23
     */
    @Component
    public class MyBeanPostProcessor implements BeanPostProcessor, PriorityOrdered {
    
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("MyBeanPostProcessor#postProcessBeforeInitialization");
            if (bean instanceof UserService) {
                System.out.println(beanName);
            }
            // 自己的逻辑
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("MyBeanPostProcessor#postProcessAfterInitialization");
            // 自己的逻辑
            return bean;
        }
    
        @Override
        public int getOrder() {
            return 0;
        }
    }

这样，在 Spring 创建 bean 实例时，执行初始化方法前会调用 MyBeanPostProcessor 的 postProcessBeforeInitialization 方法，在执行初始化方法后会调用 MyBeanPostProcessor 的 postProcessAfterInitialization 方法。

## 总结 ##

如同 invokeBeanFactoryPostProcessors 方法一样，registerBeanPostProcessors 方法的内容也比较少，核心过程在**代码块1**的注释已经写清楚，这边稍微总结一下。

1.整个 registerBeanPostProcessors 方法围绕 BeanPostProcessor 接口展开，和 invokeBeanFactoryPostProcessors 不同的是，invokeBeanFactoryPostProcessors 方法会直接调用 BeanFactoryPostProcessor 实现类的方法，而 registerBeanPostProcessors 方法只是将 BeanPostProcessor 实现类注册到 BeanFactory 的 beanPostProcessors 缓存中。这是因为，此时还未到 BeanPostProcessor 实现类“出场的时候”。

2.BeanPostProcessor 实现类具体的 “出场时机” 在创建 bean 实例时，执行初始化方法前后。postProcessBeforeInitialization 方法在执行**初始化方法前**被调用，postProcessAfterInitialization 方法在执行**初始化方法后**被调用。

3.BeanPostProcessor 实现类和 BeanFactoryPostProcessor 实现类一样，也可以通过实现 PriorityOrdered、Ordered 接口来调整自己的优先级。

4.registerBeanPostProcessors 方法和 invokeBeanFactoryPostProcessors 也会触发 bean 实例的创建，创建 Bean 实例是 IoC 的核心内容，之后会单独解析，目前暂不深入解析。

[Spring IoC]: https://blog.csdn.net/v123411739/article/details/99308642
[Spring IoC 1]: https://blog.csdn.net/v123411739/article/details/85934686
[Link 1]: https://blog.csdn.net/v123411739/article/details/88088316
[Spring IoC 2]: https://blog.csdn.net/v123411739/article/details/86555733
[Spring IoC 3]: https://blog.csdn.net/v123411739/article/details/86563620
[Spring IoC 4]: https://blog.csdn.net/v123411739/article/details/86669952
[Spring IoC 5]: https://blog.csdn.net/v123411739/article/details/87447290
[Spring IoC_context_component-scan]: https://blog.csdn.net/v123411739/article/details/87477952
[Spring IoC 6]: https://blog.csdn.net/v123411739/article/details/87741251
[Spring IoC 7]: https://blog.csdn.net/v123411739/article/details/87886900
[Spring IoC 8]: https://blog.csdn.net/v123411739/article/details/87907784
[Spring IoC 9]: https://blog.csdn.net/v123411739/article/details/87954818
[Spring IoC 10]: https://blog.csdn.net/v123411739/article/details/87994934
[Spring IoC 11]: https://blog.csdn.net/v123411739/article/details/88077817
[Spring IoC_finishRefresh]: https://blog.csdn.net/v123411739/article/details/99288413