相关源码注释
ApplicationContext
Spring 5 DefaultResourceLoader 源码注释
Spring 5 AbstractApplicationContext 源码注释
BeanFactory
Spring 5 SimpleAliasRegistry 源码注释
Spring 5 DefaultSingletonBeanRegistry 源码注释
Spring 5 FactoryBeanRegistrySupport 源码注释
Spring 5 AbstractBeanFactory 源码注释
Spring 5 AbstractAutowireCapableBeanFactory 源码注释
Spring 5 DefaultLisbaleBeanFactory 源码注释
UML类图
源码
/**
* Abstract implementation of the {@link org.springframework.context.ApplicationContext}
* interface. Doesn't mandate the type of storage used for configuration; simply
* implements common context functionality. Uses the Template Method design pattern,
* requiring concrete subclasses to implement abstract methods.
* <p>
* {@link org.springframework.context.ApplicationContext}接口的抽象实现。
* 不强制用于配置的存储类型；简单实现通用上下文功能。使用模板方法设计模式，
* 需要具体的子类来实现抽象方法
* </p>
*
* <p>In contrast to a plain BeanFactory, an ApplicationContext is supposed
* to detect special beans defined in its internal bean factory:
* Therefore, this class automatically registers
* {@link org.springframework.beans.factory.config.BeanFactoryPostProcessor BeanFactoryPostProcessors},
* {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessors},
* and {@link org.springframework.context.ApplicationListener ApplicationListeners}
* which are defined as beans in the context.
* <p>
* 与具体的BeanFactory相反，一个ApplicationContext应该检查其内部bean工厂中
* 定义的特殊bean：因此，这些类会被自动注册：
* {@link org.springframework.beans.factory.config.BeanFactoryPostProcessor BeanFactoryPostProcessors},
* {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessors},
* {@link org.springframework.context.ApplicationListener ApplicationListeners}
* 在上下文中被定义为bean
* </p>
*
* <p>A {@link org.springframework.context.MessageSource} may also be supplied
* as a bean in the context, with the name "messageSource"; otherwise, message
* resolution is delegated to the parent context. Furthermore, a multicaster
* for application events can be supplied as an "applicationEventMulticaster" bean
* of type {@link org.springframework.context.event.ApplicationEventMulticaster}
* in the context; otherwise, a default multicaster of type
* {@link org.springframework.context.event.SimpleApplicationEventMulticaster} will be used.
* <p>
* A {@link org.springframework.context.MessageSource}可以同时被提供作为一个
* 上下文中bean，名称为'messageSource'；否，将消息解析委托给父级上下文。此外，
* 还有一个提供用于应用程序时间的多播器以{@link org.springframework.context.event.ApplicationEventMulticaster}
* 类型，名称为'applicationEventMulticaster'在上下文中；除此之外，还使用到了类型为
* {@link org.springframework.context.event.SimpleApplicationEventMulticaster}的默认多播器
* </p>
* <p>Implements resource loading by extending
* {@link org.springframework.core.io.DefaultResourceLoader}.
* Consequently treats non-URL resource paths as class path resources
* (supporting full class path resource names that include the package path,
* e.g. "mypackage/myresource.dat"), unless the {@link #getResourceByPath}
* method is overridden in a subclass.
* <p>
* 通过扩展 {@link org.springframework.core.io.DefaultResourceLoader}来实现资源加载。
* 因此，将非URL资源路径视为类路径资源（支持包含程序包路径的完整类路径资源名称，如
* 'mypackage/myresource.dat'),除非 {@link #getResourceByPath}在子类中被覆盖
* </p>
* @author Rod Johnson
* @author Juergen Hoeller
* @author Mark Fisher
* @author Stephane Nicoll
* @author Sam Brannen
* @since January 21, 2001
* @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
*/
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
/**
* Name of the MessageSource bean in the factory.
* If none is supplied, message resolution is delegated to the parent.
* <p>MessageSource在工厂中的bean名.如果未提供，则将消息解析位委托给父类</p>
* @see MessageSource
*/
public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";
/**
* Name of the LifecycleProcessor bean in the factory.
* If none is supplied, a DefaultLifecycleProcessor is used.
* <p>
* LifecycleProcessor在工厂中的bean名。如果未提供，就用DefaultLifecycleProcessor
* </p>
* @see org.springframework.context.LifecycleProcessor
* @see org.springframework.context.support.DefaultLifecycleProcessor
*/
public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
/**
* Name of the ApplicationEventMulticaster bean in the factory.
* If none is supplied, a default SimpleApplicationEventMulticaster is used.
* <p>
* ApplicationEventMulticaster在工厂中的bean名。如果为提供，
* 就用默认的SimpleApplicationEventMulticaster
* </p>
* @see org.springframework.context.event.ApplicationEventMulticaster
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
static {
// Eagerly load the ContextClosedEvent class to avoid weird classloader issues
// on application shutdown in WebLogic 8.1. (Reported by Dustin Woods.)
// 饿汉式加载ContextClosedEvent类，以避免出现奇怪的类加载问题
// Weblogic8.1中应用程序关闭时发生的故障。（达斯汀·伍兹报道）
ContextClosedEvent.class.getName();
}
/** Logger used by this class. Available to subclasses. <p>此类用于日志记录。可用于子类</p> */
protected final Log logger = LogFactory.getLog(getClass());
/**
* Unique id for this context, if any.
* <p>此上下文的唯一ID（如果有）</p>
* <p>ObjectUtils.identityToString:可得到(obj的全类名+'@'+obj的hashCode的十六进制字符串)</p>
* */
private String id = ObjectUtils.identityToString(this);
/**
* Display name.
* <p>展示名</p>
* <p>ObjectUtils.identityToString:可得到(obj的全类名+'@'+obj的hashCode的十六进制字符串)</p>
* */
private String displayName = ObjectUtils.identityToString(this);
/** Parent context. <p>父级上下文</p>*/
@Nullable
private ApplicationContext parent;
/** Environment used by this context.
* <p>此上下文使用的环境，SpringBoot默认使用StandardServletEnvironment</p> */
@Nullable
private ConfigurableEnvironment environment;
/** BeanFactoryPostProcessors to apply on refresh.
* <p>BeanFactoryPostProcessors 应用于刷新</p>
* */
private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();
/**
* System time in milliseconds when this context started.
* <p>此上下文启动时的系统时间（以毫秒为单位）</p>
* */
private long startupDate;
/**
* Flag that indicates whether this context is currently active.
* <p>指示此上下文当前是否处于活动状态的标记，该变量是线程安全的</p>
* */
private final AtomicBoolean active = new AtomicBoolean();
/**
* Flag that indicates whether this context has been closed already.
* <p>指示此上下文是否已经关闭的标记，该变量是线程安全的</p>
* */
private final AtomicBoolean closed = new AtomicBoolean();
/**
* Synchronization monitor for the "refresh" and "destroy".
* <p>'refresh'和'destory'的同步监控</p>
* */
private final Object startupShutdownMonitor = new Object();
/** Reference to the JVM shutdown hook, if registered. */
@Nullable
private Thread shutdownHook;
/**
* ResourcePatternResolver used by this context.
* <p>默认得到的是PathMatchingResourcePatternResolver, 这个一个支持Ant-style位置模式的类</p>
* Ant-styple:https://blog.csdn.net/my__sun_/article/details/76444435
* */
private ResourcePatternResolver resourcePatternResolver;
/** LifecycleProcessor for managing the lifecycle of beans within this context. */
@Nullable
private LifecycleProcessor lifecycleProcessor;
/**
* MessageSource we delegate our implementation of this interface to.
* <p>我们将此接口的实现委托给 MessageSource </p>
* */
@Nullable
private MessageSource messageSource;
/**
* Helper class used in event publishing.
* <p>事件发布中使用的 helper 类</p>
* */
@Nullable
private ApplicationEventMulticaster applicationEventMulticaster;
/**
* Statically specified listeners.
* 静态指定的监听器集
* */
private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
/**
* Local listeners registered before refresh.
* <p>刷新之前已注册本地侦听器</p>
* */
@Nullable
private Set<ApplicationListener<?>> earlyApplicationListeners;
/**
* ApplicationEvents published before the multicaster setup.
* <p>在多播程序设置之前发布的ApplicationEvent</p>
* */
@Nullable
private Set<ApplicationEvent> earlyApplicationEvents;
/**
* Create a new AbstractApplicationContext with no parent.
* 创建一个新的无父类的AbatractApplciationContext
*/
public AbstractApplicationContext() {
//默认得到的是PathMatchingResourcePatternResolver, 这个一个支持Ant-style位置模式的类
//Ant-styple:https://blog.csdn.net/my__sun_/article/details/76444435
this.resourcePatternResolver = getResourcePatternResolver();
}
/**
* Create a new AbstractApplicationContext with the given parent context.
* @param parent the parent context
*/
public AbstractApplicationContext(@Nullable ApplicationContext parent) {
///默认将resourcePatternResolver赋值为PathMatchingResourcePatternResolver,
// 这个一个支持Ant-style位置模式的类
// Ant-styple:https://blog.csdn.net/my__sun_/article/details/76444435
this();
//设置应用程序上下文的父级
//如果父级引用程序上下文不为null且它的environment是ConfigurableEnvironment 的实例，
// 将会和子级的应用程序上下文进行合并
setParent(parent);
}
//---------------------------------------------------------------------
// Implementation of ApplicationContext interface
//---------------------------------------------------------------------
/**
* Set the unique id of this application context.
* <p>设置此应用程序上下文的唯一ID</p>
*
* <p>Default is the object id of the context instance, or the name
* of the context bean if the context is itself defined as a bean.
* <p>默认值为上下文实例的对象ID,如果上下文定义为Bean，则为上下文bean的名称。</p>
* @param id the unique id of the context
*/
@Override
public void setId(String id) {
this.id = id;
}
@Override
public String getId() {
return this.id;
}
@Override
public String getApplicationName() {
return "";
}
/**
* Set a friendly name for this context.
* <p>为此上下文设置一个友好的名称</p>
*
* Typically done during initialization of concrete context implementations.
* <p>通常在初始化具体上下文实现期间完成</p>
*
* <p>Default is the object id of the context instance.
* <p>默认值为上下文实例的对象Id</p>
*/
public void setDisplayName(String displayName) {
//如果displayName为null或者为空字符串，抛出异常
Assert.hasLength(displayName, "Display name must not be empty");
this.displayName = displayName;
}
/**
* Return a friendly name for this context.
* <p>返回此上下文的友好名称</p>
* @return a display name for this context (never {@code null})
* -- 此上下文的显示名称（不要{@code null}）
*/
@Override
public String getDisplayName() {
return this.displayName;
}
/**
* Return the parent context, or {@code null} if there is no parent
* (that is, this context is the root of the context hierarchy).
* <p>返回父上下文，如果没有父级，则返回{@code null}(也就是说，此上下文层次结构
* 的根)</p>
*/
@Override
@Nullable
public ApplicationContext getParent() {
return this.parent;
}
/**
* Set the {@code Environment} for this application context.
* <p>Default value is determined by {@link #createEnvironment()}. Replacing the
* default with this method is one option but configuration through {@link
* #getEnvironment()} should also be considered. In either case, such modifications
* should be performed <em>before</em> {@link #refresh()}.
* @see org.springframework.context.support.AbstractApplicationContext#createEnvironment
*/
@Override
public void setEnvironment(ConfigurableEnvironment environment) {
this.environment = environment;
}
/**
* Return the {@code Environment} for this application context in configurable
* form, allowing for further customization.
* <p>以可配置的形式返回此应用程序上下文的{@code Environment}，以便进行进一步的自定义。</p>
* <p>If none specified, a default environment will be initialized via
* {@link #createEnvironment()}.
* <p>如果未指定，则默认环境将通过{@link #createEnvironment()}进行初始化。</p>
*/
@Override
public ConfigurableEnvironment getEnvironment() {
//如果当前上下文没有environment对象
if (this.environment == null) {
//创建一个新的StandardEnvironment
this.environment = createEnvironment();
}
return this.environment;
}
/**
* Create and return a new {@link StandardEnvironment}.
* <p>创建并返回一个新的{@link StandardEnvironment}</p>
* <p>Subclasses may override this method in order to supply
* a custom {@link ConfigurableEnvironment} implementation.
* <p>子类可以重新此方法，以提供一个自定义{@link ConfigurableEnvironment}实现</p>
*/
protected ConfigurableEnvironment createEnvironment() {
//StandardEnvironment:使用与"标准"(即非网络)应用程序的Environment实现,
// 除了ConfigurableEnvironment的常用功能(例如属性解析和配置文件相关的操作)之外，
// 此实现还配置了两个默认的属性源，将按一下顺序进行搜索:
// 1. system properties 系统属性
// 2. system environment variables 系统环境属性
return new StandardEnvironment();
}
/**
* Return this context's internal bean factory as AutowireCapableBeanFactory,
* if already available.
* @see #getBeanFactory()
*/
@Override
public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException {
return getBeanFactory();
}
/**
* Return the timestamp (ms) when this context was first loaded.
*/
@Override
public long getStartupDate() {
return this.startupDate;
}
/**
* Publish the given event to all listeners.
* <p>将给定事件发布到所有监听器。</p>
* <p>Note: Listeners get initialized after the MessageSource, to be able
* to access it within listener implementations. Thus, MessageSource
* implementations cannot publish events.
* <p>注意:侦听器在MessageSource之后被初始化，以便能够在侦听器实现中访问它。
* 因此，MessageSource实现不能发布事件</p>
* @param event the event to publish (may be application-specific or a
* standard framework event)
* -- 要发布的事件(可能是特定于应用程序的事件或标准框架事件)
*/
@Override
public void publishEvent(ApplicationEvent event) {
publishEvent(event, null);
}
/**
* Publish the given event to all listeners.
* <p>将给定事件发布到所有监听器。</p>
* <p>Note: Listeners get initialized after the MessageSource, to be able
* to access it within listener implementations. Thus, MessageSource
* implementations cannot publish events.
* <p>注意:侦听器在MessageSource之后被初始化，以便能够在侦听器实现中访问它。 因此，MessageSource实现不能发布事件</p>
* @param event the event to publish (may be an {@link ApplicationEvent}
* or a payload object to be turned into a {@link PayloadApplicationEvent})
* -- 要发布的事件(可能是特定于应用程序的事件或标准框架事件)
*/
@Override
public void publishEvent(Object event) {
publishEvent(event, null);
}
/**
* <p>将 event 多播到所有适合的监听器。如果 event 不是 ApplicationEvent 实例，会将其封装成 PayloadApplicationEvent 对象
* 再进行多播。</p>
* <p>当上下文的多播器没有初始化时，会将event暂时保存起来，待多播器初始化后才将缓存的event进行多播</p>
* Publish the given event to all listeners.
* <p>将给定事件发布到所有监听器</p>
* @param event the event to publish (may be an {@link ApplicationEvent}
* or a payload object to be turned into a {@link PayloadApplicationEvent})
* -- 要发布的事件(可能是特定于应用程序的事件或标准框架事件)
* @param eventType the resolved event type, if known -- 已解析的事件类型(如果已知)
* @since 4.2
*/
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
//如果 event 为null，抛出异常
Assert.notNull(event, "Event must not be null");
// Decorate event as an ApplicationEvent if necessary
// 装饰事件作为一个应用事件，如果有必要
ApplicationEvent applicationEvent;
//如果 event 是 ApplicationEvent 的 实例
if (event instanceof ApplicationEvent) {
//将 event 强转为 ApplicationEvent 对象
applicationEvent = (ApplicationEvent) event;
}
else {
//PayloadApplicationEvent：携带任意有效负载的ApplicationEvent。
//创建一个新的 PayloadApplicationEvent
applicationEvent = new PayloadApplicationEvent<>(this, event);
//如果 eventType 为 null
if (eventType == null) {
//将 applicationEvent 转换为 PayloadApplicationEvent 对象，引用其 ResolvableType 对象
eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
}
}
// Multicast right now if possible - or lazily once the multicaster is initialized
// 如果可能的话，现在就进行组播——或者在组播初始化后延迟
// earlyApplicationEvents：在多播程序设置之前发布的ApplicationEvent
// 如果 earlyApplicationEvents 不为 null，这种情况只在上下文的多播器还没有初始化的情况下才会成立， 会将 applicationEvent
// 添加到 earlyApplicationEvents 保存起来，待多博器初始化后才继续进行多播到适当的监听器
if (this.earlyApplicationEvents != null) {
//将applicationEvent添加到 earlyApplicationEvents
this.earlyApplicationEvents.add(applicationEvent);
}
else {
//多播applicationEvent到适当的监听器
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// Publish event via parent context as well...
// 通过父上下文发布事件
// 如果 parent 不为 null
if (this.parent != null) {
//如果 parent 是 AbstractApplicationContext 的实例
if (this.parent instanceof AbstractApplicationContext) {
//将 event 多播到所有适合的监听器。如果 event 不是 ApplicationEvent 实例，会将其封装成 PayloadApplicationEvent 对象再进行多播
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
//通知与event事件应用程序注册的所有匹配的监听器
this.parent.publishEvent(event);
}
}
}
/**
* Return the internal ApplicationEventMulticaster used by the context.
* <p>返回上下文使用的内部 ApplicationEventMulticater </p>
* @return the internal ApplicationEventMulticaster (never {@code null})
* -- 内部的 ApplicationEventMulticaster (永不为 null)
* @throws IllegalStateException if the context has not been initialized yet
* -- 如果上下文尚未初始化
*/
ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
//如果 applicationEventMulticaster 为 null
if (this.applicationEventMulticaster == null) {
//抛出非法状态异常：ApplicationEventMulticaster 没有被初始化 - 在通过上下文多播事件之前先调用 'refresh'方法
throw new IllegalStateException("ApplicationEventMulticaster not initialized - " +
"call 'refresh' before multicasting events via the context: " + this);
}
//返回 applicationEventMulticaster
return this.applicationEventMulticaster;
}
/**
* Return the internal LifecycleProcessor used by the context.
* <p>返回 上下文使用的内部生命周期处理器</p>
* @return the internal LifecycleProcessor (never {@code null})
* -- 内部生命周期处理器(从不为 null)
* @throws IllegalStateException if the context has not been initialized yet
* -- 如果上下文还没有初始化
*/
LifecycleProcessor getLifecycleProcessor() throws IllegalStateException {
//如果 lifecycleProcessor 为 null
if (this.lifecycleProcessor == null) {
//抛出 非法状态异常：生命周期处理器未初始化 - 在通过上下文调用生命周期方法调用'refresh'
throw new IllegalStateException("LifecycleProcessor not initialized - " +
"call 'refresh' before invoking lifecycle methods via the context: " + this);
}
//返回 lifecycleProcessor
return this.lifecycleProcessor;
}
/**
* Return the ResourcePatternResolver to use for resolving location patterns
* into Resource instances. Default is a
* {@link org.springframework.core.io.support.PathMatchingResourcePatternResolver},
* supporting Ant-style location patterns.
* <p>返回ResourcePatternResolver，用于将位置模式解析为Resouce实例 。默认值
* 为{@link org.springframework.core.io.support.PathMatchingResourcePatternResolver},
* 支持Ant样式的位置模式</p>
*
* <p>Can be overridden in subclasses, for extended resolution strategies,
* for example in a web environment.
* <p>可以在子类中覆盖，以用于扩展解析策略，例如在Web环境中，可以在子类中覆盖它</p>
*
* <p><b>Do not call this when needing to resolve a location pattern.</b>
* Call the context's {@code getResources} method instead, which
* will delegate to the ResourcePatternResolver.
*
* <p>在需要解析位置模式时不要调用此方法，而是调用上下文的{@code getResources}方法,
* 该方法将委托给ResourcePatternResolver</p>
*
* @return the ResourcePatternResolver for this context
* -- 此上下文的ResourcePatternResolver
* @see #getResources
* @see org.springframework.core.io.support.PathMatchingResourcePatternResolver
*/
protected ResourcePatternResolver getResourcePatternResolver() {
return new PathMatchingResourcePatternResolver(this);
}
//---------------------------------------------------------------------
// Implementation of ConfigurableApplicationContext interface
//---------------------------------------------------------------------
/**
* Set the parent of this application context.
* -设置应用程序上下文的父级
* <p>The parent {@linkplain ApplicationContext#getEnvironment() environment} is
* {@linkplain ConfigurableEnvironment#merge(ConfigurableEnvironment) merged} with
* this (child) application context environment if the parent is non-{@code null} and
* its environment is an instance of {@link ConfigurableEnvironment}.
* <p>如果父级引用程序上下文不为null且它的environment是{@link ConfigurableEnvironment}
* 的实例，将会和子级的应用程序上下文进行合并</p>
* @see ConfigurableEnvironment#merge(ConfigurableEnvironment)
*/
@Override
public void setParent(@Nullable ApplicationContext parent) {
this.parent = parent;
if (parent != null) {
Environment parentEnvironment = parent.getEnvironment();
if (parentEnvironment instanceof ConfigurableEnvironment) {
//将给定的父环境的活动配置文件，默认配置文件和属性源追加到此(子)环境各自集合中
getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
}
}
}
@Override
public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor) {
Assert.notNull(postProcessor, "BeanFactoryPostProcessor must not be null");
this.beanFactoryPostProcessors.add(postProcessor);
}
/**
* Return the list of BeanFactoryPostProcessors that will get applied
* to the internal BeanFactory.
* <p>返回将应用于内部BeanFactory的BeanFactoryPostPorcessor列表</p>
*/
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}
@Override
public void addApplicationListener(ApplicationListener<?> listener) {
Assert.notNull(listener, "ApplicationListener must not be null");
if (this.applicationEventMulticaster != null) {
this.applicationEventMulticaster.addApplicationListener(listener);
}
this.applicationListeners.add(listener);
}
/**
* Return the list of statically specified ApplicationListeners.
* <p>返回静态指定的applicationListenere列表</p>
*/
public Collection<ApplicationListener<?>> getApplicationListeners() {
return this.applicationListeners;
}
@Override
public void refresh() throws BeansException, IllegalStateException {
//同步，startupShutdownMonitor只是一个普通的object对象，
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// 准备该上下文的刷新
// p:准备该上下文以进行刷新，设置其启动日期和activie标记以及
// 执行属性源的任何 初始化。还有监听器都初始化
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 告诉子类刷新新内部bean工厂
//对此上下文的基础bean工厂进行实际刷新，关闭前一个bean工厂（如果有），
// 并为上下文生命周期的下一个阶段初始化一个新的bean工厂,并使用XmlBeanDefinitionReader
// 将bean定义加载给bean工厂中
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 准备这种情况下使用的bean工厂
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 允许在上下文子类中对bean工厂进行后处理
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 调用在上下文中注册为bean的工厂处理器
// 实例化并调用所有注册BeanFactoryPostProcess bean，并遵从显式顺序（如果给定的话）
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 注册拦截Bean创建的 BeanPostProcessor
// 实例化和注册所有 BeanPostProcessor 类型的Bean对象,如果给定的话，遵循显示顺序.
// 必须在应用程序Bean的任何实例化之前调用
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 为此上下文初始化消息源
// 从当前BeanFactory中获取名为 'messageSource' 的 MessageSource 类型的Bean对象,如果没有找到，就创建 一个
// DelegatingMessageSource 对象作为该上下文的 messageSource 属性值,并将该上下文的 messageSource 注册到 该
// 上下文的BeanFactory中。
// 默认对该上下文的messageSource设置父级messageSource,父级messageSource为父级上下文的messageSoure属性对象
// 或者父级上下文本身
initMessageSource();
// Initialize event multicaster for this context.
// 为此上下文初始化事件多播器
// 从从beanFactory中获取名为 'applicationEventMulticaster' 的 ApplicationEventMulticaster 类型的Bean对象，
// 引用到 该上下文的 applicationEventMulticaster 属性，如果获取不到，就新建一个
// SimpleApplicationEventMulticaster 实例 引用 到 上下文的 applicationEventMulticaster 属性 中
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 初始化特定上下文子类中的其他特殊Bean
onRefresh();
// Check for listener beans and register them.
// 检查监听器Bean并注册它们
//注册静态指定的监听器和beanFactory内的监听器Bean对象【不会导致监听器Bean对象实例化，仅记录其Bean名】到当前上
// 下文 的多播器，然后发布在多播程序设置之前发布的ApplicationEvent集到各个监听器中
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.`
// 实例化所有剩余的(非延迟初始化)的单例
//完成这个上下文BeanFactory的初始化，初始化所有剩余的 单例(非延迟初始化) Bean对象
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 最后一步：发布相应的事件
// 1. 清空在资源加载器中的所有资源缓存
// 2. 初始化 LifecycleProcessor.如果上下文中找到 'lifecycleProcessor' 的 LifecycleProcessor Bean对象， 则使用 DefaultLifecycleProcessor
// 3. 将刷新传播到生命周期处理器
// 4. 新建 ContextRefreshedEvent 事件对象，将其发布到所有监听器。
// 5. 注册 当前上下文 到 LiveBeansView，以支持 JMX 服务
finishRefresh();
}
catch (BeansException ex) {//捕捉在初始化Bean时抛出的 Bean异常
//如果当前日志级别时 警告
if (logger.isWarnEnabled()) {
// 在上下文初始化过程中遇到异常 - 尝试取消刷新
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
// 销毁已经创建的单例，以避免悬空资源
// 默认实现此上下文中销毁所有缓存的单例，调用DisposableBean.destroy()和 或指定的'destory-method'
destroyBeans();
// Reset 'active' flag.
// 重置 'active' 标记
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...
// 在 Spring的核心中重置常见的自省缓存，因为我们可能不再需要单例Bean的元数据了。
//删除ReflectionUtils，AnnotationUtils，ResolvableType的缓存，清除当前的类加载器的自省缓存，
// 删除该类加载器下 所有类的自省结果，并从接受列表中删除类加载器(及其子类)
resetCommonCaches();
}
}
}
/**
* <p>ApplicationContext刷新前的准备工作：
* <ol>
* <li>设置上下文启动时的系统时间，startupDate</li>
* <li>设置上下文为不关闭状态，closed</li>
* <li>设置上下文为活动状态，active</li>
* <li>根据日志级别打印日志,提示准备刷新ApplicationContext</li>
* <li>创建Environment对象，默认情况下Environment对象是StandardEnvironment对象</li>
* <li>提供一个钩子方法，交由子类替换任何存根属性源。默认情况下子类GenericWebApplicationContext，
* 通过该方法设置sources中的servletContextInitParams和servletConfigInitParams属性，以供更方便的
* 形式获取SerlvetContext。</li>
* <li>初始化用于存储已注册本地侦听器的LinkedHashSet集合，earlyApplicationListeners</li>
* <li>初始化用于收集早期的ApplicationEvents的LinkeHashSet集合，earlyApplicationEvents</li>
* </ol>
* </p>
* Prepare this context for refreshing, setting its startup date and
* active flag as well as performing any initialization of property sources.
* <p>准备该上下文以进行刷新，设置其启动日期和activie标记以及执行属性源的任何
* 初始化。</p>
*/
protected void prepareRefresh() {
// Switch to active. 切换到互动状态
//p:设置上下文启动时的系统时间
this.startupDate = System.currentTimeMillis();
//p:设置上下文为不关闭状态,该变量是线程安全的
this.closed.set(false);
///p:设置上下文为活动状态,该变量是线程安全的
this.active.set(true);
//根据日志级别打印日志
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
// Initialize any placeholder property sources in the context environment.
// 在上下文环境中初始化任何占位符属性源
//p:这个一个钩子方法，用于交由子类替换任何存根属性源
initPropertySources();
// Validate that all properties marked as required are resolvable:
// see ConfigurablePropertyResolver#setRequiredProperties
// 验证所有标记为必须的属性都是可解析的，请参见
// ConfigurablePropertyResolver#setRequiredProperties方法，
// p:该方法的默认实现是AbstractPropertyResolver类
// p:只是验证要必须要有的属性不会为null，验证不通过会抛出MissingRequiredPropertiesException
// SpringBoot默认情况下不存在必要的属性
getEnvironment().validateRequiredProperties();
// Store pre-refresh ApplicationListeners... 存储预刷新的ApplicationListeners
// p:初始化earlyApplicationListeners
if (this.earlyApplicationListeners == null) {
//p:LinkedHashSet是Set集合的一个实现，具有set集合不重复的特点，同时具有
// 可预测的迭代顺序，也就是我们插入的顺序,并且linkedHashSet是一个非线程安全的集合。
// 如果有多个线程同时访问当前linkedhashset集合容器，并且有一个线程对当前容器中的元素
// 做了修改，那么必须要在外部实现同步保证数据的冥等性
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
// 将本地应用程序监听器重置为预刷新状态
// p:清空静态指定的监听器集
this.applicationListeners.clear();
// p:将 刷新之前已注册本地侦听器 全部添加到静态指定的监听器集中
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
// 允许收集早期的ApplicationEvents，一旦多播器可用就发布
this.earlyApplicationEvents = new LinkedHashSet<>();
}
/**
* <p>Replace any stub property sources with actual instances.
* <p>用实际实例替换任何存根属性源</p>
* @see org.springframework.core.env.PropertySource.StubPropertySource
* @see org.springframework.web.context.support.WebApplicationContextUtils#initServletPropertySources
*/
protected void initPropertySources() {
// For subclasses: do nothing by default. 对于子类：默认情况下不执行任何操作
}
/**
* <p>
* 获取新的Bean工厂：
* <ol>
* <li>调用供子类实现refreshBeanFactory()方法执行实际的配置加载</li>
* <li>调用供子类实现的getBeanFactory()方法获取子类提供的Bean工厂</li>
* </ol>
* </p>
* Tell the subclass to refresh the internal bean factory.
* <p>告诉子类刷新内部bean工厂。</p>
* @return the fresh BeanFactory instance --新的BeanFactorty实例
* @see #refreshBeanFactory()
* @see #getBeanFactory()
*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//调用子类实现方法执行实际的配置加载
refreshBeanFactory();
//返回子类提供的Bean工厂，
return getBeanFactory();
}
/**
* <p>对bean工厂做准备工作：
* <ol>
* <li>设置beanFactory的bean的类加载器，通常是当前线程的上下文类加载器,AppClassLoader</li>
* <li>为bean定义值中的表达式指定解析策略，这里设置的是标准的Spring EL表达式解析器,StandardBeanExpressionResolver</li>
* <li>添加属性编辑器到bean工厂,ResourceEditorRegistrar</li>
* <li>为bean工厂添加 为实现了某种Aware接口的bean设置ApplicationContext中相应的属性的BeanPostProcessor，ApplicationContextAwareProcessor</li>
* <li>忽略 EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,ApplicationEventPublisherAware,MessageSourceAware
* ApplicationContextAware依赖接口进行自动装配</li>
* <li>添加自动装配对象：BeanFactory，ResourceLoader，ApplicationEventPublisher，ApplicationContext</li>
* <li>如果该bean工厂包含具有给定名称的BeanDefinition对象或外部注册的singleton实例，会添加用于回调LoadTimeWeaverAware#setLoadTimeWeaver(LoadTimeWeaver)
* 方法的BeanPostProcessor，以及设置一个ContextTypeMatchClassLoader的临时类加载器用于对每个调用loadClass的类【除指定排除类外】，都会新建一个
* ContextOverridingClassLoader类加载器进行加载，并对每个类的字节缓存起来，以便在父类ClassLoader中拾取 最近加载的类</li>
* <li>注册environment,systemProperties,systemEnvironment单例对象到该工厂</li>
* </ol>
* </p>
* Configure the factory's standard context characteristics,
* such as the context's ClassLoader and post-processors.
* <p>配置工厂的标准上下文特征，例如上下文的ClassLoader和后处理器。</p>
* @param beanFactory the BeanFactory to configure -- 要配置的BeanFactory
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
// 告诉内部bean工厂使用上下文的类加载器等
//设置beanFactory的bean的类加载器，通常是当前线程的上下文类加载器
beanFactory.setBeanClassLoader(getClassLoader());
//为bean定义值中的表达式指定解析策略，这里设置的是标准的Spring EL表达式解析器
//StandardBeanExpressionResolver:用于解析SpEL表达式的解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//添加属性编辑器到bean工厂,ResourceEditorRegistrar：属性编辑器的注册器，里面默认提供了一下简单通用常用类型的属性编辑器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
//使用上下文回调配置Bean工厂
//为bean工厂添加ApplicationContextAwareProcessor
//ApplicationContextAwareProcessor:一个Spring内部工具，它实现了接口BeanPostProcessor,用于向实现了如下某种Aware接口
// 的bean设置ApplicationContext中相应的属性:EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware
// ApplicationEventPublisherAware,MessageSourceAware,ApplicationContextAware,
// 如果bean实现了以上接口中的某几个，那么这些接口方法调用的先后顺序就是上面接口排列的先后顺序。
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);
// BeanFactory interface not registered as resolvable type in a plain factory.
// BeanFactory接口未在普通工厂中注册为可解析类型
// MessageSource registered (and found for autowiring) as a bean.
// MessageSource注册为Bean(并发现用于自定装配)
//用beanFactory对象注册一个BeanFactory类型
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
//用本类对象注册一个ResourceLoader类型
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
//用本类对象注册一个ApplicationEventPublisher类型
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
//用本类对象注册一个ApplicationContext类型
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
// 注册早期的后处理器以将内部bean检测为ApplicationListeners
// ApplicationListenerDetector:该BeanPostProcessor检测那些实现了接口ApplicationListener的bean，在它们创建时初始化之后，
// 将它们添加到应用上下文的事件多播器上；并在这些ApplicationListener bean销毁之前，
// 将它们从应用上下文的事件多播器上移除。
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 标记1 - start
// Detect a LoadTimeWeaver and prepare for weaving, if found.
// 如果发现LoadTimeWeaver,请准备编制
// beanFactory.containBean除了检查bean对象是否存在，还可以判断BeanDefinition对象是否存在，存在一样会返回true。
// 所以这里是是检查有没有loadTimeWeaver的BeanDefinition对象
// SpringBoot默认情况下该bean工厂不包含loadTimeWeaver的bean定义或外部注册的singleton实例
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
//LoadTimeWeaverAwareProcessor只是用实现了LoadTimeWeaverAware接口的bean
// // 回调LoadTimeWeaverAware.setLoadTimeWeaver(LoadTimeWeaver)方法
// // 参考博客：https://blog.csdn.net/weixin_34112208/article/details/89750308
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
//设置一个临时的ClassLoader以进行匹配
//ContextTypeMatchClassLoader:该类加载器破坏了双亲委派机制，除指定排除类外，
// 对每个调用loadClass的类，都会新建一个ContextOverridingClassLoader类加载器进行
// 加载，并对每个类的字节缓存起来，以便在父类ClassLoader中拾取 最近加载的类型
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 标记1 - end
// Register default environment beans. - 注册默认的环境bean
//如果bean工厂中没有包含名为'environment'的bean,(忽略在祖先上下文定义的bean)
//SpringBoot默认情况下该bean工厂是否包含loadTimeWeaver的bean定义或外部注册的singleton实例
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
//获取该ApplicationContext的环境对象，注册到bean工厂中，命名为'environment'
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
//如果bean工厂中没有包含名为'systemProperties'的bean,(忽略在祖先上下文定义的bean)
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
//获取该ApplicationContext的环境对象的系统属性Map，注册到bean工厂中，命名为'systemProperties'
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
//如果bean工厂中没有包含名为'systemEnvironment'的bean,(忽略在祖先上下文定义的bean)
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
//获取该ApplicationContext的环境对象的系统环境属性Map，注册到bean工厂中，命名为'systemProperties'
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
/**
* Modify the application context's internal bean factory after its standard
* initialization. All bean definitions will have been loaded, but no beans
* will have been instantiated yet. This allows for registering special
* BeanPostProcessors etc in certain ApplicationContext implementations.
* <p>标准初始化后，修改应用程序上下文的内部bena工厂。所有bean定义都将被加载，
* 但尚未实例化任何bean。这允许在某些ApplicationContext实现中注册特殊的
* BeanPostProcessor</p>
* @param beanFactory the bean factory used by the application context
* - 应用程序上下文使用的bean工厂
*/
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}
/**
* Instantiate and invoke all registered BeanFactoryPostProcessor beans,
* respecting explicit order if given.
* <p>实例化并调用所有注册BeanFactoryPostProcess bean，并遵从显式顺序（如果给定的话）</p>
* <p>Must be called before singleton instantiation.
* <p>必须在单例实例化之前调用</p>
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//回调 BeanFactoryPostPorcessors 和 beanFactory的所有BeanFactoryPostProcessor对象的回调方法
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
// 检测LoadTimeWeaver并准备编织（如果在此期间发现)
// (e.g. 通过 ConfigurationClassPostProcessor注册@Bean方法)
//如果bean工厂没有设置临时类加载器 且 'loadTimeWeaver' 不存在于bean工厂中
// 下面的代码其实跟prepareBeanFactory方法的标记1的代码一样，应该是因为该方法的上一个步是供给子类重写的钩子方法，
// Spring开发人担心经过上一步的处理后，会导致'loadTimeWeaver'被玩坏了，所有才
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
//LoadTimeWeaverAwareProcessor只是用实现了LoadTimeWeaverAware接口的bean
// 回调LoadTimeWeaverAware.setLoadTimeWeaver(LoadTimeWeaver)方法
// 参考博客：https://blog.csdn.net/weixin_34112208/article/details/89750308
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
//ContextTypeMatchClassLoader:该类加载器破坏了双亲委派机制，除指定排除类外，
// 对每个调用loadClass的类，都会新建一个ContextOverridingClassLoader类加载器进行
// 加载，并对每个类的字节缓存起来，以便在父类ClassLoader中拾取 最近加载的类型
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
/**
* Instantiate and register all BeanPostProcessor beans,
* respecting explicit order if given.
* <p>实例化和注册所有 BeanPostProcessor 类型的Bean对象,如果给定的话，遵循显示顺序</p>
* <p>Must be called before any instantiation of application beans.
* <p>必须在应用程序Bean的任何实例化之前调用</p>
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//注册 BeanPostProcessors 到 beanFactory 中
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
/**
* <p>从当前BeanFactory中获取名为 'messageSource' 的 MessageSource 类型的Bean对象,如果没有找到，就创建
* 一个 DelegatingMessageSource 对象作为该上下文的 messageSource 属性值,并将该上下文的 messageSource 注册到
* 该上下文的BeanFactory中。</p>
* <p>默认对该上下文的messageSource设置父级messageSource,父级messageSource为父级上下文的messageSoure属性对象
* 或者父级上下文本身</p>
* Initialize the MessageSource.
* Use parent's if none defined in this context.
* <p>初始化 MessageSource.</p>
* <p>如果在此上下文中没有定义，则使用父级的</p>
*/
protected void initMessageSource() {
//MessageSource:用于解析消息的策略界面，支持此类消息参数化和国际化
//获取当前上下文的BeanFactory对象
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//如果本地BeanFactory包含messageSource的bean，忽略父工厂
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
//从beanFactory中获取名为 'messageSource' 的 MessageSouce 类型的Bean对象
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
// 使 MessageSource 知道 父 MessageSouce
// HierarchicalMessageSource:MessageSource 的子接口，由能分层解析消息的对象实现
// 如果 parent 不为 null && messageSource 是 HierarchicalMessageSource 对象
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
//强转 messageSource 为 HierarchicalMessageSource 对象
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
//获取 hms 的 MessageSource 的父级 MessageSource 对象
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
// 如果还没有注册 父级 MessageSource，只能将父级上下文设置父级 MessageSource
// 获取父级上下文的 MessageSource 对象，将其设置 hms 的 父级 MessagoueSource 对象
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
//如果当前跟踪日志级别
if (logger.isTraceEnabled()) {
// 使用 MessageSource [messageSource]
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {//没有在beanFactory中找到'messageSource'Bean对象时
// Use empty MessageSource to be able to accept getMessage calls.
// 使用 空的 MessageSource 来能够接收 getMessage 调用
DelegatingMessageSource dms = new DelegatingMessageSource();
// 获取父级上下文的 MessageSource 对象，将其设置 hms 的 父级 MessagoueSource 对象
dms.setParentMessageSource(getInternalParentMessageSource());
//设置当前上下文的 messageSource 为 dms
this.messageSource = dms;
//将'messageSource'与 messageSource 注册到 beanFactory 中
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
//如果当前是跟踪日志级别
if (logger.isTraceEnabled()) {
//没有名为'messageSource'的对象，使用 messageSource
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
/**
* <p>从beanFactory中获取名为 'applicationEventMulticaster' 的 ApplicationEventMulticaster 类型的Bean对象，引用到
* 该上下文的 applicationEventMulticaster 属性，如果获取不到，就新建一个 SimpleApplicationEventMulticaster 实例 引用
* 到 上下文的 applicationEventMulticaster 属性 中</p>
* Initialize the ApplicationEventMulticaster.
* <p>初始化ApplicationEventMulticaster</p>
* Uses SimpleApplicationEventMulticaster if none defined in the context.
* <p>如果上下文中没有定义，则使用SimpleApplicatioonEventMulticaster</p>
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
protected void initApplicationEventMulticaster() {
//获取当前上下文的BeanFactory对象
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//如果本地BeanFactory包含 applicationEventMulticaster 的bean，忽略父工厂
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
//从beanFactory中获取名为 'applicationEventMulticaster' 的 ApplicationEventMulticaster 类型的Bean对象
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
//如果当前是跟踪日志级别
if (logger.isTraceEnabled()) {
//跟踪日志：使用 ApplicationEventMulticaster [applicationEventMulticaster]
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {//本地BeanFactory没有applicationEventMulticaster的bean对象时
//SimpleApplicationEventMulticaster：简单实现的 ApplicationEventMulticaster 接口;将所有事件多播给所有注册的监听
// 器，让监听器忽略它们不感兴趣的事件。监听器通常 会对传入的事件对象执行相应的 instanceof 检查
//新建一个 SimpleApplicationEventMulticaster 对象
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
//将 applicationEventMulticaster 与 'applicationEventMulticaster' 注册到 beanFactory 中
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
//如果当前是跟踪日志级别
if (logger.isTraceEnabled()) {
没有名为'applicationEventMulticaster'的对象，使用 applicationEventMulticaster
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
/**
* <p><p>初始化 LifecycleProcessor.如果上下文中找到 'lifecycleProcessor' 的 LifecycleProcessor Bean对象，则使用
* DefaultLifecycleProcessor </p></p>
* Initialize the LifecycleProcessor.
* Uses DefaultLifecycleProcessor if none defined in the context.
* <p>初始化 LifecycleProcessor.如果上下文中没有定义，则使用 DefaultLifecycleProcessor </p>
* @see org.springframework.context.support.DefaultLifecycleProcessor
*/
protected void initLifecycleProcessor() {
//获取当前上下文的BeanFactory对象
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//如果 beanFactory 包含 'lifecycleProcessor' 的bean，忽略父工厂
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
//让当前上下文 引用 从beanFactory中获取名为 'lifecycleProcessor' 的 LifecycleProcessor 类型的Bean对象
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
//如果当前日志级级别是跟踪
if (logger.isTraceEnabled()) {
//打印跟踪日志：使用 LifecycleProcessor [lifecycleProcessor]
logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
else {
//创建一个 DefaultLifecycleProcessor 实例
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
//为Bean实例提供所属工厂的回调函数
defaultProcessor.setBeanFactory(beanFactory);
//让当前上下文 引用 defaultProcessor
this.lifecycleProcessor = defaultProcessor;
//将 'lifecycleProcessor' 与 lifecycleProcessor 注册到 beanFactory 中
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
//如果当前日志级级别是跟踪
if (logger.isTraceEnabled()) {
// 没有 'lifecycleProcessor' 的Bean对象，使用 [lifecycleProcessor类名]
logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
}
}
}
/**
* Template method which can be overridden to add context-specific refresh work.
* Called on initialization of special beans, before instantiation of singletons.
* <p>模板方法，可以重写该方法以添加特定上下文的刷新工作。在实例化单例对象之前，对特殊Bean进行
* 初始化时调用。</p>
* <p>This implementation is empty.
* <p>这个实现时空的。</p>
* @throws BeansException in case of errors -- 以防出现错误
* @see #refresh()
*/
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
// 对于子类：默认不做任何事情
}
/**
* <p>注册静态指定的监听器和beanFactory内的监听器Bean对象【不会导致监听器Bean对象实例化，仅记录其Bean名】到当前上下文
* 的多播器，然后发布在多播程序设置之前发布的ApplicationEvent集到各个监听器中</p>
* Add beans that implement ApplicationListener as listeners.
* Doesn't affect other listeners, which can be added without being beans.
* <p>添加将 ApplicationListener 实现为 监听器 的Bean。不会影响其他 监听器，可以在不使用
* Bean 的情况下添加其他监听器</p>
*/
protected void registerListeners() {
// Register statically specified listeners first.
// 首先注册静态指定的监听器
//遍历 静态指定的 applicationListener 列表
for (ApplicationListener<?> listener : getApplicationListeners()) {
//获取上下文使用的内部 ApplicationEventMulticater，往里面添加 listener
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 不要这里初始化FactoryBean:我们需要保持所有常规bean未初始化，以便让BeanPostProcessor应用它们
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
// 遍历listenerBeanNames
for (String listenerBeanName : listenerBeanNames) {
//获取上下文使用的内部 ApplicationEventMulticater，往里面添加一个监听器bean来通知所有事件
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// 发布早期的应用事件，现在我们终于有了一个多播器
//在多播程序设置之前发布的ApplicationEvent集
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
//将earlyApplicationEvents设置为null,因为要保证一个事件只会多播一次。
this.earlyApplicationEvents = null;
//如果 earlyEventsToProcess 不为 null
if (earlyEventsToProcess != null) {
//遍历 earlyEventsToProcess
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
//获取上下文使用的内部 ApplicationEventMulticater,多播earlyEvent到适当的监听器
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
/**
* Finish the initialization of this context's bean factory,
* initializing all remaining singleton beans.
* <p>完成这个上下文BeanFactory的初始化，初始化所有剩余的 单例Bean对象</p>
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 为此上下文初始化转换服务
// 该beanFactory包含'conversionService'的BeanDefinition对象或外部注册的singleton实例 &&
// 如果在beanFactory中 'conversionService' 与 ConversionService.class 匹配
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
//从beanFactory中获取名为 'conversionService' 的 ConversionService 类型的Bean对象 作为 beanFactory的转换属性值
// 服务，也作为JavaBeans PropertyEditor的替代方案
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.
// 如果以前没有BeanPostProcessor(比如 PropertyPlaceholderConfigurer Bean)注册过任何Bean，
// 那么注册一个默认的内嵌值解析器：此时，主要是为了解析注释属性值
// 如果当前beanFactory没有字符串解析器，默认是有一个 PropertyPlaceHolderConfigurer 解析器的
if (!beanFactory.hasEmbeddedValueResolver()) {
//新建一个StringValueResolver对象添加字符串解析器
beanFactory.addEmbeddedValueResolver(strVal ->
//获取当前环境对象，在strVal中解析${...}占位符，用getProperty解析的相应属性值 替换它们。
// 带有无默认值的不可解析的占位符将被忽略通过原样传递。
getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
// 尽早初始化 LoadTimeWeaverAware Bean，以便尽早注册它们的转换器
//获取与BeanPostProcessor.class（包括子类）匹配的bean名称，如果是FactoryBeans会根据beanDefinition 或getObjectType的值判断
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
//遍历weaverAwareNames
for (String weaverAwareName : weaverAwareNames) {
//获取在BeanFactory中weaverAwareName对应的Bean对象
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
// 停止使用临时类加载器进行类型匹配
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
// 允许缓存所有BeanDefinition元数据，而不期望进一步的更改
//冻结所有beanDefinition，表示不再进一步修改或后处理已注册的BeanDefinition，这允许工厂积极地缓存bean定义元数据
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化所有剩余的（非延迟初始化）单例
//确保所有非延迟初始化单例化都已实例化，同时也要考虑FactoryBean。
beanFactory.preInstantiateSingletons();
}
/**
* <p>完成刷新：
* <ol>
* <li> 清空在资源加载器中的所有资源缓存</li>
* <li> 初始化 LifecycleProcessor.如果上下文中找到 'lifecycleProcessor' 的 LifecycleProcessor Bean对象，
* 则使用 DefaultLifecycleProcessor</li>
* <li> 将刷新传播到生命周期处理器 </li>
* <li> 新建 ContextRefreshedEvent 事件对象，将其发布到所有监听器。 </li>
* <li> 注册 当前上下文 到 LiveBeansView，以支持 JMX 服务</li>
* </ol>
* </p>
* Finish the refresh of this context, invoking the LifecycleProcessor's
* onRefresh() method and publishing the
* {@link org.springframework.context.event.ContextRefreshedEvent}.
* <p>调用 LifecycleProcessor 的 onRefresh() 方法并发布 ContextRefreshedEvent ，完成上下
* 问刷新</p>
*/
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
// 清楚上下文级别的资源缓存(如扫描的ASM元数据)
// 清空在资源加载器中的所有资源缓存
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 为这个上下文初始化生命周期处理器
// 初始化 LifecycleProcessor.如果上下文中找到 'lifecycleProcessor' 的 LifecycleProcessor Bean对象，
// 则使用 DefaultLifecycleProcessor
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 首先将刷新传播到生命周期处理器
// 上下文刷新的通知，例如自动启动的组件
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 发布最终事件
// 新建 ContextRefreshedEvent 事件对象，将其发布到所有监听器。
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
// 参与 LiveBeansView MBean，如果是活动的
// LiveBeansView:Sping 用于支持 JMX 服务的类，详情请参考：https://www.jianshu.com/p/fa4e88f95631
// 注册 当前上下文 到 LiveBeansView，以支持 JMX 服务
LiveBeansView.registerApplicationContext(this);
}
/**
* Cancel this context's refresh attempt, resetting the {@code active} flag
* after an exception got thrown.
* <p> 取消 此上下文的刷新尝试，在抛出异常后 重置 active 标志</p>
* @param ex the exception that led to the cancellation
* -- 导致取消的异常
*/
protected void cancelRefresh(BeansException ex) {
this.active.set(false);
}
/**
* <p>删除ReflectionUtils，AnnotationUtils，ResolvableType的缓存，清除当前的类加载器的自省缓存，删除该类加载器下
* 所有类的自省结果，并从接受列表中删除类加载器(及其子类)</p>
* Reset Spring's common reflection metadata caches, in particular the
* {@link ReflectionUtils}, {@link AnnotationUtils}, {@link ResolvableType}
* and {@link CachedIntrospectionResults} caches.
* <p>在 Spring 的核心中重置常见的自省缓存，因为我们可能不再需要单例bean的元数据了</p>
* @since 4.2
* @see ReflectionUtils#clearCache()
* @see AnnotationUtils#clearCache()
* @see ResolvableType#clearCache()
* @see CachedIntrospectionResults#clearClassLoader(ClassLoader)
*/
protected void resetCommonCaches() {
//将ReflectionUtil的DeclaredMethod缓存,declaredFields缓存清空【使用ReflectionUtil来解析出类的DeclaredMethod，declaredFields都会加入到该缓存中】
ReflectionUtils.clearCache();
//清除内部注解元数据缓存
AnnotationUtils.clearCache();
//清除内部的ResolvableType缓存和SerializableTypeWrapper缓存
ResolvableType.clearCache();
//CachedIntrospectionResults：为Java类缓存JavaBeans PropertyDescriptor信息的内部类。不打算由应用程序代码直接 使用
//清除当前的类加载器的自省缓存，删除该类加载器下所有类的自省结果，并从接受列表中删除类加载器(及其子类)
CachedIntrospectionResults.clearClassLoader(getClassLoader());
}
/**
* Register a shutdown hook {@linkplain Thread#getName() named}
* {@code SpringContextShutdownHook} with the JVM runtime, closing this
* context on JVM shutdown unless it has already been closed at that time.
* <p>Delegates to {@code doClose()} for the actual closing procedure.
* @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() {
synchronized (startupShutdownMonitor) {
doClose();
}
}
};
Runtime.getRuntime().addShutdownHook(this.shutdownHook);
}
}
/**
* Callback for destruction of this instance, originally attached
* to a {@code DisposableBean} implementation (not anymore in 5.0).
* <p>The {@link #close()} method is the native way to shut down
* an ApplicationContext, which this method simply delegates to.
* @deprecated as of Spring Framework 5.0, in favor of {@link #close()}
*/
@Deprecated
public void destroy() {
close();
}
/**
* Close this application context, destroying all beans in its bean factory.
* <p>Delegates to {@code doClose()} for the actual closing procedure.
* Also removes a JVM shutdown hook, if registered, as it's not needed anymore.
* @see #doClose()
* @see #registerShutdownHook()
*/
@Override
public void close() {
synchronized (this.startupShutdownMonitor) {
doClose();
// If we registered a JVM shutdown hook, we don't need it anymore now:
// We've already explicitly closed the context.
if (this.shutdownHook != null) {
try {
Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
}
catch (IllegalStateException ex) {
// ignore - VM is already shutting down
}
}
}
}
/**
* Actually performs context closing: publishes a ContextClosedEvent and
* destroys the singletons in the bean factory of this application context.
* <p>Called by both {@code close()} and a JVM shutdown hook, if any.
* @see org.springframework.context.event.ContextClosedEvent
* @see #destroyBeans()
* @see #close()
* @see #registerShutdownHook()
*/
protected void doClose() {
// Check whether an actual close attempt is necessary...
if (this.active.get() && this.closed.compareAndSet(false, true)) {
if (logger.isDebugEnabled()) {
logger.debug("Closing " + this);
}
LiveBeansView.unregisterApplicationContext(this);
try {
// Publish shutdown event.
publishEvent(new ContextClosedEvent(this));
}
catch (Throwable ex) {
logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
}
// Stop all Lifecycle beans, to avoid delays during individual destruction.
if (this.lifecycleProcessor != null) {
try {
this.lifecycleProcessor.onClose();
}
catch (Throwable ex) {
logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
}
}
// Destroy all cached singletons in the context's BeanFactory.
destroyBeans();
// Close the state of this context itself.
closeBeanFactory();
// Let subclasses do some final clean-up if they wish...
onClose();
// Reset local application listeners to pre-refresh state.
if (this.earlyApplicationListeners != null) {
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// Switch to inactive.
this.active.set(false);
}
}
/**
* Template method for destroying all beans that this context manages.
* The default implementation destroy all cached singletons in this context,
* invoking {@code DisposableBean.destroy()} and/or the specified
* "destroy-method".
* <p>用于销毁此上下文管理的所有bean的模板方法。
* 默认实现此上下文中销毁所有缓存的单例，调用{@code DisposableBean.destroy()}和
* 或指定的'destory-method'</p>
*
* <p>Can be overridden to add context-specific bean destruction steps
* right before or right after standard singleton destruction,
* while the context's BeanFactory is still active.
* <p>可以被覆盖以添加上下文特定的bean销毁步骤在标准单例销毁之前或之后，在上下文
* 的BeanFactory仍处于活动状态时</p>
*
* @see #getBeanFactory()
* @see org.springframework.beans.factory.config.ConfigurableBeanFactory#destroySingletons()
*/
protected void destroyBeans() {
//销毁在工厂中的所有单例bean，包括已注册为一次性的内部bean。在工厂关闭时调用。
getBeanFactory().destroySingletons();
}
/**
* Template method which can be overridden to add context-specific shutdown work.
* The default implementation is empty.
* <p>Called at the end of {@link #doClose}'s shutdown procedure, after
* this context's BeanFactory has been closed. If custom shutdown logic
* needs to execute while the BeanFactory is still active, override
* the {@link #destroyBeans()} method instead.
*/
protected void onClose() {
// For subclasses: do nothing by default.
}
@Override
public boolean isActive() {
return this.active.get();
}
/**
* <p>如果此上下文没有处于活动状态，就抛出异常</p>
* Assert that this context's BeanFactory is currently active,
* throwing an {@link IllegalStateException} if it isn't.
* <p>断言 此上下文的BeanFactory当前是活动的，如果不是，则抛出 IllegalStateException</p>
* <p>Invoked by all {@link BeanFactory} delegation methods that depend
* on an active context, i.e. in particular all bean accessor methods.
* <p>由依赖于活动上下文的所有BeanFactory的所有BeanFactory委托方法调用，特别是所有Bean访问器方法</p>
* <p>The default implementation checks the {@link #isActive() 'active'} status
* of this context overall. May be overridden for more specific checks, or for a
* no-op if {@link #getBeanFactory()} itself throws an exception in such a case.
* <p>默认实现检查上下文的'active'状态。对应更具体的检查，或者对应无操作（如果getBeanfactory()）本身
* 再这种情况下抛出异常），可能会被覆盖</p>
*/
protected void assertBeanFactoryActive() {
//如果 此上下文没有处于活动状态
if (!this.active.get()) {
//如果此上下文处于关闭状态
if (this.closed.get()) {
//抛出 非法状态异常：displayName 已经关闭
throw new IllegalStateException(getDisplayName() + " has been closed already");
}
else {
//抛出 非法状态异常：displayName 还没有刷新完
throw new IllegalStateException(getDisplayName() + " has not been refreshed yet");
}
}
}
//---------------------------------------------------------------------
// Implementation of BeanFactory interface
//---------------------------------------------------------------------
@Override
public Object getBean(String name) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name);
}
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name, requiredType);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name, args);
}
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(requiredType);
}
@Override
public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(requiredType, args);
}
@Override
public <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType) {
assertBeanFactoryActive();
return getBeanFactory().getBeanProvider(requiredType);
}
@Override
public <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType) {
assertBeanFactoryActive();
return getBeanFactory().getBeanProvider(requiredType);
}
@Override
public boolean containsBean(String name) {
return getBeanFactory().containsBean(name);
}
@Override
public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().isSingleton(name);
}
@Override
public boolean isPrototype(String name) throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().isPrototype(name);
}
@Override
public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().isTypeMatch(name, typeToMatch);
}
@Override
public boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException {
//如果此上下文没有处于活动状态，就抛出异常
assertBeanFactoryActive();
//检查具有给定名称的bean是否与指定的类型匹配
return getBeanFactory().isTypeMatch(name, typeToMatch);
}
@Override
@Nullable
public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().getType(name);
}
@Override
@Nullable
public Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().getType(name, allowFactoryBeanInit);
}
@Override
public String[] getAliases(String name) {
return getBeanFactory().getAliases(name);
}
//---------------------------------------------------------------------
// Implementation of ListableBeanFactory interface
//---------------------------------------------------------------------
@Override
public boolean containsBeanDefinition(String beanName) {
return getBeanFactory().containsBeanDefinition(beanName);
}
@Override
public int getBeanDefinitionCount() {
return getBeanFactory().getBeanDefinitionCount();
}
@Override
public String[] getBeanDefinitionNames() {
return getBeanFactory().getBeanDefinitionNames();
}
@Override
public String[] getBeanNamesForType(ResolvableType type) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type);
}
@Override
public String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
}
@Override
public String[] getBeanNamesForType(@Nullable Class<?> type) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type);
}
@Override
public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
}
@Override
public <T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBeansOfType(type);
}
@Override
public <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBeansOfType(type, includeNonSingletons, allowEagerInit);
}
@Override
public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForAnnotation(annotationType);
}
@Override
public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBeansWithAnnotation(annotationType);
}
@Override
@Nullable
public <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().findAnnotationOnBean(beanName, annotationType);
}
//---------------------------------------------------------------------
// Implementation of HierarchicalBeanFactory interface
//---------------------------------------------------------------------
@Override
@Nullable
public BeanFactory getParentBeanFactory() {
return getParent();
}
@Override
public boolean containsLocalBean(String name) {
return getBeanFactory().containsLocalBean(name);
}
/**
* Return the internal bean factory of the parent context if it implements
* ConfigurableApplicationContext; else, return the parent context itself.
* <p>如果父级bean工厂实现了ConfigurableApplicationContext接口,则返回父上下文的
* 内部bean工厂。否则，返回父上下文本身</p>
* @see org.springframework.context.ConfigurableApplicationContext#getBeanFactory
*/
@Nullable
protected BeanFactory getInternalParentBeanFactory() {
return (getParent() instanceof ConfigurableApplicationContext ?
((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent());
}
//---------------------------------------------------------------------
// Implementation of MessageSource interface
//---------------------------------------------------------------------
@Override
public String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale) {
return getMessageSource().getMessage(code, args, defaultMessage, locale);
}
@Override
public String getMessage(String code, @Nullable Object[] args, Locale locale) throws NoSuchMessageException {
return getMessageSource().getMessage(code, args, locale);
}
@Override
public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
return getMessageSource().getMessage(resolvable, locale);
}
/**
* Return the internal MessageSource used by the context.
* @return the internal MessageSource (never {@code null})
* @throws IllegalStateException if the context has not been initialized yet
*/
private MessageSource getMessageSource() throws IllegalStateException {
if (this.messageSource == null) {
throw new IllegalStateException("MessageSource not initialized - " +
"call 'refresh' before accessing messages via the context: " + this);
}
return this.messageSource;
}
/**
* Return the internal message source of the parent context if it is an
* AbstractApplicationContext too; else, return the parent context itself.
* <p>如果父上下文也是 AbstractApplicationContext ,则返回父上下文的内部消息源；
* 否则，返回父上下文本身</p>
*/
@Nullable
protected MessageSource getInternalParentMessageSource() {
//如果父级上下文是AbstractApplicationContext对象，就返回其messageSource；否则直接返回父级上下文
return (getParent() instanceof AbstractApplicationContext ?
((AbstractApplicationContext) getParent()).messageSource : getParent());
}
//---------------------------------------------------------------------
// Implementation of ResourcePatternResolver interface
//---------------------------------------------------------------------
@Override
public Resource[] getResources(String locationPattern) throws IOException {
return this.resourcePatternResolver.getResources(locationPattern);
}
//---------------------------------------------------------------------
// Implementation of Lifecycle interface
//---------------------------------------------------------------------
@Override
public void start() {
getLifecycleProcessor().start();
publishEvent(new ContextStartedEvent(this));
}
@Override
public void stop() {
getLifecycleProcessor().stop();
publishEvent(new ContextStoppedEvent(this));
}
@Override
public boolean isRunning() {
return (this.lifecycleProcessor != null && this.lifecycleProcessor.isRunning());
}
//---------------------------------------------------------------------
// Abstract methods that must be implemented by subclasses
//---------------------------------------------------------------------
/**
* Subclasses must implement this method to perform the actual configuration load.
* The method is invoked by {@link #refresh()} before any other initialization work.
* <p>子类必须实现此方法才能执行实际的配置加载。在进行任何其他舒适化工作之前，该方法由
* {@link #refresh()}调用。</p>
*
* <p>A subclass will either create a new bean factory and hold a reference to it,
* or return a single BeanFactory instance that it holds. In the latter case, it will
* usually throw an IllegalStateException if refreshing the context more than once.
* <p>子类创建一个新的bean工厂并保留对其的引用，或者返回它持有的单个BeanFactory实例。在
* 后一种情况下，如果多次属性上下文，通常会抛出IllegalStateException</p>
*
* @throws BeansException if initialization of the bean factory failed
* -- 如果bean工厂初始化失败
* @throws IllegalStateException if already initialized and multiple refresh
* attempts are not supported
* -- 如果已经初始化并且不支持多次刷新尝试
*/
protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
/**
* Subclasses must implement this method to release their internal bean factory.
* This method gets invoked by {@link #close()} after all other shutdown work.
* <p>子类必须必须实现此方法才能释放其内部bean工厂。在所有其他关闭工作之后，此方法
* 将由{@link #close()}调用</p>
*
* <p>Should never throw an exception but rather log shutdown failures.
* <p>永远不要抛出异常，应该记录关闭失败</p>
*/
protected abstract void closeBeanFactory();
/**
* <p>获取当前上下文的BeanFactory对象</p>
* Subclasses must return their internal bean factory here. They should implement the
* lookup efficiently, so that it can be called repeatedly without a performance penalty.
* <p>子类必须在此返回其内部bean工厂。他们应该有效地实现查找，以便可以重复调用它而不
* 影响性能</p>
*
* <p>Note: Subclasses should check whether the context is still active before
* returning the internal bean factory. The internal factory should generally be
* considered unavailable once the context has been closed.
* <p>注意：子类应在返回内部bean工厂之前检验上下文是否仍处于活动状态。一旦关闭上下
* 文，通常应将内部工厂视为不可用，</p>
*
* @return this application context's internal bean factory (never {@code null})
* --此应用程序上下文的内部bean工厂（永远不为{@code null})
* @throws IllegalStateException if the context does not hold an internal bean factory yet
* (usually if {@link #refresh()} has never been called) or if the context has been
* closed already
* -- 如果上下文尚未拥有内部bean工厂（通常是从未调用过{@link #refresh()}),或上下文已经关闭
* @see #refreshBeanFactory()
* @see #closeBeanFactory()
*/
@Override
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
/**
* Return information about this context.
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder(getDisplayName());
sb.append(", started on ").append(new Date(getStartupDate()));
ApplicationContext parent = getParent();
if (parent != null) {
sb.append(", parent: ").append(parent.getDisplayName());
}
return sb.toString();
}
}
131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
