SpringIoc源码（九）- ApplicationContext（五）- refresh（invokeBeanFactoryPostProcessors和registerBeanPostProc）

目录

1、invokeBeanFactoryPostProcessors

2、registerBeanPostProcessors

1)、registerBeanPostProcessors

2）、ApplicationListenerDetector

1、BeanPostProcessor

2、MergedBeanDefinitionPostProcessor

3、DestructionAwareBeanPostProcessor

---

1、invokeBeanFactoryPostProcessors

    Spring允许在Bean的生命周期调用BeanPostProcessor回调方法，也允许在Spring容器生命周期内回调BeanFactoryPostProcessor的postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)方法，BeanDefinitionRegistryPostProcessor也是继承自BeanFactoryPostProcessor并且新定义了接口postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)，允许回调时处理已经注册好的beanDefinition信息。并且按照是否实现了PriorityOrdered或Ordered或未实现排序接口等六种情况进行处理回调对应的方法。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

    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()));
    }
}

    对上面六种情况，即九种接口进行回调后，再进行织入的处理。之前以为Spring项目肯定会写的很怎么样，但是看到这个方法懵逼了很久，原来也写这么长的方法。首先，getBeanFactoryPostProcessors是调用AbstractApplicationContext的beanFactoryPostProcessors容器，是硬编码（通过方法addBeanFactoryPostProcessor）添加到容器中的。比如Spring Boot项目在启动之前就会往里面添加：

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

    // BeanDefinitionRegistryPostProcessors类型容器
    Set<String> processedBeans = new HashSet<>();

    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        // 遍历通过addBeanFactoryPostProcessor方法硬编码添加的BeanFactoryPostProcessor 
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            // BeanDefinitionRegistryPostProcessor类型，需要回调两个接口 
            // （postProcessBeanDefinitionRegistry）
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                // 普通类型的BeanFactoryPostProcessor只回调接口 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.
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // 处理BeanDefinitionRegistryPostProcessors类型并且实现了PriorityOrdered接口
        String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,
            true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        // 实现了PriorityOrdered或者Ordered都需要进行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        // 遍历，回调BeanDefinitionRegistryPostProcessors的 
        // postProcessBeanDefinitionRegistry接口
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // 处理BeanDefinitionRegistryPostProcessors实现了Ordered接口
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            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);
        // 回调postProcessBeanDefinitionRegistry接口
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // 实现了BeanDefinitionRegistryPostProcessors但是没有实现排序接口的所有
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                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);
            currentRegistryProcessors.clear();
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        // Invoke factory processors registered with the context instance.
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }


    // 下面处理只实现了BeanFactoryPostProcessor接口的实现
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // 同样还是按照是否实现了PriorityOrdered接口、或者Ordered接口, 为实现排序接口
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // 处理实现PriorityOrdered接口的
    // 排序再回调
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 处理实现Ordered接口的.
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    // 排序再回调
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 最后处理所以为实现排序的BeanFactoryPostProcessors
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    // 不进行排序直接回调
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // Clear cached merged bean definitions since the post-processors might have
    // modified the original metadata, e.g. replacing placeholders in values...
    beanFactory.clearMetadataCache();
}

     过程其实没那么复杂，只是都写到同一个方法中了，里面用到了几个通用的方法。最主要的是回调invokeBeanDefinitionRegistryPostProcessors方法时候，ConfigurationClassPostProcessor类型的BeanDefinitionRegistryPostProcessor，在调用processConfigBeanDefinitions时候，对@Bean、@Component、@PropertySources、@ComponentScans、@ComponentScan、ImportResource接口等进行了实现。后面详解

 

2、registerBeanPostProcessors

    实现了BeanFactoryPostProcessor或者BeanDefinitionRegistryPostProcessor的在上面就进行了回调。属于Spring容器级别的。而下面处理的是实现了BeanPostProcessor接口的，这里仅仅是进行注入到容器中，到后面每个Bean进行getBean时在生命周期中会进行回调。

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

    同样是委派给PostProcessorRegistrationDelegate进行实现

public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 获取BeanPostProcessor类型
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // 由于之前分析过，BeanFactory中有接口是关于注册的个数，所以需要进行计数
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // 同样处理BeanPostProcessor还是按照是否实现PriorityOrdered,Ordered或者为实现排序
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    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);
        }
    }

    // 对实现PriorityOrdered类型，先排序再注册到AbstractBeanFactory的addBeanPostProcessor方法进行注册
    // 添加到beanPostProcessors容器中
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // 同样方式处理实现了Ordered接口的，先排序再添加到容器
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    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);

    // 处理其余没有实现排序接口的BeanPostProcessors
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        // 处理实现了MergedBeanDefinitionPostProcessor类型
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // 最后对MergedBeanDefinitionPostProcessor类型进行排序和注册，如果之前注册过
    // 会进行先移除再注册，在sortPostProcessors中实现
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // 添加一个监听探测器ApplicationListenerDetector
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

1)、registerBeanPostProcessors

    注册BeanPostProcessor类型，分为是否集中情况进行处理

•     实现了PriorityOrdered接口（先排序再注册）
•     实现了Ordered接口（先排序再注册）
•     MergedBeanDefinitionPostProcessor类型（同样先排序再注册）
•     最后为普通BeanPostProcessor直接进行注册

2）、ApplicationListenerDetector

    是实现事件发送（详细参见Spring源码-事件监听机制（实现EventListener接口））很重要的一步，当然这里只是注册BeanPostProcess，调用还是在refresh的最后一步，将所有非懒加载的单利Bean初始化，则会回调该容器。结构如下：

class ApplicationListenerDetector implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {

    private final transient AbstractApplicationContext applicationContext;

    private final transient Map<String, Boolean> singletonNames = new ConcurrentHashMap<>(256);
}

    一个存储单利Bean的容器，实现了DestructionAwareBeanPostProcessor和MergedBeanDefinitionPostProcessor接口，并且顶级父类是BeanPostProcessor。

1、BeanPostProcessor

    实现了postProcessAfterInitialization接口，那么在refresh在最后阶段会对非懒加载的所有单利Bean进行，getBean操作，则会回调该方法：

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean instanceof ApplicationListener) {
        // potentially not detected as a listener by getBeanNamesForType retrieval
        Boolean flag = this.singletonNames.get(beanName);
        if (Boolean.TRUE.equals(flag)) {
            // singleton bean (top-level or inner): register on the fly
            this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
        }
        else if (Boolean.FALSE.equals(flag)) {
            this.singletonNames.remove(beanName);
        }
    }
    return bean;
}

    逻辑比较简单，先判断是否ApplicationListener子类，判断是否单利类型。不是则将容器中该类型删除（不进行管理）。否则则添加到SimpleApplicationEventMulticaster的retrieverCache中，详细参见：Spring源码-事件监听机制（实现EventListener接口）

2、MergedBeanDefinitionPostProcessor

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {

    void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
        Class<?> beanType, String beanName);

    default void resetBeanDefinition(String beanName) {
    }
}

    实现了postProcessMergedBeanDefinition接口，回调时将所有的Bean都添加自己的容器singletonNames中。当refresh的最后，所有非懒加载的单利bean把生命周期走完，则全部加载到该容器中。

public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
    Class<?> beanType, String beanName) {

    this.singletonNames.put(beanName, beanDefinition.isSingleton());
}

3、DestructionAwareBeanPostProcessor

public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {

    void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;

    default boolean requiresDestruction(Object bean) {
        return true;
    }

}

实现了resetBeanDefinition接口，比较简单，判断是否为ApplicationListener类型的子类。

public boolean requiresDestruction(Object bean) {
    return (bean instanceof ApplicationListener);
}

    实现了postProcessBeforeDestruction接口，那么在Bean进行销毁时，会调用该方法。则从添加的缓存中删除数据，则就不会再发送该事件，监听失效。

public void postProcessBeforeDestruction(Object bean, String beanName) {
    if (bean instanceof ApplicationListener) {
        try {
            ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();
            multicaster.removeApplicationListener((ApplicationListener<?>) bean);
            multicaster.removeApplicationListenerBean(beanName);
        }
        catch (IllegalStateException ex) {
            // ApplicationEventMulticaster not initialized yet - no need to remove a listener
        }
    }
}