一、概述

二、invokeBeanFactoryPostProcessors(beanFactory)：执行BeanFactoryPostProcessor后置处理器的postProcessBeanFactory()增强方法

三、registerBeanPostProcessors(beanFactory)：注册BeanPostProcessor

四、initMessageSource()：为上下文初始化MessageSource

五、initApplicationEventMulticaster()：初始化事件多播器

六、onRefresh()：模板方法，留给子类初始化其他的bean

七、registerListeners()：注册监听器

一、概述

前面一篇文章我们详细分析了Spring IOC容器启动方法refresh()方法的前面四个方法，简单回顾一下：

prepareRefresh()：创建 Bean 容器前的准备工作；
obtainFreshBeanFactory()：创建Bean容器，解析XML配置，封装成bean定义信息；
prepareBeanFactory(beanFactory)：准备Bean工厂，设置一些属性；
postProcessBeanFactory(beanFactory)：留给子类对BeanFactory定制化处理；

如果没有阅读前面一篇文章的读者，可以先阅读前面一篇文章Spring IOC源码笔记(一)_weixiaohuai的博客-CSDN博客，连贯起来有助于理解。

本篇文章我们接着分析refresh()方法的其他几个方法：

invokeBeanFactoryPostProcessors(beanFactory)：执行BeanFactoryPostProcessor后置处理器的postProcessBeanFactory()增强方法；
registerBeanPostProcessors(beanFactory)：注册BeanPostProcessor；
initMessageSource()：为上下文初始化MessageSource；
initApplicationEventMulticaster()：初始化事件多播器；
onRefresh()：模板方法，留给子类初始化其他的bean；
registerListeners()：注册监听器；

其中标红的几个方法是IOC中的重要方法，读者可以多留意具体实现。

二、invokeBeanFactoryPostProcessors(beanFactory)：执行BeanFactoryPostProcessor后置处理器的postProcessBeanFactory()增强方法

invokeBeanFactoryPostProcessors(beanFactory)方法会实例化和调用所有 BeanFactoryPostProcessor（包括其子类 BeanDefinitionRegistryPostProcessor）。

首先需要明白BeanFactoryPostProcessor是什么？

BeanFactoryPostProcessor，Bean工厂增强器，是 Spring 初始化 BeanFactory 时对外暴露的扩展点，Spring IoC 容器允许 BeanFactoryPostProcessor 在容器实例化任何 bean 之前读取 bean 的定义，并可以修改它。

其定义如下：

@FunctionalInterface
public interface BeanFactoryPostProcessor {void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;}

BeanFactoryPostProcessor是一个函数式接口，内部包含一个postProcessBeanFactory()方法，当我们自定义BeanFactoryPostProcessor后，在invokeBeanFactoryPostProcessors()方法中就会回调我们自定义的那些BeanFactoryPostProcessor的postProcessBeanFactory()方法：

// 实例化并调用所有已注册的BeanFactoryPostProcessor.
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {// 1.拿到当前应用上下文beanFactoryPostProcessors变量中的值// 2.实例化并调用所有已注册的BeanFactoryPostProcessorPostProcessorRegistrationDelegate.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()));}
}

关键逻辑在invokeBeanFactoryPostProcessors()方法中，代码如下：

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {// Invoke BeanDefinitionRegistryPostProcessors first, if any.// 记录已经处理过的BeanFactoryPostProcessor集合，无需重复执行Set<String> processedBeans = new HashSet<>();// 对BeanDefinitionRegistry类型的处理if (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;// 存放普通的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();// 存放BeanDefinitionRegistryPostProcessor，BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();// 循环遍历硬编码方式注册的BeanFactoryPostProcessor后置处理器for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {// 区分普通的BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor，分别放入不同的集合中if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {BeanDefinitionRegistryPostProcessor registryProcessor =(BeanDefinitionRegistryPostProcessor) postProcessor;// 如果是BeanDefinitionRegistryPostProcessor的话，直接执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法registryProcessor.postProcessBeanDefinitionRegistry(registry);// BeanDefinitionRegistryPostProcessorregistryProcessors.add(registryProcessor);}else {// 普通BeanFactoryPostProcessorregularPostProcessors.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.// 记录本次要执行的BeanDefinitionRegistryPostProcessorList<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();// 配置注册的后置处理器// 1、调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类// 找出所有实现BeanDefinitionRegistryPostProcessor接口的BeanString[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);// 循环遍历，判断是否实现PriorityOrdered接口for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));// 添加到将要执行的集合中，避免重复执行processedBeans.add(ppName);}}// 按照优先级进行排序sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);// 调用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();// 2、调用所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor实现类// 找出所有实现BeanDefinitionRegistryPostProcessor接口的类postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);// 循环遍历，判断是否实现Ordered接口for (String ppName : postProcessorNames) {// 未执行过 && 实现Ordered接口if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));// 添加到将要执行的集合中，避免重复执行processedBeans.add(ppName);}}// 按照order排序sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);// 调用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();// 3、调用所有剩下的BeanDefinitionRegistryPostProcessorsboolean 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);// 调用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();}// 回调所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);// 回调普通BeanFactoryPostProcessor的postProcessBeanFactory方法invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}else {// 调用在上下文实例中注册的工厂处理器invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}// Do not initialize FactoryBeans here: We need to leave all regular beans// uninitialized to let the bean factory post-processors apply to them!// 从bean工厂中获取到BeanFactoryPostProcessorString[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,// Ordered, and the rest.// 存放实现了PriorityOrdered接口的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();// 存放实现了Ordered接口的BeanFactoryPostProcessorList<String> orderedPostProcessorNames = new ArrayList<>();// 存放其它BeanFactoryPostProcessorList<String> nonOrderedPostProcessorNames = new ArrayList<>();// 循环从工厂中获取的BeanFactoryPostProcessor, 分别存入到三个不同的集合中for (String ppName : postProcessorNames) {// 针对已经处理过的BeanFactoryPostProcessor,不做任何操作，无需重复执行if (processedBeans.contains(ppName)) {// skip - already processed in first phase above}else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {// PriorityOrdered接口的BeanFactoryPostProcessorpriorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {// Ordered接口的BeanFactoryPostProcessororderedPostProcessorNames.add(ppName);}else {// 普通BeanFactoryPostProcessornonOrderedPostProcessorNames.add(ppName);}}// 1、调用所有实现PriorityOrdered接口的BeanFactoryPostProcessor// 排序sortPostProcessors(priorityOrderedPostProcessors, beanFactory);// 执行postProcessBeanFactory()回调invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// 2、调用所有实现Ordered接口的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();for (String postProcessorName : orderedPostProcessorNames) {orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}// 排序sortPostProcessors(orderedPostProcessors, beanFactory);// 执行postProcessBeanFactory()回调invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);// 3、调用所有其他BeanFactoryPostProcessorList<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();for (String postProcessorName : nonOrderedPostProcessorNames) {nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}// 执行postProcessBeanFactory()回调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();
}

执行完invokeBeanFactoryPostProcessors(beanFactory)方法，观察控制台输出：

===========================实例化之前===========================
执行MyBeanFactoryPostProcessor的postProcessBeanFactory()方法

简单总结一下invokeBeanFactoryPostProcessors(beanFactory)方法：

a、处理实现了BeanDefinitionRegistryPostProcessor接口的BeanFactoryPostProcessor，并按照实现了PriorityOrdered 接口、Ordered 接口、普通BeanFactoryPostProcessor顺序，依次回调postProcessBeanDefinitionRegistry()和postProcessBeanFactory()方法；
b、处理实现了BeanFactoryPostProcessor接口的bean，同样按照按照实现了PriorityOrdered 接口、Ordered 接口、普通BeanFactoryPostProcessor顺序，依次回调postProcessBeanFactory()方法；
c、最后，清除元数据缓存；

三、registerBeanPostProcessors(beanFactory)：注册BeanPostProcessor

registerBeanPostProcessors(beanFactory)主要是将所有实现了BeanPostProcessor接口的类注册到BeanFactory 中。注意，只是完成了注册工作，并没有执行BeanPostProcessor的增强逻辑，真正执行是在bean初始化前、后，后面我们看到bean初始化逻辑的时候可以看到。

首先需要明白什么BeanPostProcessor是什么?

BeanPostProcessor是bean的后置处理器，它允许我们在bean实例化后，在bean初始化前、初始化后，对bean实例进行修改。BeanPostProcessor是一个接口，其定义如下：

public interface BeanPostProcessor {// bean初始化前执行@Nullabledefault Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}// bean初始化后执行@Nullabledefault Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {return bean;}}

在bean实例化之后，执行初始化方法前会调用所有BeanPostProcessor的 postProcessBeforeInitialization()方法，在执行初始化方法后会调用所有 BeanPostProcessor 的 postProcessAfterInitialization()方法。

读者需要注意区分BeanFactoryPostProcessor 和 BeanPostProcessor。

BeanFactoryPostProcessor 是针对 BeanFactory 的扩展，主要用在 bean 实例化之前，读取 bean 的定义，允许我们修改它；
BeanPostProcessor 是针对 bean 的扩展，主要用在 bean 实例化之后，执行初始化方法前后，允许我们对 bean 实例进行修改；

接下来，我们看下registerBeanPostProcessors(beanFactory)方法的核心逻辑：

// 注册BeanPostProcessor，注意，这里还不会执行BeanPostProcessor对应的增强方法
// 真正调用是在bean初始化前、初始化后
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

核心逻辑在registerBeanPostProcessors()方法，源码如下：

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {// 1、从bean工厂中获取到所有实现了BeanPostProcessor接口的bean// 如本例中我们自定义的MyBeanPostProcessor就会在这里被扫描出String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);// Register BeanPostProcessorChecker that logs an info message when// a bean is created during BeanPostProcessor instantiation, i.e. when// a bean is not eligible for getting processed by all BeanPostProcessors.int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;// 往bean工厂中添加一个BeanPostProcessor -> BeanPostProcessorChecker// BeanPostProcessorChecker是一个在创建bean期间记录信息消息的BeanPostProcessorbeanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));// 存放实现了PriorityOrdered接口的BeanPostProcessorList<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();// 存放实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessorList<BeanPostProcessor> internalPostProcessors = new ArrayList<>();// 存放实现了Ordered接口的BeanPostProcessorList<String> orderedPostProcessorNames = new ArrayList<>();// 存放普通的BeanPostProcessorList<String> nonOrderedPostProcessorNames = new ArrayList<>();// 2、循环遍历扫描出的所有的BeanPostProcessor，然后分别存放到前面定义的几个集合中for (String ppName : postProcessorNames) {// 实现了PriorityOrdered接口的BeanPostProcessorif (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {// 通过getBean获取对应的Bean实例，然后添加到priorityOrderedPostProcessors集合中// 这里涉及到获取bean的过程，暂且不深入分析BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);priorityOrderedPostProcessors.add(pp);// 如果同时实现了MergedBeanDefinitionPostProcessor接口，加入到internalPostProcessors集合中if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {// 实现了Ordered接口的BeanPostProcessororderedPostProcessorNames.add(ppName);}else {// 普通BeanPostProcessornonOrderedPostProcessorNames.add(ppName);}}// 排序sortPostProcessors(priorityOrderedPostProcessors, beanFactory);// 3、注册实现了PriorityOrdered接口的BeanPostProcessorregisterBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();for (String ppName : orderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);orderedPostProcessors.add(pp);// 如果同时实现了MergedBeanDefinitionPostProcessor接口，加入到internalPostProcessors集合中if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}// 排序sortPostProcessors(orderedPostProcessors, beanFactory);// 4、注册实现了Ordered接口的BeanPostProcessor// 通过beanFactory.addBeanPostProcessor(postProcessor)添加BeanPostProcessorregisterBeanPostProcessors(beanFactory, orderedPostProcessors);// Now, register all regular BeanPostProcessors.// 5、注册其他普通的BeanPostProcessorList<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();for (String ppName : nonOrderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);nonOrderedPostProcessors.add(pp);// 如果同时实现了MergedBeanDefinitionPostProcessor接口，加入到internalPostProcessors集合中if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}// 通过beanFactory.addBeanPostProcessor(postProcessor)添加BeanPostProcessorregisterBeanPostProcessors(beanFactory, nonOrderedPostProcessors);// 排序sortPostProcessors(internalPostProcessors, beanFactory);// 通过beanFactory.addBeanPostProcessor(postProcessor)添加BeanPostProcessor// 6、注册所有内部 BeanPostProcessorregisterBeanPostProcessors(beanFactory, internalPostProcessors);// Re-register post-processor for detecting inner beans as ApplicationListeners,// moving it to the end of the processor chain (for picking up proxies etc).// 7、往bean工厂中添加一个BeanPostProcessor -> ApplicationListenerDetector// ApplicationListenerDetectorbeanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

可以看到，处理逻辑跟之前BeanFactoryPostProcessor类似，同样按照实现了PriorityOrdered 接口、Ordered 接口、普通BeanPostProcessor的顺序，然后注册到bean工厂中。注册给定的BeanPostProcessor主要是在registerBeanPostProcessors()方法中实现的：

// 注册给定的BeanPostProcessor
private static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {// 遍历给定的BeanPostProcessor集合，挨个通过addBeanPostProcessor方法，向bean工厂中添加，保存到BeanFactory的beanPostProcessors成员变量中// private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();for (BeanPostProcessor postProcessor : postProcessors) {beanFactory.addBeanPostProcessor(postProcessor);}
}

我们可以看到，通过遍历前面扫描出来的BeanPostProcessor集合，然后调用addBeanPostProcessor方法，向bean工厂中添加指定的BeanPostProcessor：

//org.springframework.beans.factory.support.AbstractBeanFactory#addBeanPostProcessor
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");// 如果当前beanPostProcessor已经存在，则先移除this.beanPostProcessors.remove(beanPostProcessor);// Track whether it is instantiation/destruction awareif (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {this.hasInstantiationAwareBeanPostProcessors = true;}if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {this.hasDestructionAwareBeanPostProcessors = true;}// 将beanPostProcessor添加到beanPostProcessors成员属性中// private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();this.beanPostProcessors.add(beanPostProcessor);
}

并且注册后的BeanPostProcessor保存在BeanFactory的成员变量beanPostProcessors中：

// 存放工厂中所有的BeanPostProcessor实例
private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();

到这里，BeanPostProcessor已经成功注册到bean工厂中了，但是我们看到，这里并没有执行BeanPostProcessor的增强方法，实际上BeanPostProcessor的增强是在bean初始化前、初始化后阶段执行。

简单总结一下registerBeanPostProcessors(beanFactory)方法：

a、从bean工厂中获取到所有实现了BeanPostProcessor接口的bean；
b、循环遍历扫描出的所有的BeanPostProcessor，然后分别存放到几个集合中；
c、注册实现了PriorityOrdered接口的BeanPostProcessor；
d、注册实现了Ordered接口的BeanPostProcessor；
e、注册其他普通的BeanPostProcessor；
f、注册所有内部 BeanPostProcessor；
g、往bean工厂中添加一些BeanPostProcessor ，如BeanPostProcessorChecker、ApplicationListenerDetector；

四、initMessageSource()：为上下文初始化MessageSource

initMessageSource()主要是完成MessageSource消息源的初始化，用于国际化处理。总体实现思路也比较清晰：

获取到bean工厂；
判断工厂中是否包含id为messageSource的bean，即用户自定义的消息源；
如果存在用户自定义的MessageSource，则使用用户自定义的；否则新建一个默认的消息源，并注册到bean工厂中；

源码如下：

// 为上下文初始化MessageSource，即不同语言的消息体，即国际化处理
protected void initMessageSource() {// 1、获取到当前的bean工厂对象，类型为DefaultListableBeanFactoryConfigurableListableBeanFactory beanFactory = getBeanFactory();// 2、判断bean工厂中是否存在id为messageSource的beanif (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {// 3、如果存在，从bean工厂中获取到对应的bean，判断获取的bean是不是HierarchicalMessageSource类型的，如果是的话，则设置其父级消息源this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);// Make MessageSource aware of parent MessageSource.if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;if (hms.getParentMessageSource() == null) {// Only set parent context as parent MessageSource if no parent MessageSource registered already.// 如果尚未注册父消息源，则将父上下文设置为父消息源hms.setParentMessageSource(getInternalParentMessageSource());}}if (logger.isTraceEnabled()) {logger.trace("Using MessageSource [" + this.messageSource + "]");}}else {// 4、如果bean工厂中不存在名称为messageSource的bean对象，则新建DelegatingMessageSource类作为messageSource的Bean，并注册到bean工厂中// Use empty MessageSource to be able to accept getMessage calls.DelegatingMessageSource dms = new DelegatingMessageSource();// 设置父消息源dms.setParentMessageSource(getInternalParentMessageSource());this.messageSource = dms;// 把.messageSource作为单例Bean注册到bean工厂中,存入一级缓存singletonObjects中beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);if (logger.isTraceEnabled()) {logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");}}
}

五、initApplicationEventMulticaster()：初始化事件多播器

initApplicationEventMulticaster()用于初始化事件多播器，方法实现比较简单：先判断有没有用户自定义的ApplicationEventMulticaster事件多播器，没有的话就新建一个SimpleApplicationEventMulticaster，并作为单例bean注册到bean工厂。

源码如下：

// 初始化事件多播器
protected void initApplicationEventMulticaster() {// 获取到当前bean工厂ConfigurableListableBeanFactory beanFactory = getBeanFactory();// 1、如果用户自定义了事件广播器，那么使用用户自定义的事件广播器（实现ApplicationEventMulticaster接口）// 判断bean工厂中是否存在id为applicationEventMulticaster的beanif (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {// 如果存在，则通过getBean获取对应的beanthis.applicationEventMulticaster =beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);if (logger.isTraceEnabled()) {logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");}}else {// 2、如果用户没有自定义事件广播器，则使用默认的事件广播器：SimpleApplicationEventMulticaster// 如果不存在，则新建一个简单的SimpleApplicationEventMulticaster事件多播器this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);// 作为单例bean注册到bean工厂,存入一级缓存singletonObjects中beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);if (logger.isTraceEnabled()) {logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");}}
}

六、onRefresh()：模板方法，留给子类初始化其他的bean

onRefresh()又是一个Spring留给我们进行扩展的点，典型的模板方法，项目中如果有需要初始化其他的bean的场景，可以通过重写onRefresh()方法来实现。

// 模板方法，留给子类初始化其他的bean
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}

七、registerListeners()：注册监听器

registerListeners()完成监听器的注册工作，整体思路：

获取通过硬编码调用addApplicationListener方法添加的监听器，注册到前面初始化好的事件多播器中；
从bean工厂中找出所有实现了ApplicationListener接口的bean名称，循环添加到事件多播器中；
如果存在早期应用事件, 则直接发布早期的应用程序事件到相应的监听器,并将earlyApplicationEvents早期事件置为空；

Spring监听器使用到了典型的设计模式 - 观察者模式，源码如下：

// 注册监听器
protected void registerListeners() {// 1. 获取静态指定的监听器集合，循环添加到事件多播器中，事件多播器在前面一个步骤initApplicationEventMulticaster()中已经初始化// getApplicationListeners()就是获取的AbstractApplicationContext#applicationListeners成员属性的值，即通过硬编码调用addApplicationListener方法添加的监听器for (ApplicationListener<?> listener : getApplicationListeners()) {// 把手动注册的监听器添加到事件多播器中,这里直接添加的是类型是ApplicationListenergetApplicationEventMulticaster().addApplicationListener(listener);}// Do not initialize FactoryBeans here: We need to leave all regular beans// uninitialized to let post-processors apply to them!// 2. 从bean工厂中找出所有实现了ApplicationListener接口的bean名称,循环添加到事件多播器中// 通过配置文件或注解注入的监听器String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);for (String listenerBeanName : listenerBeanNames) {// 由于实现了ApplicationListener接口的类此时还没有实例化，这里添加的是监听器对应的bean的名称，在获取所有的事件监听器方法AbstractApplicationEventMulticaster.DefaultListenerRetriever#getApplicationListeners中，会通过beanFactory.getBean(listenerBeanName, ApplicationListener.class)获取到对应的监听器beangetApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);}// 3. 如果存在早期应用事件, 则直接发布早期的应用程序事件到相应的监听器,并将earlyApplicationEvents早期事件置为空//早期应用程序事件this.earlyApplicationEvents在AbstractApplicationContext#prepareRefresh()方法中已经初始化Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;// 清空早期应用程序事件this.earlyApplicationEvents = null;// 如果早期应用程序事件不为空，则直接执行multicastEvent()方法发布事件if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {for (ApplicationEvent earlyEvent : earlyEventsToProcess) {getApplicationEventMulticaster().multicastEvent(earlyEvent);}}
}

好了，本篇文章暂且先分析前面几个方法的具体实现，到这里，refresh方法还剩下最后两个没有分析，咱们放到下篇文章来单独分析，如下：

finishBeanFactoryInitialization(beanFactory)：初始化所有剩下的非懒加载的单例Bean；
finishRefresh()：完成上下文的刷新工作；

希望本篇文章对读者有所帮助，也希望大家能反馈表述错误或不合理的地方。

Spring IOC源码笔记(二)相关推荐

Spring IoC 源码导读
源码记录:spring-framework-5.1.7-source-code-read 文章导读 Spring IoC 源码系列(一)BeanDefinition 初始化与注册 Spring IoC ...
Spring IoC源码：getBean 详解
文章目录 Spring源码系列: 前言正文方法1:getObjectForBeanInstance 方法2:getObjectFromFactoryBean 方法3:doGetObjectFrom ...
【源码】Spring IOC源码
从Spring为什么要用IoC的支点,我撬动了整个Spring的源码脉络! - 掘金 https://juejin.cn/post/7124482061364609038 seaswalker/spr ...
Spring IOC源码解析笔记
小伙伴们,你们好,我是老寇 Spring最重要的概念就算IOC和AOP,本篇主要记录Spring IOC容器的相关知识,本文适合有spring相关基础并且想了解spring ioc的相关原理的人看本 ...
Spring IoC 源码系列（五）getBean 流程分析
一.FactoryBean 用法讲解在分析源码流程之前,我们先来看一下 FactoryBean,乍一看这家伙和 BeanFactory 很像,它们都可以用来获取 bean 对象,简单来说 Facto ...
Spring IoC 源码系列（一）BeanDefinition 初始化与注册
一.BeanDefinition 1.1 什么是 BeanDefinition 在一般的 Spring 项目中,主要通过 XML 的方式配置 bean,而 BeanDefinition 就是 XML ...
Spring Ioc 源码分析(一)--Spring Ioc容器的加载
1.目标:熟练使用spring,并分析其源码,了解其中的思想.这篇主要介绍spring ioc 容器的加载 2.前提条件:会使用debug 3.源码分析方法:Intellj idea debug 模式 ...
Spring Ioc源码分析之 Bean的加载（4）：实例化Bean（createBeanInstance()方法）
实例化 Bean 在doCreateBean()代码 <2> 处,有一行代码instanceWrapper = createBeanInstance(beanName, mbd, args ...
java获取当前周一_Java互联网架构-Spring IOC源码分析
欢迎关注头条号:java小马哥周一至周日下午三点半!精品技术文章准时送上!!! 精品学习资料获取通道,参见文末源码介绍之前,看几个问题: Bean的承载对象是什么? Bean的定义如何存储的? B ...
Spring IoC 源码系列（四）bean创建流程与循环依赖问题分析
创建单例 bean 的代码细节在 org.springframework.beans.factory.support.AbstractBeanFactory#getBean 中,getBean 顾名思 ...

Spring IOC源码笔记(二)

一、概述

二、invokeBeanFactoryPostProcessors(beanFactory)：执行BeanFactoryPostProcessor后置处理器的postProcessBeanFactory()增强方法

三、registerBeanPostProcessors(beanFactory)：注册BeanPostProcessor

四、initMessageSource()：为上下文初始化MessageSource

五、initApplicationEventMulticaster()：初始化事件多播器

六、onRefresh()：模板方法，留给子类初始化其他的bean

七、registerListeners()：注册监听器

Spring IOC源码笔记(二)相关推荐

最新文章

热门文章