本文详细介绍了Spring的ApplicationContext在初始化过程中涉及的关键步骤，包括属性设置、刷新上下文的具体流程，如环境准备、加载BeanFactory、激活BeanFactory后处理器、注册BeanPostProcessor等。在刷新上下文中，Spring对BeanFactory进行功能填充，如支持SpEL、属性编辑器、AspectJ等功能，并实现了Bean生命周期管理和事件广播机制。最后，文章总结了ApplicationContext相对于BeanFactory的拓展功能，如SpEL支持、 Aware接口、消息源和生命周期管理等。
一、属性设置
对于ApplicationContext，其实例化前必须要设置的就是配置文件的路径--configLocation。例如：
对于非Web环境下的ClasspathXmlApplicationContext，需要通过构造函数或调用setConfigLocation设置配置文件路径；
对于Web环境下的XmlWebApplicationContext，会使用web.xml中配置的contextConfigLocation作为配置文件路径
//另外Web环境下使用的WebXmlApplicationContext还会保存ServletContext对象以及一些Web环境下的参数。
二、刷新上下文
refresh方法基本算是ApplicationContext最重要的方法之一，基本包含了ApplicationContext的大部分功能。需要注意的是，refresh方法并不是在ApplicationContext接口中定义的，而是在其子接口ConfigurableApplicationContext中定义的。下面是refresh的实现（代码位于AbstractApplicationContext）：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 准备刷新的上下文
prepareRefresh();
// 初始化BeanFactory，并读取配置文件
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 对BeanFactory进行填充
prepareBeanFactory(beanFactory);
try {
// 模版方法，由子类对初始化好的BeanFactory进行额外的处理
postProcessBeanFactory(beanFactory);
// 调用BeanFactoryPostProcessor后处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 注册Bean处理器
registerBeanPostProcessors(beanFactory);
// 初始化Message源，与国际化处理相关
initMessageSource();
// 初始化应用消息广播器，并作为一个Bean注册到BeanFactory中
initApplicationEventMulticaster();
// 模版方法，交由子类实现，刷新前的特殊处理
onRefresh();
// 在注册的bean列表中查找Listener类型的bean，注册到消息广播器中
registerListeners();
// 提前初始化单例bean（非惰性的）
finishBeanFactoryInitialization(beanFactory);
// 通知生命周期处理器LifecycleProcessor刷新过程，并且发出ContextRefreshEvent事件
finishRefresh();
}
catch (BeansException ex) {
//log..
// 销毁已经创建好的bean
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
throw ex;
}
finally {
resetCommonCaches();
}
}
}
刷新的流程为：
- 初始化的准备工作，如系统属性或环境变量的准备和验证
- 创建BeanFactory，并读取xml配置文件
- 对BeanFactory进行功能填充
- 通过模版方法模式，交由子类覆盖方法postProcessBeanFactory，对BeanFactory做额外处理
- 激活BeanFactory后处理器
- 注册拦截Bean创建的Bean处理器
- 初始化Message源
- 初始化消息广播器
- 留给子类初始化其他bean
- 将注册的Listener bean注册到消息广播器中
- 提前初始化单例bean（非惰性）
- 完成刷新，发出ContextRefreshEvent事件，并通知生命周期处理器LifecycleProcessor刷新过程
1、环境准备
主要是做些准备工作，对属性进行初始化和验证工作
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
//log...
// 交由子类覆盖
initPropertySources();
// 验证需要的属性是否都已经被放入环境中
getEnvironment().validateRequiredProperties();
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}
2、加载BeanFactory
ApplicationContext通过obtainFreshBeanFactory函数创建BeanFactory，自此方法后也就拥有了BeanFactory的所有功能：
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//委托给了refreshBeanFactory方法
refreshBeanFactory();
//因为创建BeanFactory实在子类中实现的，所以需要通过getBeanFactory才能获取到实例
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
下面是refreshBeanFactory的实现（位于AbstractRefreshableApplicationContext）：
protected final void refreshBeanFactory() throws BeansException {
//如果已经创建过BeanFactory，则销毁所有已经创建的Bean并且重新创建BeanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
//实例化
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
//设置一些属性
customizeBeanFactory(beanFactory);
//加载xml配置文件
loadBeanDefinitions(beanFactory);
//将BeanFactory实例设置到ApplicationContext中
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
初始化流程：
- 如果已经创建过，则销毁、清理掉以前创建的BeanFactory
- 实例化BeanFactory
- 定制BeanFactory
- 加载xml配置文件
a、实例化BeanFactory
实例化的代码比较简单，直接新建了一个DefaultListableBeanFactory，并且传入父ApplicationContext（如果存在的话）中的BeanFactory作为父BeanFactory，下面是实例化代码：
protected DefaultListableBeanFactory createBeanFactory() {
//如果存在父ApplicationContext，会通过它获取父BeanFactory传出构造函数
return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
getInternalParentBeanFactory实现：
protected BeanFactory getInternalParentBeanFactory() {
return (getParent() instanceof ConfigurableApplicationContext) ?
((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
}
如果父ApplicationContext类型是ConfigurableApplicationContext，则获取其中的BeanFactory，否则将父ApplicationContext作为BeanFactory传入。
b、定制BeanFactory
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
//allowBeanDefinitionOverriding：是否允许覆盖同名称的不同定义的对象
if (this.allowBeanDefinitionOverriding != null) {
beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
//allowCircularReferences：是否允许循环依赖
if (this.allowCircularReferences != null) {
beanFactory.setAllowCircularReferences(this.allowCircularReferences);
}
}
主要是对allowBeanDefinitionOverriding和allowCircularReferences属性进行设置，在AbstractRefreshableApplicationContext中并未对这两个属性进行设置，而是需要由子类来进行配置。
c、加载配置文件
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 为指定的BeanFactory创建XmlBeanDefinitionReader
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// 对XmlBeanDefinitionReader设置环境变量
beanDefinitionReader.setEnvironment(getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// 设置XmlBeanDefinitionReader的属性
initBeanDefinitionReader(beanDefinitionReader);
//加载配置文件
loadBeanDefinitions(beanDefinitionReader);
}
2、BeanFactory功能填充
对BeanFactory的功能填充是在prepareBeanFactory方法中完成的，再次之前，BeanFactory已经创建好并且完成了对xml配置文件的解析：
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置BeanFactory的ClassLoader为当前Context的ClassLoader
beanFactory.setBeanClassLoader(getClassLoader());
//设置BeanFactory的表达式语言处理器，例如对#{bean.xx}调用相关值
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//对bean属性等设置管理的工具
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加PostPrecessor
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.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 添加PostPrecessor（该PostProcessor功能是对AspectJ的支持）
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 在BeanFactory中注册系统环境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());
}
}
上面代码中的拓展包括：
- 对SpEL（Spring Expression Language）的支持
- 对属性编辑器的支持
- 增加一些内置类，如EnvironmentAware、MessageSourceAware的信息注入
- 设置依赖功能需要忽略的接口
- 增加AspectJ的支持
- 将环境变量和属性注册的对象注册到BeanFactory中
- 注册了一些固定的依赖属性，如BeanFactory、ApplicationContext等
3、激活BeanFactory后处理器
BeanFactoryPostProcessor接口与BeanPostProcessor类似，能够在Bean创建过程中修改bean的定义信息。Spring允许BeanFactoryPostProcessor在容器实例化bean前读取bean定义，并可以修改它。下面是激活的代码：
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//激活BeanFactoryPostProcessor的功能委托给了PostProcessorRegistrationDelegate
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
//tempClassLoader为null && BeanFactory包含"loadTimeWeaver"名的bean
//将loadTimeWeaver封装到一个BeanPostProcessor中
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
PostProcessorRegistrationDelegate中的实现：
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 存放处理过的BeanFactoryPostProcessor，避免重复添加、处理
Set<String> processedBeans = new HashSet<String>();
//BeanDefinitionRegistry的处理
//因为DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，所以会进入下面的代码
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
new LinkedList<BeanDefinitionRegistryPostProcessor>();
/*
*硬编码注册的后处理器
*/
//调用BeanDefinitionRegistryPostProcessor的额外方法
//将处理器分类保存到registryPostProcessors和regularPostProcessors
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
//BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcesso,
//并在BeanFactoryPostProcessor基础上还定义了postProcessBeanDefinitionRegistry方法
//所以需要西先调用额外定义的方法
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryPostProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
registryPostProcessors.add(registryPostProcessor);
}
else {
//记录常规beanFactoryPostProcessors
regularPostProcessors.add(postProcessor);
}
}
/*
*通过配置注册的BeanDefinitionRegistryPostProcessor后处理器
*/
//先获取的是后处理器的beanName列表，而不是后处理器的实例
//Sping会依次处理实现了PriorityOrdered、Ordered接口的后处理器，最后处理剩下的常规后处理器
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 处理实现了PriorityOrdered接口的后处理器，结果暂存到priorityOrderedPostProcessors
List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//排序（通过PriorityOrdered接口）
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
//将结果添加到registryPostProcessors
registryPostProcessors.addAll(priorityOrderedPostProcessors);
//和上面一样，调用BeanDefinitionRegistryPostProcessor中自己定义的方法postProcessBeanDefinitionRegistry
invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
//处理实现了Ordered接口的后处理器，结果暂存到orderedPostProcessors（处理过程和PriorityOrdered接口的类似）
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
//该PostProcessor还未被处理过 && 实现了Ordered接口
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(beanFactory, orderedPostProcessors); //排序（通过Ordered接口）
//结果添加到registryPostProcessors
registryPostProcessors.addAll(orderedPostProcessors);
//和上面一样，调用BeanDefinitionRegistryPostProcessor中自己定义的方法postProcessBeanDefinitionRegistry
invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
// 最后，处理剩下的BeanDefinitionRegistryPostProcessor
boolean reiterate = true;
while (reiterate) {
reiterate = false;
//获取所有BeanDefinitionRegistryPostProcessor类型的bean
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//如果还未被处理过
if (!processedBeans.contains(ppName)) {
BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
//将结果添加到registryPostProcessors
registryPostProcessors.add(pp);
processedBeans.add(ppName);
//调用BeanDefinitionRegistryPostProcessor中自己定义的方法postProcessBeanDefinitionRegistry
pp.postProcessBeanDefinitionRegistry(registry);
reiterate = true;
}
}
}
// 调用BeanFactoryPostProcessor中定义的postProcessBeanFactory方法
//（前面调用的都是registryPostProcessors，定义在BeanDefinitionRegistryPostProcessor中）
invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// 调用BeanFactoryPostProcessor中定义的postProcessBeanFactory方法.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
/*
*上面代码已经将硬编码的BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor和配置中的BeanDefinitionRegistryPostProcessor分类处理了
*后面代码需要处理配置中的BeanFactoryPostProcessor类型的后处理器
*/
// 获取通过配置注册的BeanFactoryPostProcessor后处理器的beanName列表
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
//Spring还是会将处理器分为排序和不需要排序两类，分别处理
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
//过滤掉处理过的，剩下的就是配置中的BeanFactoryPostProcessor
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
//分类添加到不同列表
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 对实现了PriorityOrdered的处理器排序，并依次应用BeanFactoryPostProcessor
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 对实现了Ordered的处理器排序，并依次应用BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(beanFactory, orderedPostProcessors);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 应用常规BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 因为可能修改了Bean的定义信息。所以需要清除缓存的merged beanDefinitions
beanFactory.clearMetadataCache();
}
Spring中少有的长代码。。
上面代码功能就是应用BeanFactoryPostProcessor后处理器。但是，由一点比较特特殊的是BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor，并且还定义了一个postProcessBeanDefinitionRegistry方法（BeanFactoryPostProcessor中只定义了一个方法-postProcessBeanFactory）。所以，在应用BeanFactoryPostProcessor后处理器中的postProcessBeanFactory方法前，需要先调用BeanDefinitionRegistryPostProcessor中的方法。
另外，向ApplicationContext中添加BeanFactoryPostProcessor的方法由两种：一是通过context直接调用addBeanFactoryPostProcessor硬编码添加；二是通过配置文件或@Component等注解向BeanFactory中注册一个BeanFactoryPostProcessor类型的bean。Spring针对两种配置，需要分类处理。
如果后处理器继承了PriorityOrdered或Ordered接口，Spring会优先将这些处理器排序后依次调用。（对于硬编码添加和配置添加的都会进行排序，但是对于Spring3以前的版本，并不会对硬编码方式添加的后处理器进行排序）
调用顺勋：PriorityOrdered --> Ordered --> 常规处理器
处理流程如下：
- 对BeanDefinitionRegistryPostProcessor的特殊处理，调用其postProcessBeanDefinitionRegistry方法
- 处理硬编码的所有BeanFactoryPostProcessor后处理器以及通过配置注册的BeanDefinitionRegistryPostProcessor后处理器：按照 PriorityOrdered --> Ordered --> 常规处理器 的顺序应用BeanFactoryPostProcessor中的方法
- 处理剩下的通过配置注册的BeanFactoryPostProcessor。因为BeanDefinitionRegistryPostProcessor已经在上一步中处理过了，这一步只需要按照 PriorityOrdered --> Ordered --> 常规处理器 的顺序应用剩下的BeanFactoryPostProcessor
3、注册BeanPostProcessor
Spring的大部分功能都是通过BeanPostProcessor来拓展添加的，在这一步，Spring会将BeanFactory中所有的BeanPostProcessor类型的bean注册为后处理器，具体代码如下：
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//真正注册的功能委托给了PostProcessorRegistrationDelegate
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
PostProcessorRegistrationDelegate中的实现：
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//获取BeanFactory中所有BeanPostProcessor类型的beanName
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
//注册一个特殊的BeanPostProcessor：BeanPostProcessorChecker
//该后处理器的功能就是如果一个bean在BeanPostProcessor还没全部加载完成的时候创建，Spring会打印一条info级别的信息，
//打印信息表明该bean并没有被所有BeanPostProcessor处理
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 根据是否支持排序分类处理BeanPostProcessor
// 处理顺序为PriorityOrdered -> Ordered -> 常规后处理器
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
//内部使用的BeanPostProcessor（如果后处理器类型是MergedBeanDefinitionPostProcessor的话，会放入该列表）
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 注册继承自PriorityOrdered接口的BeanPostProcessor
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 注册继承自Ordered接口的BeanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(beanFactory, orderedPostProcessors);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 注册剩下的常规BeanPostProcessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
//最后重新注册一遍内部BeanPostProcessor（会将这些BeanPostProcessor放在列表最后）
sortPostProcessors(beanFactory, internalPostProcessors);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 会注册一个特殊的BeanPostProcessor
// ApplicationListenerDetector的功能是将类型是 ApplicationListener 的bean添加到事件广播器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
上述代码处理流程为：
- 注册BeanPostProcessorChecker。该BeanPostProcessor功能是：如果一个bean在BeanPostProcessor还没全部加载完成的时候创建，Spring会打印一条info级别的信息，该信息内容表明该创建的bean并未被所有BeanPostProcessor处理
- 查找出BeanFactory中所有BeanPostProcessor的bean，并作为BeanPostProcessor注册到BeanFactory中。同时支持排序接口，注册顺序为：PriorityOrdered -> Ordered -> 常规后处理器。比较特殊的是，MergedBeanDefinitionPostProcessor类型的后处理器是作为Spring内部使用的，所以会在添加到BeanPostProcessor列表末尾
- 注册ApplicationListenerDetector。该BeanPostProcessor功能：在创建bean的时候，如果bean类型是ApplicationListener ，会被添加到事件广播器
4、初始化消息资源
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//如果配置了messageSource，就将其实例保存到this.messageSource中
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
//log...
}
else {
// 如果用户没有定义，使用默认的DelegatingMessageSource作为messageSource
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 + "]");
}
}
}
5、初始化ApplicationEventMulticaster
事件广播器作用就是发布各种事件，然后由ApplicationListener处理（前面注册BeanPostProcessor中专门有一个ApplicationListenerDetector来注册用户配置的ApplicationListener），初始化并注册的代码如下：
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//如果BeanFactory中包含名称为“applicationEventMulticaster”的bean，就使用该bean作为事件广播器
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
// log...
}
else {
//使用默认的SimpleApplicationEventMulticaster作为广播器，并注册到BeanFactory中
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
//log...
}
}
6、注册监听器
在上一步初始化好事件广播器后，Spring接着会向其添加监听器：
protected void registerListeners() {
// 将前面硬编码方式注册的监听器添加到广播器中
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
//配置文件或者注解注册的监听器处理
//为了使监听器得到后处理器的加工，这里并没有实例化监听器，而是保存beanName
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 发布earlyApplicationEvents的事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
7、初始化非延迟单例
除了初始化单例bean以外，这一步还会完成一部分初始化BeanFactory的功能，包括：ConversionService的设置、冻结配置、设置EmbeddedValueResolver、初始化LoadTimeWeaverAware，源码如下：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化conversionService，如果存在的话
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));
}
// 注册一个默认的StringValueResolver到embeddedValueResolver
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
// 提前初始化 LoadTimeWeaverAware
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// 冻结bean定义，表明注册的bean定义将无法再次被修改
beanFactory.freezeConfiguration();
// 初始化剩余的非延迟加载单例
beanFactory.preInstantiateSingletons();
}
下面是初始化非延加载单例的源码：
public void preInstantiateSingletons() throws BeansException {
//log...
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// 遍历beanNames，初始化其中的非惰性单例bean
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//非Abstract || 单例 || 非惰性
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//FactoryBean类型bean的处理
if (isFactoryBean(beanName)) {
//对于普通FactoryBean类型的bean，Spring会初始化其对应的FactoryBean，并不会初始化实际的bean
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
//对于SmartFactoryBean类型并且isEagerInit返回true的bean，Spring会初始化真正的bean
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
//普通bean直接调用getBean初始化
getBean(beanName);
}
}
}
- 对于FactoryBean，Spring会提前初始化其FactoryBean；如果类型是SmartFactoryBean并且isEagerInit 返回true（表示需要立即初始化），Spring才会初始化其真正的bean单例
- 对于普通bean，Spring会直接调用getBean进行初始化
8、finnishRefresh
在完成刷新上下文后，Spring会通知Lifecycle调用其start方法（销毁时会调用stop方法），进行生命周期管理；并且发布刷新完成的事件：
protected void finishRefresh() {
// 初始化lifecycleProcessor
initLifecycleProcessor();
// 通知lifecycleProcessor
getLifecycleProcessor().onRefresh();
// 发布ContextRefreshedEvent事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
- 初始化生命周期管理器lifecycleProcessor
- 通知Lifecycle类型的bean，调用其start方法（ApplicationContext销毁时会调用其stop方法）
- 发布ContextRefreshedEvent事件
至此，完成了上下文的刷新。
总结
ApplicationContext继承了BeanFactory相关的接口，所以具备BeanFactory的所有功能，在此之上，ApplicationContext拓展的功能有：
- 注册StandardBeanExpressionResolver对SpEL（Spring Expression Language）的支持
- 注册ResourceEditorRegistrar，对属性编辑器的支持
- 激活BeanFactoryPostProcessor功能，实例化Bean前修改BeanFactory的状态
- 添加了一些内置的BeanPostProcessor，并且将用户配置的BeanPostProcessor注册到BeanFactory中
- 增加AspectJ的支持
- 增加了几个Aware接口的支持，如：EnvironmentAware、ApplicationContextAware、MessageSourceAware等
- MessageSource消息源的支持，用于国际化
- 事件广播器、监听器的支持
- Lifecycle接口的支持，用于bean的生命周期管理
扫一扫
233
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
