Spring容器初始化过程

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();
       }

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;

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 工具类的使用（以后整理）

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);
             }
       }

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));
                }
       }

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);
       }

protected void onRefresh() throws BeansException {//--扩展点

package org.springframework.context;
      // For subclasses: do nothing by default.
}

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

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);

}

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);
              }
       }