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

一，Spring启动流程概述

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

容器启动阶段
Bean实例化阶段

容器初始化

加载配置
分析配置信息
将Bean信息装配到BeanDeFinition
将Bean信息注册到相应的BeanDeFinitionRegistry
其他后续处理

容器实例化

根据策略实例化对象
装配依赖
Bean初始化前处理
对象初始化
对象其他处理
注册回调接口

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

spring spring

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

容器初始化

容器实例化

调用后处理器

相关文章