Spring启动流程解析-5-调用后处理器

一，Spring启动流程概述

Spring的IoC容器在实现控制反转和依赖注入的过程中，可以划分为两个阶段：

• 容器启动阶段

• Bean实例化阶段

容器初始化

1. 加载配置

2. 分析配置信息

3. 将Bean信息装配到BeanDefinition

4. 将Bean信息注册到相应的BeanDefinitionRegistry

5. 其他后续处理

容器实例化

1. 根据策略实例化对象

2. 装配依赖

3. Bean初始化前处理

4. 对象初始化

5. 对象其他处理

6. 注册回调接口

二，Spring启动流程详解

调用后处理器

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

BeanFactoryPostProcessor

BeanFactoryPostProcessor接口与BeanPostProcessor相似，但有一个主要区别：BeanFactoryPostProcessor用来操作Bean的配置元数据。也就是说，Spring IoC容器允许BeanFactoryPostProcessor读取配置元数据，并能在容器实例化任何Bean之前更改这些元数据。换句话说 ：就是可以让我们随心所欲地修改BeanFactory内所有BeanDefinition定义数据。

BeanDefinitionRegistryPostProcessor 是对标准BeanFactoryPostProcessor的扩展，允许在进行常规BeanFactoryPostProcessor检测之前注册其他Bean定义。特别是，BeanDefinitionRegistryPostProcessor注册的Bean定义又定义了BeanFactoryPostProcessor实例。

使用示例

Xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="car" class="xxx.xxx.processor.Car">
        <property name="name" value="benz"/>
    </bean>

    <bean id="carBeanFactoryPostProcessor1"
          class="xxx.xxx.processor.CarBeanFactoryPostProcessor1">
        <property name="order" value="0" />
    </bean>

    <bean id="carBeanFactoryPostProcessor2"
          class="xxx.xxx.processor.CarBeanFactoryPostProcessor2">
        <property name="order" value="1" />
    </bean>
</beans>

自定义BeanFactoryPostProcessor

// 1号后置处理器
public class CarBeanFactoryPostProcessor1 implements BeanFactoryPostProcessor, Ordered {
    int order;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException {
        System.out.println("=======> 执行CarBeanFactoryPostProcessor1");
        BeanDefinition bd = beanFactory.getBeanDefinition("car");
        bd.getPropertyValues().addPropertyValue("name", "bmw");
    }

    public void setOrder(int order) {
        this.order = order;
    }

    @Override
    public int getOrder() {
        return order;
    }
}

// 2号后置处理器
public class CarBeanFactoryPostProcessor2 implements BeanFactoryPostProcessor, Ordered {
    int order;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException {
        System.out.println("=======> 执行CarBeanFactoryPostProcessor2");
        BeanDefinition bd = beanFactory.getBeanDefinition("car");
        bd.getPropertyValues().addPropertyValue("color", "red");
    }

    public void setOrder(int order) {
        this.order = order;
    }

    @Override
    public int getOrder() {
        return order;
    }
}

// 实现BeanDefinitionRegistryPostProcessor接口的后处理器类
public class MobileBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("=======> 执行MobileBeanFactoryPostProcessor_1");
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(Mobile.class);
        registry.registerBeanDefinition("mobile", beanDefinitionBuilder.getBeanDefinition());
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("=======> 执行MobileBeanFactoryPostProcessor_2");
        BeanDefinition bd = beanFactory.getBeanDefinition("mobile");
        bd.getPropertyValues().addPropertyValue("number", "123");
    }
}

可以在项目中配置多个BeanFactoryPostProcessor，同时通过设置Order属性来控制这些BeanFactoryPostProcessor的执行顺序，当然仅当BeanFactoryPostProcessor实现Ordered接口时，才可以设置此属性。

Spring排序接口

Spring框架中有很多实现了相同接口的类，那么这些实现类之间必定会有优先级的问题。Spring提供了Ordered接口来处理相同接口实现类的优先级问题。Ordered接口，顾名思义，就是用来排序的。

流程源码分析

源码流程

源码解析

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

    // 临时缓存，用来记录已经调用过的BeanFactoryPostProcessor
    Set<String> processedBeans = new HashSet<String>();

    // 如果BeanFactory实现了BeanDefinitionRegistry接口
    // 从类图上可以看到其实是指DefaultListableBeanFactory或者GenericApplicationContext
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 存放普通BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
        // 存放BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();

        // 循环applicationContext中已经注册的BeanFactoryPostProcessor
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            // 如果是实现了BeanDefinitionRegistryPostProcessor的后处理器
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                    (BeanDefinitionRegistryPostProcessor) postProcessor;
                // 执行postProcessBeanDefinitionRegistry回调
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                // 把该后处理器加入到registryProcessors
                registryProcessors.add(registryProcessor);
            }
            else {
                // 否则就是普通的后处理器
                regularPostProcessors.add(postProcessor);
            }
        }

        // 在这里先不初始化FactoryBeans，因为需要保留这些Beans让BeanFactoryPostProcessor进行处理
        // BeanDefinitionRegistryPostProcessor将按照PriorityOrdered，Ordered进行分类
        
        // 临时缓存，用来记录待执行回调方法的BeanFactoryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();

        // 首先，处理实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
        String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 保存到待执行BeanFactoryPostProcess回调的缓存
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 保存到已经执行过BeanFactoryPostProcess回调的缓存
                processedBeans.add(ppName);
            }
        }
        // 对待执行缓存进行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        // 执行BeanFactoryPostProcess的回调函数
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 清空待执行BeanFactoryPostProcess回调的缓存
        currentRegistryProcessors.clear();

        // 其次，再处理实现了Ordered接口的BeanDefinitionRegistryPostProcessor
        Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                // 保存到待执行BeanFactoryPostProcess回调的缓存
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 保存到已经执行过BeanFactoryPostProcess回调的缓存
                processedBeans.add(ppName);
            }
        }
        // 对待执行缓存进行排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        // 执行BeanFactoryPostProcess的回调函数
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 清空待执行BeanFactoryPostProcess回调的缓存
        currentRegistryProcessors.clear();

        // 最后，处理所有其他BeanDefinitionRegistryPostProcessor
        boolean reiterate = true;
        // 循环处理其他BeanDefinitionRegistryPostProcessor
        while (reiterate) {
            reiterate = false;
            // 把所有实现BeanDefinitionRegistryPostProcessor的类名取出来
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            // 遍历postProcessorNames
            for (String ppName : postProcessorNames) {
                // 已经处理过的缓存不包含该类名
                if (!processedBeans.contains(ppName)) {
                    // 保存到待执行BeanFactoryPostProcess回调的缓存
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 保存到已经执行过BeanFactoryPostProcess回调的缓存
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            // 对待执行缓存进行排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            // 执行BeanFactoryPostProcess的回调函数
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 清空待执行BeanFactoryPostProcess回调的缓存
            currentRegistryProcessors.clear();
        }

        // 处理所有处理器，并执行postProcessBeanFactory回调
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }
    else {
        // 调用在上下文中注册的工厂处理器
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // 在这里不初始化FactoryBeans，因为需要让BeanFactoryPostProcessor来进行处理
    // 获取所有实现了BeanFactoryPostProcessor接口的类名称
    String[] postProcessorNames =
        beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // 实现了PriorityOrdered接口的PostProcessor缓存
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    // 实现了Ordered接口的PostProcessor缓存
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    // 没有实现任何Order接口的PostProcessor缓存
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    // 遍历postProcessorNames开始处理BeanFactoryPostProcessor
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // 如果包含，代表在上面的代码已经处理过则跳过
        }
        // 首先，处理实现了PriorityOrdered接口的BeanFactoryPostProcessor
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        // 其次，处理实现了Ordered接口的BeanFactoryPostProcessor
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        // 最后，处理没有实现任何Order接口接口的BeanFactoryPostProcessor
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // 首先，处理实现了PriorityOrdered接口的BeanFactoryPostProcessor
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

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

    // // 最后，处理所有其他BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // 清除被缓存的BeanDefinition，因为后处理器可能已经修改了原始元数据，例如：替换占位符
    beanFactory.clearMetadataCache();
}