一、前沿
Spring 是java后台开发人员再熟悉不过的框架，其中有一个好处就是通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码
造成程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用，真正实现了写一次，可以到处运行的机制
既然 Spring 是管理bean的容器，那么它是如何加载的呢？后续将为大家通过源码来为其解开神秘面纱。Spring 中所有 bean 的加载都是在 ApplicationContext 上下文刷新方法中完成的，而 bean的加载分为两个阶段，即 bean注册 和 bean实例化，本文中主要讲解了 bean 的注册部分，即所有的 bean 定义转换成了 BeanDefinition，bean 的实例化（即 getBean）将在下一节详细分析，下面就让我们看一看 ApplicationContext 上下文刷新方法的完整逻辑吧
二、ApplicationContext 上下文刷新
下面先从一个测试代码开始，如下：
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/org/springframework/context/support/simpleContext.xml");ClassPathXmlApplicationContext 这个类非常重要，是我们最常见的扩展Spring获取bean使用的方式，它的功能是负责将配置文件中的所有bean给注册到Spring容器中去，下面先看一下它的结构，如下图：
从结构上就可以看出 ClassPathXmlApplicationContext 的功能复杂性，它实现了诸多类，主要实现的接口有 ApplicationEventPublisher、BeanFactory、ResourceLoader、InitializingBean 和 Aware，继承了 AbstractXmlApplicationContext
接下来开始分析其源码，如下：
/**
* Create a new ClassPathXmlApplicationContext, loading the definitions
* from the given XML file and automatically refreshing the context.
* @param configLocation resource location
* @throws BeansException if context creation failed
*/
// 1、ClassPathXmlApplicationContext 的 ClassPathXmlApplicationContext
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
// configLocation 是给定的 xml 文件路径
// 加载给定的 xml 文件中的bean定义，并自动刷新上下文
this(new String[] {configLocation}, true, null);
}
/**
* Create a new ClassPathXmlApplicationContext with the given parent,
* loading the definitions from the given XML files.
* @param configLocations array of resource locations
* @param refresh whether to automatically refresh the context,
* loading all bean definitions and creating all singletons.
* Alternatively, call refresh manually after further configuring the context.
* @param parent the parent context
* @throws BeansException if context creation failed
* @see #refresh()
*/
// 2、ClassPathXmlApplicationContext 的 ClassPathXmlApplicationContext
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
// 父类的构造方法
super(parent);
// 给上下文中设置配置文件路径
setConfigLocations(configLocations);
// refresh 默认传参是 true，即需要刷新上下文
if (refresh) {
// 调用父类 AbstractApplicationContext 的 refresh 方法刷新上下文
refresh();
}
}接下来就是重中之重的刷新上下文逻辑了，它是Spring的核心所在，入口在 AbstractApplicationContext 的 refresh 方法中，源码如下：
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// 1、为刷新上下文做准备
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 2、获取 BeanFactory，解析xml文件生成所有的 BeanDefinition
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 3、填充 BeanFactory 各种功能，比如加载器、表达式解析器、属性解析器等
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 4、这里交给ApplicationContext上下文的子类实现该方法对BeanFactory做扩展处理
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 5、激活 BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 6、注册 BeanPostProcessor
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 7、初始化消息资源
initMessageSource();
// Initialize event multicaster for this context.
// 8、初始化广播事件 ApplicationEventMulticaster
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 9、刷新上下文，这里是空实现，留给子类扩展实现自己的逻辑，例如初始化一些特殊的bean
onRefresh();
// Check for listener beans and register them.
// 10、注册事件监听器
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 11、完成所有剩下的非延迟加载的bean的实例化
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 12、完成上下文刷新
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}refresh 方法主要实现了以下逻辑：
1）、环境准备，即为刷新上下文做准备
2）、获取 BeanFactory ，先创建 DefaultListableBeanFactory，然后解析xml文件生成所有的bean定义，即 BeanDefinition，然后存储在 DefaultListableBeanFactory 的 beanDefinitionMap 属性中
3）、填充 BeanFactory 各种功能，比如加载器、表达式解析器、属性解析器等
4）、BeanFactory做扩展处理
5）、激活 BeanFactoryPostProcessor
6）、注册 BeanPostProcessor
7）、初始化消息资源
8）、初始化广播事件 ApplicationEventMulticaster
9）、刷新上下文，这里是空实现，留给子类扩展实现自己的逻辑，例如初始化一些特殊的bean
10）、注册事件监听器
11）、完成所有剩下的非延迟加载的bean的实例化
12）、完成上下文刷新
2.1 环境准备（prepareRefresh 方法）
刷新上下文前的准备工作，例如对系统属性及环境变量的初始化及验证，源码如下：
/**
* Prepare this context for refreshing, setting its startup date and
* active flag as well as performing any initialization of property sources.
*/
// AbstractApplicationContext 的 prepareRefresh 方法
protected void prepareRefresh() {
// Switch to active.
// 开始日期
this.startupDate = System.currentTimeMillis();
// 设置 closed 和 active 标识
this.closed.set(false);
this.active.set(true);
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
// Initialize any placeholder property sources in the context environment.
// 上下文中初始化占位符数据源，由子类自己实现
initPropertySources();
// Validate that all properties marked as required are resolvable:
// see ConfigurablePropertyResolver#setRequiredProperties
// 验证所需要的属性文件是否已经放入环境中
getEnvironment().validateRequiredProperties();
// Store pre-refresh ApplicationListeners...
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
this.earlyApplicationEvents = new LinkedHashSet<>();
}2.2 获取 BeanFactory（obtainFreshBeanFactory 方法）
obtainFreshBeanFactory 方法从字面上就可以看出它实现了获取 BeanFactory 的功能，在获取 BeanFactory 的过程中分为了两部分，一是创建 （加载）DefaultListableBeanFactory，二是解析xml文件加载 BeanDefinition，其中 BeanDefinition 存储在 DefaultListableBeanFactory 的 beanDefinitionMap 属性中
2.2.1 加载 BeanFactory，即 DefaultListableBeanFactory
加载 BeanFactory 的逻辑很简单，源码如下：
/**
* Tell the subclass to refresh the internal bean factory.
* @return the fresh BeanFactory instance
* @see #refreshBeanFactory()
* @see #getBeanFactory()
*/
// 1、AbstractApplicationContext 的 obtainFreshBeanFactory 方法
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 调用AbstractRefreshableApplicationContext 的 refreshBeanFactory 方法刷新 BeanFactory
refreshBeanFactory();
// 调用 AbstractRefreshableApplicationContext 的 getBeanFactory 方法返回 BeanFactory
return getBeanFactory();
}
/**
* This implementation performs an actual refresh of this context's underlying
* bean factory, shutting down the previous bean factory (if any) and
* initializing a fresh bean factory for the next phase of the context's lifecycle.
*/
// 2、AbstractRefreshableApplicationContext 的 refreshBeanFactory
@Override
protected final void refreshBeanFactory() throws BeansException {
// 验证 BeanFactory 是否存在
if (hasBeanFactory()) {
// BeanFactory 存在，销毁 BeanFactory 中所有的 bean
destroyBeans();
// 关闭 BeanFactory
closeBeanFactory();
}
try {
// BeanFactory 不存在，创建默认的 BeanFactory，即 DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 设置序列化id
beanFactory.setSerializationId(getId());
// 定制的 BeanFactory 属性设置，即是否允许覆盖bean的定义和循环依赖
customizeBeanFactory(beanFactory);
// 调用 XmlWebApplicationContext 的 loadBeanDefinitions 方法解析xml文件，加载bean的定义，即 BeanDefinition
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
// 3、AbstractRefreshableApplicationContext 的 customizeBeanFactory 方法
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
if (this.allowBeanDefinitionOverriding != null) {
// 设置是否允许bean定义覆盖
beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
if (this.allowCircularReferences != null) {
// 设置是否允许循环依赖
beanFactory.setAllowCircularReferences(this.allowCircularReferences);
}
}
// 4、AbstractRefreshableApplicationContext 的 getBeanFactory 方法
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
synchronized (this.beanFactoryMonitor) {
if (this.beanFactory == null) {
throw new IllegalStateException("BeanFactory not initialized or already closed - " +
"call 'refresh' before accessing beans via the ApplicationContext");
}
return this.beanFactory;
}
}加载 BeanFactory 过程中实现了以下逻辑：
1）、BeanFactory 存在时，销毁 BeanFactory 中所有的 bean 和 关闭 BeanFactory
2）、BeanFactory 不存在时，创建 DefaultListableBeanFactory，设置序列化id和自定义属性（bean定义是否可以被覆盖和是否允许循环依赖）
3）、解析xml文件加载所有的bean定义 BeanDefinition，然后保存在 DefaultListableBeanFactory 对象中
4）、返回 DefaultListableBeanFactory
2.2.2 加载 BeanDefinition（loadBeanDefinitions 方法）
首先定义 XmlBeanDefinitionReader 来读取 xml、，将 xml 中定义的所有 bean 和其他标签的对象解析成 BeanDefinition ，存储在 DefaultListableBeanFactory 对象中，源码如下：
/**
* Loads the bean definitions via an XmlBeanDefinitionReader.
* @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
* @see #initBeanDefinitionReader
* @see #loadBeanDefinitions
*/
// 1、XmlApplicationContext 的 loadBeanDefinitions 方法
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
// 创建 XmlBeanDefinitionReader
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
// 为 XmlBeanDefinitionReader 设置环境变量和资源
beanDefinitionReader.setEnvironment(getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
// 空实现，这里交给子类重写该方法实现扩展功能，可以进一步处理 XmlBeanDefinitionReader
initBeanDefinitionReader(beanDefinitionReader);
// 使用 XmlBeanDefinitionReader 加载xml文件中bean的定义
loadBeanDefinitions(beanDefinitionReader);
}
// 2、XmlWebApplicationContext 的 loadBeanDefinitions
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
// 获取配置文件路径数组
String[] configLocations = getConfigLocations();
if (configLocations != null) {
for (String configLocation : configLocations) {
// 加载configLocations对应的xml文件中的所有bean定义
reader.loadBeanDefinitions(configLocation);
}
}
}解析后的 BeanDefinition 如下图所示：
解析xml文件生成 BeanDefinition 的过程将在后续的章节中单独讲解，这里就不在展开分析了
2.3 填充 BeanFactory 各种功能（prepareBeanFactory 方法）
prepareBeanFactory 方法丰富了 BeanFactory 的各种功能，源码如下：
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
// 设置 ClassLoader
beanFactory.setBeanClassLoader(getClassLoader());
// 设置表达式语言处理器 StandardBeanExpressionResolver ，默认可以使用 #{bean.xxx} 形式来调用 bean 的属性
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 设置默认属性编辑器 ResourceEditorRegistrar
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 设置 BeanPostProcessor ApplicationContextAwareProcessor
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 设置了一些忽略自动装配的接口 xxxAware，例如 EnvironmentAware、ApplicationEventPublisherAware、ApplicationContextAware 等
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
// 注册解析依赖
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
// 设置 BeanPostProcessor ApplicationListenerDetector
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
// 增加对 AspectJ 的支持
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
// 注册单例的默认系统环境Bean
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}prepareBeanFactory 方法主要实现了以下逻辑：
1）、增加对 SPEL 表达式的支持
2）、增加对属性编辑器的支持
3）、增加后置处理器 BeanPostProcessor
4）、设置依赖需要忽略的接口
5）、注册一些特殊依赖，需要这些依赖时直接获取即可
6）、增加对 AspectJ 的支持
7）、注册单例的默认系统环境Bean
下面分别对上述五个步骤做详细说明
2.3.1 增加对 SPEL 表达式的支持
Spring表达式语言全称“Spring Expression Language”，缩写为 “SPEL”，类似于 Struts2.x 中的 OGNL 表达式语言，能在运行期间构建复杂表达式、存取对象属性、对象方法调用等，并能与Spring功能完美整合，比如用来配置bean定义。SPEL 是单独模块，只依赖于 core 模块，不依赖于其他模块，可以单独使用。
SPEL 使用 #{....} 作为界定符，所有在大框括号中的字符都被认为是 SPEL，使用格式如下：
SPEL 功能非常强大，使用好可以大大提高开发效率，那么注册之后Spring又是在什么时候调用这个解析器解析的呢？
Spring在bean进行初始化的时候会有属性填充的一步，而在这一步中Spring会调用 AbstractAutowireCapableBeanFactory 类的 applyPropertyValues 方法来完成此功能，就在这个方法中会构造 BeanDefinitionValueResolver 类型实例 valueResolver 来进行属性值的解析，同时在这一步骤中通过 AbstractBeanFactory 中的 evaluateBeanDefinitionString 方法去完成SPEL的解析，如下图所示：
2.3.2 增加对属性编辑器的支持
属性编辑器后面有单独的章节讲解，这里不再做分析了
2.3.3 增加后置处理器 BeanPostProcessor
ApplicationContextAwareProcessor 实现了 BeanPostProcessor 接口，其中实现了 BeanPostProcessor 接口中的两个非常重要的方法 postProcessBeforeInitialization 和 postProcessAfterInitialization ，源码如下：
// ApplicationContextAwareProcessor 的 postProcessBeforeInitialization
@Override
@Nullable
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
AccessControlContext acc = null;
if (System.getSecurityManager() != null &&
(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareInterfaces(bean);
return null;
}, acc);
}
else {
// 调用 Aware 接口
invokeAwareInterfaces(bean);
}
return bean;
}
private void invokeAwareInterfaces(Object bean) {
// bean 是 Aware 类型
if (bean instanceof Aware) {
// 具体的 Aware 设置自己相关的属性，注意这些 Aware 都是 BeanFactory 中忽略的 Aware 接口
// 实现这些 Aware 接口的bean在初始化的时候就可以直接获取到对应的资源
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
}
// ApplicationContextAwareProcessor 的 postProcessAfterInitialization
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
// 直接返回bean
return bean;
}BeanPostProcessor 的 postProcessBeforeInitialization 和 postProcessAfterInitialization 方法是在 Spring初始化 bean 的 init-method 方法前后分别调用的
2.3.4 设置忽略依赖
BeanFactory 设置了 ApplicationContextAwareProcessor 后置处理器后，在 postProcessBeforeInitialization 中调用的 invokeAwareInterfaces 方法获取的 Aware 类已经不是普通的 bean了，如 ResourceLoaderAware、ApplicationEventPublisherAware 等，那么Spring在依赖注入的时候自然要忽略它们，因为它们不需要依赖注入了
2.3.5 注册特殊依赖
Spring 中有了忽略依赖注入接口的功能，当然也会有注册依赖的功能，当注册了依赖解析后，例如当注册了对 BeanFactory.class 的解析依赖后，当 bean 的属性注入的时候，一旦检测到属性为 BeanFactory 类型便会将 BeanFactory 的实例注入进去
2.4 对BeanFactory做扩展（postProcessBeanFactory 方法）
AbstractApplicationContext 的 postProcessBeanFactory 方法中是空实现，源码如下：
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}这里交给 ApplicationContext 的子类来实现该方法达到对BeanFactory做扩展的目的，这里是扩展点之一哦
2.5 激活 BeanFactoryPostProcessor（invokeBeanFactoryPostProcessors 方法）
激活 BeanFactoryPostProcessor 的入口在 AbstractApplicationContext 的 invokeBeanFactoryPostProcessors 方法，源码如下：
/**
* Instantiate and invoke all registered BeanFactoryPostProcessor beans,
* respecting explicit order if given.
* <p>Must be called before singleton instantiation.
*/
// 1、AbstractApplicationContext 的 invokeBeanFactoryPostProcessors 方法
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// PostProcessorRegistrationDelegate 的 invokeBeanFactoryPostProcessors 方法对 BeanFactoryPostProcessor 处理
// getBeanFactoryPostProcessors 方法获取 BeanFactoryPostProcessor 列表
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)
// BeanFactory 中不存在 TempClassLoader && BeanFactory 中包含名称为 loadTimeWeaver 的 BeanDefinition
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
// BeanFactory 设置 LoadTimeWeaverAwareProcessor 后置处理器
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// BeanFactory 设置 ContextTypeMatchClassLoader 加载器
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
// 2、PostProcessorRegistrationDelegate 的 invokeBeanFactoryPostProcessors 方法
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
// DefaultListableBeanFactory 实现了 BeanDefinitionRegistry 接口，因此是 BeanDefinitionRegistry 类型
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 存储普通类型的 BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 存储 BeanDefinitionRegistryPostProcessor 类型的 BeanFactoryPostProcessor
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 硬编码注册的 BeanFactoryPostProcessor 列表，即代码中写的
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
// BeanDefinitionRegistryPostProcessor 类型的 BeanFactoryPostProcessor 处理
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 对于 BeanDefinitionRegistryPostProcessor 类型的 BeanFactoryPostProcessor，在 BeanFactoryPostProcessor
// 基础方法上还有自己定义的方法，这里先调用自己的方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 添加到 registryProcessors 列表中
registryProcessors.add(registryProcessor);
}
else {
// 非 BeanDefinitionRegistryPostProcessor 类型的 BeanFactoryPostProcessor 添加到 regularPostProcessors 列表中
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<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 从 BeanFactory 中获取 BeanDefinitionRegistryPostProcessor 类型的 beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 实现了 PriorityOrdered 的 beanName
// 例如：ConfigurationClassPostProcessor（继承了BeanDefinitionRegistryPostProcessor，实现了PriorityOrdered）
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 实例化 PriorityOrdered 类型的 BeanDefinitionRegistryPostProcessor，即 实例化 ConfigurationClassPostProcessor
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 添加到已经处理过的 bean 列表中
processedBeans.add(ppName);
}
}
// 按照优先级（实现了 PriorityOrdered）对 currentRegistryProcessors 中的 BeanDefinitionRegistryPostProcessor 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 先处理优先级高的 BeanDefinitionRegistryPostProcessor，例如 ：ConfigurationClassPostProcessor
// 调用 ConfigurationClassPostProcessor 的 postProcessBeanDefinitionRegistry 方法将类中带有 @Bean、@Configuration 等注解的方法或者类
// 生成对应的 BeanDefinition，存入DefaultListableBeanFactory 中，以便 Spring 容器统一管理其bean
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 已经处理过的 bean 列表中不包含当前 beanName && 实现了 Ordered 的 beanName
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 实例化 Ordered 类型的 BeanDefinitionRegistryPostProcessor
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 添加到已经处理过的 bean 列表中
processedBeans.add(ppName);
}
}
// 按照优先级（实现了 Ordered）对 currentRegistryProcessors 中的 BeanDefinitionRegistryPostProcessor 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 处理没有实现 PriorityOrdered 和 Ordered 的 BeanDefinitionRegistryPostProcessor，过程和上述过程一样
// 例如 Mybatis 的 MapperScannerConfigurer（继承了BeanDefinitionRegistryPostProcessor，没有实现 PriorityOrdered 或者 Ordered）
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
// MapperScannerConfigurer 实例化bean
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 这里主要调用 MapperScannerConfigurer 的 postProcessBeanDefinitionRegistry 方法，
// 将 basePackage 包路径下的所有类转换成 BeanDefinition，然后存入 DefaultListableBeanFactory 中，以便 Spring 容器统一管理其bean
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);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// 从 BeanFactory 中获取 BeanFactoryPostProcessor 类型的 beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
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
// 忽略已经处理过的 beanName
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 先实例化优先级高（实现了PriorityOrdered）的 BeanFactoryPostProcessor
// 例如：PropertySourcesPlaceholderConfigurer（继承了BeanFactoryPostProcessor，实现了 PriorityOrdered）
// 实例化 bean PropertySourcesPlaceholderConfigurer
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 这里调用 PropertySourcesPlaceholderConfigurer 的 postProcessBeanFactory 方法解析bean中定义的占位符${...}并用值替换
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
// 实例化实现了 Ordere 的 BeanFactoryPostProcessor
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
// 实例化没有实现 Ordered 排序的 BeanFactoryPostProcessor
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();
}
上述代码的逻辑相对复杂，一定要通过debug调试来理解，总体来说，对于 BeanFactoryPostProcessor 的处理分为两种类型：
1）、BeanDefinitionRegistryPostProcessor（继承了 BeanFactoryPostProcessor） 类型
2）、普通的 BeanFactoryPostProcessor 类型
对于硬编码注册的 BeanFactoryPostProcessor 主要是通过 AbstractApplicationContext 的 addBeanFactoryPostProcessor 方法添加到 beanFactoryPostProcessors 中，这里可以作为自己实现的 BeanFactoryPostProcessor 的扩展，源码如下：
// AbstractApplicationContext 的 addBeanFactoryPostProcessor 方法
@Override
public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
Assert.notNull(postProcessor, "BeanFactoryPostProcessor must not be null");
this.beanFactoryPostProcessors.add(postProcessor);
}2.5.1 BeanDefinitionRegistryPostProcessor（继承了 BeanFactoryPostProcessor ）
BeanDefinitionRegistryPostProcessor 继承了 BeanFactoryPostProcessor ，不但有 BeanFactoryPostProcessor 的特性，同时还有自己定义的个性方法 postProcessBeanDefinitionRegistry ，调用 postProcessBeanDefinitionRegistry 方法来将 @Bean、@Configuration 等注解的方法或者类生成对应的 BeanDefinition，存入DefaultListableBeanFactory 中，以便 Spring 容器统一管理其bean
Mybatis 和 Spring 的结合就是利用此特性将自己的 bean 交给了 Spring 容器管理，具体过程如下：
MapperScannerConfigurer（继承了BeanDefinitionRegistryPostProcessor，没有实现 PriorityOrdered 或者 Ordered），调用了 postProcessBeanDefinitionRegistry 方法将 basePackage 包路径下的mybatis要使用的所有类转换成 BeanDefinition，然后存入DefaultListableBeanFactory 中，以便 Spring 容器统一管理其bean
因此要从 BeanFactoryPostProcessors 中首先挑出 BeanDefinitionRegistryPostProcessor 类型的后处理器，并且按照其实现的顺序 PriorityOrdered、Ordered 优先级进行其 postProcessBeanDefinitionRegistry 方法的激活 和 postProcessBeanFactory 方法的调用做一些额外处理，例如：
ConfigurationClassPostProcessor 的 postProcessBeanFactory 方法为所有@Configuration注解的类用cglib方式生成了代理子类
这里之所以使用 cglib 生成代理类的原因有二：
1）、@Configuration 注解的类一般都是配置作用，不会有接口定义，因此无法使用 JDK 动态代理
2）、保证了bean的单例性，利用cglib代理增强，通过这个代理对象的方法拦截器，可以解决配置类内部bean依赖调用的时候都从容器 BeanFactory 中去获取，避免了多例（即多次new对象）的出现
@Configuration 和 @Component 最大的区别是 Component 注解的类是原型的，即使用一次即实例化一次，因此@Component 配置类内部bean依赖调用的时候都会重新 new 对象（实例化），每次生成的对象都不一样
2.5.2 普通 BeanFactoryPostProcessor
BeanFactoryPostProcessor 也是按照其实现的顺序 PriorityOrdered、Ordered 优先级进行 postProcessBeanFactory 方法的调用做一些额外处理，例如：
PropertySourcesPlaceholderConfigurer 的 postProcessBeanFactory 方法解析bean中定义的占位符${...}并用值替换
总结其实现了如下逻辑：
1）、实例化了所有的 BeanFactoryPostProcessor
2）、将特殊注解的bean转成了BeanDefinition
2.6 注册 BeanPostProcessor（registerBeanPostProcessors 方法）
registerBeanPostProcessors 方法只是注册了 BeanPostProcessor，并没有调用，真正的调用是在 bean 的实例化阶段进行的。Spring 中大部分功能都是通过后处理器的方式扩展的，这是Spring的一个很重要的特性，但是在 BeanFactory 中其实并没有实现后处理的自动注册，所以在调用的时候如果没有进行注册其实是不能使用的
自定义的 BeanPostProcessor，示例demo如下：
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
/**
* 自定义BeanPostProcessor
*
* @date 2019-12-10 16:33
**/
public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
System.out.println(beanName +"实例化之前");
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println(beanName +"实例化之后");
return true;
}
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
System.out.println(beanName + "属性填充了");
return pvs;
}
}运行测试代码，如下：
运行结果是什么也没有输出，这是由于虽然定义了自定义的 BeanPostProcessor，但是没有注册到 Spring 容器中，因此不会生效，如果想生效的话，只需要将 MyBeanPostProcessor 配置到 xml 文件中，Spring 解析xml文件内容时会将 MyBeanPostProcessor 注册到 Spring 容器中，配置文件修改如下：
再次运行结果显示如下：
由此看出在bean的实例化前后和属性填充时分别输出了日志内容
了解了 BeanPostProcessor 的扩展使用后，下面我们就看一下 BeanPostProcessor 是如何注册到 BeanFactory 中去的，入口在 AbstractApplicationContext 的 registerBeanPostProcessors 方法，整个过程源码如下：
/**
* Instantiate and register all BeanPostProcessor beans,
* respecting explicit order if given.
* <p>Must be called before any instantiation of application beans.
*/
// 1、AbstractApplicationContext 的 registerBeanPostProcessors 方法
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 调用 PostProcessorRegistrationDelegate 的 registerBeanPostProcessors 方法注册 BeanPostProcessor
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
// 2、PostProcessorRegistrationDelegate 的 registerBeanPostProcessors 方法
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 从 BeanFactory 中获取类型是 BeanPostProcessor 所有的 beanName 数组
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;
// BeanFactory 中设置 BeanPostProcessorChecker
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 存储实现了 PriorityOrdered 的 BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 存储 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 存储实现了 Ordered 的 BeanPostProcessor
List<String> orderedPostProcessorNames = new ArrayList<>();
// 存储没有实现任何顺序的普通 BeanPostProcessor
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 实例化实现了 PriorityOrdered 的 BeanPostProcessor
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor 添加到 internalPostProcessors 列表中
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 实现了 PriorityOrdered 的 BeanPostProcessor 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 实现了 PriorityOrdered 的 BeanPostProcessor 注册到 BeanFactory 中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement 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);
// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
// 个人猜想这里将 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor 从实现顺序的 BeanPostProcessor 单独分开来主要是为了相同业务的归并，
// 换句话说就是 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor 有自己的业务逻辑实现
registerBeanPostProcessors(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).
// BeanFactory 中增加了 ApplicationListenerDetector
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
/**
* Register the given BeanPostProcessor beans.
*/
// 3、PostProcessorRegistrationDelegate 的 registerBeanPostProcessors
private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
for (BeanPostProcessor postProcessor : postProcessors) {
// 调用 AbstractBeanFactory 的 addBeanPostProcessor 方法添加 BeanPostProcessor
beanFactory.addBeanPostProcessor(postProcessor);
}
}
// 4、AbstractBeanFactory 的 addBeanPostProcessor 方法
@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
// Remove from old position, if any
// 移除已存在的 BeanPostProcessor，这里保证了 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor 重复注册
this.beanPostProcessors.remove(beanPostProcessor);
// Track whether it is instantiation/destruction aware
if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
// 存在 InstantiationAwareBeanPostProcessor 类型的 BeanPostProcessor 标识
this.hasInstantiationAwareBeanPostProcessors = true;
}
if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
// 存在 DestructionAwareBeanPostProcessor 类型的 BeanPostProcessor 标识
this.hasDestructionAwareBeanPostProcessors = true;
}
// Add to end of list
// BeanFactory 中添加 BeanPostProcessor，作为最后的顺序
this.beanPostProcessors.add(beanPostProcessor);
}BeanPostProcessor 与 BeanFactoryPostProcessor 的处理极为相似，但是有一些不一样的地方，通过比较我们发现，BeanFactoryPostProcessor 的处理分为两种情况，一种是通过硬编码方式的处理，另一种是通过配置文件方式的处理。那么为什么在 BeanPostProcessor 只有配置文件方式的处理而没有硬编码方式的处理呢？如果你有这个疑问就说明还没有完全理解两者实现的功能，如下所示：
BeanFactoryPostProcessor ： 对于 BeanFactoryPostProcessor 的处理不仅要实现注册功能，还要实现对后置处理器的激活操作，所以需要载入配置中的定义并进行激活，硬编码的方式实现的功能是将后置处理器注册并调用
BeanPostProcessor ： 只需要将配置文件中的 BeanPostProcessor 提取出来并注册到 BeanFactory 中就行了，并不需要马上调用
2.7 初始化消息资源（initMessageSource 方法）
这里先简单介绍一下背景：假设我们正在开发一个支持多国语言的WEB应用程序，要求系统能够根据客户端的系统的语言类型返回对应的界面。例如：英文操作返回英文界面，中文操作返回中文界面等——这便是典型的 il18 国际化问题。对于国际化的要求的应用系统，我们不能简单的采用硬编码的方式编写用户界面、报错信息等内容，而必须为这些需要国际化的信息进行特殊的处理。简单来说就是为每种语言提供一套相应的资源文件，并以规范化命名的方式保存在特定的目录中，由系统自动根据客户端语言选择适合的资源文件
Spring 中定义了访问国际化信息的 MessageSource 接口，并提供了AbstractApplicationContext、 ResourceBundleMessageSource 和 ReloadableResourceBundleMessageSource 等实现类，如下图所示：
其中重要的两个实现类便是 ResourceBundleMessageSource 和 ReloadableResourceBundleMessageSource，它们仅通过资源名来加载国际化资源，ReloadableResourceBundleMessageSource 还提供了定时刷新功能，允许在不重启系统的情况下，更新资源的信息
下面先看一个使用 ResourceBundleMessageSource 的 demo 例子：
ResourceBundleMessageSource 使用demo看过之后，相信你对消息资源有了一点了解，下面咱们看 initMessageSource 方法实现初始化消息资源的过程，源码如下：
/**
* Initialize the MessageSource.
* Use parent's if none defined in this context.
*/
// AbstractApplicationContext 的 initMessageSource 方法
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判断 BeanFactory 中是否包含名称为 messageSource 的 bean，这里要求了xml中必须配置资源的id值为 messageSource
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
// 实例化 MessageSource
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.
// HierarchicalMessageSource 类型的 MessageSource 不存在父类消息资源时，将国际父类消息资源设置为父类消息资源
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
// 没有配置 MessageSource，则使用默认的 DelegatingMessageSource 消息资源
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
// 将 DelegatingMessageSource 以单例模式注册到 BeanFactory 中
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}上述方法主要实现了以下逻辑：
1）、存在配置的 MessageSource 资源时（注意这里要求配置的 MessageSource 的id值一定要是 messageSource），实例化该 MessageSource
2）、如果不存在配置的 MessageSource 时，使用 DelegatingMessageSource 作为默认消息资源
2.8 初始化广播事件 ApplicationEventMulticaster（initApplicationEventMulticaster 方法）
ApplicationEventMulticaster 中主要是遍历注册的所有Spring事件监听器并执行，因此在学习初始化 ApplicationEventMulticaster 源码之前，我们先要学习怎么样注册一个自定义的Spring事件监听器，示例demo如下：
/**
* 自定义事件
*
* @date 2019-12-11 11:20
**/
public class MyEvent extends ApplicationEvent {
private String message;
/**
* Create a new {@code ApplicationEvent}.
*
* @param source the object on which the event initially occurred or with
* which the event is associated (never {@code null})
*/
public MyEvent(Object source) {
super(source);
}
public MyEvent(Object source, String message) {
super(source);
this.message = message;
}
public void printMsg(){
System.out.println( this.getSource() + "-----" + this.message);
}
}
/**
* 自定义事件监听器
*
* @date 2019-12-11 11:13
**/
public class MyApplicationListener implements ApplicationListener<MyEvent> {
@Override
public void onApplicationEvent(MyEvent event) {
event.printMsg();
}
}
了解了事件监听器用法之后，下面来看看 ApplicationEventMulticaster 是如何被初始化的，initApplicationEventMulticaster 方法源码如下：
/**
* Initialize the ApplicationEventMulticaster.
* Uses SimpleApplicationEventMulticaster if none defined in the context.
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
// AbstractApplicationContext 的 initApplicationEventMulticaster 方法
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判断 BeanFactory 中是否包含名称为 applicationEventMulticaster 的 bean，这里要求了xml中必须配置事件广播器的id值为 applicationEventMulticaster
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 实例化 applicationEventMulticaster 的 bean
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 没有配置 applicationEventMulticaster 时，使用默认的 SimpleApplicationEventMulticaster
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 将 SimpleApplicationEventMulticaster 以单例模式注册到 BeanFactory 中
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() + "]");
}
}
}注册好了广播事件 ApplicationEventMulticaster，Spring事件监听器在什么时候触发呢？Spring事件监听器的调用在默认广播事件 SimpleApplicationEventMulticaster 中，源码如下：
// 1、SimpleApplicationEventMulticaster 的 multicastEvent 方法
// 事件监听器的触发事件
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
Executor executor = getTaskExecutor();
// 遍历所有的事件监听器 ApplicationListener
for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
if (executor != null) {
// 如果使用了线程池，则使用多线程方式调用 ApplicationListener 的 onApplicationEvent 方法
executor.execute(() -> invokeListener(listener, event));
}
else {
// 如果没有使用线程池，则使用普通方式调用 ApplicationListener 的 onApplicationEvent 方法
invokeListener(listener, event);
}
}
}
// 2、SimpleApplicationEventMulticaster 的 invokeListener 方法
protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
ErrorHandler errorHandler = getErrorHandler();
if (errorHandler != null) {
// 配置了ErrorHandler，则使用 ErrorHandler 来处理调用 ApplicationListener 的 onApplicationEvent 方法异常
try {
// 真正调用 ApplicationListener 的方法
doInvokeListener(listener, event);
}
catch (Throwable err) {
errorHandler.handleError(err);
}
}
else {
// 真正调用 ApplicationListener 的方法
doInvokeListener(listener, event);
}
}
// 3、SimpleApplicationEventMulticaster 的 doInvokeListener 方法
@SuppressWarnings({"unchecked", "rawtypes"})
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
try {
// 调用 ApplicationListener 的 onApplicationEvent 方法触发监听事件
listener.onApplicationEvent(event);
}
catch (ClassCastException ex) {
String msg = ex.getMessage();
if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
// Possibly a lambda-defined listener which we could not resolve the generic event type for
// -> let's suppress the exception and just log a debug message.
Log logger = LogFactory.getLog(getClass());
if (logger.isDebugEnabled()) {
logger.debug("Non-matching event type for listener: " + listener, ex);
}
}
else {
throw ex;
}
}
}注册广播事件逻辑和调用事件监听器逻辑简单，看源码注释就可以理解了，这里不在做过多的赘述了
2.9 刷新上下文（onRefresh 方法），空实现
AbstractApplicationContext 的 onRefresh 方法是空实现，这里留给子类扩展实现自己的逻辑，例如初始化一些特殊的bean，源码如下：
/**
* Template method which can be overridden to add context-specific refresh work.
* Called on initialization of special beans, before instantiation of singletons.
* <p>This implementation is empty.
* @throws BeansException in case of errors
* @see #refresh()
*/
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}2.10 注册事件监听器（registerListeners 方法）
2.8 中初始化了广播事件 ApplicationEventMulticaster 后，就需要注册 Spring 事件监听器 ApplicationListener 了，注册入口在 AbstractApplicationContext 的 registerListeners 方法，源码如下：
/**
* Add beans that implement ApplicationListener as listeners.
* Doesn't affect other listeners, which can be added without being beans.
*/
// AbstractApplicationContext 的 registerListeners 方法
protected void registerListeners() {
// Register statically specified listeners first.
// 处理硬编码注册进来的 ApplicationListener 列表，注册入口在 AbstractApplicationContext 的 addApplicationListener 方法
for (ApplicationListener<?> listener : getApplicationListeners()) {
// 将 ApplicationListener 添加到广播事件 ApplicationEventMulticaster 中
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 配置文件中配置的 ApplicationListener，从 BeanFactory 中获取 ApplicationListener 类型的 beanNames 数组
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
// 将 ApplicationListener name 添加到广播事件 ApplicationEventMulticaster 中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// 发布早期的广播事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
// 广播事件器广播早期事件
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}registerListeners 方法主要实现了以下逻辑：
1）、先处理通过 AbstractApplicationContext 的 addApplicationListener 方法硬编码注册的 ApplicationListener，将其添加到 ApplicationEventMulticaster 中
2）、处理配置文件中配置的 ApplicationListener，将其 ApplicationListener beanName 添加到 ApplicationEventMulticaster 中
3）、使用广播事件器广播早期事件
2.11 完成所有剩下的非延迟加载的bean的实例化（finishBeanFactoryInitialization 方法）
ApplicationContext 实现的默认行为就是在启动的时候将所有单例 bean 提前进行实例化，提前实例化意味着作为初始化过程的一部分，ApplicationContext 实例会创建并配置所有的单例 bean。通常情况下这是一个好事，因为在这样的配置中的任何错误就会即刻被发现（否则的话可能要花几个小时甚至几天），而这个实例化的过程就是在 DefaultListableBeanFactory 的 preInstantiateSingletons 方法中完成的
完成 BeanFactory 的所有初始化工作，其中包括了 ConversionService 的设置、处理占位符解析器的设置，LoadTimeWeaverAware 实例化，配置冻结以及非延迟加载的 bean 的实例化工作，入口在 finishBeanFactoryInitiallization 方法，源码如下：
/**
* Finish the initialization of this context's bean factory,
* initializing all remaining singleton beans.
*/
// 1、AbstractApplicationContext 的 finishBeanFactoryInitialization 方法
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 处理 ConversionService 类型的 bean
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
// 实例化 ConversionService bean，设置到 BeanFactory 中
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
// 不存在像 PropertyPlaceholderConfigurer 这样的处理占位符的 bean，则在 BeanFactory 添加默认处理占位符的 StringValueResolver
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
// 实例化 LoadTimeWeaverAware 类型的 bean
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
// 停止使用临时的ClassLoader
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
// 这里冻结所有缓存的 BeanDefinition ，防止 bean 定义被修改，这里调用 DefaultListableBeanFactory 的 freezeConfiguration 方法
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化剩下的非延迟加载的单例bean，这里调用 DefaultListableBeanFactory 的 preInstantiateSingletons 方法
beanFactory.preInstantiateSingletons();
}
// 2、DefaultListableBeanFactory 的 freezeConfiguration 方法
@Override
public void freezeConfiguration() {
// 配置冻结标识
this.configurationFrozen = true;
// 将所有的 BeanDefinition 名称赋值给 frozenBeanDefinitionNames
this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}
// 3、DefaultListableBeanFactory 的 preInstantiateSingletons 方法
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
// 所有的 BeanDefinition 名称列表
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
// 获取顶级父类的 BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 顶级父类的 BeanDefinition 非抽象 && 单例 && 非延迟初始化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// FactoryBean 类型的 bean, 一般名称都是以"&"开头
if (isFactoryBean(beanName)) {
// 实例化 FactoryBean 类型的 bean，这里名字前加上"&"前缀
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
// SmartFactoryBean 类型的 bean && isEagerInit 方法返回是否需要尽早实例化
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
// 需要尽早实例化的bean，实例化该 bean
getBean(beanName);
}
}
}
else {
// 普通 bean 的实例化
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
// 为所有的实例化好之后的 SmartInitializingSingleton 类型的 bean 触发初始化后的后置处理
for (String beanName : beanNames) {
// 获取单例 bean 对象
Object singletonInstance = getSingleton(beanName);
// SmartInitializingSingleton 类型的 bean
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
// 触发实例化后的后置处理
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
// 触发实例化后的后置处理
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
上述代码主要实现了以下逻辑：
1）、 设置 ConversionService 、设置处理占位符解析器，LoadTimeWeaverAware 实例化，配置冻结
2）、实例化剩下的非延迟加载的所有bean
2.12 完成上下文刷新（finishRefresh 方法）
完成上下文刷新入口在 finishRefresh 方法，源码如下：
/**
* Finish the refresh of this context, invoking the LifecycleProcessor's
* onRefresh() method and publishing the
* {@link org.springframework.context.event.ContextRefreshedEvent}.
*/
// AbstractApplicationContext 的 finishRefresh 方法
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
// 清除所有的资源缓存
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 初始化生命周期处理器 LifecycleProcessor，默认的是 DefaultLifecycleProcessor
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 启动所有实现了 Lifecycle 接口的bean，即调用这些 bean 的 start 方法
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 发布所有注册的事件监听器 ApplicationListener
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
// 如果配置了spring.liveBeansView.mbeanDomain 属性，则将上下文注册到 MBeanServer 中
LiveBeansView.registerApplicationContext(this);
}finishRefresh 方法实现了以下逻辑：
1）、清除所有的资源缓存
2）、初始化生命周期处理器 LifecycleProcessor，默认的是 DefaultLifecycleProcessor
3）、启动所有实现了 Lifecycle 接口的bean，即调用这些 bean 的 start 方法
4）、发布所有注册的事件监听器 ApplicationListener
5）、如果配置了spring.liveBeansView.mbeanDomain 属性，则将上下文注册到 MBeanServer 中
其中 2、3、4 是重点部分，下面分别对这三部分进行源码分析
2.12.1 初始化生命周期处理器 LifecycleProcessor（initLifecycleProcessor 方法）
Spring 中有一个重要的功能就是管理 Spring 组件的生命周期，Spring 提供了 Lifecycle 接口，Lifecycle 中包含了 start、stop 和 isRunning 三个方法，实现此接口后 Spring 会保证在启动的时候调用其 start 方法开始生命周期，并在 Spring 关闭的时候调用其 stop 方法来结束生命周期，通常用来配置后台程序，在启动后一直运行（如对 MQ 进行轮询等），而在 ApplicationContext 的完成刷新部分实现了这一功能。
当 ApplicationContext 启动或者停止时，它会通过 LifecycleProcessor 来与所有声明的 bean 的周期做状态更新，而在 LifecycleProcessor 的使用前必须先实例化，源码如下：
/**
* Initialize the LifecycleProcessor.
* Uses DefaultLifecycleProcessor if none defined in the context.
* @see org.springframework.context.support.DefaultLifecycleProcessor
*/
// AbstractApplicationContext 的 initLifecycleProcessor 方法
protected void initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
// 存在 lifecycleProcessor 名称的 LifecycleProcessor
// 实例化 LifecycleProcessor
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
if (logger.isTraceEnabled()) {
logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
else {
// BeanFactory 中不存在 LifecycleProcessor，则使用默认的 DefaultLifecycleProcessor
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
// DefaultLifecycleProcessor 以单例模式注册到 BeanFactory 中
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
if (logger.isTraceEnabled()) {
logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
}
}
}2.12.2 启动所有实现了 Lifecycle 接口的bean（DefaultLifecycleProcessor 的 onRefresh 方法）
当 LifecycleProcessor 初始化之后就会调用 LifecycleProcessor 的 onRefresh 方法启动所有实现了 Lifecycle 接口的bean（Spring组件），这里以默认的 DefaultLifecycleProcessor 为例，整个过程源码如下：
// 1、DefaultLifecycleProcessor 的 onRefresh 方法
@Override
public void onRefresh() {
// 调用 DefaultLifecycleProcessor 的 startBeans 方法启动 bean
startBeans(true);
this.running = true;
}
// 2、DefaultLifecycleProcessor 的 startBeans 方法
private void startBeans(boolean autoStartupOnly) {
// 获取所有实现了 Lifecycle 接口的bean
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<>();
lifecycleBeans.forEach((beanName, bean) -> {
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
// 根据bean的生命周期阶段来分组
int phase = getPhase(bean);
LifecycleGroup group = phases.get(phase);
if (group == null) {
group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
phases.put(phase, group);
}
group.add(beanName, bean);
}
});
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<>(phases.keySet());
// 按照生命周期阶段排序
Collections.sort(keys);
for (Integer key : keys) {
// 按照分组来启动bean
phases.get(key).start();
}
}
}
// 3、DefaultLifecycleProcessor 的内部类 LifecycleGroup 的 start 方法
public void start() {
if (this.members.isEmpty()) {
return;
}
if (logger.isDebugEnabled()) {
logger.debug("Starting beans in phase " + this.phase);
}
Collections.sort(this.members);
for (LifecycleGroupMember member : this.members) {
// 调用 doStart 方法启动bean
doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
}
}
// 4、DefaultLifecycleProcessor 的 doStart 方法
private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
// 移除马上要被处理的bean
Lifecycle bean = lifecycleBeans.remove(beanName);
if (bean != null && bean != this) {
// 获取bean的所有依赖bean
String[] dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName);
for (String dependency : dependenciesForBean) {
// 递归处理启动bean
doStart(lifecycleBeans, dependency, autoStartupOnly);
}
if (!bean.isRunning() &&
(!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
if (logger.isTraceEnabled()) {
logger.trace("Starting bean '" + beanName + "' of type [" + bean.getClass().getName() + "]");
}
try {
// bean 没有处于 running 状态，调用具体 bean 的 start 方法
bean.start();
}
catch (Throwable ex) {
throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
}
if (logger.isDebugEnabled()) {
logger.debug("Successfully started bean '" + beanName + "'");
}
}
}
}2.12.3 发布所有注册的事件监听器 ApplicationListener（publishEvent 方法）
当完成 ApplicationContext 的初始化的时候，要通过 Spring 中的事件发布机制来发出 ContextRefreshedEvent 事件，以保证对应的所有事件监听器触发，源码过程如下：
/**
* Publish the given event to all listeners.
* @param event the event to publish (may be an {@link ApplicationEvent}
* or a payload object to be turned into a {@link PayloadApplicationEvent})
* @param eventType the resolved event type, if known
* @since 4.2
*/
// AbstractApplicationContext 的 publishEvent 方法
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
Assert.notNull(event, "Event must not be null");
// Decorate event as an ApplicationEvent if necessary
// ContextRefreshedEvent 继承了 ApplicationEvent，是 ApplicationEvent 类型
ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent) {
applicationEvent = (ApplicationEvent) event;
}
else {
// 其他类型的 ApplicationEvent
applicationEvent = new PayloadApplicationEvent<>(this, event);
if (eventType == null) {
eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
}
}
// Multicast right now if possible - or lazily once the multicaster is initialized
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
else {
// 调用广播事件器发布广播事件，即调用注册的所有事件监听器 ApplicationListener 的触发方法 onApplicationEvent
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// Publish event via parent context as well...
// 如果父类存在的话，父类也需要发布广播事件
if (this.parent != null) {
if (this.parent instanceof AbstractApplicationContext) {
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
this.parent.publishEvent(event);
}
}
}三、总结
ApplicationContext 的 refresh 方法可以说是 Spring 容器的核心方法，经过此方法之后，Spring 不仅完成了所有 bean 的加载，还发布了广播事件，完成了所有注册的事件监听器的触发，这部分是 Spring 的重中之重，在这个过程中我们学习到了很多的扩展点，如下所示：
1）、实现 BeanDefinitionRegistryPostProcessor（postProcessBeanDefinitionRegistry 方法），可以将自己的bean注册到 BeanFactory 中，交给 Spring 容器管理
2）、实现 BeanPostProcessor（postProcessBeforeInitialization 和 postProcessAfterInitialization 方法） ，实现 bean 初始化的前后置处理
3）、实现 InitializingBean（afterPropertiesSet 方法），实现 bean 初始化之后的处理
4）、实现 BeanFactoryPostProcessor（postProcessBeanFactory 方法），实现对 BeanFactory 的扩展
5）、实现 InstantiationAwareBeanPostProcessor（postProcessBeforeInstantiation、 postProcessAfterInstantiation 和 postProcessProperties），实现 bean 的实例化前后置和属性填充时的处理
6）、实现 XXXAware（setXXX 方法） ，Spring 容器自动实现对 XXX 对象的设置，以便获取 XXX 对象使用
7）、实现 ApplicationListener（onApplicationEvent 方法），实现事件监听逻辑处理
8）、重写 AbstractApplicationContext 的 postProcessBeanFactory 方法，实现对 BeanFactory 的扩展
9）、重写 AbstractApplicationContext 的 onRefresh 方法，实现初始化一些特殊的bean等业务
Spring 框架最大的可取之处就是扩展性做的特别好，希望大家好好调试源码理解学习，如有不正之处请指正，谢谢