AbstractApplicationContext
package org.springframework.context.support;
/**
抽象实现{@link org.springframework.context. context}*接口。
不强制要求配置使用的存储类型;简单的实现公共上下文功能。使用模板方法设计模式，*需要具体的子类来实现抽象方法。** 与普通的BeanFactory相比，应用程序上下文是假定的*检测其内部bean工厂定义的特殊bean:*因此，
该类自动注册* {@link org.springframework.beans.factory.config。BeanFactoryPostProcessor BeanFactoryPostProcessor},*
{@link org.springframework.beans.factory.config。BeanPostProcessor BeanPostProcessors}和
{@link org.springframe .context。ApplicationListener ApplicationListeners}*在上下文中定义为bean。** A
{@link org.springframework.context. html还可以提供MessageSource}*
作为上下文中的bean，名称为“messageSource”;否则,消息*决议被委托给父上下文。此外,传播（组装，注册）*
for application events可以作为“applicationEventMulticaster”bean提供*类型为
{@link org.springframework.context.event.ApplicationEventMulticaster}*在上下文中;否则，默认的传播（组装，注册）器类型*
{@link org.springframework.context.event。将使用SimpleApplicationEventMulticaster}。** 通过扩展实现资源加载*
{@link org.springframework.core.io.DefaultResourceLoader}。*因此将非url资源路径视为类路径资源*(支持包含包路径的完整类路径资源名，*如。"mypackage/myresource.dat")，除非
{@link #getResourceByPath}方法在子类中被重写。
*/
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext, DisposableBean {
/**
* 工厂中MessageSource bean的名称。*如果没有提供，则将消息解析委托给父级。
*/
public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";
/**
* 工厂中的LifecycleProcessor bean的名称。*如果没有提供，则使用DefaultLifecycleProcessor。
* @see org.springframework.context.LifecycleProcessor
* @see org.springframework.context.support.DefaultLifecycleProcessor
*/
public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
/**
* 工厂中的ApplicationEventMulticaster bean的名称。*如果没有提供，则使用默认的SimpleApplicationEventMulticaster。
* @see org.springframework.context.event.ApplicationEventMulticaster
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
static {
// 急切地加载ContextClosedEvent类，以避免奇怪的类加载器问题//在WebLogic 8.1中关闭应用程序。(达斯汀·伍兹[Dustin Woods]报道。)
ContextClosedEvent.class.getName();
}
/** 该类使用的日志记录器。可用于子类。 */
protected final Log logger = LogFactory.getLog(getClass());
/** 此上下文的唯一id(如果有的话) */
private String id = ObjectUtils.identityToString(this);
/** 显示名称 */
private String displayName = ObjectUtils.identityToString(this);
/** 父上下文中 */
private ApplicationContext parent;
/** 此上下文使用的环境 */
private ConfigurableEnvironment environment;
/** 应用于刷新的beanfactorypostprocessor bean工厂后处理程序*/
private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors =
new ArrayList<BeanFactoryPostProcessor>();
/** S此上下文启动时的系统时间(以毫秒为单位) */
private long startupDate;
/** 标志，指示此上下文当前是否处于活动状态 */
private final AtomicBoolean active = new AtomicBoolean();
/** 标志，指示此上下文是否已关闭 */
private final AtomicBoolean closed = new AtomicBoolean();
/** 刷新”和“销毁”同步监视器 */
private final Object startupShutdownMonitor = new Object();
/** 如果注册，则引用JVM关机钩子 */
private Thread shutdownHook;
/** 此上下文使用的资源模式解析器 */
private ResourcePatternResolver resourcePatternResolver;
/** 生命周期处理器，用于在此上下文中管理bean的生命周期 */
private LifecycleProcessor lifecycleProcessor;
/** 我们将此接口的实现委托给MessageSource */
private MessageSource messageSource;
/** H用于事件发布的elper类 */
private ApplicationEventMulticaster applicationEventMulticaster;
/** Statically specified listeners */
private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<ApplicationListener<?>>();
/** ApplicationEvents早期发表的 */
private Set<ApplicationEvent> earlyApplicationEvents;
/**
* 创建一个新的没有父类的AbstractApplicationContext。
*/
public AbstractApplicationContext() {
this.resourcePatternResolver = getResourcePatternResolver();
}
/**
* 使用给定的父上下文创建一个新的AbstractApplicationContext。
* @param parent the parent context
*/
public AbstractApplicationContext(ApplicationContext parent) {
this();
setParent(parent);
}
//---------------------------------------------------------------------
// 实现ApplicationContext接口
//---------------------------------------------------------------------
/**
* 设置此应用程序上下文的唯一id。* 默认值是上下文实例的对象id或名称如果上下文本身定义为bean，则上下文bean的。
* @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 "";
}
/**
* 为这个上下文设置一个友好的名称。*通常在初始化具体上下文实现期间完成。* 默认值是上下文实例的对象id。
*/
public void setDisplayName(String displayName) {
Assert.hasLength(displayName, "Display name must not be empty");
this.displayName = displayName;
}
/**
* 返回此上下文的友好名称。
* @return a display name for this context (never {@code null})
*/
@Override
public String getDisplayName() {
return this.displayName;
}
/**
* 返回父上下文，如果没有父上下文，则返回{@code null}
* (that is, this context is the root of the context hierarchy).
*/
@Override
public ApplicationContext getParent() {
return this.parent;
}
/**
* 为这个应用程序上下文设置{@code环境}。* 默认值由{@link #createEnvironment()}决定。取代了
*此方法的默认值是一个选项，但是通过{@link进行配置
* #getEnvironment()}也应该考虑。无论哪种情况，这些修改
*应该在 {@link #refresh()}之前执行。
* @see org.springframework.context.support.AbstractApplicationContext#createEnvironment
*/
@Override
public void setEnvironment(ConfigurableEnvironment environment) {
this.environment = environment;
}
/**
* 以可配置的方式返回此应用程序上下文的，允许进一步定制。
* 如果没有指定，默认环境将通过{@link #createEnvironment()}.
*/
@Override
public ConfigurableEnvironment getEnvironment() {
if (this.environment == null) {
this.environment = createEnvironment();
}
return this.environment;
}
/**
* 创建并返回一个新的{@link StandardEnvironment}。* 子类可以覆盖此方法来提供
* a custom {@link ConfigurableEnvironment} implementation.
*/
protected ConfigurableEnvironment createEnvironment() {
return new StandardEnvironment();
}
/**
* 将这个上下文的内部bean工厂返回为AutowireCapableBeanFactory，*如果已经有的话。
* @see #getBeanFactory()
*/
@Override
public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException {
return getBeanFactory();
}
/**
* 返回第一次加载此上下文时的时间戳(ms)。
*/
@Override
public long getStartupDate() {
return this.startupDate;
}
/**
* 将给定的事件发布给所有侦听器。
* 注意:侦听器在MessageSource之后初始化，以便能够在侦听器实现中访问它。因此，MessageSource实现不能发布事件。
* @param事件要发布的事件(可以是特定于应用程序的事件，也可以是标准框架事件)
*/
@Override
public void publishEvent(ApplicationEvent event) {
publishEvent(event, null);
}
/**
* 将给定的事件发布给所有侦听器。
* 注意:侦听器在MessageSource之后初始化，以便能够在侦听器实现中访问它。因此，MessageSource实现不能发布事件。
* @param事件要发布的事件(可以是{@link ApplicationEvent})*或将转换为{@link PayloadApplicationEvent}的有效负载对象)
*/
@Override
public void publishEvent(Object event) {
publishEvent(event, null);
}
/**
* 将给定的事件发布给所有侦听器。
* @param事件要发布的事件(可以是{@link ApplicationEvent}或要转换为{@link PayloadApplicationEvent}的有效负载对象)
* @param eventType已解析事件类型(如果已知)
* @since 4.2
*/
protected void publishEvent(Object event, ResolvableType eventType) {
Assert.notNull(event, "Event must not be null");
if (logger.isTraceEnabled()) {
logger.trace("Publishing event in " + getDisplayName() + ": " + event);
}
// 必要时将事件装饰为ApplicationEvent
ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent) {
applicationEvent = (ApplicationEvent) event;
}
else {
applicationEvent = new PayloadApplicationEvent<Object>(this, event);
if (eventType == null) {
eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
}
}
// 如果可能的话，现在就进行传播（组装，注册）——或者在初始化传播（组装，注册）之后延迟地进行传播（组装，注册）
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
else {
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// 也可以通过父上下文发布事件…
if (this.parent != null) {
if (this.parent instanceof AbstractApplicationContext) {
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
this.parent.publishEvent(event);
}
}
}
/**
* 返回上下文使用的内部ApplicationEventMulticaster。
* @返回内部ApplicationEventMulticaster(从来没有{@code null})
* @如果上下文还没有初始化，则抛出IllegalStateException
*/
ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
if (this.applicationEventMulticaster == null) {
throw new IllegalStateException("ApplicationEventMulticaster not initialized - " +
"call 'refresh' before multicasting events via the context: " + this);
}
return this.applicationEventMulticaster;
}
/**
* 返回上下文使用的内部LifecycleProcessor。
* @返回内部LifecycleProcessor(绝不是{@code null})
* @如果上下文还没有初始化，则抛出IllegalStateException
*/
LifecycleProcessor getLifecycleProcessor() throws IllegalStateException {
if (this.lifecycleProcessor == null) {
throw new IllegalStateException("LifecycleProcessor not initialized - " +
"call 'refresh' before invoking lifecycle methods via the context: " + this);
}
return this.lifecycleProcessor;
}
/**
* 返回要用于解析位置模式的资源解析器
*进入资源实例。默认是一个* {@link org.springframework.core.io.support.PathMatchingResourcePatternResolver},支持ant样式的位置模式。
* 可以在子类中重写，对于扩展解析策略，*例如在web环境中。在需要解析位置模式时不要调用这个
*调用上下文的{@code getResources}方法将委托给ResourcePatternResolver。
* @返回此上下文的ResourcePatternResolver* @see # getresource* @see org.springframework.core.io.support.PathMatchingResourcePatternResolver
*/
protected ResourcePatternResolver getResourcePatternResolver() {
return new PathMatchingResourcePatternResolver(this);
}
//---------------------------------------------------------------------
// ConfigurableApplicationContext接口的实现
//---------------------------------------------------------------------
/**
* 设置此应用程序上下文的父。父{@linkplain ApplicationContext#getEnvironment() environment}是
* {@linkplain ConfigurableEnvironment#merge(ConfigurableEnvironment) merge} with
*如果父类不是-{@code null}，则此(子)应用程序上下文环境*它的环境是{@link ConfigurableEnvironment}的一个实例。
* @see ConfigurableEnvironment #合并(ConfigurableEnvironment)
*/
@Override
public void setParent(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);
}
/**
* 返回将应用于内部BeanFactory的beanfactorypostprocessor列表。
*/
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);
}
else {
this.applicationListeners.add(listener);
}
}
/**
* 返回静态指定的applicationlistener列表。
*/
public Collection<ApplicationListener<?>> getApplicationListeners() {
return this.applicationListeners;
}
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 准备好刷新上下文。
prepareRefresh();
// 告诉子类刷新内部bean工厂。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 准备bean工厂，以便在此上下文中使用。
prepareBeanFactory(beanFactory);
try {
// 允许在上下文子类中对bean工厂进行后处理。
postProcessBeanFactory(beanFactory);
// 调用上下文中注册为bean的工厂处理器。
invokeBeanFactoryPostProcessors(beanFactory);
// 注册bean创建的bean处理器。
registerBeanPostProcessors(beanFactory);
// 初始化此上下文的消息源。
initMessageSource();
// 初始化此上下文的事件传播（注册，组装）程序。
initApplicationEventMulticaster();
//初始化特定上下文子类中的其他特殊bean。
onRefresh();
// 检查侦听器bean并注册它们。
registerListeners();
// 实例化所有剩余的(非惰性初始化)单例。
finishBeanFactoryInitialization(beanFactory);
//最后一步:发布相应的事件。
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 销毁已经创建的单例，以避免挂起资源。
destroyBeans();
// 重置“活跃”的旗帜。
cancelRefresh(ex);
// 将异常传播给调用者。
throw ex;
}
finally {
// 重置Spring核心中的常见内省缓存，因为我们
//可能再也不需要单例bean的元数据了……
resetCommonCaches();
}
}
}
/**
* 准备此上下文用于刷新、设置其启动日期和活动标志以及执行任何属性源的初始化。
*/
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// 在上下文环境中初始化任何占位符属性源
initPropertySources();
// 验证所有标记为必需的属性都是可解析的
//看到ConfigurablePropertyResolver # setRequiredProperties
getEnvironment().validateRequiredProperties();
// 允许收集早期应用程序事件，一旦传播（组装，注册）机可用，将发布…
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}
/**
* 用实际实例替换任何存根属性源。
* @see org.springframework.core.env.PropertySource.StubPropertySource
* @see org.springframework.web.context.support.WebApplicationContextUtils#initServletPropertySources
*/
protected void initPropertySources() {
// For subclasses: do nothing by default.
}
/**
* 告诉子类刷新内部bean工厂。
* @return the fresh BeanFactory instance
* @see #refreshBeanFactory()
* @see #getBeanFactory()
*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
/**
* 配置工厂的标准上下文特征，例如上下文的类加载器和后处理程序。
* @param beanFactory the BeanFactory to configure
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 告诉内部bean工厂使用上下文的类加载器等等。
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 使用上下文回调配置bean工厂。
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 在普通工厂中未注册为可解析类型的BeanFactory接口。
// MessageSource registered (and found for autowiring) as a bean.
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 将早期后处理器注册为application监听器，用于检测内部bean。
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 检测LoadTimeWeaver并准备编织(如果找到)。
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// 为类型匹配设置一个临时类加载器。
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
//注册缺省环境bean。
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
/**
* 根据应用程序上下文的标准修改其内部bean工厂初始化。所有bean定义都已加载，但还没有实例化bean。
* 这允许在特定的ApplicationContext实现中注册特殊的beanpostprocessor等。
* @param beanFactory应用程序上下文使用的bean工厂
*/
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}
/**
* 实例化并调用所有已注册的BeanFactoryPostProcessor bean，
*如果给出明确的顺序。 必须在单例实例化之前调用。
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// 检测LoadTimeWeaver并准备编织，如果同时发现
//(例如，通过ConfigurationClassPostProcessor注册的@Bean方法)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
/**
* 实例化并调用所有已注册的BeanPostProcessor bean，如果给定显式顺序，则遵循显式顺序。* 必须在应用程序bean的任何实例化之前调用。
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
/**
* 初始化MessageSource。*如果在此上下文中没有定义父类，则使用父类。
*/
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// 让MessageSource知道父消息源。
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// 如果没有父消息源，则只将父上下文设置为父消息源
// 注册了。
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isDebugEnabled()) {
logger.debug("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// 使用空MessageSource能够接受getMessage调用。
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
"': using default [" + this.messageSource + "]");
}
}
}
/**
* 初始化ApplicationEventMulticaster。如果上下文中没有定义，则使用SimpleApplicationEventMulticaster。
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
*/
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isDebugEnabled()) {
logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
"': using default [" + this.applicationEventMulticaster + "]");
}
}
}
/**
* 初始化LifecycleProcessor。如果上下文中没有定义DefaultLifecycleProcessor，则使用它。
* @see org.springframework.context.support.DefaultLifecycleProcessor
*/
protected void initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
if (logger.isDebugEnabled()) {
logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
else {
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate LifecycleProcessor with name '" +
LIFECYCLE_PROCESSOR_BEAN_NAME +
"': using default [" + this.lifecycleProcessor + "]");
}
}
}
/**
* 模板方法，可以重写该方法以添加特定于上下文的刷新工作。*在实例化单例之前，在初始化特殊bean时调用。* 这个实现是空的。
* @throws BeansException in case of errors
* @see #refresh()
*/
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}
/**
* 添加实现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 (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
/**
* 完成此上下文的bean工厂的初始化，初始化所有剩余的单例bean。
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化此上下文的转换服务。
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));
}
// 如果没有bean后处理器，注册一个默认的嵌入式值解析器//(例如PropertyPlaceholderConfigurer bean)以前注册过:
//此时，主要用于解析注释属性值。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
// 尽早初始化LoadTimeWeaverAware bean，以便尽早注册它们的转换器。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
//停止使用临时类加载器进行类型匹配。
beanFactory.setTempClassLoader(null);
// 允许缓存所有bean定义元数据，不期望有进一步的更改。
beanFactory.freezeConfiguration();
// 实例化所有剩余的(非惰性初始化)单例。
beanFactory.preInstantiateSingletons();
}
/**
* 完成此上下文的刷新，调用LifecycleProcessor的onRefresh()方法并发布
* {@link org.springframework.context.event.ContextRefreshedEvent}.
*/
protected void finishRefresh() {
// 初始化此上下文的生命周期处理器。
initLifecycleProcessor();
// 首先将refresh传播到生命周期处理器。
getLifecycleProcessor().onRefresh();
// 发布最终事件。
publishEvent(new ContextRefreshedEvent(this));
// 如果活动，请参与LiveBeansView MBean。
LiveBeansView.registerApplicationContext(this);
}
/**
* 取消此上下文的刷新尝试，在抛出异常后重置{@code active}标志。
* @param ex the exception that led to the cancellation
*/
protected void cancelRefresh(BeansException ex) {
this.active.set(false);
}
/**
* 重置Spring的公共核心缓存，特别是{@link ReflectionUtils}，
* {@link ResolvableType} and {@link CachedIntrospectionResults} caches.
* @since 4.2
* @see ReflectionUtils#clearCache()
* @see ResolvableType#clearCache()
* @see CachedIntrospectionResults#clearClassLoader(ClassLoader)
*/
protected void resetCommonCaches() {
ReflectionUtils.clearCache();
ResolvableType.clearCache();
CachedIntrospectionResults.clearClassLoader(getClassLoader());
}
/**
* 向JVM运行时注册一个关机钩子，在JVM关机时关闭这个上下文，除非它当时已经关闭。
* 委托给{@code doClose()}执行实际的关闭过程。
* @see Runtime#addShutdownHook
* @see #close()
* @see #doClose()
*/
@Override
public void registerShutdownHook() {
if (this.shutdownHook == null) {
// No shutdown hook registered yet.
this.shutdownHook = new Thread() {
@Override
public void run() {
synchronized (startupShutdownMonitor) {
doClose();
}
}
};
Runtime.getRuntime().addShutdownHook(this.shutdownHook);
}
}
/**
* 销毁此实例的抛出bean回调。
* {@link #close()}方法是关闭ApplicationContext的本机方法，该方法只是将其委托给ApplicationContext。
* @see #close()
*/
@Override
public void destroy() {
close();
}
/**
* 关闭此应用程序上下文，销毁其bean工厂中的所有bean。
* 委托给{@code doClose()}执行实际的关闭过程。
*还删除了一个JVM关闭挂钩(如果注册了)，因为它不再需要了。
* @see #doClose()
* @see #registerShutdownHook()
*/
@Override
public void close() {
synchronized (this.startupShutdownMonitor) {
doClose();
// 如果我们注册了一个JVM关机钩子，现在就不需要它了:
// 我们已经显式地关闭了上下文。
if (this.shutdownHook != null) {
try {
Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
}
catch (IllegalStateException ex) {
// ignore - VM is already shutting down
}
}
}
}
/**
* 实际执行上下文关闭:发布ContextClosedEvent并销毁此应用程序上下文的bean工厂中的单例。
* 由{@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.isInfoEnabled()) {
logger.info("Closing " + this);
}
LiveBeansView.unregisterApplicationContext(this);
try {
// 发布关闭事件。
publishEvent(new ContextClosedEvent(this));
}
catch (Throwable ex) {
logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
}
// 停止所有生命周期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();
this.active.set(false);
}
}
/**
* 用于销毁此上下文管理的所有bean的模板方法。*默认实现调用{@code dispose bean .destroy()}和/指定的“destroy-method”销毁此上下文中所有缓存的单例。
* 可以被覆盖，在标准单例销毁之前或之后添加上下文特定的bean销毁步骤，而上下文的BeanFactory仍然是活动的。
* @see #getBeanFactory()
* @see org.springframework.beans.factory.config.ConfigurableBeanFactory#destroySingletons()
*/
protected void destroyBeans() {
getBeanFactory().destroySingletons();
}
/**
* 模板方法，可以重写该方法以添加特定于上下文的关机工作。*默认实现为空。
* 在{@link doClose}的关闭过程结束时调用，此时上下文的BeanFactory已经关闭。如果自定义关闭逻辑需要在BeanFactory仍然处于活动状态时执行，则重写
* {@link #destroyBeans()方法。
*/
protected void onClose() {
// For subclasses: do nothing by default.
}
@Override
public boolean isActive() {
return this.active.get();
}
/**
* 断言该上下文的BeanFactory当前处于活动状态，如果不是，则抛出{@link IllegalStateException}。
* 由依赖于活动上下文的所有{@link BeanFactory}委托方法调用，特别是所有bean访问器方法。
* 默认实现检查{@link #isActive()整体上下文的“活动”状态。
* 如果{@link #getBeanFactory()}本身在这种情况下抛出异常，则可能会为更具体的检查或no-op重写。
*/
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接口
//---------------------------------------------------------------------
@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 <T> T getBean(Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(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, Object... args) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(requiredType, args);
}
@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();
return getBeanFactory().isTypeMatch(name, typeToMatch);
}
@Override
public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
assertBeanFactoryActive();
return getBeanFactory().getType(name);
}
@Override
public String[] getAliases(String name) {
return getBeanFactory().getAliases(name);
}
//---------------------------------------------------------------------
// ListableBeanFactory接口的实现
//---------------------------------------------------------------------
@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(Class<?> type) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type);
}
@Override
public String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
assertBeanFactoryActive();
return getBeanFactory().getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
}
@Override
public <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBeansOfType(type);
}
@Override
public <T> Map<String, T> getBeansOfType(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
public <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException{
assertBeanFactoryActive();
return getBeanFactory().findAnnotationOnBean(beanName, annotationType);
}
//---------------------------------------------------------------------
// 分层beanfactory接口的实现
//---------------------------------------------------------------------
@Override
public BeanFactory getParentBeanFactory() {
return getParent();
}
@Override
public boolean containsLocalBean(String name) {
return getBeanFactory().containsLocalBean(name);
}
/**
* 如果实现，返回父上下文的内部bean工厂* ConfigurableApplicationContext;否则，返回父上下文本身。
* @see org.springframework.context.ConfigurableApplicationContext#getBeanFactory
*/
protected BeanFactory getInternalParentBeanFactory() {
return (getParent() instanceof ConfigurableApplicationContext) ?
((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
}
//---------------------------------------------------------------------
// MessageSource接口的实现
//---------------------------------------------------------------------
@Override
public String getMessage(String code, Object args[], String defaultMessage, Locale locale) {
return getMessageSource().getMessage(code, args, defaultMessage, locale);
}
@Override
public String getMessage(String code, 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);
}
/**
* 返回上下文使用的内部MessageSource。
* @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;
}
/**
* 如果是，则返回父上下文的内部消息源* AbstractApplicationContext;否则，返回父上下文本身。
*/
protected MessageSource getInternalParentMessageSource() {
return (getParent() instanceof AbstractApplicationContext) ?
((AbstractApplicationContext) getParent()).messageSource : getParent();
}
//---------------------------------------------------------------------
// ResourcePatternResolver接口的实现
//---------------------------------------------------------------------
@Override
public Resource[] getResources(String locationPattern) throws IOException {
return this.resourcePatternResolver.getResources(locationPattern);
}
//---------------------------------------------------------------------
// 生命周期接口的实现
//---------------------------------------------------------------------
@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());
}
//---------------------------------------------------------------------
// 必须由子类实现的抽象方法
//---------------------------------------------------------------------
/**
* 子类必须实现此方法来执行实际的配置负载。*方法在任何其他初始化工作之前由{@link #refresh()}调用。
* 子类将创建一个新的bean工厂并保存对它的引用，或者返回它所保存的一个bean工厂实例。在后一种情况下，如果不止一次刷新上下文，它通常会抛出一个IllegalStateException。
* @throws BeansException if initialization of the bean factory failed
* @throws IllegalStateException if already initialized and multiple refresh
* attempts are not supported
*/
protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
/**
* 子类必须实现此方法来释放其内部bean工厂。*在所有其他关机工作之后，{@link #close()}调用此方法。
* 不应该抛出异常，而是应该记录关闭失败。
*/
protected abstract void closeBeanFactory();
/**
* 子类必须在这里返回它们的内部bean工厂。它们应该有效地实现查找，这样就可以重复调用它而不会影响性能。
* 注意:子类应该在返回内部bean工厂之前检查上下文是否仍然处于活动状态。一旦上下文被关闭，通常应该认为内部工厂不可用。
* @return这个应用程序上下文的内部bean工厂(从来没有{@code null}) @抛出IllegalStateException，如果上下文还没有包含内部bean工厂(通常如果{@link #refresh()}从来没有被调用)，或者如果上下文已经被调用
* closed already
* @see #refreshBeanFactory()
* @see #closeBeanFactory()
*/
@Override
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
/**
* 返回关于此上下文的信息。
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder(getDisplayName());
sb.append(": startup date [").append(new Date(getStartupDate()));
sb.append("]; ");
ApplicationContext parent = getParent();
if (parent == null) {
sb.append("root of context hierarchy");
}
else {
sb.append("parent: ").append(parent.getDisplayName());
}
return sb.toString();
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
