我們知道啟動spring容器兩常見的兩種方式（其實都是加載spring容器的xml配置文件時啟動的）：

1.在應用程序下加載

ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-context.xml");

2.web模式下加載

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-context.xml</param-value
 
>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

可以發現，執行new ClassPathXmlApplicationContext()的時候會打印以下日誌：

2017-5-15 12:48:48 org.springframework.context.support.AbstractApplicationContext prepareRefresh

即調用AbstractApplicationContext類的prepareRefresh方法，我們去看AbstractApplicationContext類：

通過類圖可以發現AbstractApplicationContext是一個抽象類，也屬於BeanFactory體系，實現了ApplicationContext，再往下找到他的子類ClassPathXmlApplicationContext，來看它的具體實現

類裏有很多重載的構造函數，到最後都是調用這個：

public ClassPathXmlApplicationContext(String[] paths, Class clazz, ApplicationContext parent) 
 
throws BeansException {
　　super(parent);
    Assert.notNull(paths, "Path array must not be null");
    Assert.notNull(clazz, "Class argument must not be null");
    this.configResources = new Resource[paths.length];
    for (int i = 0; i < paths.length; i++) {
            this.configResources[i] = new ClassPathResource(paths[i], clazz);
    }
　　 //IOC初始化過程
    refresh();
}

這裏就到重點了，refresh方法定義了ioc容器啟動的整個過程，來看源碼

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1.Prepare this context for refreshing.
        prepareRefresh();

        // 2.Tell the subclass to refresh the internal bean factory.
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 3.Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            4.// Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);

            5.// Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

            6.// Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);

            7.// Initialize message source for this context.
            initMessageSource();

            8.// Initialize event multicaster for this context.
            initApplicationEventMulticaster();

            9.// Initialize other special beans in specific context subclasses.
            onRefresh();

            10.// Check for listener beans and register them.
            registerListeners();

            11.// Instantiate all remaining (non-lazy-init) singletons.
            finishBeanFactoryInitialization(beanFactory);

            //12. Last step: publish corresponding event.
            finishRefresh();
        }

        catch (BeansException ex) {
            // 13.Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // 14.Reset ‘active‘ flag.
            cancelRefresh(ex);

            // 15.Propagate exception to caller.
            throw ex;
        }
    }
}

接下來，一步一步分析spring幹了哪些事

1．初始化BeanFactory：根據配置文件實例化BeanFactory，getBeanFactory()方法由具體子類實現。在這一步裏，Spring將配置文件的信息解析成為一個個的BeanDefinition對象並裝入到容器的Bean定義註冊表（BeanDefinitionRegistry）中，但此時Bean還未初始化；obtainFreshBeanFactory()會調用自身的refreshBeanFactory(),而refreshBeanFactory()方法由子類AbstractRefreshableApplicationContext實現，該方法返回了一個創建的DefaultListableBeanFactory對象，這個對象就是由ApplicationContext管理的BeanFactory容器對象。這一步的操作相當於，如果我們在自己的應用代碼中不用ApplicationContext而直接用BeanFactory時創建BeanFactory對象的操作，核心代碼如下：

reader.loadBeanDefinitions(configLocations);

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，用它來在此註冊自定義屬性編輯器，核心代碼如下：

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接口代碼如下，實際的操作由用戶擴展並配置：

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 接口代碼如下，實際的操作由用戶擴展並配置：

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中的代碼如下：

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 {
        // 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 的源代碼如下：

/**
     * 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();

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，最後發布上下文刷新事件。

spring啟動加載過程源碼分析