备战面试日记（4.2.7）- （框架.Spring【七】之Spring IOC 源码invokeBeanFactoryPostProcessors()）

舍其小伙伴

已于 2022-01-25 17:24:10 修改

阅读量270

点赞数

分类专栏：面试准备 Spring IOC相关文章标签： spring 面试 java

于 2022-01-19 15:26:51 首次发布

本文链接：https://blog.csdn.net/weixin_44414492/article/details/122582117

版权

面试准备同时被 2 个专栏收录

39 篇文章 1 订阅

订阅专栏

Spring IOC相关

14 篇文章 0 订阅

订阅专栏

本人本科毕业，21届毕业生，一年工作经验，简历专业技能如下，现根据简历，并根据所学知识复习准备面试。

记录日期：2022.1.4

大部分知识点只做大致介绍，具体内容根据推荐博文链接进行详细复习。

文章目录

框架原理 - Spring（七）之Spring IOC 源码invokeBeanFactoryPostProcessors()
- AbstractApplicationContext#invokeBeanFactoryPostProcessors()

框架原理 - Spring（七）之Spring IOC 源码invokeBeanFactoryPostProcessors()

AbstractApplicationContext#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 (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

getBeanFactoryPostProcessors()

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

private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();

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

那么如果我们自己想添加一个BeanFactoryPostProcessor到beanFactory中的话，如下所示。

我们可以在refresh方法之前去添加一个自定义的**BeanFactoryPostProcessor** 到容器中，通常来讲有两种方式：

通过注解的方式，将自己实现的beanFactoryPostProcessor注册到beanFactory中。

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("postProcessBeanFactory");
    }
}

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

此时我们是通过web容器初始化的时候去做的添加，就要去掉 @Component 注解。

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("postProcessBeanFactory");
    }
}

然后在SpringApplicationContextInitializer 中addBeanFactoryPostProcessor()。

public class SpringApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
	public void initialize(ConfigurableApplicationContext context) {
        MyBeanFactoryPostProcessor myBeanFactoryPostProcessor = new MyBeanFactoryPostProcessor();
        context.addBeanFactoryPostProcessor(myBeanFactoryPostProcessor);
    }
}

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

<context-param>
	<param-name>contextInitializerClasses</param-name>
    <param-value>com.test.SpringApplicationContextInitializer</param-value>
</context-param>

invokeBeanFactoryPostProcessors()

用于执行BeanFactoryPostProcessors的方法。

我们来看一下代码实现：

public static void invokeBeanFactoryPostProcessors(
    ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    /*【警告注释翻译】
    警告：尽管此方法的主体似乎可以很容易地重构，以避免使用多个循环和多个列表，
    但在处理器名称上使用多个列表和多次传递是有意的。
    我们必须确保遵守优先订购和订购处理器的合同。
    具体来说，我们不能导致处理器被实例化（通过getBean（）调用）或以错误的顺序在ApplicationContext中注册。
	在提交更改此方法的请求请求（PR）之前，
	请查看所有涉及对后处理程序RegistrationLegate进行更改的被拒绝的PR列表，
	以确保您的提案不会导致重大更改：
	https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22
    */
    
    // 首先调用BeanDefinitionRegistryPostProcessors，如果存在的话。
    // 前面说过了BeanDefinitionRegistryPostProcessors，它是BeanFactoryPostProcessor的子类
    // 执行优先级高
    Set<String> processedBeans = new HashSet<>();

    // 1. 判断 beanFctory 是否为 BeanDefinitionRegistry
    // beanFctory 为 DefaultListableBeanFactory
    // 而 DefaultListableBeanFactory 实现了 BeanDefinitionRegistry 接口，所以为true
    if (beanFactory instanceof BeanDefinitionRegistry) {
        // 进行类型转换 BeanDefinitionRegistry
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 用于存放普通的 BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        // 用于存放 BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
		// 2. 首先处理入参的 beanFactoryPostProcessors
        // 遍历所有的 beanFactoryPostProcessors
        // 将 BeanDefinitionRegistryPostProcessor 和 普通的 BeanFactoryPostProcessor 区分开
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            // 2.1 判断是 BeanDefinitionRegistryPostProcessor 的话
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                // 进行类型转换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);
            }
        }

        /*【注释翻译】
        	不要在这里初始化FactoryBeans：我们需要让所有常规bean保持未初始化状态，
        	以便让bean factory后处理器应用于它们！
			在实现PriorityOrdered、Ordered和rest的BeanDefinitionRegistryPostProcessor之间进行分离。
        */
        // 用于保存本次要执行的BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // 【注释翻译】首先，调用实现 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor
        // 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中
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 3.5 将要被执行的加入processedBeans，避免后续重复执行
                processedBeans.add(ppName);
            }
        }
        // 3.6 进行排序（根据PriorityOrdered、Order接口和order值来排序）
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 3.7 添加到registryProcessors（同上）
        registryProcessors.addAll(currentRegistryProcessors);
        // 3.8 遍历执行currentRegistryProcessors中所有BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        // 3.9 执行完毕后，清空currentRegistryProcessors
        currentRegistryProcessors.clear();

        // 【注释翻译】接下来，调用实现Ordered的BeanDefinitionRegistryPostProcessor
        // 4. 调用所有实现了Ordered的BeanDefinitionRegistryPostProcessor（步骤和3相同）
        // 4.1 找出所有实现了BeanDefinitionRegistryPostProcessor接口的类，这边重复查找是因为执行完上面的BeanDefinitionRegistryPostProcessor，可能会新增加了其他的BeanDefinitionRegistryPostProcessor，因此需要重新查找
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        // 4.2 遍历postProcessorNames
        for (String ppName : postProcessorNames) {
            // 4.3 检验是否是 未执行过 并且 实现了Ordered接口
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                // 4.4 获取ppName对应的bean实例，添加到currentRegistryProcessors中
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 4.5 将要被执行的加入processedBeans，避免后续重复执行
                processedBeans.add(ppName);
            }
        }
        // 同上...
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 同上...
        registryProcessors.addAll(currentRegistryProcessors);
        // 同上...
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        // 同上...
        currentRegistryProcessors.clear();

        // 【注释翻译】最后，调用所有其他BeanDefinitionRegistryPostProcessor，直到不再出现其他BeanDefinitionRegistryPostProcessor
        // 5. 最后调用所有剩下的BeanDefinitionRegistryPostProcessors
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            // 5.1 找出所有实现了BeanDefinitionRegistryPostProcessor接口的类
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            // 5.2 遍历
            for (String ppName : postProcessorNames) {
                // 5.3 跳过已执行过的
                if (!processedBeans.contains(ppName)) {
                    // 5.4 添加到currentRegistryProcessors
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 5.5 添加到processedBeans
                    processedBeans.add(ppName);
                    // 5.6 如果有BeanDefinitionRegistryPostProcessor被执行了，则有可能产生新的BeanDefinitionRegistryPostProcessor
                    // 所以这边要将reiterate设置为true，代表需要再循环遍历一次
                    reiterate = true;
                }
            }
            // 同上...
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 同上...
            registryProcessors.addAll(currentRegistryProcessors);
            // 同上...
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            // 同上...
            currentRegistryProcessors.clear();
        }

        // 【注释翻译】现在，调用到目前为止处理的所有处理器的postProcessBeanFactory回调
        // 6. 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
        // （前面说过，BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor）
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        // 7. 最后，调用所有入参BeanFactoryPostProcessor的postProcessBeanFactory()方法
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        // 当没有实现了 BeanDefinitionRegistry 接口时
        // 【注释翻译】调用在上下文实例中注册的工厂处理器
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // 【注释翻译】不要在这里初始化FactoryBeans：我们需要让所有常规bean保持未初始化状态，以便让bean factory后处理器应用于它们！
    // 到此为止时，我们已经处理完了：
    // 入参的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
    // 容器中的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
    // 所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
    // 入参的BeanFactoryPostProcessor的postProcessBeanFactory()方法
    // 下面开始处理容器中的所有的BeanFactoryPostProcessor
    
    // 8. 找出所有BeanFactoryPostProcessor接口的类
    String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    
    // 【注释翻译】在实现PriorityOrdered、Ordered和rest的BeanFactory后处理器之间进行分离。
    // 用于存放实现了 PriorityOrdered 接口的 BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    // 用于存放实现了 Ordered 接口的BeanFactoryPostProcessor的beanName
    List<String> orderedPostProcessorNames = new ArrayList<>();
    // 用于存放普通的BeanFactoryPostProcessor的beanName
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    // 8.1 遍历postProcessorNames，将BeanFactoryPostProcessor按实现了PriorityOrdered接口、实现Ordered接口、普通三种分开
    for (String ppName : postProcessorNames) {
        // 8.1.1 跳过已经执行过的
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 8.1.2 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 8.1.3 添加实现了Ordered接口的BeanFactoryPostProcessor
            orderedPostProcessorNames.add(ppName);
        }
        else {
            // 8.1.4 添加普通的BeanFactoryPostProcessor
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // 【注释翻译】首先，调用实现PriorityOrdered的BeanFactoryPostProcessor
    // 9.调用所有实现了 PriorityOrdered 接口的 BeanFactoryPostProcessor
    // 9.1 对priorityOrderedPostProcessors排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 9.2 遍历 priorityOrderedPostProcessors 执行 postProcessBeanFactory() 方法
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 【注释翻译】接下来，调用实现Ordered的BeanFactoryPostProcessor
    // 10. 调用所有实现了 Ordered 接口的 BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        // 根据postProcessorName获取对应bean实例，添加到orderedPostProcessors，准备执行
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    // 10.1 对orderedPostProcessors排序
    sortPostProcessors(orderedPostProcessors, beanFactory);
    // 10.2 遍历 orderedPostProcessors 执行 postProcessBeanFactory() 方法
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 【注释翻译】最后，调用所有其他BeanFactoryPostProcessor
    // 11. 调用剩下的 BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        // 根据postProcessorName获取对应bean实例，添加到nonOrderedPostProcessors，准备执行
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    // 11.1 不排序了，直接遍历 nonOrderedPostProcessors 执行 postProcessBeanFactory() 方法
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // 【注释翻译】清除缓存的合并bean定义，因为后处理器可能修改了原始元数据，例如替换值中的占位符。。。
    // 清楚元数据缓存（mergedBeanDefinitions、allBeanNameByType、singletonBeanNamesByType），
    // 因为后处理器可能已经修改了原始元数据，例如替换值中的占位符等......
    beanFactory.clearMetadataCache();
}

到此为止，所有实现了 BeanFactoryPostProcessor 接口的 Bean都已经被执行了。

我们再来关注一下 invokeBeanFactoryPostProcessors() 里面几个常出现的方法。

sortPostProcessors()：用来对postProcessors集合进行排序。

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

默认情况下，比较器为 OrderComparator，如果配置了 annotation-config，并且值为true，使用的是 AnnotationAwareOrderComparator，AnnotationAwareOrderComparator 继承自 OrderComparator，只是重写了部分方法。

我们来看一下OrderComparator的代码实现：

public class OrderComparator implements Comparator<Object> {
    
 	public static final OrderComparator INSTANCE = new OrderComparator();
    
	@Override
	public int compare(@Nullable Object o1, @Nullable Object o2) {
		return doCompare(o1, o2, null);
	}

	private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
        // 判断o1是否实现了PriorityOrdered接口
		boolean p1 = (o1 instanceof PriorityOrdered);
        // 判断o2是否实现了PriorityOrdered接口
		boolean p2 = (o2 instanceof PriorityOrdered);
        // 如果o1实现了PriorityOrdered接口, 而o2没有, 则o1排前面
		if (p1 && !p2) {
			return -1;
		}
        // 如果o2实现了PriorityOrdered接口, 而o1没有, 则o2排前面
		else if (p2 && !p1) {
			return 1;
		}
		
        // 如果o1和o2都实现（都没实现）PriorityOrdered接口，走到下面
        // 拿到o1的order值, 如果没实现Ordered接口, 值为Ordered.LOWEST_PRECEDENCE
		int i1 = getOrder(o1, sourceProvider);
        // 拿到o2的order值, 如果没实现Ordered接口, 值为Ordered.LOWEST_PRECEDENCE
		int i2 = getOrder(o2, sourceProvider);
        // 通过order值(order值越小, 优先级越高)排序
		return Integer.compare(i1, i2);
	}
}

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

总结执行顺序

首先BeanDefinitionRegistryPostProcessor 具有更高的优先级，执行顺序在 BeanFactoryPostProcessor 之前。

方法中主要处理的是三大对象：

入参 beanFactoryPostProcessors
BeanDefinitionRegistryPostProcessor接口实现类
常规 BeanFactoryPostProcessor 接口实现类

执行的优先顺序如下：

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

舍其小伙伴

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
备战面试日记（4.2.7）- （框架.Spring【七】之Spring IOC 源码invokeBeanFactoryPostProcessors()）

本人本科毕业，21届毕业生，一年工作经验，简历专业技能如下，现根据简历，并根据所学知识复习准备面试。记录日期：2022.1.4大部分知识点只做大致介绍，具体内容根据推荐博文链接进行详细复习。文章目录框架原理 - Spring（七）之Spring IOC 源码invokeBeanFactoryPostProcessors()AbstractApplicationContext#invokeBeanFactoryPostProcessors()getBeanFactoryPostProcessors(
复制链接

扫一扫