spring源码阅读--容器启动过程

      最近把spring又拿起来看了一下，以下是一些阅读笔记(多点耐心，往下看完)。
      首先选用ClassPathXmlApplicationContext作为容器。不多说，直接上代码      

package com.example.demo.springcontext;

import com.example.demo.beanfactory.Car;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author <a href="mailto:wujia@2dfire.com">linxiaohui</a>
 * @version 1.0 18/10/11
 * @since 1.0
 */
public class ApplicationContextTest {

    public static void main(String[] args) {
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        Car car = ctx.getBean("car", Car.class);
        car.introduce();
    }
}

     ClassPathXmlApplicationContext的构造函数

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
   this(new String[] {configLocation}, true, null);
}
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
      throws BeansException {

   super(parent);
   //对传入的配置文件名称进行解析，比如文件名称中使用了占位符的，那就需要替换成真实的值
   setConfigLocations(configLocations);
   if (refresh) {
      //调用容器的启动方法
      refresh();
   }
}

      下面我们先来整体看下spring容器启动的步骤，然后再逐步分析下每一步都干了些什么事情。

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 1、容器启动前的准备工作
      prepareRefresh();

      // 2、初始化beanFactory,加载配置文件，转换为beanDefinition，并注册这些beanDefinition
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 3、设置beanFactory的一些属性，增强功能
      prepareBeanFactory(beanFactory);

      try {
         // 4、完成步骤3后，可以对beanFactory做一些后置处理。由子类扩展实现
         postProcessBeanFactory(beanFactory);

         // 5、调用容器中注册的beanFactory后置处理方法
         invokeBeanFactoryPostProcessors(beanFactory);

         // 6、注册bean的后置处理器。（tips:触发时机是bean实例化后，在bean初始化的前后。）
         registerBeanPostProcessors(beanFactory);

         // 7、初始化国际化用到的资源
         initMessageSource();

         // 8、初始化事件广播器
         initApplicationEventMulticaster();

         // 9、初始化其他特殊的bean，由特定的子类去实现
         onRefresh();

         // 10、注册事件监听器，发布需要提前广播的事件
         registerListeners();

         // 11、实例化剩下的非延迟加载的单例
         finishBeanFactoryInitialization(beanFactory);

         // 12、完成容器启动，处理后置事件以及发布通知事件
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            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;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

step1、容器启动前的准备工作

/**
 * Prepare this context for refreshing, setting its startup date and
 * active flag as well as performing any initialization of property sources.
 */
protected void prepareRefresh() {
   //设置启动时间
   this.startupDate = System.currentTimeMillis();
   //设置容器状态
   this.closed.set(false);
   this.active.set(true);

   if (logger.isInfoEnabled()) {
      logger.info("Refreshing " + this);
   }

   // 初始化文件，由子类实现
   initPropertySources();

   // 验证必须要的属性是否已经存在
   // see ConfigurablePropertyResolver#setRequiredProperties
   getEnvironment().validateRequiredProperties();

   // 保存容器需要提前广播的事件
   // tips:这些提前事件会在registerListeners()注册事件监听器的时候直接广播
   this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}

    第1步主要做一些容器启动前的状态设置，以及必须属性的校验。

step2、初始化beanFactory,加载配置文件

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   //主要看这个方法代码
   refreshBeanFactory();
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
   }
   return beanFactory;
}

protected final void refreshBeanFactory() throws BeansException {
   //已经存在beanFactory
   if (hasBeanFactory()) {
      //清理所有的单例缓存
      destroyBeans();
      //设置beanFactory为null
      closeBeanFactory();
   }
   try {
      //使用DefaultListableBeanFactory创建beanFactory实例
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      //设置序列化id
      beanFactory.setSerializationId(getId());
      //自定义属性设置：1、是否允许同名bean(后者覆盖前者)  2、是否允许循环依赖
      customizeBeanFactory(beanFactory);
      //加载解析xml文件配置，转化为内存中的beanDefinition格式，并注册到对应的集合列表当中
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

      第2步主要是新创建一个beanFactory,设置序列化id,以及自定义属性，然后解析xml配置的bean信息备用。

step3、设置beanFactory的一些属性，扩展功能

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // 设置AppClassLoader作为类加载器
   beanFactory.setBeanClassLoader(getClassLoader());
   //设置spring EL 表达式解析器
   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   //设置属性编辑器
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   // 设置bean后置处理器，让我们可以获取整个容器，同时会注入资源。（EnvironmentAware，EmbeddedValueResolverAware
   //，ResourceLoaderAware，ApplicationEventPublisherAware，MessageSourceAware，ApplicationContextAware）
   //在bean实例化的时候会用到。（后续文章会分析preInstantiateSingletons()->getBean() ->
   //doGetBean()->createBean()->doCreateBean()->initializeBean()->invokeAwareMethods()）   
   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);

   // 注册spring自己的系统bean,和业务bean区分
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   // 注册ApplicationListenerDarecror后置处理器，把实现了ApplicationListener接口的单例对象
   // 注册到容器的事件集合中去
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // AOP支持。此处不扩展，后续AOP模块再分析
   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()));
   }

   // 注册默认的系统环境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());
   }
}

step4、完成步骤3后对beanFactory做一些后置处理。由子类扩展

/**
 * Modify the application context's internal bean factory after its standard
 * initialization. All bean definitions will have been loaded, but no beans
 * will have been instantiated yet. This allows for registering special
 * BeanPostProcessors etc in certain ApplicationContext implementations.
 * @param beanFactory the bean factory used by the application context
 */
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    //在beanFactory加载解析xml配置文件后，bean实例化之前，子类可以在这个时期做一些特殊的处理，对
    //beanFactory进行属性增强（可参考不同容器子类的具体实现）
}

step5、调用容器中注册的beanFactory后置处理器的方法

      在此处先穿插一个知识点--spring容器扩展点。我们在这里主要简单讲下BeanPostProcessor和BeanFactoryPostProcessor。

      BeanPostProcessor是在spring容器加载了bean的定义文件并且实例化bean之后执行的,分别为bean调用初始化init-method的前后。(操作目标对象为bean对象)

      BeanFactoryPostProcessor是在spring容器加载了bean的定义文件（xml文件）之后，在bean实例化之前执行的。（操作目标对象为beanFactory对象）

      我们知道了两者的执行时机和使用目的，就可以继续往下看了。至于两者的详细使用，此处不扩展开了。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   //核心代码，看下文注释
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

   // AOP支持。此处不扩展，后续AOP模块再分析
   if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
}

//看此处代码之前，首先得知道，BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，子接口
//扩展了父接口，所以下面对两种处理器分开执行
public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
   Set<String> processedBeans = new HashSet<String>();
   //是否BeanDefinitionRegistry类型
   if (beanFactory instanceof BeanDefinitionRegistry) {
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      //保存BeanFactoryPostProcessor处理器
      List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
      //保存BeanDefinitionRegistryPostProcessor后置处理器
      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
      //遍历手动编码注册的BeanFactoryProcessor（查看入参getBeanFactoryPostProcessors()）
      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
         //如果是BeanDefinitionRegistryPostProcessor
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            //先调用BeanDefinitionRegistryPostProcessor扩展的方法
            registryProcessor.postProcessBeanDefinitionRegistry(registry);
            //放入registryProcessors集合，后续调用继承自父接口的方法
            registryProcessors.add(registryProcessor);
         }
         else {
            //放入regularPostProcessors集合
            regularPostProcessors.add(postProcessor);
         }
      }

      // Do not initialize FactoryBeans here: We need to leave all regular beans
      // uninitialized to let the bean factory post-processors apply to them!
      // Separate between BeanDefinitionRegistryPostProcessors that implement
      // PriorityOrdered, Ordered, and the rest.
      // 临时集合
      List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();

      // 获取配置文件中所有实现了BeanDefinitionRegistryPostProcessor的bean名称
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      //遍历配置文件中的这些bean
      for (String ppName : postProcessorNames) {
         //如果实现了PriorityOrdered接口
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            //拎出来放入临时集合中
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            //添加到已执行的set集合中，防止重复执行（后续判断条件会用到）
            processedBeans.add(ppName);
         }
      }
      //把实现了PriorityOrer接口的这些处理器bean排序
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      //把这些配置文件中的BeanDefinitionRegistryPostProcessor放入registryProcessors列表中
      registryProcessors.addAll(currentRegistryProcessors);
      //执行BeanDefinitionRegistryPostProcessor中扩展的方法
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      //清空临时集合
      currentRegistryProcessors.clear();

      // 这步特殊处理实现了Ordered接口的BeanDefinitionRegistryPostProcessor处理器，和上面步骤一样，
      // （掘金这编辑器不好用，就不重复打字了.）
      postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
         if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            processedBeans.add(ppName);
         }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // 执行剩下的BeanDefinitionRegistryPostProcessors，步骤同上.
      boolean reiterate = true;
      while (reiterate) {
         reiterate = false;
         postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
         for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName)) {
               currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
               processedBeans.add(ppName);
               reiterate = true;
            }
         }
         sortPostProcessors(currentRegistryProcessors, beanFactory);
         registryProcessors.addAll(currentRegistryProcessors);
         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
         currentRegistryProcessors.clear();
      }

      // 执行所有BeanDrfinitionRegistryPostProcessor（包括手动编码注册和配置文件中配置的）
      // 继承自BeanFactoryPostProcessor的方法
      invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
      // 执行所有手动编码注册的BeanFactoryPostProcessor的后置处理方法
      invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   }

   else {
      // 直接执行手动编码注册的后置处理器的方法
      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }

   // Do not initialize FactoryBeans here: We need to leave all regular beans
   // uninitialized to let the bean factory post-processors apply to them!
   // 获取所有配置文件中配置的BeanFactoryPostProcessor(手动注册的上面已经执行过了)
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   // 以下几步就是对配置文件中配置的BeanFactory后处理器按实现PriortyOrdered,Ordered以及没有实现顺序接口
   // 分类，分别排序处理，步骤和上面一个样（这个编辑器不好用，就不多打字了）
   List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
   List<String> orderedPostProcessorNames = new ArrayList<String>();
   List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
   for (String ppName : postProcessorNames) {
      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);
      }
   }

   // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
   List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
   for (String postProcessorName : orderedPostProcessorNames) {
      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

   // Finally, invoke all other BeanFactoryPostProcessors.
   List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
   for (String postProcessorName : nonOrderedPostProcessorNames) {
      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

   // 由于BeanFactoryPostProcessor后置处理器的方法可能修改了元数据，例如PropertyPlaceholderConfigurer替换了属性值的
   // 占位符，所以需要清理相关缓存  
   beanFactory.clearMetadataCache();
}

step6、注册bean的后置处理器（关于这个处理器，上文中有简单描述，应该可以帮助大家理解了，不清楚的童鞋先往前翻翻）

/**
 * Instantiate and invoke all registered BeanPostProcessor beans,
 * respecting explicit order if given.
 * <p>Must be called before any instantiation of application beans.
 */
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
   // 获取所有配置文件中配置的BeanPostProcessor
   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

   //beanProcessorTargetCount = 手动注册的BeanPostProcessor数量+1+配置文件中配置的BeanPostProcessor数量   
   //  加1因为额外要注册BeanPostProcessorChecker记录日志。
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   //注册BeanPostProcessorChecker的作用，是当没有注册完后置处理器就开始实例化其他bean，会记录日志
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

   // BeanPostProcessors按实现了PriorityOrdered,Ordered和未实现顺序接口分类，各自排序注册。（和上文对BeanFactory的后置
   // 处理器的处理方法一个样）.
   List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
   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) {
            // 把MergedBeanDefinitionPostProcessor类型的拎出来
            internalPostProcessors.add(pp);
         }
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   // First, register the BeanPostProcessors that implement PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // Next, register the BeanPostProcessors that implement Ordered.
   List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
   for (String ppName : orderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      orderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         // 把MergedBeanDefinitionPostProcessor类型的拎出来
         internalPostProcessors.add(pp);
      }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   // Now, register all regular BeanPostProcessors.
   List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
   for (String ppName : nonOrderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      nonOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         // 把MergedBeanDefinitionPostProcessor类型的拎出来
         internalPostProcessors.add(pp);
      }
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

   // 排序，再次注册MergedBeanDefinitionPostProcessor类型的bean（注册过的会被清理再次注册）
   sortPostProcessors(internalPostProcessors, beanFactory);
   // 从效果上看是让这些类型的处理器注册顺序排到最后
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

   // 重新注册ApplicationListenerDetector
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

step7、初始化国际化用到的资源

public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";/**
 * Initialize the MessageSource.
 * Use parent's if none defined in this context.
 */
protected void initMessageSource() {
   //获取BeanFactory
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 如果存在命名为messageSource的bean (此处为spring硬编码)
   if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
      // 初始化这个bean
      this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
      // 建立MessageSource和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());
         }
      }
      if (logger.isDebugEnabled()) {
         logger.debug("Using MessageSource [" + this.messageSource + "]");
      }
   }
   else {
      // 不存在，这创建一个空的MessageSource去处理获取资源的请求，并命名为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 + "]");
      }
   }
}

step8、 初始化事件广播器(观察者模式)

      不了解观察者模式的童鞋可以先简单了解下，这个模式的实现虽然比较简单，但是对于了解spring的事件广播和监听很有帮助。

public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";

/**
 * Initialize the ApplicationEventMulticaster.
 * Uses SimpleApplicationEventMulticaster if none defined in the context.
 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
 */
protected void initApplicationEventMulticaster() {
   // 获取BeanFactory
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 包含命名为applicationEventMulticaster的bean（硬编码的多路广播器）
   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 {
      // 不包含，那么就创建一个SimpleApplicationEventMulticaster并命名为applicationEventMulticaster
      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 + "]");
      }
   }
}

step9、 初始化其他特殊的bean,有特定的子类容器去实现

/**
 * Template method which can be overridden to add context-specific refresh work.
 * Called on initialization of special beans, before instantiation of singletons.
 * <p>This implementation is empty.
 * @throws BeansException in case of errors
 * @see #refresh()
 */
protected void onRefresh() throws BeansException {
   // For subclasses: do nothing by default.
}

step10、 注册事件监听器，发布需要提前广播的事件

/**
 * Add beans that implement ApplicationListener as listeners.
 * Doesn't affect other listeners, which can be added without being beans.
 */
protected void registerListeners() {
   // 注册所有手动编码添加的事件监听器
   for (ApplicationListener<?> listener : getApplicationListeners()) {
      getApplicationEventMulticaster().addApplicationListener(listener);
   }

   // 注册所有配置文件配置的事件监听器
   String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
   for (String listenerBeanName : listenerBeanNames) {
      getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
   }

   // 发布需要提前广播的事件
   Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
   this.earlyApplicationEvents = null;
   if (earlyEventsToProcess != null) {
      for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
         getApplicationEventMulticaster().multicastEvent(earlyEvent);
      }
   }
}

      下面我们通过具体的事件广播方法，看下观察者模式的使用

@Override
public void multicastEvent(ApplicationEvent event) {
   multicastEvent(event, resolveDefaultEventType(event));
}

@Override
public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
   ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
   // 遍历监听该事件的所有监听器
   for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
      Executor executor = getTaskExecutor();
      if (executor != null) {
         executor.execute(new Runnable() {
            @Override
            public void run() {
               // 发布事件
               invokeListener(listener, event);
            }
         });
      }
      else {
         invokeListener(listener, event);
      }
   }
}

step11、 实例化剩下的非延迟加载的单例

String CONVERSION_SERVICE_BEAN_NAME = "conversionService";
/**
 * Finish the initialization of this context's bean factory,
 * initializing all remaining singleton beans.
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // 存在类型转换器，就加载注册
   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));
   }

   // 如果没有默认的embedded value resolver，则注册一个
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
         @Override
         public String resolveStringValue(String strVal) {
            return getEnvironment().resolvePlaceholders(strVal);
         }
      });
   }

   // AOP功能，后续在AOP模块分析
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

   // 停用为了类型匹配创建的类加载器
   beanFactory.setTempClassLoader(null);

   // 冻结修改，缓存所有的bean元数据
   beanFactory.freezeConfiguration();

   // 实例化所有非延迟加载的bean
   beanFactory.preInstantiateSingletons();
}

      下面简单看下实例化的步骤

@Override
public void preInstantiateSingletons() throws BeansException {
   if (this.logger.isDebugEnabled()) {
      this.logger.debug("Pre-instantiating singletons in " + this);
   }

   // Iterate over a copy to allow for init methods which in turn register new bean definitions.
   // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
   // 获取所有注册的bean
   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

   // 遍历
   for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 非抽象 && 单例 && 非延迟加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         // 如果是FactoryBean
         if (isFactoryBean(beanName)) {
            // ‘&’ 前缀 + beanName 获取 FactoryBean 本身
            final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
            boolean isEagerInit;
            // 判断是否需要立即加载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(beanName);
         }
      }
   }

   // 实现了SmartInitializingSingleton的单例，可以触发afterSingletonsInstantiated回调方法
   for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
      if (singletonInstance instanceof SmartInitializingSingleton) {
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
               @Override
               public Object run() {
                  smartSingleton.afterSingletonsInstantiated();
                  return null;
               }
            }, getAccessControlContext());
         }
         else {
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

step12、 容器刷新完成，处理容器启动后置事件以及发布完成通知事件

protected void finishRefresh() {
   // 初始化lifecycleProcessor
   initLifecycleProcessor();

   // 获取所有实现了Lifecycle的bean,并执行start()
   getLifecycleProcessor().onRefresh();

   // 发布容器启动完成事件
   publishEvent(new ContextRefreshedEvent(this));

   // 把当前容器注册到LiveBeansView的集合中
   LiveBeansView.registerApplicationContext(this);
}

      

      好了，spring容器的启动过程到这里已经结束了。中间还有很多点可以扩展，鉴于本人的水平有限，有些点可能没有讲详细，后续会尽量再补充一些分析文章，聊胜于无。😄