Spring IoC源码学习：invokeBeanFactoryPostProcessors 详解

分手后的思念是犯贱 2023-10-18 14:37 5阅读 0赞

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

**目录**

Spring IoC源码学习全系列

前言

概述

正文

invokeBeanFactoryPostProcessors

代码块1：getBeanFactoryPostProcessors

代码块2：invokeBeanFactoryPostProcessors

代码块3：sortPostProcessors

基本使用

1.BeanDefinitionRegistryPostProcessor 的扩展使用

2.BeanFactoryPostProcessor 的扩展使用

总结

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

## 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：context:component-scan节点解析][Spring IoC_context_component-scan] 的结束，obtainFreshBeanFactory 方法的解析也告一段落，我们通过5篇文章，完整的介绍了obtainFreshBeanFactory 方法。本文将介绍 obtainFreshBeanFactory 方法之后的另一个重要方法——invokeBeanFactoryPostProcessors。

## 概述 ##

本方法会实例化和调用所有 BeanFactoryPostProcessor（包括其子类 BeanDefinitionRegistryPostProcessor）。

BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点，Spring IoC 容器允许 BeanFactoryPostProcessor 在容器实例化任何 bean 之前读取 bean 的定义，并可以修改它。

BeanDefinitionRegistryPostProcessor 继承自 BeanFactoryPostProcessor，比 BeanFactoryPostProcessor 具有更高的优先级，主要用来在常规的 BeanFactoryPostProcessor 检测开始之前注册其他 bean 定义。特别是，你可以通过 BeanDefinitionRegistryPostProcessor 来注册一些常规的 BeanFactoryPostProcessor，因为此时所有常规的 BeanFactoryPostProcessor 都还没开始被处理。

注：这边的 “常规 BeanFactoryPostProcessor” 主要用来跟 BeanDefinitionRegistryPostProcessor 区分。

## 正文 ##

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

### invokeBeanFactoryPostProcessors ###

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // 1.getBeanFactoryPostProcessors(): 拿到当前应用上下文beanFactoryPostProcessors变量中的值
        // 2.invokeBeanFactoryPostProcessors: 实例化并调用所有已注册的BeanFactoryPostProcessor
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
        // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
        // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }

1.拿到当前应用上下文 beanFactoryPostProcessors 变量中的值，**见代码块1详解**。

2.实例化并调用所有已注册的 BeanFactoryPostProcessor，**见代码块2详解**。

### **代码块1：getBeanFactoryPostProcessors** ###

public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
        return this.beanFactoryPostProcessors;
    }

这边 getBeanFactoryPostProcessors() 会拿到当前应用上下文中已经注册的 BeanFactoryPostProcessor，在默认情况下，this.beanFactoryPostProcessors 是返回空的。

**如何添加自定义 BeanFactoryPostProcessor 到 this.beanFactoryPostProcessors 变量中了？**

如果还有印象的话，我们在 [Spring IoC：refresh前的环境准备][Spring IoC 2] 中的**代码块12**介绍过 customizeContext 方法，该方法是 Spring 提供给开发者的一个扩展点，用于自定义应用上下文，并且在 refresh() 方法前就被调用。在这边就可以通过该方法来添加自定义的 BeanFactoryPostProcessor。

简单的实现如下：

1.新建一个 ApplicationContextInitializer 的实现类 SpringApplicationContextInitializer ，并在 initialize 方法中写我们的逻辑。

package com.joonwhee.open.demo.spring;
    
    import org.springframework.context.ApplicationContextInitializer;
    import org.springframework.context.ConfigurableApplicationContext;
    
    /**
     * @author joonwhee
     * @date 2019/1/19
     */
    public class SpringApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    
        @Override
        public void initialize(ConfigurableApplicationContext applicationContext) {
            FirstBeanDefinitionRegistryPostProcessor firstBeanDefinitionRegistryPostProcessor = new FirstBeanDefinitionRegistryPostProcessor();
            // 将自定义的firstBeanDefinitionRegistryPostProcessor添加到应用上下文中
            applicationContext.addBeanFactoryPostProcessor(firstBeanDefinitionRegistryPostProcessor);
            // ...自定义操作
            System.out.println("SpringApplicationContextInitializer#initialize");
        }
    }

2.将 SpringApplicationContextInitializer 作为初始化参数 contextInitializerClasses 配置到 web.xml 中。

<context-param>
        <param-name>contextInitializerClasses</param-name>
        <param-value>
            com.joonwhee.open.demo.spring.SpringApplicationContextInitializer
        </param-value>
    </context-param>

这样，在启动应用时，FirstBeanDefinitionRegistryPostProcessor 就会被添加到 this.beanFactoryPostProcessors 中。

### 代码块2：invokeBeanFactoryPostProcessors ###

public static void invokeBeanFactoryPostProcessors(
            ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
        // Invoke BeanDefinitionRegistryPostProcessors first, if any.
        Set<String> processedBeans = new HashSet<String>();
    
        // 1.判断beanFactory是否为BeanDefinitionRegistry，beanFactory为DefaultListableBeanFactory,
        // 而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，因此这边为true
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            // 用于存放普通的BeanFactoryPostProcessor
            List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
            // 用于存放BeanDefinitionRegistryPostProcessor
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
    
            // 2.首先处理入参中的beanFactoryPostProcessors
            // 遍历所有的beanFactoryPostProcessors, 将BeanDefinitionRegistryPostProcessor和普通BeanFactoryPostProcessor区分开
            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    // 2.1 如果是BeanDefinitionRegistryPostProcessor
                    BeanDefinitionRegistryPostProcessor registryProcessor =
                            (BeanDefinitionRegistryPostProcessor) postProcessor;
                    // 2.1.1 直接执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    // 2.1.2 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
                    registryProcessors.add(registryProcessor);
                } else {
                    // 2.2 否则，只是普通的BeanFactoryPostProcessor
                    // 2.2.1 添加到regularPostProcessors(用于最后执行postProcessBeanFactory方法)
                    regularPostProcessors.add(postProcessor);
                }
            }
    
            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let the bean factory post-processors apply to them!
            // Separate between BeanDefinitionRegistryPostProcessors that implement
            // PriorityOrdered, Ordered, and the rest.
            // 用于保存本次要执行的BeanDefinitionRegistryPostProcessor
            List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
    
            // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
            // 3.调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
            // 3.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
            String[] postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            // 3.2 遍历postProcessorNames
            for (String ppName : postProcessorNames) {
                // 3.3 校验是否实现了PriorityOrdered接口
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    // 3.4 获取ppName对应的bean实例, 添加到currentRegistryProcessors中,
                    // beanFactory.getBean: 这边getBean方法会触发创建ppName对应的bean对象, 目前暂不深入解析
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 3.5 将要被执行的加入processedBeans，避免后续重复执行
                    processedBeans.add(ppName);
                }
            }
            // 3.6 进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序)
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 3.7 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
            registryProcessors.addAll(currentRegistryProcessors);
            // 3.8 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 3.9 执行完毕后, 清空currentRegistryProcessors
            currentRegistryProcessors.clear();
    
            // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
            // 4.调用所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor实现类（过程跟上面的步骤3基本一样）
            // 4.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类, 这边重复查找是因为执行完上面的BeanDefinitionRegistryPostProcessor,
            // 可能会新增了其他的BeanDefinitionRegistryPostProcessor, 因此需要重新查找
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                // 校验是否实现了Ordered接口，并且还未执行过
                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            // 4.2 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();
    
            // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
            // 5.最后, 调用所有剩下的BeanDefinitionRegistryPostProcessors
            boolean reiterate = true;
            while (reiterate) {
                reiterate = false;
                // 5.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                for (String ppName : postProcessorNames) {
                    // 5.2 跳过已经执行过的
                    if (!processedBeans.contains(ppName)) {
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                        // 5.3 如果有BeanDefinitionRegistryPostProcessor被执行, 则有可能会产生新的BeanDefinitionRegistryPostProcessor,
                        // 因此这边将reiterate赋值为true, 代表需要再循环查找一次
                        reiterate = true;
                    }
                }
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
                // 5.4 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                currentRegistryProcessors.clear();
            }
    
            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
            // 6.调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法(BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor)
            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            // 7.最后, 调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        } else {
            // Invoke factory processors registered with the context instance.
            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
        }
    
        // 到这里 , 入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕,
        // 下面开始处理容器中的所有BeanFactoryPostProcessor
    
        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // 8.找出所有实现BeanFactoryPostProcessor接口的类
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        // 用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
        // 用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
        List<String> orderedPostProcessorNames = new ArrayList<String>();
        // 用于存放普通BeanFactoryPostProcessor的beanName
        List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
        // 8.1 遍历postProcessorNames, 将BeanFactoryPostProcessor按实现PriorityOrdered、实现Ordered接口、普通三种区分开
        for (String ppName : postProcessorNames) {
            // 8.2 跳过已经执行过的
            if (processedBeans.contains(ppName)) {
                // skip - already processed in first phase above
            } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 8.3 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                // 8.4 添加实现了Ordered接口的BeanFactoryPostProcessor的beanName
                orderedPostProcessorNames.add(ppName);
            } else {
                // 8.5 添加剩下的普通BeanFactoryPostProcessor的beanName
                nonOrderedPostProcessorNames.add(ppName);
            }
        }
    
        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
        // 9.调用所有实现PriorityOrdered接口的BeanFactoryPostProcessor
        // 9.1 对priorityOrderedPostProcessors排序
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        // 9.2 遍历priorityOrderedPostProcessors, 执行postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
        // 10.调用所有实现Ordered接口的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
        for (String postProcessorName : orderedPostProcessorNames) {
            // 10.1 获取postProcessorName对应的bean实例, 添加到orderedPostProcessors, 准备执行
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        // 10.2 对orderedPostProcessors排序
        sortPostProcessors(orderedPostProcessors, beanFactory);
        // 10.3 遍历orderedPostProcessors, 执行postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    
        // Finally, invoke all other BeanFactoryPostProcessors.
        // 11.调用所有剩下的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            // 11.1 获取postProcessorName对应的bean实例, 添加到nonOrderedPostProcessors, 准备执行
            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        // 11.2 遍历nonOrderedPostProcessors, 执行postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    
        // Clear cached merged bean definitions since the post-processors might have
        // modified the original metadata, e.g. replacing placeholders in values...
        // 12.清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、singletonBeanNamesByType），
        // 因为后处理器可能已经修改了原始元数据，例如， 替换值中的占位符...
        beanFactory.clearMetadataCache();
    }

1.判断 beanFactory 是否为 BeanDefinitionRegistry。beanFactory 是在之前的 obtainFreshBeanFactory 方法构建的，具体代码在：AbstractRefreshableApplicationContext.refreshBeanFactory() 方法，代码如下。

@Override
    protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            // 创建一个新的BeanFactory
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

可以看出，我们构建的 beanFactory 是一个 DefaultListableBeanFactory ，而 DefaultListableBeanFactory 实现了BeanDefinitionRegistry 接口，因此 beanFactory instanceof BeanDefinitionRegistry 结果为 true。

3.4 获取 ppName 对应的 bean 实例，添加到 currentRegistryProcessors 中，准备执行。beanFactory.getBean 方法会触发创建 ppName 对应的 bean 实例对象，创建 bean 实例是 IoC 的另一个核心内容，之后会单独解析，目前暂不深入解析。

3.6 进行排序，该方法在下面也被调用了好几次，**见代码块3详解。**

### **代码块3：sortPostProcessors** ###

private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
        Comparator<Object> comparatorToUse = null;
        if (beanFactory instanceof DefaultListableBeanFactory) {
            // 1.获取设置的比较器
            comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
        }
        if (comparatorToUse == null) {
            // 2.如果没有设置比较器, 则使用默认的OrderComparator
            comparatorToUse = OrderComparator.INSTANCE;
        }
        // 3.使用比较器对postProcessors进行排序
        Collections.sort(postProcessors, comparatorToUse);
    }

默认情况下，比较器为 OrderComparator；如果配置了 annotation-config，并且值为true，使用的是 AnnotationAwareOrderComparator（ [Spring IoC：context:component-scan节点解析][Spring IoC_context_component-scan] **代码块17中**设置了dependencyComparator 属性为 AnnotationAwareOrderComparator.INSTANCE），AnnotationAwareOrderComparator 继承自 OrderComparator，只是重写了部分方法，比较器的部分代码如下：

@Override
    public int compare(Object o1, Object o2) {
        return doCompare(o1, o2, null);
    }
    
    private int doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider) {
        // 判断o1是否实现了PriorityOrdered接口
        boolean p1 = (o1 instanceof PriorityOrdered);
        // 判断o2是否实现了PriorityOrdered接口
        boolean p2 = (o2 instanceof PriorityOrdered);
        // 1.如果o1实现了PriorityOrdered接口, 而o2没有, 则o1排前面
        if (p1 && !p2) {
            return -1;
        }
        // 2.如果o2实现了PriorityOrdered接口, 而o1没有, 则o2排前面
        else if (p2 && !p1) {
            return 1;
        }
    
        // 3.如果o1和o2都实现（都没实现）PriorityOrdered接口
        // Direct evaluation instead of Integer.compareTo to avoid unnecessary object creation.
        // 拿到o1的order值, 如果没实现Ordered接口, 值为Ordered.LOWEST_PRECEDENCE
        int i1 = getOrder(o1, sourceProvider);
        // 拿到o2的order值, 如果没实现Ordered接口, 值为Ordered.LOWEST_PRECEDENCE
        int i2 = getOrder(o2, sourceProvider);
        // 4.通过order值(order值越小, 优先级越高)排序
        return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
    }

比较器的逻辑很简单，实现 PriorityOrdered 接口的优先级最高，如果两个对象都实现（都没实现）PriorityOrdered 接口，则根据 order 值（实现 Ordered 接口时，需要实现 getOrder() 方法，返回 order 值）来进行比较，order 值越小，优先级越高。

## 基本使用 ##

### 1.BeanDefinitionRegistryPostProcessor 的扩展使用 ###

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

package com.joonwhee.open.demo.spring;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
    import org.springframework.core.Ordered;
    import org.springframework.stereotype.Component;
    
    /**
     * @author joonwhee
     * @date 2019/2/18
     */
    @Component
    public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor, Ordered {
    
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            System.out.println("MyBeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry");
            // 自己的逻辑处理
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("MyBeanDefinitionRegistryPostProcessor#postProcessBeanFactory");
            // 自己的逻辑处理
        }
    
        @Override
        public int getOrder() {
            return 0;
        }
    }

具体的使用场景，需要读者自己去探讨，这边给一个常见的使用例子。

**例子：**

我们通常在使用 Mybatis + Spring 时，经常用到的 org.mybatis.spring.mapper.MapperScannerConfigurer 就是一个BeanDefinitionRegistryPostProcessor。MapperScannerConfigurer 在 postProcessBeanDefinitionRegistry 方法中进行了一些操作，主要是：扫描 basePackage 指定的目录，将该目录下的类（通常是 DAO/MAPPER 接口）封装成 BeanDefinition 并加载到 BeanFactory 中。因此，我们可以看到我们项目中的 DAO（MAPPER）接口，通常都没有使用注解或 XML 的方式注册到 Spring 容器，但是我们还是可以在 Service 服务中，使用 @Autowire 注解来将其注入到 Service 中，就是因为这个原因。

MapperScannerConfigurer.java

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3YxMjM0MTE3Mzk_size_16_color_FFFFFF_t_70][]

### 2.BeanFactoryPostProcessor 的扩展使用 ###

使用方法跟 BeanDefinitionRegistryPostProcessor 类似。

package com.joonwhee.open.demo.spring;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.stereotype.Component;
    
    /**
     * @author joonwhee
     * @date 2019/2/18
     */
    @Component
    public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println("MyBeanFactoryPostProcessor#postProcessBeanFactory");
            // 自己的逻辑处理
        }
    }

## 总结 ##

invokeBeanFactoryPostProcessors 方法的内容其实比较少，大部分过程在**代码块2**的注释都已经写清楚，这边在稍微总结一下。

1.整个 invokeBeanFactoryPostProcessors 方法围绕两个接口，BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor，其中 BeanDefinitionRegistryPostProcessor 继承了 BeanFactoryPostProcessor 。BeanDefinitionRegistryPostProcessor 主要用来在常规 BeanFactoryPostProcessor 检测开始之前注册其他 Bean 定义，说的简单点，就是 BeanDefinitionRegistryPostProcessor 具有更高的优先级，执行顺序在 BeanFactoryPostProcessor 之前。

2.整个 invokeBeanFactoryPostProcessors 方法操作了 3 种 bean 对象：

*  入参 beanFactoryPostProcessors：这个我们在**代码块1**中解析过，拿的是 AbstractApplicationContext 类的 beanFactoryPostProcessors 属性值，也就是在之前已经添加到 beanFactoryPostProcessors 中的 BeanFactoryPostProcessor。
 *  BeanDefinitionRegistryPostProcessor 接口实现类：实现了 BeanDefinitionRegistryPostProcessor 接口，并且注册到 Spring IoC容器中。
 *  常规 BeanFactoryPostProcessor 接口实现类：实现了 BeanFactoryPostProcessor 接口，并且注册到 Spring IoC容器中。

3.操作3种 bean 对象具体指的是调用它们重写的方法，调用实现方法时会遵循以下的优先级：

*  第一优先级：入参 beanFactoryPostProcessors 中的 BeanDefinitionRegistryPostProcessor， 调用 postProcessBeanDefinitionRegistry 方法（2.1.1）。
 *  第二优先级：BeanDefinitionRegistryPostProcessor 接口实现类，并且实现了 PriorityOrdered 接口，调用 postProcessBeanDefinitionRegistry 方法（3.8）。
 *  第三优先级：BeanDefinitionRegistryPostProcessor 接口实现类，并且实现了 Ordered 接口，调用 postProcessBeanDefinitionRegistry 方法（4.2）。
 *  第四优先级：除去第二优先级和第三优先级，剩余的 BeanDefinitionRegistryPostProcessor 接口实现类，调用 postProcessBeanDefinitionRegistry 方法（5.4）。
 *  第五优先级：所有 BeanDefinitionRegistryPostProcessor 接口实现类，调用 postProcessBeanFactory 方法（6）。
 *  第六优先级：入参 beanFactoryPostProcessors 中的常规 BeanFactoryPostProcessor，调用 postProcessBeanFactory 方法（7）。
 *  第七优先级：常规 BeanFactoryPostProcessor 接口实现类，并且实现了 PriorityOrdered 接口，调用 postProcessBeanFactory 方法（9.2）。
 *  第八优先级：常规 BeanFactoryPostProcessor 接口实现类，并且实现了 Ordered 接口，调用 postProcessBeanFactory 方法（10.3）。
 *  第九优先级：除去第七优先级和第八优先级，剩余的常规 BeanFactoryPostProcessor 接口的实现类，调用 postProcessBeanFactory 方法（11.2）。

4.本文还引入了两个**用于排序**的重要接口：PriorityOrdered 和 Ordered，其中 PriorityOrdered 继承了 Ordered，并且 PriorityOrdered 的优先级要高于 Ordered，这跟 BeanDefinitionRegistryPostProcessor 继承 BeanFactoryPostProcessor 有点类似。实现 Ordered 接口需要重写 getOrder 方法，返回一个用于排序的 order 值，order 值的范围为 Integer.MIN\_VALUE ~ Integer.MAX\_VALUE，order 值越小优先级越高，Integer.MIN\_VALUE 拥有最高优先级，而 Integer.MAX\_VALUE 则对应的拥有最低优先级。

5.常见的 Java EE 相关的框架或者中间件，经常使用 BeanFactoryPostProcessor 来进行扩展，例如上面的 Mybatis，因此了解 BeanFactoryPostProcessor 的原理会对之后理解其他中间件的原理有帮助。

## 推荐阅读 ##

[字节、美团、快手核心部门面试总结（真题解析）][Link 2]

[4 年 Java 经验，阿里网易拼多多面试总结、心得体会][4 _ Java]

[面试阿里，HashMap 这一篇就够了][HashMap]

[面试必问的 MySQL，你懂了吗？][MySQL]

[面试必问的线程池，你懂了吗？][Link 3]

> 另外，我还准备了很多**大厂面试资料、0基础自学教程**，由于不能放外链，所以有需要的小伙伴去公众号【**程序员囧辉**】回复【**资料**】自行获取好了。

[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
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3YxMjM0MTE3Mzk_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190114235040917.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3YxMjM0MTE3Mzk=,size_16,color_FFFFFF,t_70
[Link 2]: https://joonwhee.blog.csdn.net/article/details/109588711
[4 _ Java]: https://joonwhee.blog.csdn.net/article/details/99708892
[HashMap]: https://joonwhee.blog.csdn.net/article/details/106324537
[MySQL]: https://joonwhee.blog.csdn.net/article/details/106893197
[Link 3]: https://joonwhee.blog.csdn.net/article/details/106609583