/*
* 基于Spring6.2.0版本
* Copyright 2002-2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.context.support;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.CachedIntrospectionResults;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.support.ResourceEditorRegistrar;
import org.springframework.context.*;
import org.springframework.context.event.*;
import org.springframework.context.expression.StandardBeanExpressionResolver;
import org.springframework.context.weaving.LoadTimeWeaverAware;
import org.springframework.context.weaving.LoadTimeWeaverAwareProcessor;
import org.springframework.core.NativeDetector;
import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.metrics.ApplicationStartup;
import org.springframework.core.metrics.StartupStep;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* {@link org.springframework.context.ApplicationContext} 接口的抽象实现。
* 不强制要求用于配置的存储类型;仅实现常见的上下文功能。使用模板方法设计模式,要求具体的子类实现抽象方法。
* 与普通的 BeanFactory 相比,ApplicationContext 应该能够检测到其内部 bean 工厂中定义的特殊 bean:
* 因此,该类自动注册作为上下文中的 bean 定义的
* {@link org.springframework.beans.factory.config.BeanFactoryPostProcessor BeanFactoryPostProcessors}、
* {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessors} 和
* {@link org.springframework.context.ApplicationListener ApplicationListeners}。
* 一个 {@link org.springframework.context.MessageSource}
* 也可以作为一个名为 "messageSource" 的 bean 在上下文中提供;否则,消息解析将委托给父上下文。
* 此外,一个应用程序事件的多播器也可以作为上下文中的类型为 {@link org.springframework.context.event.ApplicationEventMulticaster} 的 "applicationEventMulticaster" bean 提供;
* 否则,将使用类型为 {@link org.springframework.context.event.SimpleApplicationEventMulticaster} 的默认多播器。
* 通过扩展 {@link org.springframework.core.io.DefaultResourceLoader} 来实现资源加载。
* 因此,对非 URL 资源路径进行处理,将其视为类路径资源(支持包含包路径的完整类路径资源名称,例如 "mypackage/myresource.dat"),除非在子类中覆盖了 {@link #getResourceByPath} 方法。
*
* @author Rod Johnson
* @author Juergen Hoeller
* @author Mark Fisher
* @author Stephane Nicoll
* @author Sam Brannen
* @author Sebastien Deleuze
* @author Brian Clozel
* @see #refreshBeanFactory
* @see #getBeanFactory
* @see org.springframework.beans.factory.config.BeanFactoryPostProcessor
* @see org.springframework.beans.factory.config.BeanPostProcessor
* @see org.springframework.context.event.ApplicationEventMulticaster
* @see org.springframework.context.ApplicationListener
* @see org.springframework.context.MessageSource
* @since January 21, 2001
*/
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
/**
* 在上下文中的 {@link MessageSource} bean 的名称。
* 如果未提供,则消息解析将委托给父级。
*
* @see org.springframework.context.MessageSource
* @see org.springframework.context.support.ResourceBundleMessageSource
* @see org.springframework.context.support.ReloadableResourceBundleMessageSource
* @see #getMessage(MessageSourceResolvable, Locale)
*/
public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";
/**
* 在上下文中的 {@link ApplicationEventMulticaster} bean 的名称。
* 如果未提供,则使用 {@link SimpleApplicationEventMulticaster}。
*
* @see org.springframework.context.event.ApplicationEventMulticaster
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
* @see #publishEvent(ApplicationEvent)
* @see #addApplicationListener(ApplicationListener)
*/
public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
/**
* 在上下文中的 {@link LifecycleProcessor} bean 的名称。
* 如果未提供,则使用 {@link DefaultLifecycleProcessor}。
*
* @see org.springframework.context.LifecycleProcessor
* @see org.springframework.context.support.DefaultLifecycleProcessor
* @see #start()
* @see #stop()
* @since 3.0
*/
public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
static {
// 提前加载 ContextClosedEvent 类,
// 以避免在 WebLogic 8.1 中应用程序关闭时出现奇怪的类加载器问题。 (由 Dustin Woods 报告。)
ContextClosedEvent.class.getName();
}
/**
* 此类使用的日志记录器。可供子类使用。
*/
protected final Log logger = LogFactory.getLog(getClass());
/**
* 此上下文的唯一标识符(如果有)。
*/
private String id = ObjectUtils.identityToString(this);
/**
* 显示名称
*/
private String displayName = ObjectUtils.identityToString(this);
/**
* 父上下文
*/
@Nullable
private ApplicationContext parent;
/**
* 此上下文使用的环境。
*/
@Nullable
private ConfigurableEnvironment environment;
/**
* 在刷新时应用的 BeanFactoryPostProcessors
*/
private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();
/**
* 此上下文启动时的系统时间(以毫秒为单位).
*/
private long startupDate;
/**
* 表示此上下文当前是否活动的标志。
*/
private final AtomicBoolean active = new AtomicBoolean();
/**
* 表示此上下文是否已关闭的标志。.
*/
private final AtomicBoolean closed = new AtomicBoolean();
/**
* "刷新"和 "关闭" 的同步锁
*/
private final Lock startupShutdownLock = new ReentrantLock();
/**
* 当前活动的启动/关闭线程。
*/
@Nullable
private volatile Thread startupShutdownThread;
/**
* 注册的 JVM 关闭挂钩的引用,如果已注册的话。
*/
@Nullable
private Thread shutdownHook;
/**
* 此上下文使用的 ResourcePatternResolver。
*/
private final ResourcePatternResolver resourcePatternResolver;
/**
* 用于管理此上下文中 bean 生命周期的 LifecycleProcessor。
*/
@Nullable
private LifecycleProcessor lifecycleProcessor;
/**
* 我们将此接口的实现委托给的 MessageSource。
*/
@Nullable
private MessageSource messageSource;
/**
* 用于事件发布的辅助类
*/
@Nullable
private ApplicationEventMulticaster applicationEventMulticaster;
/**
* 应用程序启动指标.
**/
private ApplicationStartup applicationStartup = ApplicationStartup.DEFAULT;
/**
* 静态指定的监听器.
*/
private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
/**
* 刷新之前注册的本地监听器.
*/
@Nullable
private Set<ApplicationListener<?>> earlyApplicationListeners;
/**
* 在多播器设置之前发布的 ApplicationEvent。
*/
@Nullable
private Set<ApplicationEvent> earlyApplicationEvents;
/**
* 创建一个没有父上下文的新 AbstractApplicationContext。
*/
public AbstractApplicationContext() {
this.resourcePatternResolver = getResourcePatternResolver();
}
/**
* 创建一个具有给定父上下文的新 AbstractApplicationContext。
*
* @param parent the parent context
*/
public AbstractApplicationContext(@Nullable ApplicationContext parent) {
this();
setParent(parent);
}
//---------------------------------------------------------------------
// Implementation of ApplicationContext interface
//---------------------------------------------------------------------
/**
* 设置此应用程序上下文的唯一标识符。
* <p>默认情况下是上下文实例的对象标识符,或者如果上下文本身被定义为一个 bean,则是上下文 bean 的名称。
*
* @param id 上下文的唯一标识符
*/
@Override
public void setId(String id) {
this.id = id;
}
/**
* 获取上下文标识符
*
* @return
*/
@Override
public String getId() {
return this.id;
}
/**
* 获取ApplicationName 如子类未实现 默认返
* <p>
* 回""
*
* @return
*/
@Override
public String getApplicationName() {
return "";
}
/**
* 为此上下文设置一个友好名称。
* 通常在具体上下文实现的初始化期间完成。
* <p>默认情况下是上下文实例的对象标识符。
*/
public void setDisplayName(String displayName) {
Assert.hasLength(displayName, "Display name must not be empty");
this.displayName = displayName;
}
/**
* 返回此上下文的友好名称。
*
* @return 此上下文的显示名称(永远不会为 {@code null})
*/
@Override
public String getDisplayName() {
return this.displayName;
}
/**
* 返回父上下文,如果没有父上下文则返回 {@code null}
* (也就是说,此上下文是上下文层次结构的根)。
*/
@Override
@Nullable
public ApplicationContext getParent() {
return this.parent;
}
/**
* 设置此应用程序上下文的 {@code Environment}。
* <p>默认值由 {@link #createEnvironment()} 确定。用此方法替换默认值是一种选择,但应该
* 考虑通过 {@link #getEnvironment()} 进行配置。在任何情况下,这些修改都应该在 {@link #refresh()} 之前执行。
*
* @see org.springframework.context.support.AbstractApplicationContext#createEnvironment
*/
@Override
public void setEnvironment(ConfigurableEnvironment environment) {
this.environment = environment;
}
/**
* 以可配置的形式返回此应用程序上下文的 {@code Environment},允许进一步自定义。
* <p>如果未指定,则会通过 {@link #createEnvironment()} 初始化默认环境。
* {@link #createEnvironment()}.
*/
@Override
public ConfigurableEnvironment getEnvironment() {
//如果为空 通过createEnvironment()初始化默认环境
if (this.environment == null) {
this.environment = createEnvironment();
}
return this.environment;
}
/**
* 创建并返回一个新的 {@link StandardEnvironment}。
* <p>子类可以重写此方法以提供自定义的 {@link ConfigurableEnvironment} 实现。
*/
protected ConfigurableEnvironment createEnvironment() {
return new StandardEnvironment();
}
/**
* 返回此上下文的内部 bean 工厂作为 AutowireCapableBeanFactory,如果已经可用。
*
* @see #getBeanFactory()
*/
@Override
public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException {
return getBeanFactory();
}
/**
* 返回此上下文首次加载时的时间戳(毫秒)。
*/
@Override
public long getStartupDate() {
return this.startupDate;
}
/**
* 将给定事件发布到所有监听器。
* <p>注意:监听器在 MessageSource 之后初始化,以便能够在监听器实现中访问它。
* 因此,MessageSource 实现不能发布事件。
*
* @param event 要发布的事件(可能是特定于应用程序的或标准框架事件)
*/
@Override
public void publishEvent(ApplicationEvent event) {
publishEvent(event, null);
}
/**
* 将给定事件发布到所有监听器。
* <p>注意:监听器在 MessageSource 之后初始化,以便能够在监听器实现中访问它。
* 因此,MessageSource 实现不能发布事件。
*
* @param event 要发布的事件(可能是 {@link ApplicationEvent}
* 或要转换为 {@link PayloadApplicationEvent} 的负载对象)
*/
@Override
public void publishEvent(Object event) {
publishEvent(event, null);
}
/**
* 将给定事件发布到所有监听器。
* <p>这是所有其他 {@code publishEvent} 方法都引用的内部委托。不应直接调用它,
* 而应作为层次结构中应用程序上下文之间的传播机制,可能在子类中进行自定义传播安排时覆盖。
*
* @param event 要发布的事件(可能是 {@link ApplicationEvent} 或要转换为 {@link PayloadApplicationEvent} 的负载对象)
* @param typeHint 已解析的事件类型(如果已知)。
* 此方法的实现还容忍用于要转换为 {@link PayloadApplicationEvent} 的负载对象的负载类型提示。
* 但是,对于这种情况,建议通过 {@link PayloadApplicationEvent#PayloadApplicationEvent(Object, Object, ResolvableType)}
* 构造一个实际的事件对象。
* @see ApplicationEventMulticaster#multicastEvent(ApplicationEvent, ResolvableType)
* @since 4.2
*/
protected void publishEvent(Object event, @Nullable ResolvableType typeHint) {
//断言事件不能为空
Assert.notNull(event, "Event must not be null");
ResolvableType eventType = null;
// 如果需要,将事件装饰为 ApplicationEvent
ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent applEvent) {
applicationEvent = applEvent;
eventType = typeHint;
} else {
// 如果事件不是 ApplicationEvent 类型,则创建一个 PayloadApplicationEvent
ResolvableType payloadType = null;
if (typeHint != null && ApplicationEvent.class.isAssignableFrom(typeHint.toClass())) {
eventType = typeHint;
} else {
payloadType = typeHint;
}
applicationEvent = new PayloadApplicationEvent<>(this, event, payloadType);
}
// 仅在需要时确定事件类型(用于多播和父级发布)
if (eventType == null) {
eventType = ResolvableType.forInstance(applicationEvent);
if (typeHint == null) {
typeHint = eventType;
}
}
// 如果早期应用程序事件列表不为空,则将事件添加到列表中
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
// 否则,如果 applicationEventMulticaster 不为空,则进行多播事件
else if (this.applicationEventMulticaster != null) {
this.applicationEventMulticaster.multicastEvent(applicationEvent, eventType);
}
// 通过父上下文也发布事件
if (this.parent != null) {
// 如果父上下文是 AbstractApplicationContext,则调用其 publishEvent 方法
if (this.parent instanceof AbstractApplicationContext abstractApplicationContext) {
abstractApplicationContext.publishEvent(event, typeHint);
}
// 否则,直接调用父上下文的 publishEvent 方法
else {
this.parent.publishEvent(event);
}
}
}
/**
* 返回上下文使用的内部 ApplicationEventMulticaster。
*
* @return 内部的 ApplicationEventMulticaster(永远不会为 {@code null})
* @throws IllegalStateException 如果上下文尚未初始化
*/
ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
// 如果 applicationEventMulticaster 为空,则抛出 IllegalStateException
if (this.applicationEventMulticaster == null) {
throw new IllegalStateException("ApplicationEventMulticaster not initialized - " +
"call 'refresh' before multicasting events via the context: " + this);
}
// 返回 applicationEventMulticaster
return this.applicationEventMulticaster;
}
@Override
public void setApplicationStartup(ApplicationStartup applicationStartup) {
// 断言 applicationStartup 不为空
Assert.notNull(applicationStartup, "ApplicationStartup must not be null");
// 设置 applicationStartup
this.applicationStartup = applicationStartup;
}
@Override
public ApplicationStartup getApplicationStartup() {
// 返回 applicationStartup
return this.applicationStartup;
}
/**
* 返回上下文使用的内部 LifecycleProcessor。
*
* @return 内部的 LifecycleProcessor(永远不会为 {@code null})
* @throws IllegalStateException 如果上下文尚未初始化
*/
LifecycleProcessor getLifecycleProcessor() throws IllegalStateException {
// 如果 lifecycleProcessor 为空,则抛出 IllegalStateException
if (this.lifecycleProcessor == null) {
throw new IllegalStateException("LifecycleProcessor not initialized - " +
"call 'refresh' before invoking lifecycle methods via the context: " + this);
}
// 返回 lifecycleProcessor
return this.lifecycleProcessor;
}
/**
* 返回用于将位置模式解析为资源实例的 ResourcePatternResolver。
* 默认值是一个支持 Ant 样式位置模式的 PathMatchingResourcePatternResolver。
* <p>可以在子类中重写,以扩展解析策略,例如在 Web 环境中。
* <p><b>需要解析位置模式时,请不要调用此方法。</b>
* 相反,请调用上下文的 {@code getResources} 方法,该方法将委托给 ResourcePatternResolver。
*
* @return 此上下文的 ResourcePatternResolver
* @see #getResources
* @see org.springframework.core.io.support.PathMatchingResourcePatternResolver
*/
protected ResourcePatternResolver getResourcePatternResolver() {
// 创建一个 PathMatchingResourcePatternResolver,并传入当前 ApplicationContext 对象
return new PathMatchingResourcePatternResolver(this);
}
//---------------------------------------------------------------------
// ConfigurableApplicationContext 接口的实现
//---------------------------------------------------------------------
/**
* 设置此应用程序上下文的父级。
* <p>如果父级不为 {@code null},并且其环境是 {@link ConfigurableEnvironment} 的实例,
* 则父级 {@linkplain ApplicationContext#getEnvironment() environment} 会与此(子级)应用程序上下文的环境
* {@linkplain ConfigurableEnvironment#merge(ConfigurableEnvironment) 合并}。
*
* @see ConfigurableEnvironment#merge(ConfigurableEnvironment)
*/
@Override
public void setParent(@Nullable ApplicationContext parent) {
this.parent = parent;
// 如果父级不为 null
if (parent != null) {
// 获取父级 ApplicationContext 的环境
Environment parentEnvironment = parent.getEnvironment();
// 如果父级环境是 ConfigurableEnvironment 的实例
if (parentEnvironment instanceof ConfigurableEnvironment configurableEnvironment) {
// 将父级环境与当前环境进行合并
getEnvironment().merge(configurableEnvironment);
}
}
}
/**
* 添加一个 BeanFactoryPostProcessor 到内部 BeanFactory 中。
*/
@Override
public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
// 断言 postProcessor 不为空
Assert.notNull(postProcessor, "BeanFactoryPostProcessor must not be null");
// 将 postProcessor 添加到 beanFactoryPostProcessors 列表中
this.beanFactoryPostProcessors.add(postProcessor);
}
/**
* 返回将应用于内部 BeanFactory 的 BeanFactoryPostProcessor 列表。
*/
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}
/**
* 添加一个 ApplicationListener 到应用程序上下文中。
*/
@Override
public void addApplicationListener(ApplicationListener<?> listener) {
// 断言 listener 不为空
Assert.notNull(listener, "ApplicationListener must not be null");
// 如果 applicationEventMulticaster 不为空,则将 listener 添加到其中
if (this.applicationEventMulticaster != null) {
this.applicationEventMulticaster.addApplicationListener(listener);
}
// 将 listener 添加到 applicationListeners 列表中
this.applicationListeners.add(listener);
}
/**
* 从应用程序上下文中移除一个 ApplicationListener。
*/
@Override
public void removeApplicationListener(ApplicationListener<?> listener) {
// 断言 listener 不为空
Assert.notNull(listener, "ApplicationListener must not be null");
// 如果 applicationEventMulticaster 不为空,则从其中移除 listener
if (this.applicationEventMulticaster != null) {
this.applicationEventMulticaster.removeApplicationListener(listener);
}
// 从 applicationListeners 列表中移除 listener
this.applicationListeners.remove(listener);
}
/**
* 返回静态指定的 ApplicationListeners 列表。
*/
public Collection<ApplicationListener<?>> getApplicationListeners() {
return this.applicationListeners;
}
/**
* 刷新该应用程序上下文,将其状态更新为最新。
*
* @throws BeansException 如果在刷新过程中发生 Bean 异常
* @throws IllegalStateException 如果上下文已经启动或处于关闭状态
*/
@Override
public void refresh() throws BeansException, IllegalStateException {
// 加锁,以确保线程安全
this.startupShutdownLock.lock();
try {
// 当前线程标记
this.startupShutdownThread = Thread.currentThread();
// 开始跟踪刷新上下文的步骤
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
// 上下文刷新前准备工作
prepareRefresh();
// 告诉子类刷新内部 bean 工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//为在此上下文中使用的 bean 工厂做准备.
prepareBeanFactory(beanFactory);
try {
// 允许在上下文子类中对 bean 工厂进行后处理.
postProcessBeanFactory(beanFactory);
// 开始跟踪 bean 后置处理的步骤
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// 调用在上下文中注册为 bean 的工厂处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 注册拦截 bean 创建的 bean 处理器。
registerBeanPostProcessors(beanFactory);
//结束跟踪 bean 后置处理的步骤
beanPostProcess.end();
//初始化此上下文的消息源
initMessageSource();
//初始化此上下文的事件多播器.
initApplicationEventMulticaster();
//初始化特定上下文子类中的其他特殊 bean.
onRefresh();
// 检查监听器 bean 并注册它们.
registerListeners();
// 实例化所有剩余的(非懒加载)单例 bean.
finishBeanFactoryInitialization(beanFactory);
// 最后一步:发布相应的事件.
finishRefresh();
} catch (RuntimeException | Error ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
//销毁已创建的单例,以避免悬空资源
destroyBeans();
//重置 'active' 标志
cancelRefresh(ex);
// 将异常传播给调用者.
throw ex;
} finally {
//结束跟踪刷新上下文的步骤
contextRefresh.end();
}
} finally {
//清除线程标记
this.startupShutdownThread = null;
//解锁关闭过程
this.startupShutdownLock.unlock();
}
}
/**
* 这段代码是准备上下文以进行刷新的方法。以下是方法中的各个步骤:
* <p>
* 设置启动日期和活动标志: 将上下文的启动日期设置为当前时间戳,将关闭标志设为 false(表示上下文处于打开状态),将活动标志设为 true(表示上下文处于活动状态)。
* <p>
* 输出刷新日志: 如果日志级别为 DEBUG,则输出刷新日志。如果 TRACE 级别被启用,则输出包含该上下文引用的 TRACE 日志,否则输出 DEBUG 日志。
* <p>
* 初始化属性源: 调用 initPropertySources() 方法,初始化上下文环境中的任何占位符属性源。这个步骤用于解析属性文件中的占位符属性值。
* <p>
* 验证必需属性: 调用 getEnvironment().validateRequiredProperties() 方法,验证所有在环境中标记为必需的属性是否都被解析。这一步骤确保应用程序所需的所有属性都已正确设置。
* <p>
* 存储刷新前的 ApplicationListeners: 如果 earlyApplicationListeners 为空,则将当前的应用程序监听器列表复制到 earlyApplicationListeners 中,否则清空当前的应用程序监听器列表,并将 earlyApplicationListeners 中的监听器重新添加到当前列表中。
* <p>
* 收集早期的 ApplicationEvents: 初始化一个早期应用程序事件集合 earlyApplicationEvents,以便在多播器可用后发布这些事件。
* <p>
* 准备该上下文以进行刷新,设置其启动日期和活动标志,以及执行属性源的任何初始化
*/
protected void prepareRefresh() {
// 切换到活动状态
// 设置上下文的启动时间为当前时间戳
this.startupDate = System.currentTimeMillis();
// 将关闭标志设为 false,表示上下文处于打开状态
this.closed.set(false);
// 将活动标志设为 true,表示上下文处于活动状态
this.active.set(true);
// 如果日志级别为 DEBUG,则输出刷新日志
if (logger.isDebugEnabled()) {
// 如果日志级别为 TRACE,则输出刷新日志
if (logger.isTraceEnabled()) {
// 输出 TRACE 级别的刷新日志
logger.trace("Refreshing " + this);
} else {
// 输出 DEBUG 级别的刷新日志
logger.debug("Refreshing " + getDisplayName());
}
}
// / 初始化上下文环境中的任何占位符属性源。
initPropertySources();
//验证所有标记为必需的属性是否可解析:
// 参见 ConfigurablePropertyResolver#setRequiredProperties
getEnvironment().validateRequiredProperties();
// 存储刷新前的 ApplicationListeners...
if (this.earlyApplicationListeners == null) {
//创建存储刷新前ApplicationListeners容器
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
} else {
// 将本地应用程序监听器重置为刷新前的状态。
// 清空当前的应用程序监听器列表
this.applicationListeners.clear();
// 重新添加刷新前的应用程序监听器列表
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// 允许收集早期的 ApplicationEvents,
// 一旦多播器可用,就会发布它们...
// 初始化早期应用程序事件集合
this.earlyApplicationEvents = new LinkedHashSet<>();
}
/**
* <p>用实际实例替换任何存根属性源。
* <p>在子类中,通常可以通过覆盖此方法来初始化属性源。
* * 例如,在 Web 应用程序上下文中,可以使用 {@link org.springframework.web.context.support.WebApplicationContextUtils#initServletPropertySources} 方法来初始化属性源。
*
* @see org.springframework.core.env.PropertySource.StubPropertySource
* @see org.springframework.web.context.support.WebApplicationContextUtils#initServletPropertySources
*/
protected void initPropertySources() {
// 对于子类:默认情况下不执行任何操作。
}
/**
* 告知子类刷新内部的 bean 工厂。
*
* @return 刷新后的 BeanFactory 实例
* @see #refreshBeanFactory()
* @see #getBeanFactory()
*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 调用 refreshBeanFactory() 方法刷新内部的 bean 工厂
refreshBeanFactory();
// 返回刷新后的 BeanFactory 实例
return getBeanFactory();
}
/**
* 设置工厂的类加载器和 Bean 表达式解析器。
* 注册属性编辑器注册器。
* 配置工厂使用上下文回调。
* 注册可解析的依赖项和早期后处理器。
* 检测是否存在 LoadTimeWeaver 并准备进行编织。
* 注册默认环境 bean,包括 Environment、系统属性和系统环境等。
* 配置工厂的标准上下文特性,例如上下文的类加载器和后处理器。
*
* @param beanFactory 要配置的 BeanFactory
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 告知内部 bean 工厂使用上下文的类加载器等。
// 设置工厂使用上下文的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置 Bean 表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 注册属性编辑器注册器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 使用上下文回调配置 bean 工厂。
// 添加 ApplicationContextAware 后处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 忽略 EnvironmentAware 接口
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
// 忽略 EmbeddedValueResolverAware 接口
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
// 忽略 ResourceLoaderAware 接口
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
// 忽略 ApplicationEventPublisherAware 接口
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
// 忽略 MessageSourceAware 接口
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
// 忽略 ApplicationContextAware 接口
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 忽略 ApplicationStartupAware 接口
beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);
// 在普通工厂中不将 BeanFactory 接口注册为可解析的类型。
// 将 MessageSource 注册(并在自动装配时找到)为一个 bean。
// 注册 BeanFactory 为可解析的依赖项
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
// 注册 ResourceLoader 为可解析的依赖项
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
// 注册 ApplicationEventPublisher 为可解析的依赖项
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
// 注册 ApplicationContext 为可解析的依赖项
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 注册用于检测内部 bean 是否为 ApplicationListener 的早期后置处理器
// 添加用于检测内部 bean 是否为 ApplicationListener 的后置处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 检测是否存在 LoadTimeWeaver 并准备进行编织(如果找到)
if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
// 添加 LoadTimeWeaverAwareProcessor
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// 设置临时的 ClassLoader 用于类型匹配
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 注册默认环境 bean。
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
//注册 Environment bean
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
// 注册 Environment bean
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
// 注册系统环境 bean
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
// 注册应用启动器 bean
beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
}
}
/**
* 在标准初始化后修改应用程序上下文的内部Bean工厂。初始定义资源将已加载,
* 但尚未运行任何后处理器,也未注册任何派生Bean定义,
* 最重要的是,还未实例化任何Bean。
* <p>这个模板方法允许在某些 AbstractApplicationContext 子类中注册特殊的 BeanPostProcessor 等。
*
* @param beanFactory 应用程序上下文使用的Bean工厂
*/
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}
/**
* 实例化和调用所有已注册的 BeanFactoryPostProcessor bean,
* 如果给定,则遵循显式顺序。
* <p>必须在单例实例化之前调用。
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 调用 PostProcessorRegistrationDelegate 的 invokeBeanFactoryPostProcessors 方法
// 传入 beanFactory 和 beanFactoryPostProcessors 列表
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// 检测 LoadTimeWeaver,并准备进行织入(例如通过 ConfigurationClassPostProcessor 注册的 @Bean 方法)
if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null &&
beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
// 添加一个 LoadTimeWeaverAwareProcessor,并设置临时类加载器
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
/**
* 实例化和注册所有 BeanPostProcessor bean,
* 如果给定,则遵循显式顺序。
* <p>必须在应用程序 bean 的任何实例化之前调用。
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 调用 PostProcessorRegistrationDelegate 的 registerBeanPostProcessors 方法
// 传入 beanFactory 和 this(当前应用程序上下文)
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
/**
* 初始化 MessageSource。
* <p>如果此上下文中未定义 MessageSource,则使用父级的 MessageSource。
*
* @see #MESSAGE_SOURCE_BEAN_NAME
*/
protected void initMessageSource() {
// 获取 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 获取 BeanFactory
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
// 从 BeanFactory 中获取 MessageSource
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// 如果存在父上下文,并且 MessageSource 是 HierarchicalMessageSource 的实例,
// 则设置父级 MessageSource
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource hms &&
hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
// 输出trace日志
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
} else {
// 如果此上下文中未定义 MESSAGE_SOURCE_BEAN_NAME bean,则创建一个空的 DelegatingMessageSource
// 以便接受 getMessage 调用
DelegatingMessageSource dms = new DelegatingMessageSource();
// 将父级 MessageSource 设置为内部父级 MessageSource
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
// 在 BeanFactory 中注册 MESSAGE_SOURCE_BEAN_NAME bean
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
// 输出trace日志
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
/**
* 初始化 ApplicationEventMulticaster。
* <p>如果上下文中未定义 ApplicationEventMulticaster,则使用 SimpleApplicationEventMulticaster。
*
* @see #APPLICATION_EVENT_MULTICASTER_BEAN_NAME
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
protected void initApplicationEventMulticaster() {
// 获取 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如果此上下文包含 APPLICATION_EVENT_MULTICASTER_BEAN_NAME bean
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 从 BeanFactory 中获取 ApplicationEventMulticaster
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
// 输出trace日志
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
} else {
// 如果此上下文中未定义 APPLICATION_EVENT_MULTICASTER_BEAN_NAME bean,则创建一个 SimpleApplicationEventMulticaster
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 在 BeanFactory 中注册 APPLICATION_EVENT_MULTICASTER_BEAN_NAME bean
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
// 输出trace日志
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
/**
* 初始化 LifecycleProcessor。
* <p>如果上下文中未定义 LifecycleProcessor,则使用 DefaultLifecycleProcessor。
*
* @see #LIFECYCLE_PROCESSOR_BEAN_NAME
* @see org.springframework.context.support.DefaultLifecycleProcessor
* @since 3.0
*/
protected void initLifecycleProcessor() {
// 获取 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如果此上下文包含 LIFECYCLE_PROCESSOR_BEAN_NAME bean
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
// 从 BeanFactory 中获取 LifecycleProcessor
this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
// 输出trace日志
if (logger.isTraceEnabled()) {
logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
} else {
// 如果此上下文中未定义 LIFECYCLE_PROCESSOR_BEAN_NAME bean,则创建一个 DefaultLifecycleProcessor
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
// 设置 BeanFactory
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
// 在 BeanFactory 中注册 LIFECYCLE_PROCESSOR_BEAN_NAME bean
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
// 输出trace日志
if (logger.isTraceEnabled()) {
logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
}
}
}
/**
* 模板方法,可以被覆盖以添加特定于上下文的刷新工作。
* 在特殊 Bean 初始化之前调用,但在单例实例化之前。
* <p>这个实现为空。
*
* @throws BeansException 如果发生错误
* @see #refresh()
*/
protected void onRefresh() throws BeansException {
// 对于子类:默认情况下不执行任何操作。
}
/**
* 将实现 ApplicationListener 接口的 Bean 添加为监听器。
* 不影响其他监听器,其他监听器可以在不作为 Bean 的情况下添加。
*/
protected void registerListeners() {
// 首先注册静态指定的监听器
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 不要在这里初始化 FactoryBeans:我们需要保持所有常规 Bean 未初始化,
// 以便让后处理器应用到它们!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 现在我们终于有了一个多播器,可以发布早期的应用程序事件了...
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
/**
* 完成此上下文的 Bean 工厂初始化,初始化所有剩余的单例 Bean。
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化此上下文的引导执行器。
if (beanFactory.containsBean(BOOTSTRAP_EXECUTOR_BEAN_NAME) &&
beanFactory.isTypeMatch(BOOTSTRAP_EXECUTOR_BEAN_NAME, Executor.class)) {
beanFactory.setBootstrapExecutor(
beanFactory.getBean(BOOTSTRAP_EXECUTOR_BEAN_NAME, Executor.class));
}
// 初始化此上下文的转换服务。
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));
}
// 如果之前没有注册任何 BeanFactoryPostProcessor(例如 PropertySourcesPlaceholderConfigurer Bean),则注册默认的嵌入式值解析器:
// 此时,主要用于在注解属性值中进行解析。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 提前初始化 LoadTimeWeaverAware Bean,以便早期注册它们的转换器。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时的 ClassLoader 进行类型匹配。
beanFactory.setTempClassLoader(null);
// 允许缓存所有 Bean 定义元数据,不期望进一步的更改。
beanFactory.freezeConfiguration();
// 实例化所有剩余的(非延迟初始化)单例。
beanFactory.preInstantiateSingletons();
}
/**
* 完成此上下文的刷新,调用 LifecycleProcessor 的 onRefresh() 方法,
* 并发布 {@link org.springframework.context.event.ContextRefreshedEvent}。
*/
protected void finishRefresh() {
// 重置 Spring 核心基础设施中的常见内省缓存。
resetCommonCaches();
// 清除上下文级别的资源缓存(例如来自扫描的 ASM 元数据)。
clearResourceCaches();
// 初始化此上下文的生命周期处理器。
initLifecycleProcessor();
// 首先将刷新传播到生命周期处理器。
getLifecycleProcessor().onRefresh();
// 发布最终事件。
publishEvent(new ContextRefreshedEvent(this));
}
/**
* 取消此上下文的刷新尝试,在抛出异常后重置 {@code active} 标志。
*
* @param ex 导致取消的异常
*/
protected void cancelRefresh(Throwable ex) {
this.active.set(false);
// 重置 Spring 核心缓存。
resetCommonCaches();
}
/**
* 重置 Spring 的常见反射元数据缓存,特别是 {@link ReflectionUtils}、
* {@link AnnotationUtils}、{@link ResolvableType}
* 和 {@link CachedIntrospectionResults} 缓存。
*
* @see ReflectionUtils#clearCache()
* @see AnnotationUtils#clearCache()
* @see ResolvableType#clearCache()
* @see CachedIntrospectionResults#clearClassLoader(ClassLoader)
* @since 4.2
*/
protected void resetCommonCaches() {
ReflectionUtils.clearCache();
AnnotationUtils.clearCache();
ResolvableType.clearCache();
CachedIntrospectionResults.clearClassLoader(getClassLoader());
}
@Override
public void clearResourceCaches() {
// 调用父类的清除资源缓存方法
super.clearResourceCaches();
// 如果资源模式解析器是 PathMatchingResourcePatternResolver 类型的
if (this.resourcePatternResolver instanceof PathMatchingResourcePatternResolver pmrpr) {
//清除资源模式解析器的缓存
pmrpr.clearCache();
}
}
/**
* 使用 JVM 运行时注册一个名为 {@code SpringContextShutdownHook} 的关闭钩子线程,
* 在 JVM 关闭时关闭此上下文,除非在那时已经关闭。
* <p>委托 {@code doClose()} 进行实际的关闭过程。
*
* @see Runtime#addShutdownHook
* @see ConfigurableApplicationContext#SHUTDOWN_HOOK_THREAD_NAME
* @see #close()
* @see #doClose()
*/
@Override
public void registerShutdownHook() {
// 如果关闭钩子尚未注册
if (this.shutdownHook == null) {
// No shutdown hook registered yet.
this.shutdownHook = new Thread(SHUTDOWN_HOOK_THREAD_NAME) {
@Override
public void run() {
// 如果启动关闭线程卡住
if (isStartupShutdownThreadStuck()) {
active.set(false);
return;
}
// 加锁以避免并发问题
startupShutdownLock.lock();
try {
// 执行关闭逻辑
doClose();
} finally {
// 解锁
startupShutdownLock.unlock();
}
}
};
// 注册关闭钩子线程
Runtime.getRuntime().addShutdownHook(this.shutdownHook);
}
}
/**
* 判断当前是否存在处于活动状态的启动/关闭线程卡住,
* 例如在用户组件中调用 {@code System.exit}。
*/
private boolean isStartupShutdownThreadStuck() {
// 获取活动的启动/关闭线程
Thread activeThread = this.startupShutdownThread;
// 如果活动线程不为空且处于等待状态
if (activeThread != null && activeThread.getState() == Thread.State.WAITING) {
// 永久等待:可能是 Thread.join 或类似的操作,或者是 System.exit
// 中断活动线程
activeThread.interrupt();
try {
// 等待一小段时间以确保中断生效
Thread.sleep(1);
} catch (InterruptedException ex) {
// 恢复当前线程的中断状态
Thread.currentThread().interrupt();
}
if (activeThread.getState() == Thread.State.WAITING) {
// 如果活动线程仍然处于等待状态,则很可能是 System.exit 调用导致的
return true;
}
}
return false;
}
/**
* 关闭此应用程序上下文,销毁其 Bean 工厂中的所有 Bean。
* <p>委托 {@code doClose()} 执行实际的关闭过程。
* 还会移除注册的 JVM 关闭钩子,因为它不再需要。
*
* @see #doClose()
* @see #registerShutdownHook()
*/
@Override
public void close() {
// 如果启动/关闭线程卡住,则设置活动状态为 false 并返回
if (isStartupShutdownThreadStuck()) {
this.active.set(false);
return;
}
// 加锁以避免并发问题
this.startupShutdownLock.lock();
try {
// 将当前线程设置为启动/关闭线程
this.startupShutdownThread = Thread.currentThread();
// 执行关闭逻辑
doClose();
// 如果注册了 JVM 关闭钩子,则不再需要它:
// 因为已经明确关闭了上下文。
if (this.shutdownHook != null) {
try {
// 移除 JVM 关闭钩子
Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
} catch (IllegalStateException ex) {
// 忽略 - VM 已经在关闭中
}
}
} finally {
// 清空启动/关闭线程,并释放锁
this.startupShutdownThread = null;
this.startupShutdownLock.unlock();
}
}
/**
* 实际执行上下文关闭:发布 ContextClosedEvent 并销毁此应用程序上下文的 Bean 工厂中的单例。
* <p>由 {@code close()} 和 JVM 关闭钩子调用。
*
* @see org.springframework.context.event.ContextClosedEvent
* @see #destroyBeans()
* @see #close()
* @see #registerShutdownHook()
*/
protected void doClose() {
// 检查是否需要进行实际关闭尝试...
if (this.active.get() && this.closed.compareAndSet(false, true)) {
if (logger.isDebugEnabled()) {
logger.debug("Closing " + this);
}
try {
// 发布关闭事件
publishEvent(new ContextClosedEvent(this));
} catch (Throwable ex) {
logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
}
// 停止所有 Lifecycle Bean,以避免在单个销毁期间出现延迟。
if (this.lifecycleProcessor != null) {
try {
this.lifecycleProcessor.onClose();
} catch (Throwable ex) {
logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
}
}
// 销毁上下文的 BeanFactory 中的所有缓存单例。
destroyBeans();
// 关闭此上下文本身的状态。
closeBeanFactory();
// 如果需要,让子类进行一些最后的清理...
onClose();
// 重置公共的内置缓存以避免类引用泄漏。
resetCommonCaches();
// 将本地的应用程序监听器重置为刷新前的状态。
if (this.earlyApplicationListeners != null) {
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// 重置内部委托。
this.applicationEventMulticaster = null;
this.messageSource = null;
this.lifecycleProcessor = null;
// 切换为非活动状态。
this.active.set(false);
}
}
/**
* 模板方法,用于销毁此上下文管理的所有 Bean。
* 默认实现会销毁此上下文中的所有缓存单例,
* 调用 {@code DisposableBean.destroy()} 和/或指定的 "destroy-method"。
* <p>可以重写此方法,添加上下文特定的 Bean 销毁步骤,
* 位于标准单例销毁之前或之后,此时上下文的 BeanFactory 仍处于活动状态。
*
* @see #getBeanFactory()
* @see org.springframework.beans.factory.config.ConfigurableBeanFactory#destroySingletons()
*/
protected void destroyBeans() {
//销毁单例池
getBeanFactory().destroySingletons();
}
/**
* 模板方法,可以被重写以添加上下文特定的关闭工作。
* 默认实现为空。
* <p>在 {@link #doClose} 的关闭过程末尾调用,
* 在此上下文的 BeanFactory 被关闭之后。
* 如果需要在 BeanFactory 仍处于活动状态时执行自定义关闭逻辑,
* 则应重写 {@link #destroyBeans()} 方法。
*/
protected void onClose() {
// 对于子类:默认情况下什么都不做
}
/**
* 判断当前标志是否活跃
*
* @return
*/
@Override
public boolean isActive() {
return this.active.get();
}
/**
* 断言此上下文的 BeanFactory 当前是否处于活动状态,
* 如果不是,则抛出 {@link IllegalStateException}。
* <p>由所有依赖于活动上下文的 {@link BeanFactory} 委托方法调用,
* 特别是所有 Bean 访问器方法。
* <p>默认实现检查此上下文的整体 {@link #isActive() 'active'} 状态。
* 可以针对更具体的检查进行重写,或者在此情况下 {@link #getBeanFactory()} 本身抛出异常时进行无操作。
*/
protected void assertBeanFactoryActive() {
if (!this.active.get()) {
if (this.closed.get()) {
//关闭状态
throw new IllegalStateException(getDisplayName() + " has been closed already");
} else {
throw new IllegalStateException(getDisplayName() + " has not been refreshed yet");
}
}
}
//---------------------------------------------------------------------
// BeanFactory 接口的实现
//---------------------------------------------------------------------
/**
* 根据名称获取一个bean实例
*
* @param name beanName
* @return
* @throws BeansException
*/
@Override
public Object getBean(String name) throws BeansException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取bean实例
return getBeanFactory().getBean(name);
}
/**
* 根据名称和要求的类型获取一个bean实例
*
* @param name beanName
* @param requiredType type of Bean
* @param <T>
* @return
* @throws BeansException
*/
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取bean实例
return getBeanFactory().getBean(name, requiredType);
}
/**
* 根据名称和参数获取一个bean实例
*/
@Override
public Object getBean(String name, Object... args) throws BeansException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取bean实例
return getBeanFactory().getBean(name, args);
}
/**
* 根据要求的类型获取一个bean实例
*/
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取bean实例
return getBeanFactory().getBean(requiredType);
}
/**
* 根据要求的类型和参数获取一个bean实例
*/
@Override
public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取bean实例
return getBeanFactory().getBean(requiredType, args);
}
/**
* 获取一个指定类型的ObjectProvider
*/
@Override
public <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType) {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取ObjectProvider
return getBeanFactory().getBeanProvider(requiredType);
}
/**
* 获取一个指定类型的ObjectProvider
*/
@Override
public <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType) {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取ObjectProvider
return getBeanFactory().getBeanProvider(requiredType);
}
/**
* 判断容器是否包含指定名称的bean
*/
@Override
public boolean containsBean(String name) {
// 委托给BeanFactory判断是否包含指定名称的bean
return getBeanFactory().containsBean(name);
}
/**
* 判断指定名称的bean是否为单例
*/
@Override
public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory判断指定名称的bean是否为单例
return getBeanFactory().isSingleton(name);
}
/**
* 判断指定名称的bean是否为原型
*/
@Override
public boolean isPrototype(String name) throws NoSuchBeanDefinitionException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory判断指定名称的bean是否为原型
return getBeanFactory().isPrototype(name);
}
/**
* 判断指定名称的bean是否与指定类型匹配
*/
@Override
public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory判断指定名称的bean是否与指定类型匹配
return getBeanFactory().isTypeMatch(name, typeToMatch);
}
/**
* 判断指定名称的bean是否与指定类型匹配
*/
@Override
public boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory判断指定名称的bean是否与指定类型匹配
return getBeanFactory().isTypeMatch(name, typeToMatch);
}
/**
* 获取指定名称的bean的类型
*/
@Override
@Nullable
public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取指定名称的bean的类型
return getBeanFactory().getType(name);
}
/**
* 获取指定名称的bean的类型
*/
@Override
@Nullable
public Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException {
// 断言BeanFactory处于活动状态
assertBeanFactoryActive();
// 委托给BeanFactory获取指定名称的bean的类型
return getBeanFactory().getType(name, allowFactoryBeanInit);
}
/**
* 获取指定名称的bean的别名
*/
@Override
public String[] getAliases(String name) {
// 委托给BeanFactory获取指定名称的bean的别名
return getBeanFactory().getAliases(name);
}
//---------------------------------------------------------------------
// ListableBeanFactory 接口的实现
//---------------------------------------------------------------------
/**
* 判断BeanFactory中是否包含指定名称的Bean定义
*/
@Override
public boolean containsBeanDefinition(String beanName) {
return getBeanFactory().containsBeanDefinition(beanName);
}
/**
* 获取BeanFactory中定义的所有Bean的数量
*/
@Override
public int getBeanDefinitionCount() {
return getBeanFactory().getBeanDefinitionCount();
}
/**
* 获取BeanFactory中定义的所有Bean的名称
*/
@Override
public String[] getBeanDefinitionNames() {
return getBeanFactory().getBeanDefinitionNames();
}
/**
* 获取指定类型的ObjectProvider,用于延迟获取Bean实例
*/
@Override
public <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType, boolean allowEagerInit) {
assertBeanFactoryActive();
return getBeanFactory().getBeanProvider(requiredType, allowEagerInit);
}
/**
* 获取指定类型的ObjectProvider,用于延迟获取Bean实例
*/
@Override
public <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType, boolean allowEagerInit) {
assertBeanFactoryActive();
return getBeanFactory().getBeanProvider(requiredType, allowEagerInit);
}
/**
* 获取指定类型的所有Bean的名称
*/
@Override
public String[] getBeanNamesForType(ResolvableType type) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type);
}
/**
* 获取指定类型的所有Bean的名称
*/
@Override
public String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
}
/**
* 获取指定类型的所有Bean的名称
*/
@Override
public String[] getBeanNamesForType(@Nullable Class<?> type) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type);
}
/**
* 获取指定类型的所有Bean的名称
*/
@Override
public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
}
/**
* 获取指定类型的所有Bean实例的Map
*/
@Override
public <T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBeansOfType(type);
}
/**
* 获取指定类型的所有Bean实例的Map
*/
@Override
public <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBeansOfType(type, includeNonSingletons, allowEagerInit);
}
/**
* 获取带有指定注解的所有Bean的名称
*/
@Override
public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForAnnotation(annotationType);
}
/**
* 获取带有指定注解的所有Bean的Map
*/
@Override
public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBeansWithAnnotation(annotationType);
}
/**
* 在指定Bean上查找指定类型的注解
*/
@Override
@Nullable
public <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().findAnnotationOnBean(beanName, annotationType);
}
/**
* 在指定Bean上查找指定类型的注解
*/
@Override
@Nullable
public <A extends Annotation> A findAnnotationOnBean(
String beanName, Class<A> annotationType, boolean allowFactoryBeanInit)
throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().findAnnotationOnBean(beanName, annotationType, allowFactoryBeanInit);
}
/**
* 获取指定Bean上所有指定类型的注解的集合
*/
@Override
public <A extends Annotation> Set<A> findAllAnnotationsOnBean(
String beanName, Class<A> annotationType, boolean allowFactoryBeanInit)
throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().findAllAnnotationsOnBean(beanName, annotationType, allowFactoryBeanInit);
}
//---------------------------------------------------------------------
// 实现HierarchicalBeanFactory接口
//---------------------------------------------------------------------
/**
* 返回当前上下文的父级BeanFactory
*/
@Override
@Nullable
public BeanFactory getParentBeanFactory() {
return getParent();
}
/**
* 检查本地BeanFactory是否包含指定名称的Bean
*/
@Override
public boolean containsLocalBean(String name) {
return getBeanFactory().containsLocalBean(name);
}
/**
* 如果父上下文实现了ConfigurableApplicationContext,则返回其内部的Bean工厂;
* 否则,返回父上下文本身。
*
* @see org.springframework.context.ConfigurableApplicationContext#getBeanFactory
*/
@Nullable
protected BeanFactory getInternalParentBeanFactory() {
// 获取父上下文的内部Bean工厂
return (getParent() instanceof ConfigurableApplicationContext cac ?
cac.getBeanFactory() : getParent());
}
//---------------------------------------------------------------------
// 实现 MessageSource 接口
//---------------------------------------------------------------------
/**
* 获取消息源中指定代码的消息
*
* @param code 要查找的消息代码,例如 'calculator.noRateSet'。
* 鼓励 MessageSource 用户将消息名称基于合格的类
* 或包名称,避免潜在的冲突并确保最大程度的清晰度。
* @param args 一个参数数组,将在其中填充参数
* 消息(消息中的参数类似于“{0}”、“{1,date}”、“{2,time}”),
* 或 {@code null} 如果没有
* @param defaultMessage 查找失败时返回的默认消息
* @param locale 进行查找的语言环境
* @return
*/
@Override
public String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale) {
return getMessageSource().getMessage(code, args, defaultMessage, locale);
}
/**
* 获取消息源中指定代码的消息
*
* @param code 要查找的消息代码,例如 '计算器.noRateSet'。
* 鼓励 MessageSource 用户将消息名称基于合格的类
* 或包名称,避免潜在的冲突并确保最大程度的清晰度。
* @param args 一个参数数组,将在其中填充参数
* 消息(消息中的参数类似于“{0}”、“{1,date}”、“{2,time}”),
* 或 {@code null} 如果没有
* @param locale 进行查找的区域设置
* @return
* @throws NoSuchMessageException
*/
@Override
public String getMessage(String code, @Nullable Object[] args, Locale locale) throws NoSuchMessageException {
return getMessageSource().getMessage(code, args, locale);
}
/**
* 获取消息源中指定解析的消息
*
* @param resolvable 存储解析消息所需属性的值对象
* (可能包括默认消息)
* @param locale 进行查找的语言环境
* @return
* @throws NoSuchMessageException
*/
@Override
public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
return getMessageSource().getMessage(resolvable, locale);
}
/**
* 返回上下文使用的内部MessageSource。
*
* @return 内部MessageSource(永不为null)
* @throws IllegalStateException 如果上下文尚未初始化
*/
private MessageSource getMessageSource() throws IllegalStateException {
//没初始化
if (this.messageSource == null) {
throw new IllegalStateException("MessageSource not initialized - " +
"call 'refresh' before accessing messages via the context: " + this);
}
// 返回上下文的内部MessageSource
return this.messageSource;
}
/**
* 如果父上下文也是AbstractApplicationContext,则返回其内部的消息源;
* 否则,返回父上下文本身。
*/
@Nullable
protected MessageSource getInternalParentMessageSource() {
//获取父上下文的内部消息源
return (getParent() instanceof AbstractApplicationContext abstractApplicationContext ?
abstractApplicationContext.messageSource : getParent());
}
//---------------------------------------------------------------------
// 实现 ResourcePatternResolver 接口
//---------------------------------------------------------------------
/**
* 解析给定的资源位置模式,返回匹配的资源数组
*
* @param locationPattern 解析的位置模式
* @return
* @throws IOException
*/
@Override
public Resource[] getResources(String locationPattern) throws IOException {
return this.resourcePatternResolver.getResources(locationPattern);
}
//---------------------------------------------------------------------
// Lifecycle 接口的实现 生命周期接口
//---------------------------------------------------------------------
@Override
public void start() {
// 调用 LifecycleProcessor 的 start 方法,启动生命周期处理器
getLifecycleProcessor().start();
// 发布 ContextStartedEvent 事件,表示上下文已启动
publishEvent(new ContextStartedEvent(this));
}
@Override
public void stop() {
// 调用 LifecycleProcessor 的 stop 方法,停止生命周期处理器
getLifecycleProcessor().stop();
// 发布 ContextStoppedEvent 事件,表示上下文已停止
publishEvent(new ContextStoppedEvent(this));
}
@Override
public boolean isRunning() {
// 检查生命周期处理器是否不为 null,并且生命周期处理器是否正在运行
return (this.lifecycleProcessor != null && this.lifecycleProcessor.isRunning());
}
//---------------------------------------------------------------------
// 必须由子类实现的抽象方法
//---------------------------------------------------------------------
/**
* 子类必须实现此方法来执行实际的配置加载。
* 该方法在 {@link #refresh()} 之前由调用执行任何其他初始化工作。
* <p>子类将创建一个新的 bean 工厂并持有其引用,或者返回一个它持有的单个 BeanFactory 实例。
* 在后一种情况下,如果多次刷新上下文,则通常会抛出 IllegalStateException。
*
* @throws BeansException 如果 bean 工厂的初始化失败
* @throws IllegalStateException 如果已经初始化,并且不支持多次刷新尝试
*/
protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
/**
* 子类必须实现此方法以释放其内部的 bean 工厂。
* 该方法在所有其他关闭工作之后由 {@link #close()} 调用。
* <p>不应该抛出异常,而应该记录关闭失败。
*/
protected abstract void closeBeanFactory();
/**
* 子类必须在此处返回它们的内部 bean 工厂。
* 它们应该有效地实现查找,以便可以重复调用而不会影响性能。
* <p>注意:子类应该在返回内部 bean 工厂之前检查上下文是否仍然处于活动状态。
* 一旦上下文已关闭,通常应该认为内部工厂不可用。
*
* @return 此应用程序上下文的内部 bean 工厂(永远不会为 {@code null})
* @throws IllegalStateException 如果上下文尚未持有内部 bean 工厂
* (通常如果从未调用 {@link #refresh()})或者如果上下文已关闭
* @see #refreshBeanFactory()
* @see #closeBeanFactory()
*/
@Override
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
/**
* 返回关于此上下文的信息。
*/
@Override
public String toString() {
// 创建一个 StringBuilder 对象,并将 ApplicationContext 的显示名称添加到其中
StringBuilder sb = new StringBuilder(getDisplayName());
// 添加启动时间信息到 StringBuilder 中,使用 Date 对象格式化启动时间
sb.append(", started on ").append(new Date(getStartupDate()));
// 获取当前 上下文 的父级 ApplicationContext
ApplicationContext parent = getParent();
if (parent != null) {
// 添加父级 ApplicationContext 的显示名称到 StringBuilder 中
sb.append(", parent: ").append(parent.getDisplayName());
}
// 返回 StringBuilder 对象的字符串表示形式
return sb.toString();
}
}
Spring源码解读之AbstractApplicationContext
最新推荐文章于 2024-08-20 12:59:56 发布