一:Spring源码之IOC
一、refresh()方法
使用模板方法模式定义的一个顶级抽象父类,方法具体实现延迟到子类 ,每一个方法都是一个钩子,可以被子类重写。
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// ② IOC初始化前的装备(配置环境参数、创建监听器、事件容器)
prepareRefresh();
// ③ 这里可以分为两类: // GenericApplicationContext: 仅仅是控制beanfactory不能重复refresh // AbstractRefreshableApplicationContext:允许重复refresh,销毁就beanfactory,创建新beanfactory并且重新扫描生成beanDefinitionMap容器。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// ④ 设置beanfactory的一些属性(bean的类加载器、忽略接口、BeanPostProcessor、环境参数单例注册到beanfactory单例容器中)
prepareBeanFactory(beanFactory);
try {
// ⑤空方法,留由子类实现。 //例如注册servlet相关的忽略接口、beanPostProcessor、各作用域生成bean的bean工厂 //注册servlet的一些单例(servletContext/servletConfig/contextparameters/contextAttributes)到beanfactory的单例容器中
postProcessBeanFactory(beanFactory);
// ⑥beanFactoryPostProcessor排序并依次调用 // beanFactoryPostProcessor:beanfactory的后置处理器,可以理解为一个beanfactory的拦截器(实例化后需要执行的自定义操作) // 例如:beanfactory初始化完成后,修改忽略接口、甚至可以对特定的beandefinition做修改
invokeBeanFactoryPostProcessors(beanFactory);
// ⑦BeanPostProcessors排序并依次注册到beanfactory的beanpostProcessor容器中 // beanPostProcessors:bean实例化的处理器,可以理解为一个bean的拦截器(实例化前+实例化后需要执行自定义操作) // 例如:bean单例化前,修改beandefinition的属性。 //实例化后DI, //拦截getbean()拦截返回一个代理类bean
registerBeanPostProcessors(beanFactory);
// ⑧初始化国际化文件,支持国际化
initMessageSource();
// ⑨初始化时间监听器并注册到beanfactory的单例容器中
initApplicationEventMulticaster();
// ⑩空方法,子类实现,初始化一些自定义bean并注册到beanfactory的单例容器中 // 例如:themeSource,支持主题切换
onRefresh();
// ⑪注册个中监听器到beanfactory指定容器中
registerListeners();
// ⑫实例化不需要延迟加载的所有单例类型的bean(scope = singleton)
finishBeanFactoryInitialization(beanFactory);
// ⑬容器初始化完成,触发各种事件监控,ApplicationListener.onApplicationEvent()的执行时机(dubbo注册就是在这里实现的) // 例如:beanfactory的生命周期监控
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// ⑭ 容器初始化失败,销毁所有已实例化的bean
destroyBeans();
// ⑮ 设置active = false
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// ⑯ 清空公共的反射缓存
resetCommonCaches();
}
}
}
① 加锁:也是SpringIOC中主要加锁方式
private final Object startupShutdownMonitor = new Object();
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
...
}
}
利用synchronized实现的一个细粒度锁。拥有ReentranLock.lock()的细粒度,还不用释放unlock()。
② prepareRefresh():IOC容器初始化之前的准备(配置环境参数,创建监听器容器,创建事件容器)
protected void prepareRefresh() {
// 容器开始时间+容器关闭开启状态
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
//初始化IOC容器的一些环境参数,默认空方法,子类可重写
//这里可以先创建一个标准环境变量StandardEnvironment,然后设置一些环境参数
//并且指定一些必须配置的参数
initPropertySources();
//若未创建,则创建一个标准环境变量StandardEnvironment
//校验上面指定的必须配置的参数是否已经配置,没有配置会抛出异常
getEnvironment().validateRequiredProperties();
// 配置一些refresh()之前的监听器
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);
}
//创建是一个事件集合
this.earlyApplicationEvents = new LinkedHashSet<>();
}
③ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory():控制refresh调用次数。
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//抽象方法,控制IOC容器的refresh()次数
//仅允许refresh()一次,再次刷新会报错:GenericApplicationContext.java
//允许重复刷新():AbstractRefreshableApplicationContext.java , //刷新逻辑是销毁旧beanfactory,实例化一个新的beanfactory;当然没有旧beanfactory这里会直接实例化一个beanfactory //并且重新扫描生成beanDefinitionMap容器
refreshBeanFactory();
//抽象方法
//返回容器类ApplicationContext创建时创建的DefaultListableBeanFactory实例
return getBeanFactory();
}
/* org/springframework/context/support/AbstractRefreshableApplicationContext.java:129 */
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
//允许重复刷新,销毁旧beanfactory
destroyBeans();
closeBeanFactory();
}
try {
//创建新的beanfactory
//传统的基于xml解析的ApplicationContext,例如spring2.x经常拿来学习的ClassPathXmlApplitionContext.java
//beanfactory是在这里实例化的,而不是在applicationContext的构造方法中
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
//重新扫描生成beandefinitionMap容器
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
④prepareBeanFactory(beanFactory):设置DefaultListableBeanFactory实例的属性(类加载器,忽略接口,BeanPostProcessor,将环境变量单例注册到beanfactory中)
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
//设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
//设置BeanPostProcessor(后置处理器)
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置需要忽略的接口,这些接口的实现类不会被IOC容器实例化
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接口不能注册为一个简单工厂的解析类型
//自动转配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后置处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
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()));
}
//将环境单例StandardEnvironment注册到beanfactory单例容器中
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());
}
}
⑤postProcessBeanFactory(beanFactory):抽象方法,子类具体实现
选取AnnotationConfigApplication的父类GenericWebApplicationContext:
将serlvet相关的后置处理器、作用域类型、servlet的bean的创建工厂设置到beanfactory中
将serlvet的servletContext、servletConfig、contextParameters、contexAttributes注册到beanfactory的单例容器中
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
if (this.servletContext != null) {
//注册servletContext相关处理器
//忽略servletContext相关的接口
beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
}
//注册beanfactory的servlet的三个作用域实例,并指定servlet相关类型的bean的创建工厂
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
//servletContex、servletConfig、contextParameters、contextAttributes实例注册到beanfactory的单例容器中
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
}
/* WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext); */
public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory,
@Nullable ServletContext sc) {
//注册servlet作用域 request session
//request:一个请求创建一个request
//session:一次会话创建一个session
beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
if (sc != null) {
//注册servlet作用域 application
//application:所有用户共享
ServletContextScope appScope = new ServletContextScope(sc);
beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
// Register as ServletContext attribute, for ContextCleanupListener to detect it.
sc.setAttribute(ServletContextScope.class.getName(), appScope);
}
//注册对应类型的实例工厂
beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
if (jsfPresent) {
FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
}
}
/* WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext); */
public static void registerEnvironmentBeans(ConfigurableListableBeanFactory bf,
@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {
//将servletContext实例注册到beanfactory单例容器中
if (servletContext != null && !bf.containsBean(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME)) {
bf.registerSingleton(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME, servletContext);
}
//将servletConfig实例注册到beanfactory单例容器中
if (servletConfig != null && !bf.containsBean(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME)) {
bf.registerSingleton(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME, servletConfig);
}
//将contextParameters转化成一个Map注册到beanfactory的单例容器中
if (!bf.containsBean(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME)) {
Map<String, String> parameterMap = new HashMap<>();
if (servletContext != null) {
Enumeration<?> paramNameEnum = servletContext.getInitParameterNames();
while (paramNameEnum.hasMoreElements()) {
String paramName = (String) paramNameEnum.nextElement();
parameterMap.put(paramName, servletContext.getInitParameter(paramName));
}
}
if (servletConfig != null) {
Enumeration<?> paramNameEnum = servletConfig.getInitParameterNames();
while (paramNameEnum.hasMoreElements()) {
String paramName = (String) paramNameEnum.nextElement();
parameterMap.put(paramName, servletConfig.getInitParameter(paramName));
}
}
bf.registerSingleton(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME,
Collections.unmodifiableMap(parameterMap));
}
//将contextAttributes转化成Map注册到beanfactory的单例容器中
if (!bf.containsBean(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME)) {
Map<String, Object> attributeMap = new HashMap<>();
if (servletContext != null) {
Enumeration<?> attrNameEnum = servletContext.getAttributeNames();
while (attrNameEnum.hasMoreElements()) {
String attrName = (String) attrNameEnum.nextElement();
attributeMap.put(attrName, servletContext.getAttribute(attrName));
}
}
bf.registerSingleton(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME,
Collections.unmodifiableMap(attributeMap));
}
}
⑥ invokeBeanFactoryPostProcessors(beanFactory):需要与上面的BeanPostProcessors区分开,主要是区分两类PostProcessor,然后对bean相关的postjProcessor实例按照优先级排序,按照优先级顺序调用。
BeanPostProcessors:处理特定的bean的后置处理器,(bean实例化的拦截器)
BeanFactoryPostProcessors:处理beanfactory下所有bean的后置处理器
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//这个方法很长有点复杂
//1、具体beanfactory中后置处理器beanFactoryPostProcessor分为两类
//①bean注册相关的后置处理器:BeanDefinitionRegistryPostProcessors
//②普通后置处理器
//2、将上面①中后置处理器按照优先级逐一调用
//①实现PriorityOrdered接口的
//②实现Ordered接口的
//③其他BeanDefinitionRegistryPostProcessors
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)
//目前还不清楚loadTimeWeaver的作用
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
⑦ registerBeanPostProcessors(beanFactory):其实内容跟上面⑥差不多,只是处理对象不同了。beanPostProcessor实例按照优先级顺序注册到beanfactory的beanpostprocessor容器中。
a 实现PriorityOrdered接口的
b 实现Ordered接口的,未实现MergedBeanDefinitionPostProcessor接口的
c 剩下的未实现MergedBeanDefinitionPostProcessor接口的
d 实现MergedBeanDefinitionPostProcessor接口的
e 提供一个末位动态注册器,可从bean单例中拉取监听器到末尾
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
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.
//获取所有beanProcessor,并注册一个记录beanProcessor数量的BeanPostProcessor
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 将beanPostProcessor区分为四类类然后按此顺序注册到beanfactory中
// 实现PriorityOrdered接口的
// 实现Ordered接口的,未实现MergedBeanDefinitionPostProcessor接口的
// 剩下的未实现MergedBeanDefinitionPostProcessor接口的
// 实现MergedBeanDefinitionPostProcessor接口的
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
//将实现PriorityOrdered接口的先排序,后注册
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
//将实现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.
//将实现MergedBeanDefinitionPostProcessor接口重新注册(原来注册过的会删除后,再注册,所以优先级比上面三种低)
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 注册一个末尾的处理器,可以实现,动态将bean单例中的applicationContextListener注册到末尾(优先级最低)
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
⑧ initMessageSource():国际化支持,注册一个new DelegatingMessageSource()到beanfactory的单例容器中,支持继承关系
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//国际化支持,支持继承关系
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
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 {
// Use empty MessageSource to be able to accept getMessage calls.
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
⑨ initApplicationEventMulticaster():注册一个applicationEvent多路广播器到beanfactory的单例容器中
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 初始化一个applicationEvent多路广播,具体作用未知
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
this.applicationEventMulticaster = new 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() + "]");
}
}
}
⑩ onrefresh():空方法,初始化一些特殊的bean。
AnnotationConfigApplicationContext:创建themeSource,主题资源注册
protected void onRefresh() {
this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
public static ThemeSource initThemeSource(ApplicationContext context) {
if (context.containsLocalBean(THEME_SOURCE_BEAN_NAME)) {
ThemeSource themeSource = context.getBean(THEME_SOURCE_BEAN_NAME, ThemeSource.class);
// Make ThemeSource aware of parent ThemeSource.
if (context.getParent() instanceof ThemeSource && themeSource instanceof HierarchicalThemeSource) {
HierarchicalThemeSource hts = (HierarchicalThemeSource) themeSource;
if (hts.getParentThemeSource() == null) {
// Only set parent context as parent ThemeSource if no parent ThemeSource
// registered already.
hts.setParentThemeSource((ThemeSource) context.getParent());
}
}
if (logger.isDebugEnabled()) {
logger.debug("Using ThemeSource [" + themeSource + "]");
}
return themeSource;
}
else {
// Use default ThemeSource to be able to accept getTheme calls, either
// delegating to parent context's default or to local ResourceBundleThemeSource.
HierarchicalThemeSource themeSource = null;
if (context.getParent() instanceof ThemeSource) {
themeSource = new DelegatingThemeSource();
themeSource.setParentThemeSource((ThemeSource) context.getParent());
}
else {
themeSource = new ResourceBundleThemeSource();
}
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ThemeSource with name '" + THEME_SOURCE_BEAN_NAME +
"': using default [" + themeSource + "]");
}
return themeSource;
}
}
⑪registerListeners():将各种监听器放入到对应的容器中
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);
}
}
}
⑫finishBeanFactoryInitialization(beanFactory):bean实例化,单独开一章研究
⑬finishRefresh();refresh结束,推送相关事件
protected void finishRefresh() {
//清空资源缓存
clearResourceCaches();
// 初始化容器的生命周期处理器
initLifecycleProcessor();
// 将refresh推送给生命周期处理器
getLifecycleProcessor().onRefresh();
// 监听器执行,ApplicationListener.onApplicationEvent()
publishEvent(new ContextRefreshedEvent(this));
// 注册容器到LiveBeansView中,由LiveBeansView监控容器?
LiveBeansView.registerApplicationContext(this);
}
⑭destroyBeans():refresh失败时,删除已经创建的单例bean
⑮cancelRefresh(ex);refresh失败时,设置active标志=false
⑯resetCommonCaches();清空公共反射缓存
protected void resetCommonCaches() {
ReflectionUtils.clearCache();
AnnotationUtils.clearCache();
ResolvableType.clearCache();
CachedIntrospectionResults.clearClassLoader(getClassLoader());
}