本文主要讲述 applicationcontext的refresh方法。
在上一篇说了在applicationcontext的预处理阶段之后，开始对其进行刷新工作。
这里把我们的applicationcontext转成了 AbstractApplicationContext ，并调用了其refresh方法。
public void refresh() throws BeansException, IllegalStateException {
# 整个方法被一个synchronized 包裹住了，保证了线程安全。
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
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();
}
}
}
1. prepareRefresh（）
这里又是对applicationcontext的预处理工作。之前在那个run方法里已经有一个预处理的过程了，只不过那个是
prepareContext，那个时候是对applicationcontext设置了environment，注册了一些必要的单实例bean，做了一些applicationcontext的初始化工作，触发监听器等。而这里是applicationcontext的prepareRefresh，做了一些预刷新工作。（也就是说之前是在applicationcontext类的外部前后做了一些处理，这里是其内部做的一些处理）。
/**
* Prepare this context for refreshing, setting its startup date and
* active flag as well as performing any initialization of property sources.
* 注释说的很清楚了
*/
protected void prepareRefresh() {
# 设置启动日期
this.startupDate = System.currentTimeMillis();
# 设置状态
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) { # 打印
logger.info("Refreshing " + this);
}
// Initialize any placeholder property sources in the context environment
# 这里面默认什么也没做，空方法，留作扩展用
initPropertySources();
// Validate that all properties marked as required are resolvable
// see ConfigurablePropertyResolver#setRequiredProperties
# 这里是对environment里的属性进行了验证
getEnvironment().validateRequiredProperties();
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
# 继续，还是赋值操作
this.earlyApplicationEvents = new LinkedHashSet<>();
}
2.ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
这里注释为告知子类刷新其内部 的beanfactory，然后获取了当前的applicationcontext的beanfactory，并返回回去。
是一个 ConfigurableListableBeanFactory
3. prepareBeanFactory(beanFactory); 对这个beanfactory做了一些预处理工作。
这里也是为beanfactory的一些属性设置值，比如设置classloader，后置处理器（post-processors）等。
4. postProcessBeanFactory(beanFactory);
这里对beanfactory做了一些后置处理
比如我们使用了springmvc，会有子容器，对子容器做了一些工作等。
5. invokeBeanFactoryPostProcessors(beanFactory);
这里开始调用了beanfactory的后置处理器
按照指定的顺序实例化并且调用所有的beanfactorypostprocesser。
6. registerBeanPostProcessors(beanFactory);
这里开始注册bean的后置处理器，它的作用是拦截bean的创建，会生成bean的代理对象来代替。（spring aop）
和beanfactorypostprocesser类似，，这里按照指定的顺序实例化并且调用所有的beanpostprocesser。
7. initMessageSource();
这里就是初始化了一些messagesources，注册一些bean。
8. initApplicationEventMulticaster
初始化事件的多播器，用于在applicationcontext中广播事件。
9. onRefresh
在这里会初始化子容器的一些bean，，比如springmvc内的bean
这个是springmvc中的applicationcontext（ org.springframework.web.context.support.GenericWebApplicationContext ）
10. registerListeners
注册了其他的我们自己实现的applicationlistener
/**
* Add beans that implement ApplicationListener as listeners.
* Doesn't affect other listeners, which can be added without being beans.
*/
protected void registerListeners() {
// Register statically specified listeners first.
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
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);
}
}
}
11 . finishBeanFactoryInitialization
这里最后实例化剩下的单实例的bean
/**
* Finish the initialization of this context's bean factory,
* initializing all remaining singleton beans.
*/
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));
}
// 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()) {
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) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
12. finishRefresh 完成applicationcontext的刷新工作
/**
* Finish the refresh of this context, invoking the LifecycleProcessor's
* onRefresh() method and publishing the
* {@link org.springframework.context.event.ContextRefreshedEvent}.
*/
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
# 清空一些缓存
clearResourceCaches();
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
// Publish the final event.
# 发布applicationcontext刷新完成的事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
到这里我们的applicationcontext就完成了刷新工作，spring对bean（包括factorybean）划分成了各个阶段（也就是bean生命周期，包括bean信息的定义，bean对应的class的加载，实例化前后（是否需要生成其代理对象，aop，事务等功能），初始化阶段（属性赋值）前后，以及最后的销毁阶段），让我们更方便的去对bean做处理，使用上也更加灵活，也方便于对其他框架的整合，使用。