一、概述
1.Spring Context概念
创建上下文并将BeanPostProcessor加载到spring
2.Spring Application Context概念
Spring通过应用上下文（Application Context）装载bean的定义并把它们组装起来。Spring应用上下文全权负责对象的创建和组装。
3. 关系
（1）Spring Context 模块核心是Spring Context
（2）Spring Context 核心是Spring Application Context
（3）Spring Application Context 的核心方法是 AbstractApplicationContext
二、AbstractApplicationContext之刷新源码分析
1. 基础源码
高效记忆：Spring应用文刷新 --- 刷机
（1）手机系统太卡了于是自己刷机。首先 准备刷机环境 （准备刷新上下文环境），准备好后老系统 初始化并加载 定义信息（初始化BeanFactory，并加载bean definitions信息）
（2）然后进行系统 配置 并（对beanFacotry进行配置）开始系统 激活 并提交过程（激活BeanFactoryPostProcessors）
（3）再进行验证码 注册 并提交过程（注册BeanPostProcessors），注册后新系统 初始化信息资源、广播 且注册监听器（初始化MessageSource、初始化事件广播器、注册事件监听器）
（4）最后系统 热加载弹粒 并（构造热加载单例bean）完成刷机 （完成刷新过程,通知生命周期处理器），如果刷机 错误 就 销户并修改 激活标识（销毁bean、修改active标识）
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh(); // #1 准备刷新上下文环境
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // #2 初始化BeanFactory，并加载bean definitions信息
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory); // #3 对beanFacotry进行配置
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory); // #4 提供给子类扩展的预留方法
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory); // #5 激活BeanFactoryPostProcessors
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory); // #6 注册BeanPostProcessors
// Initialize message source for this context.
initMessageSource(); // #7 初始化MessageSource
// Initialize event multicaster for this context.
initApplicationEventMulticaster(); // #8 初始化事件广播器
// Initialize other special beans in specific context subclasses.
onRefresh(); // #9 提供给子类初始化其他的Bean
// Check for listener beans and register them.
registerListeners(); // #10 注册事件监听器
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory); // #11 构造热加载单例bean
// Last step: publish corresponding event.
finishRefresh(); // #12 完成刷新过程,通知生命周期处理器
}
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(); // #13 出错了，销毁bean
// Reset 'active' flag.
cancelRefresh(ex); // #14 出错了，修改active标识
// 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();
}
}
}
2.初始化并加载 obtainFreshBeanFactory
AbstractApplicationContext---obtainFreshBeanFactory ----> AbstractRefreshableApplicationContext---refreshBeanFactory
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) { // #1 如果已存在BeanFactory，销毁原来的BeanFactory
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory(); // #2 创建DefaultListableBeanFactory
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
// #3 加载bean definitions信息，loadBeanDefinitions是抽象方法，不同实现类会从不同的配置中获取bean definitions信息，
// 如AnnotationConfigWebApplicationContext，XmlWebApplicationContext。
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.激活 BeanFactoryPostProcessors
（1）BeanFactoryPostProcessor是spring提供的扩展接口，可以通过BeanFactoryPostProcessor对beanFactory进行自定义处理，如修改其他BeanDefinition的配置。
（2）BeanFactoryPostProcessor可以调整beanFactory，甚至修改BeanDefinition，如CustomEditorConfigurer，将用户定义的PropertyEditor注册到beanFactory中，以便后续使用。
（3）BeanDefinitionRegistryPostProcessor可以注册新的BeanDefinition，如ConfigurationClassPostProcessor，是实现springboot很关键的类
AbstractApplicationContext---invokeBeanFactoryPostProcessors ----> PostProcessorRegistrationDelegate---invokeBeanFactoryPostProcessors
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {
Set processedBeans = new HashSet();
// #1 如果beanFactory是BeanDefinitionRegistry，需要处理BeanFactoryPostProcessors，
// BeanDefinitionRegistryPostProcessor，否则只处理BeanFactoryPostProcessors
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List regularPostProcessors = new LinkedList();
List registryPostProcessors =
new LinkedList();
// #2 方法参数beanFactoryPostProcessors是AbstractApplicationContext---beanFactoryPostProcessors属性，
// 用户可以通过AbstractApplicationContext---addBeanFactoryPostProcessor方法添加BeanFactoryPostProcessor。这里对beanFactoryPostProcessors参数进行分类
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryPostProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
registryPostProcessors.add(registryPostProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// #3 获取beanFactory已经存在的BeanDefinitionRegistryPostProcessor，这里并没有直接构建BeanDefinitionRegistryPostProcessor，而且通过beanName获取
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
List priorityOrderedPostProcessors = new ArrayList();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// #4 获取实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor，添加到priorityOrderedPostProcessors
processedBeans.add(ppName);
}
}
// #5 对priorityOrderedPostProcessors排序
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
// #6 排序结果添加到registryPostProcessors
registryPostProcessors.addAll(priorityOrderedPostProcessors);
// #7 调用BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
List orderedPostProcessors = new ArrayList();
for (String ppName : postProcessorNames) {
// #8 处理实现了Ordered的BeanDefinitionRegistryPostProcessor
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(beanFactory, orderedPostProcessors);
registryPostProcessors.addAll(orderedPostProcessors);
invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// #9 处理剩余的BeanDefinitionRegistryPostProcessor
if (!processedBeans.contains(ppName)) {
BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
registryPostProcessors.add(pp);
processedBeans.add(ppName);
pp.postProcessBeanDefinitionRegistry(registry);
reiterate = true;
}
}
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
...
}
4.初始化事件广播 initApplicationEventMulticaster
4.1 Spring事件体系包括三个组件：
ApplicationEvent事件，ApplicationListener事件监听器，ApplicationEventMulticaster事件广播器。
4.2 事件广播器负责管理事件监听器，并将事件广播给监听器。
AbstractApplicationContext --- initApplicationEventMulticaster
rotected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class); //#1 使用用户定义的事件广播器
if (logger.isDebugEnabled()) {
logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster); //#2 使用默认的事件广播器
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
"': using default [" + this.applicationEventMulticaster + "]");
}
}
}
4.3 spring事件
（1）spring提供了context start，stop，close，refresh等事件，ApplicationListener --- onApplicationEvent负责处理spring中的事件。
（2）我们可以通过实现ApplicationListener接口自行处理事件，也可以通过PublishListener自定义事件监听器。
使用默认的事件广播器 AbstractApplicationContexton --- publishEvent ----> SimpleApplicationEventMulticaster --- multicastEvent
public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
for (final ApplicationListener listener : getApplicationListeners(event, type)) {
Executor executor = getTaskExecutor(); // #1 如果配置了Executor，使用Executor多线程处理
if (executor != null) {
executor.execute(new Runnable() {
public void run() {
invokeListener(listener, event);
}
});
}
else {
invokeListener(listener, event); // #2 否则单线程处理
}
}
}
5.注册事件监听器
AbstractApplicationContext --- registerListeners将初始化事件监听器ApplicationListener，并绑定到事件广播器上。
protected void registerListeners() {
for (ApplicationListener listener : getApplicationListeners()) { // #1 getApplicationListeners()获取的是AbstractApplicationContext --- applicationListeners，用户可以通过AbstractApplicationContext --- addApplicationListener添加事件监听器
将AbstractApplicationContext#applicationListeners注册到applicationEventMulticaster
getApplicationEventMulticaster().addApplicationListener(listener);
}
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false); // #2 将上下文中的ApplicationListener注册到applicationEventMulticaster
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
Set earlyEventsToProcess = this.earlyApplicationEvents; // #3 发布在此之前已发生的事件
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
6.构造热加载单例bean
AbstractApplicationContext --- finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); //#1 初始化ConversionService，后面注入属性要使用
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() { //#2 初始化StringValueResolver，用于解析bean属性引用的properties配置
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); //#3 初始化LoadTimeWeaverAware
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
beanFactory.setTempClassLoader(null);
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons(); //#4 构造热加载单例bean
}
AbstractApplicationContext --- preInstantiateSingletons
public void preInstantiateSingletons() throws BeansException {
...
List beanNames = new ArrayList(this.beanDefinitionNames);
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { // #1 判断是否为非抽象类的热加载单例bean
if (isFactoryBean(beanName)) {
final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
@Override
public Boolean run() {
return ((SmartFactoryBean) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
getBean(beanName); // #2 构造bean：如果非FactoryBean，构造bean。如果FactoryBean并且FactoryBean.isEagerInit为true，构造bean。
}
}
}
...
}
7. 完成刷新 finishRefresh
LifecycleProcessor也是spring提供的扩展点， 通过它可以在spring content start，stop，onRefresh等时刻自定义一些额外操作
protected void finishRefresh() {
// Initialize lifecycle processor for this context.
initLifecycleProcessor(); // #1 初始化LifecycleProcessor
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh(); // #2 调用LifecycleProcessor#onRefresh()方法
// Publish the final event.
publishEvent(new ContextRefreshedEvent(this)); // #3 发布事件
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
随心所往，看见未来。Follow your heart，see night！
*欢迎点赞、关注、留言，收藏及转发，一起学习、交流！