死磕Spring系列：BeanFactoryPostProcessors源码解析

1. 流程图解

2. 源码解读

    public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
     
        // 保存已经处理过的Bean Name
        Set<String> processedBeans = new HashSet();
        // 常规的保存BeanFactoryPostProcessor的数组（非BeanDefinitionRegistryPostProcessor，BeanDefinitionRegistryPostProcessor类继承自BeanFactoryPostProcessor）
        ArrayList regularPostProcessors;
        // 保存BeanDefinitionRegistryPostProcessor的数组
        ArrayList registryProcessors;
        int var9;
        // 存放当前参与计算的BeanDefinitionRegistryPostProcessor的数组
        ArrayList currentRegistryProcessors;
        String[] postProcessorNames;
        // 如果beanFactory是BeanDefinitionRegistry的实例
        if (beanFactory instanceof BeanDefinitionRegistry) {
     
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
            regularPostProcessors = new ArrayList();
            registryProcessors = new ArrayList();
            Iterator var6 = beanFactoryPostProcessors.iterator();

            while(var6.hasNext()) {
     
                BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
                // 如果后置处理器是BeanDefinitionRegistryPostProcessor的实例
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
     
                    BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                    // 立即执行BeanDefinitionRegistry后置处理器的方法
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    // 添加到BeanDefinitionRegistry后置处理器数组
                    registryProcessors.add(registryProcessor);
                } else {
     
                    // 非BeanDefinitionRegistry后置处理器的实例
                    // 直接添加到常规的BeanFactory后置处理器数组
                    regularPostProcessors.add(postProcessor);
                }
            }

            currentRegistryProcessors = new ArrayList();
            // 从beanFactory中根据BeanDefinitionRegistryPostProcessor类型获取到容器中的所有bean名称
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            String[] var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            int var10;
            String ppName;
            for(var10 = 0; var10 < var9; ++var10) {
     
                ppName = var16[var10];
                // 判断当前BeanDefinitionRegistry后置处理器是否实现了PriorityOrdered接口，进行优先处理
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
     
                    // 添加到当前需要处理的registry后置处理器数组
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 添加到已经处理过的bean数组
                    processedBeans.add(ppName);
                }
            }
			// 如果beanFactory是DefaultListableBeanFactory的实例，且beanFactory有自身的dependencyComparator则按照dependencyComparator规则排序，否则使用默认排序，按照实现了PriorityOrdered接口中的getOrder()方法返回的数值进行排序，数值越小，越靠前（优先）
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 将当前需要处理的registry后置处理器数组添加到全部registry后置处理器数组中
            registryProcessors.addAll(currentRegistryProcessors);
            // 执行当前需要处理的registry后置处理器数组中每个对象的postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            // 清空当前需要处理的registry后置处理器数组，为后续程序备用
            currentRegistryProcessors.clear();
            
            // 重复从beanFactory中根据BeanDefinitionRegistryPostProcessor类型获取到容器中的所有bean名称
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            for(var10 = 0; var10 < var9; ++var10) {
     
                ppName = var16[var10];
                // 排除实现了PriorityOrdered接口的类，但实现了Ordered接口的类（说明PriorityOrdered优先级比Ordered高）
                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
     
                    // 添加到当前需要处理的registry后置处理器数组
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 添加到已经处理过的bean数组
                    processedBeans.add(ppName);
                }
            }
			
            // 同样排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 同样添加到全部的registry后置处理器数组中
            registryProcessors.addAll(currentRegistryProcessors);
            // 同样执行registry后置处理器对象中的postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            // 同样清空备用
            currentRegistryProcessors.clear();
            boolean reiterate = true;
				
            // 重复操作，直到beanFactory容器中没有未执行的registry后置处理器
            while(reiterate) {
     
                reiterate = false;
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                String[] var19 = postProcessorNames;
                var10 = postProcessorNames.length;

                for(int var26 = 0; var26 < var10; ++var26) {
     
                    String ppName = var19[var26];
                    if (!processedBeans.contains(ppName)) {
     
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                        reiterate = true;
                    }
                }

                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
                currentRegistryProcessors.clear();
            }
            
			// BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor
            // 优先执行BeanDefinitionRegistryPostProcessor实例中实现了BeanFactoryPostProcessor类关于BeanFactory的后置处理器的postProcessBeanFactory方法
            invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
            // 再执行BeanFactoryPostProcessor实例中的BeanFactory后置处理方法
            invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        } else {
     
            // 如果beanFactory非BeanDefinitionRegistry，则直接执行BeanFactory的后置处理方法
            invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        }

        // 在beanFactory中获取所有BeanFactoryPostProcessor的bean Name
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
        // 清空对象数据
        regularPostProcessors = new ArrayList();
        registryProcessors = new ArrayList();
        currentRegistryProcessors = new ArrayList();
        postProcessorNames = postProcessorNames;
        int var20 = postProcessorNames.length;

        String ppName;
        for(var9 = 0; var9 < var20; ++var9) {
     
            ppName = postProcessorNames[var9];
            // 如果该bean未被当成BeanDefinitionRegistry处理过
            if (!processedBeans.contains(ppName)) {
     
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
     
                    // 将实现了PriorityOrdered接口的BeanFactoryPostProcessor的bean存入regularPostProcessors
                    regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
                } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
     
                    // 将实现了Ordered接口的BeanFactoryPostProcessor的bean名称存入registryProcessors
                    registryProcessors.add(ppName);
                } else {
     
                    // 将不含有排序的BeanFactoryPostProcessor的bean名称存入currentRegistryProcessors
                    currentRegistryProcessors.add(ppName);
                }
            }
        }
		
        // 先对实现PriorityOrdered接口的BeanFactoryPostProcessor的bean进行排序再执行
        sortPostProcessors(regularPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        
        // 再根据实现Ordered接口的BeanFactoryPostProcessor的bean名称从beanFactory中获取bean实例进行排序再执行
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList(registryProcessors.size());
        Iterator var21 = registryProcessors.iterator();

        while(var21.hasNext()) {
     
            String postProcessorName = (String)var21.next();
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }

        sortPostProcessors(orderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        
        // 最后根据未排序的BeanFactoryPostProcessor的bean名称从beanFactory中获取bean实例进行执行后置处理方法
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList(currentRegistryProcessors.size());
        Iterator var24 = currentRegistryProcessors.iterator();

        while(var24.hasNext()) {
     
            ppName = (String)var24.next();
            nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }

        invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        
        // 清空beanFactory中metadata缓存
        beanFactory.clearMetadataCache();
    }