轉載自： http://blog.163.com/axuandebin@126/blog/static/118777042009410248557/
這片博客信息量很大，言簡意賅、簡明扼要地說清楚了Spring容器的啟動過程，前面紅色的“打比方”可以忽略。。。
Spring容器像一台構造精妙的機器，我們通過配置文件向機器傳達控制信息，機器就能夠按照設定的模式進行工作。如果我們將Spring容器比喻為一輛汽車，可以將BeanFactory看成汽車的發動機，而ApplicationContext則是 整輛汽車，它不但包括發動機，還包括離合器、變速器以及底盤、車身、電氣設備等其他組件。在ApplicationContext內，各個組件按部就班、有條不紊地完成汽車的各項功能。
ApplicationContext內部封裝了一個BeanFactory對象，來實現對容器的操作，初始化完成之后，BeanFactory封裝了bean的信息，而ApplicationContext通過訪問這個對象獲取bean的對象信息（BeanDefinition/Bean對象，都是由BeanFactory實際創建並管理的），為了實現接口的統一，ApplicationContext也實現了一系列的BeanFactory接口(可以說ApplicationContext對BeanFactory對象實現一種代理)。ApplicationContext建立在BeanFactory的基礎之上，對配置對象的管理最終還是交於一個DefaultListableBeanFactory來完成（裝配地址/訪問等），而ApplicationContext在應用這個DefaultListableBeanFactory對象的基礎上，不僅實現了BeanFactory接口提供的功能方法，並且黏合了一些面向應用的功能，如資源/國際化支持/框架事件支持等，並且將一些原先需要手動設置到BeanFactory的屬性通過配置文件中配置的形式代替（如工廠后處理器BeanPostProcessor/InstantiationAwareBeanPostProcessor）
同樣，因為對於BeanDefinition和bean對象的管理是由上下文持有的beanfactory對象完成的，用戶不需要擁有這樣的接口，因此，ApplicationContext的接口體系中並沒有BeanDefinitionRegistry，SingletonBeanRegistry以及AutowireCapableBeanFactory接口(ApplicationContext可以訪問一些接口方法在上述接口中也定義，但這些方法提供者為BeanFactory體系中的其他接口，BeanFactory接口體系中的接口之間有重復定義方法的)。
內部工作機制(Spring容器ApplicationContext的初始化
（一） 首先來看創建ApplicationContext ，以ClassPathXmlApplicationContext為例：
ApplicationContext = new ClassPathXmlApplicationContext(xmlPath);
源碼如下：
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation});
}
public ClassPathXmlApplicationContext(String[] configLocations) throws BeansException {
this(configLocations, (ApplicationContext) null);
}
//。。。。。。省略幾個重載的構造函數
public ClassPathXmlApplicationContext(String[] configLocations, ApplicationContext parent)
throws BeansException {
super(parent);
this.configLocations = configLocations;
//IoC容器的初始化過程，其初始化過程的大致步驟由AbstractApplicationContext來定義
refresh();
}
關鍵之處在於refresh方法，此方法繼承於ClassPathXmlApplicationContext的間接父類：
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext, DisposableBean {
Spring的AbstractApplicationContext是ApplicationContext抽象實現類，該抽象類的refresh()方法定義了Spring容器在加載配置文件后的各項處理過程，這些處理過程清晰刻畫了Spring容器啟動時所執行的各項操作（創建Spring容器如ClassPathXmlApplicationContext）。下面，我們來看一下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();--------（1）
// 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);-------------------------------------（2）
// Register bean processors that intercept bean creation
registerBeanPostProcessors(beanFactory);---------------------------------------------（3）
// Initialize message source for this context.
initMessageSource();-------------------------------------------------------------------------（4）
// Initialize event multicaster for this context.
initApplicationEventMulticaster();-----------------------------------------------------------（5）
// Initialize other special beans in specific context subclasses.
onRefresh();------------------------------------------------------------------------------------（6）
// Check for listener beans and register them.
registerListeners();----------------------------------------------------------------------------（7）
// Instantiate singletons this late to allow them to access the message source.
beanFactory.preInstantiateSingletons();--------------------------------------------------（8）
// Last step: publish corresponding event.
publishEvent(new ContextRefreshedEvent(this));---------------------------------------（9）
} catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
beanFactory.destroySingletons();
throw ex;
}
}
}
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
return beanFactory;
}
protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
1．初始化BeanFactory：根據配置文件實例化BeanFactory，getBeanFactory()方法由具體子類實現。在這一步里，Spring將配置文件的信息解析成為一個個的BeanDefinition對象並裝入到容器的Bean定義注冊表（BeanDefinitionRegistry）中，但此時Bean還未初始化；obtainFreshBeanFactory()會調用自身的refreshBeanFactory(),而refreshBeanFactory()方法由子類AbstractRefreshableApplicationContext實現，該方法返回了一個創建的DefaultListableBeanFactory對象，這個對象就是由ApplicationContext管理的BeanFactory容器對象。
這一步的操作相當於，如果我們在自己的應用代碼中不用ApplicationContext而直接用BeanFactory時創建BeanFactory對象的操作
核心代碼如下：
public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext { }
/** 該ApplicationContext管理的BeanFactory容器對象*/
private DefaultListableBeanFactory beanFactory;
protected final void refreshBeanFactory() throws BeansException {
// Shut down previous bean factory, if any.
ConfigurableListableBeanFactory oldBeanFactory = null;
synchronized (this.beanFactoryMonitor) {
oldBeanFactory = this.beanFactory;
}
if (oldBeanFactory != null) {
oldBeanFactory.destroySingletons();
synchronized (this.beanFactoryMonitor) {
this.beanFactory = null;
}
}
// Initialize fresh bean factory.
try {
// 創建容器對象
DefaultListableBeanFactory beanFactory = createBeanFactory();
// Customize the internal bean factory used by this context
customizeBeanFactory(beanFactory);
// 裝載配置文件，並傳入相關聯的BeanFactory對象，作為BeanDefinition的容器
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
} catch (IOException ex) {
throw new ApplicationContextException(
"I/O error parsing XML document for application context [" + getDisplayName() + "]", ex);
}
}
// 創建Spring默認的容器對象
protected DefaultListableBeanFactory createBeanFactory() {
return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
// 該方法為一個鈎子方法，子類可以覆蓋它對當前上下文管理的BeanFactory提供客戶化操作，也可以忽略
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
}
// 裝載配置文件的方法，需要子類實現
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
throws IOException, BeansException;
對於上面裝載配置文件的方法，由其子類擴展實現：
public abstract class AbstractXmlApplicationContext extends AbstractRefreshableApplicationContext {}
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
// 使用XMLBeanDefinitionReader來載入bean定義信息的XML文件，傳入關聯的BeanFactory
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// 這里配置reader的環境，其中ResourceLoader是我們用來定位bean定義信息資源位置的
// 因為上下文本身實現了ResourceLoader接口，所以可以直接把上下文作為ResourceLoader傳遞入
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
initBeanDefinitionReader(beanDefinitionReader);
// 這里轉到定義好的XmlBeanDefinitionReader中對載入bean信息進行處理
loadBeanDefinitions(beanDefinitionReader);
}
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}
reader.loadBeanDefinitions(configLocations);涉及到XmlBeanDefinitionReader 工具類的使用（以后整理）
2．調用工廠后處理器：根據反射機制從BeanDefinitionRegistry中找出所有BeanFactoryPostProcessor類型的Bean，並調用其postProcessBeanFactory()接口方法；
經過第一步加載配置文件，已經把配置文件中定義的所有bean裝載到BeanDefinitionRegistry這個Beanfactory中，對於ApplicationContext應用來說這個BeanDefinitionRegistry類型的BeanFactory就是Spring默認的DefaultListableBeanFactory
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry
在這些被裝載的bean中，若有類型為BeanFactoryPostProcessor的bean（配置文件中配置的），則將對應的BeanDefinition生成BeanFactoryPostProcessor對象
容器掃描BeanDefinitionRegistry中的BeanDefinition，使用java反射自動識別出Bean工廠后處理器（實現BeanFactoryPostProcessor接口）的bean，然后調用這些bean工廠后處理器對BeanDefinitionRegistry中的BeanDefinition進行加工處理，可以完成以下兩項工作(當然也可以有其他的操作，用戶自己定義)：
1 對使用到占位符的<bean>元素標簽進行解析，得到最終的配置值，這意味着對一些半成品式的BeanDefinition對象進行加工處理並取得成品的BeanDefinition對象。2 對BeanDefinitionRegistry中的BeanDefinition進行掃描，通過Java反射機制找出所有屬性編輯器的Bean（實現java.beans.PropertyEditor接口的Bean），並自動將它們注冊到Spring容器的屬性編輯器注冊表中（PropertyEditorRegistry），這個Spring提供了實現：CustomEditorConfigurer，它實現了BeanFactoryPostProcessor，用它來在此注冊自定義屬性編輯器；
AbstractApplicationContext中的代碼如下：
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// Invoke factory processors registered with the context instance.
for (Iterator it = getBeanFactoryPostProcessors().iterator(); it.hasNext();) {
BeanFactoryPostProcessor factoryProcessor = (BeanFactoryPostProcessor) it.next();
factoryProcessor.postProcessBeanFactory(beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// 通過ApplicatinContext管理的beanfactory獲取已經注冊的BeanFactoryPostProcessor類型的bean的名字
String[] factoryProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement the Ordered
// interface and those that do not.
List orderedFactoryProcessors = new ArrayList();
List nonOrderedFactoryProcessorNames = new ArrayList();
for (int i = 0; i < factoryProcessorNames.length; i++) {
if (isTypeMatch(factoryProcessorNames[i], Ordered.class)) {
// 調用beanfactory的getBean取得所有的BeanFactoryPostProcessor對象
orderedFactoryProcessors.add(beanFactory.getBean(factoryProcessorNames[i]));
}
else {
nonOrderedFactoryProcessorNames.add(factoryProcessorNames[i]);
}
}
// First, invoke the BeanFactoryPostProcessors that implement Ordered.
Collections.sort(orderedFactoryProcessors, new OrderComparator());
for (Iterator it = orderedFactoryProcessors.iterator(); it.hasNext();) {
BeanFactoryPostProcessor factoryProcessor = (BeanFactoryPostProcessor) it.next();
// 執行BeanFactoryPostProcessor的方法，傳入當前持有的beanfactory對象，以獲取要操作的
// BeanDefinition
factoryProcessor.postProcessBeanFactory(beanFactory);
}
// Second, invoke all other BeanFactoryPostProcessors, one by one.
for (Iterator it = nonOrderedFactoryProcessorNames.iterator(); it.hasNext();) {
String factoryProcessorName = (String) it.next();
((BeanFactoryPostProcessor) getBean(factoryProcessorName)).
postProcessBeanFactory(beanFactory);
}
}
BeanFactoryPostProcessor接口代碼如下，實際的操作由用戶擴展並配置（擴展點，如何擴展？）
package org.springframework.beans.factory.config;
public interface BeanFactoryPostProcessor {
/**
* Modify the application context's internal bean factory after its standard
*/
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
3．注冊Bean后處理器：根據反射機制從BeanDefinitionRegistry中找出所有BeanPostProcessor類型的Bean，並將它們注冊到容器Bean后處理器的注冊表中；
AbstractApplicatinContext中對應代碼如下：
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
String[] processorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 +
processorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory,
beanProcessorTargetCount));
List orderedProcessors = new ArrayList();
List nonOrderedProcessorNames = new ArrayList();
for (int i = 0; i < processorNames.length; i++) {
if (isTypeMatch(processorNames[i], Ordered.class)) {
orderedProcessors.add(getBean(processorNames[i]));
}
else {
nonOrderedProcessorNames.add(processorNames[i]);
}
}
// First, register the BeanPostProcessors that implement Ordered.
Collections.sort(orderedProcessors, new OrderComparator());
for (Iterator it = orderedProcessors.iterator(); it.hasNext();) {
// 注冊bean后處理器，該方法定義於ConfigurableBeanFactory接口
beanFactory.addBeanPostProcessor((BeanPostProcessor) it.next());
}
// Second, register all other BeanPostProcessors, one by one.
for (Iterator it = nonOrderedProcessorNames.iterator(); it.hasNext();) {
String processorName = (String) it.next();
beanFactory.addBeanPostProcessor((BeanPostProcessor) getBean(processorName));
}
}
整段代碼類似於第三步的調用工廠后處理器，區別之處在於，工廠后處理器在獲取后立即調用，而Bean后處理器在獲取后注冊到上下文持有的beanfactory中，供以后操作調用（在用戶獲取bean的過程中，對已經完成屬性設置工作的Bean進行后續加工，他加工的是bean，而工廠后處理器加工的是BeanDefinition）
BeanPostProcessor 接口代碼如下，實際的操作由用戶擴展並配置（擴展點，如何擴展？）
package org.springframework.beans.factory.config;
public interface BeanPostProcessor {
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
4．初始化消息源：初始化容器的國際化信息資源；
源代碼如下：
protected void initMessageSource() {
// 補充
}
5．初始化應用上下文事件廣播器；
（觀察者模式中的具體主題角色，持有觀察者角色的集合，稱為注冊表）
AbstractApplciationContext擁有一個applicationEventMulticaster 成員變量，applicationEventMulticaster 提供了容器監聽器的注冊表，成其為事件廣播器。在第七步中將會將事件監聽器裝入其中
AbstractApplicationContext中的代碼如下：
private ApplicationEventMulticaster applicationEventMulticaster;
protected void initApplicationEventMulticaster() {
// "applicationEventMulticaster"，先看配置文件中有無配置該類型類（用戶擴展 擴展點，如何擴展）
if (containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster = (ApplicationEventMulticaster)
getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
}
else {
// 若沒有，則應用Spring框架提供的事件廣播器實例
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster();
}
}
public boolean containsLocalBean(String name) {
return getBeanFactory().containsLocalBean(name);
}
public Object getBean(String name, Class requiredType) throws BeansException {
return getBeanFactory().getBean(name, requiredType);
}
Spring初始化事件廣播器，用戶可以在配置文件中為容器定義一個自定義的事件廣播器（bean的名稱要為"applicationEventMulticaster"），只要實現ApplicationEventMulticaster就可以了，Spring在此會根據beanfactory自動獲取。如果沒有找到外部配置的事件廣播器，Spring使用SimpleApplicationEventMulticaster作為事件廣播器。
6．初始化其他特殊的Bean：這是一個鈎子方法，子類可以借助這個鈎子方法執行一些特殊的操作：
如AbstractRefreshableWebApplicationContext就使用該鈎子方法執行初始化ThemeSource的操作；
protected void onRefresh() throws BeansException {（擴展點，如何擴展）
package org.springframework.context;
// For subclasses: do nothing by default.
}
7．注冊事件監聽器；（觀察者模式中的觀察者角色）
Spring根據上下文持有的beanfactory對象，從它的BeanDefinitionRegistry中找出所有實現org.springfamework.context.ApplicationListener的bean，將BeanDefinition對象生成bean，注冊為容器的事件監聽器，實際的操作就是將其添加到事件廣播器所提供的監聽器注冊表中
AbstractApplicationContext中的代碼如下：
/** Statically specified listeners */
private List applicationListeners = new ArrayList();
public List getApplicationListeners() {
return this.applicationListeners;
}
protected void registerListeners() {
// Register statically specified listeners first.
for (Iterator it = getApplicationListeners().iterator(); it.hasNext();) {
addListener((ApplicationListener) it.next());
}
// 獲取ApplicationListener類型的所有bean，即事件監聽器
// uninitialized to let post-processors apply to them!
Collection listenerBeans = getBeansOfType(ApplicationListener.class, true, false).values();
for (Iterator it = listenerBeans.iterator(); it.hasNext();) {
// 將事件監聽器裝入第五步初始化的事件廣播器
addListener((ApplicationListener) it.next());
}
}
public Map getBeansOfType(Class type, boolean includePrototypes, boolean allowEagerInit)
throws BeansException {
return getBeanFactory().getBeansOfType(type, includePrototypes, allowEagerInit);
}
protected void addListener(ApplicationListener listener) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
ApplicationListener 的源代碼如下：（擴展點，如何擴展）
package org.springframework.context;
import java.util.EventListener;
/**
* Interface to be implemented by application event listeners.
* @see org.springframework.context.event.ApplicationEventMulticaster
*/
public interface ApplicationListener extends EventListener {
void onApplicationEvent(ApplicationEvent event);
}
8．初始化singleton的Bean：實例化所有singleton的Bean，並將它們放入Spring容器的緩存中；這就是和直接在應用中使用BeanFactory的區別之處，在創建ApplicationContext對象時，不僅創建了一個BeanFactory對象，並且還應用它實例化所有單實例的bean。（在spring的配置文件中，bean默認為單例，除非在bean的配置中顯式指定scope="prototype"）
AbstractApplicationContext中的代碼如下：
beanFactory.preInstantiateSingletons();
關於BeanFactory體系的代碼參照。。。。。。
9．發布上下文刷新事件：在此處時容器已經啟動完成，發布容器refresh事件（ContextRefreshedEvent）
創建上下文刷新事件，事件廣播器負責將些事件廣播到每個注冊的事件監聽器中。
publishEvent(new ContextRefreshedEvent(this));
public void publishEvent(ApplicationEvent event) {
Assert.notNull(event, "Event must not be null");
// 在此獲取事件廣播器，並調用其方法發布事件：調用所有注冊的監聽器的方法
getApplicationEventMulticaster().multicastEvent(event);
if (this.parent != null) {
this.parent.publishEvent(event);
}
}
至此，ApplicationContext對象就完成了初始化工作：創建BeanFactory來裝配BeanDefiniton，加工處理BeanDefiniton，注冊了bean后處理器，初始化了消息資源，初始化了應用上下文事件廣播器，注冊了事件監聽器，初始化了所有singleton的bean，最后發布上下文刷新事件