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容器生命周期内回调BeanFactoryPostProcessorpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)方法,BeanDefinitionRegistryPostProcessor也是继承自BeanFactoryPostProcessor并且新定义了接口postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry),允许回调时处理已经注册好的beanDefinition信息。并且按照是否实现了PriorityOrderedOrdered或未实现排序接口等六种情况进行处理回调对应的方法。

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的容器,实现了DestructionAwareBeanPostProcessorMergedBeanDefinitionPostProcessor接口,并且顶级父类是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子类,判断是否单利类型。不是则将容器中该类型删除(不进行管理)。否则则添加到SimpleApplicationEventMulticasterretrieverCache中,详细参见: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
        }
    }
}

 

 

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值