重点类：
1、ApplicationContext是核心接口，它为一个应用提供了环境配置。当应用在运行时ApplicationContext是只读的，但你可以在该接口的实现中来支持reload功能。
定义
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
}
特点：
提供了一个bean工厂方法来访问应用组件，通过继承org.springframework.beans.factory.ListableBeanFactory来获得的；
通过通用的方式来加载文件资源的能力，通过继承org.springframework.core.io.ResourceLoader来获得的；
发布事件到注册的监听器的能力，通过继承ApplicationEventPublisher来获得的；
解析消息，支持国际化的能力，通过继承MessageSource来获得的；
context的继承机制。定义在子context将优先级别更高。这意味着，例如：一个父context可以被整个web应用共享，而每个servlet可以有自己的子context，并且这些servlet彼此独立。例如http://www.cnblogs.com/davidwang456/p/4122842.html。
另外还有标准的org.springframework.beans.factory.BeanFactory的生命周期管理能力，ApplicationContext实现类发现和触发beanApplicationContextAware，还包括ResourceLoaderAware，ApplicationEventPublisherAware，MessageSourceAware bean。
1.1 EnvironmentCapable
包含并暴露了Environment引用的接口。定义
public interface EnvironmentCapable { /**
* Return the {@link Environment} associated with this component.
*/
Environment getEnvironment();}
其中，Environment表示当前运行的应用所在的环境，它有两个重要的熟悉：profiles和properties。
proportiers相关方法通过父接口PropertyResolver来暴露。
profile用来为注册的bean进行逻辑分组的工具，例如开发环境，测试环境，发布环境等。profile的激活可以通过设置AbstractEnvironment#ACTIVE_PROFILES_PROPERTY_NAME“spring.profiles.active”的系统
属性，也可以通过调用ConfigurableEnvironment的setActiveProfiles(String…)来激活。
1.2 ListableBeanFactory
ListableBeanFactory可以枚举所有bean的实例。注意，若该Beanfactory是HierarchicalBeanFactory，那么将不会考虑BeanFactory的继承关系，只返回当前工厂定义的相关bean。可以使用BeanFactoryUtils工具类获取父beanfactory的bean。
1.3 HierarchicalBeanFactory
HierarchicalBeanFactory可以通过方法BeanFactory getParentBeanFactory()获取父BeanFactory，其子接口定义了设置父BeanFactory的方法：void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
1.4 MessageSource
MessageSource是解析消息的策略接口，支持消息的参数化和国际化。
spring提供两种开箱即用的可用于生产的实现：
org.springframework.context.support.ResourceBundleMessageSource 基于标准的java.util.ResourceBundle消息解析方式
org.springframework.context.support.ReloadableResourceBundleMessageSource 具有无需重启VM即可重载消息定义的能力。
1.5 Application事件机制
1.5.1 EventPublisher事件发布
ApplicationEventPublisher接口封装了事件发布功能，作为ApplicationContext的父接口使用。
ApplicationEvent：继承自java.util.EventObject的抽象类，可以由所有的application事件扩展，但不能作为直接发布通用事件的类。常用的事件有：
实现发布的实现在AbstractApplicationConText类中:
/**
* Publish the given event to all listeners.
* <p>Note: Listeners get initialized after the MessageSource, to be able
* to access it within listener implementations. Thus, MessageSource
* implementations cannot publish events.
* @param event the event to publish (may be application-specific or a
* standard framework event)
*/
@Override
public void publishEvent(ApplicationEvent event) {
Assert.notNull(event, "Event must not be null");
if (logger.isTraceEnabled()) {
logger.trace("Publishing event in " + getDisplayName() + ": " + event);
}
getApplicationEventMulticaster().multicastEvent(event);
if (this.parent != null) {
this.parent.publishEvent(event);
}
} /**
* Return the internal ApplicationEventMulticaster used by the context.
* @return the internal ApplicationEventMulticaster (never {@code null})
* @throws IllegalStateException if the context has not been initialized yet
*/
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;
}
其中
ApplicationEventMulticaster的初始化 来自于AbstractApplicationConText的refresh()方法
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh(); // Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory); try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory); // Initialize message source for this context.
initMessageSource(); // Initialize event multicaster for this context.
initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses.
onRefresh(); // Check for listener beans and register them.
registerListeners(); // Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event.
finishRefresh();
} catch (BeansException ex) {
logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex); // Destroy already created singletons to avoid dangling resources.
destroyBeans(); // Reset 'active' flag.
cancelRefresh(ex); // Propagate exception to caller.
throw ex;
}
}
}
调用初始化方法：
/**
* Initialize the ApplicationEventMulticaster.
* Uses SimpleApplicationEventMulticaster if none defined in the context.
* @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 + "]");
}
}
}
发布事件的默认实现SimpleApplicationEventMulticaster：
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public void multicastEvent(final ApplicationEvent event) {
for (final ApplicationListener listener : getApplicationListeners(event)) {
Executor executor = getTaskExecutor();
if (executor != null) {
executor.execute(new Runnable() {
@Override
public void run() {
listener.onApplicationEvent(event);
}
});
}
else {
listener.onApplicationEvent(event);
}
}
}
1.5.2 ApplicationListener事件监听
ApplicationListener application事件监听器的基础接口，继承于java.util.EventListener，基于监听器涉及模式。
AbstractApplicationContext注册ApplicationListener监听器
/**
* Add beans that implement ApplicationListener as listeners.
* Doesn't affect other listeners, which can be added without being beans.
*/
protected void registerListeners() {
// Register statically specified listeners first.
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String lisName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(lisName);
}
}
1.6 ResourcePatternResolver
ResourcePatternResolver是一个解析位置模式(例如ant-样式的路径模式)到Resource对象的策略接口。
它扩展了org.springframework.core.io.ResourceLoader接口。内部传递的ResourceLoader(例如，在一个运行的context中，org.springframework.context.ApplicationContext的传递通过org.springframework.context.ResourceLoaderAware来实现)可以检查它的实现是否实现了该扩展接口。
PathMatchingResourcePatternResolver是一个独立的实现，可以在Applicationcontext外部使用，也可以由ResourceArrayPropertyEditor使用来给Resource 数组 bean的属性。
ResourceArrayPropertyEditor是一个Resource数组编辑器，自动将位置模式例如file:C:/my*.txt或者classpath*:myfile.txt转换成Resource数组属性。同样，也可以将一组位置模式转换成合并的Resource数组。一个路径也许包含了${…}占位符，可以解析成org.springframework.core.env.Environment属性：如${user.dir}.不能解析的占位符默认将忽略。
它代理了一个ResourcePatternResolver，默认使用PathMatchingResourcePatternResolver。
1.7 Lifecycle
Lifecycle定义了start/stop方法里对生命周期进行管理。典型应用是控制异步处理。
可以由组件(典型的在spring beanFactory定义的spring bean)或者容器(典型的是spring ApplicationContext)。容器将会传播start/stop信号到它应用的所有组件上。
Lifecycle还可以通过JMX来直接触发或者管理各种操作。在后一种应用中，org.springframework.jmx.export.MBeanExporter和org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler一起定义活跃的可控组件对Lifecycle的可见性。
注意，Lifecycle接口仅支持最高级别的单实例bean，在别的地方，Lifecycle接口将不会被检查到而因此被忽略。同样，注意Lifeclycle的扩展接口SmartLifecycle提供更灵巧的集成容器的启动和关闭阶段。
LifecycleProcessor是一个处理ApplicationContext中bean的生命周期的策略接口。扩展了Lifecycle接口。
默认实现是DefaultLifecycleProcessor
SmartLifecycle是Lifecycle的扩展接口，使用对象是需要在ApplicationContext 刷新或者关闭时一些对象需要有序进行。isAutoStartup()方法返回值表示一个对象是否应该在context刷新时启动。stop(Runnable)方法的回调在异步关闭进程时非常有用。在整个ApplicationContext关闭时，为避免不必要的延迟，该接口的实现必须在关闭完成时触发回调的run方法。
这个接口扩展了Phased接口，并且getPhase()方法返回值表明了在组件的生命周期里应该开始或者停止的阶段。进程启动时拥有最低的阶段，结束时拥有最好的阶段值(Integer.MIN_VALUE是最低的可能值，Integer.MAX_VALUE是最高的可能值)。进程关闭时则正好相反。具有相同值的组件将会判断为处于同一阶段。
例如：如果依赖于组件A的组件B已经启动，那么组件A应该拥有比组件B更低的阶段值。在关闭进程中，组件B应该比组件A更先关闭。Context内的Lifecycle如果没有实现SmartLifecycle将会认为其阶段值为0.这种情况下，具有负的阶段值的SmartLifecycle的实现将比这些Lifecycle组件先启动，或者具有正的阶段值的SmartLifecycle的实现比这些Lifecycle晚启动。
注意：因SmartLifecycle支持auto-startup，在ApplicationContext启动的任何情况下，一个SmartLifecycle bean实例将会被初始化。所以，bean定义中的lazy-init属性将无法对SmartLifecycle bean产生影响。
Phased 定义了进程所处的阶段
/**
* Interface for objects that may participate in a phased
* process such as lifecycle management.*/
public interface Phased { /**
* Return the phase value of this object.
*/
int getPhase();}
小结：
本文围绕ApplicationContext具有的功能，对spring-context的context模块进行了解释，只要抓住ApplicationContext的核心就行。
下面列出了BeanFactory提供的功能和ApplicationContext提供的功能（包括其实现）。
特性 BeanFactory ApplicationContext
Bean 实例化/装配 Yes Yes
自动 BeanPostProcessor 注册 No Yes
自动 BeanFactoryPostProcessor 注册 No Yes
便捷的 MessageSource 访问( i18n) No Yes
ApplicationEvent 发送 No Yes
加载Resource No Yes
