spring系列-注解驱动原理及源码-spring容器创建流程

目录

一、spring容器的refresh()【创建刷新】 

二.BeanFactory 的创建及预准备工作

1.prepareRefresh()刷新前预处理工作。

2.obtainFreshBeanFactory() 获取BeanFactory

3.beanFactory的预准备工作

4.postProcessBeanFactory(beanFactory); beanFactory准备完成进行的后置处理工作

三、执行BeanFactoryPostProcessor

5.invokeBeanFactoryPostProcessors(beanFactory)执行BeanFactoryPostProcessor

四、注册BeanPostProcessors

6.registerBeanPostProcessors(beanFactory)注册BeanPostProcessor（bean的后置处理器）

五、初始化国际化功能

7.initMessageSource();初始化MessageSource组件（做国际化功能，消息绑定，消息解析）

六、初始化事件派发器及监听

8.initApplicationEventMulticaster(); 初始化事件派发器

9.onRefresh();

10.registerListeners();给容器中将项目里面的ApplicationListener注册进来

七、初始化所有剩下的单实例bean

11.finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean

八、完成BeanFactory的初始化创建工作

12.finishRefresh(); 完成BeanFactory的初始化创建工作，IOC容器就创建完成。

---

一、spring容器的refresh()【创建刷新】 

// org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class...)
public AnnotationConfigApplicationContext(Class... annotatedClasses) {
   this();
   register(annotatedClasses);
   refresh();
}

// org.springframework.context.support.AbstractApplicationContext#refresh
@Override
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();

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

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

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

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

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

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

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

         // Last step: publish corresponding event.
         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();
      }
   }
}

二.BeanFactory 的创建及预准备工作

1.prepareRefresh()刷新前预处理工作。

（1）initPropertySources()初始化一些属性设置。子类自定义个性化的 属性设置方法。

（2）getEnvironment().validateRequiredProperties() 检验属性的合法等。

（3）this.earlyApplicationEvents = new LinkedHashSet() 保存容器中的一些早期的事件

// org.springframework.context.support.AbstractApplicationContext#prepareRefresh
protected void prepareRefresh() {
   this.startupDate = System.currentTimeMillis();
   this.closed.set(false);
   this.active.set(true);

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

   // Initialize any placeholder property sources in the context environment
   initPropertySources();

   // Validate that all properties marked as required are resolvable
   // see ConfigurablePropertyResolver#setRequiredProperties
   getEnvironment().validateRequiredProperties();

   // Allow for the collection of early ApplicationEvents,
   // to be published once the multicaster is available...
   this.earlyApplicationEvents = new LinkedHashSet();
}

2.obtainFreshBeanFactory() 获取BeanFactory

（1）refreshBeanFactory() 刷新【创建】BeanFactory    

    创建了一个this.beanFactory = new DefaultListableBeanFactory(); BeanFactory    对象。

    设置id。

（2）getBeanFactory() 返回刚才GenericApplicationContext创建的BeanFactory   对象。

（3）将创建的BeanFactory -DefaultListableBeanFactory返回。

// org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   refreshBeanFactory();
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
   }
   return beanFactory;
}

3.beanFactory的预准备工作

（1）设置BeanFactory的类加载器、支持的表达式解析器等等。

（2）添加部分的BeanPostProcessor【ApplicationContextAwareProcessor】

（3）设置忽略的自动装配的接口【EnvironmentAware、EmbeddedValueResolverAware】。

（4）注册可以解析的自动装配。我们能直接在任何组件中自动注入BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext。

（5）添加BeanPostProcessor【ApplicationListenerDetector】。

（6）添加编译时的ASpecJ支持。

（7）给beanFactory中注册一些能用的组件【environment-ConfigurableEnvironment】、s【ystemProperties-Map】、【systemEnvironment-Map】

// org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // Tell the internal bean factory to use the context's class loader etc.
   beanFactory.setBeanClassLoader(getClassLoader());
   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   // Configure the bean factory with context callbacks.
   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 interface not registered as resolvable type in a plain factory.
   // MessageSource registered (and found for autowiring) as a bean.
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   // Register early post-processor for detecting inner beans as ApplicationListeners.
   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()));
   }

   // Register default environment beans.
   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());
   }
}

4.postProcessBeanFactory(beanFactory); beanFactory准备完成进行的后置处理工作

（1）子类通过重写postProcessBeanFactory方法来在BeanFactory创建并预准备完成以后做进一步的设置。

// org.springframework.context.support.AbstractApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

三、执行BeanFactoryPostProcessor

5.invokeBeanFactoryPostProcessors(beanFactory)执行BeanFactoryPostProcessor

BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的。

两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor

（1）执行BeanFactoryPostProcessor

    先执行BeanDefinitionRegistryPostProcessor

    1）获取所有的BeanDefinitionRegistryPostProcessor

    2）先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor，执行postProcessor.postProcessBeanDefinitionRegistry(registry);

    3）再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor，执行postProcessor.postProcessBeanDefinitionRegistry(registry);

    4）最后执行没有实现任何优先级或者顺序接口的BeanDefinitionRegistryPostProcessor，执行postProcessor.postProcessBeanDefinitionRegistry(registry);

    再执行BeanFactoryPostProcessor的方法

    1）获取所有的BeanFactoryPostProcessor

    2）先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor，执行postProcessor.postProcessBeanFactory(beanFactory);

    3）再执行实现了Ordered顺序接口的BeanFactoryPostProcessor，执行postProcessor.postProcessBeanFactory(beanFactory);

    4）最后执行没有实现任何优先级或者顺序接口的BeanFactoryPostProcessor，执行postProcessor.postProcessBeanFactory(beanFactory);

// org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

   // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
   // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
   if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
}

// org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.List)

public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
   Set processedBeans = new HashSet();

   if (beanFactory instanceof BeanDefinitionRegistry) {
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      List regularPostProcessors = new LinkedList();
      List registryProcessors = new LinkedList();

      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            registryProcessor.postProcessBeanDefinitionRegistry(registry);
            registryProcessors.add(registryProcessor);
         }
         else {
            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 currentRegistryProcessors = new ArrayList();

      // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      for (String ppName : postProcessorNames) {
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            processedBeans.add(ppName);
         }
      }
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      registryProcessors.addAll(currentRegistryProcessors);
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
      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();

      // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
      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();
      }

      // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
      invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
      invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   }

   else {
      // Invoke factory processors registered with the context instance.
      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!
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   List priorityOrderedPostProcessors = new ArrayList();
   List orderedPostProcessorNames = new ArrayList();
   List nonOrderedPostProcessorNames = new ArrayList();
   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 orderedPostProcessors = new ArrayList();
   for (String postProcessorName : orderedPostProcessorNames) {
      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

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

   // Clear cached merged bean definitions since the post-processors might have
   // modified the original metadata, e.g. replacing placeholders in values...
   beanFactory.clearMetadataCache();
}

四、注册BeanPostProcessors

6.registerBeanPostProcessors(beanFactory)注册BeanPostProcessor（bean的后置处理器）

【拦截bean的创建过程】

几个接口（不同接口类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的）：

    BeanPostProcessor 、

    DestructionAwareBeanPostProcessor、

    InstantationAwareBeanPostProcessor、

    SmartInstantationAwareBeanPostProcessor、

    MergedBeanDefinitionPostProcessor【放在internalPostProcessors里】。

（1）获取所有的BeanPostProcessor，后置处理器都默认可以通过PriorityOrdered、Ordered接口来指定优先级

（2）先注册PriorityOrdered优先级接口的BeanPostProcessor。

    把每一个BeanPostProcessor添加到beanFactory中。beanFactory.addBeanPostProcessor(postProcessor);

（3）再注册实现Ordered接口的。

（4）最后注册没有实现任何优先级接口的。

（5）最终注册MergedBeanDefinitionPostProcessor。

（6）注册一个ApplicationListenerDetector，在Bean创建完之后检查是否是ApplicationListenerDetector，如果是，applicationContext.addApplicationListener((ApplicationListener) bean);

// org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, org.springframework.context.support.AbstractApplicationContext)
public static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

   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.
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

   // Separate between BeanPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   List priorityOrderedPostProcessors = new ArrayList();
   List internalPostProcessors = new ArrayList();
   List orderedPostProcessorNames = new ArrayList();
   List nonOrderedPostProcessorNames = new ArrayList();
   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);
      }
   }

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

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

   // Now, register all regular BeanPostProcessors.
   List nonOrderedPostProcessors = new ArrayList();
   for (String ppName : nonOrderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      nonOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

   // Finally, re-register all internal BeanPostProcessors.
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

   // Re-register post-processor for detecting inner beans as ApplicationListeners,
   // moving it to the end of the processor chain (for picking up proxies etc).
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

五、初始化国际化功能

7.initMessageSource();初始化MessageSource组件（做国际化功能，消息绑定，消息解析）

（1）获取BeanFactory。

（2）看容器中是否有id为messageSource，类型是MessageSource的组件。

    如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource。

        MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取。

（3）把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource，调用getMessage方法。

    beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

// org.springframework.context.support.AbstractApplicationContext#initMessageSource
protected void initMessageSource() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   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());
         }
      }
      if (logger.isDebugEnabled()) {
         logger.debug("Using MessageSource [" + this.messageSource + "]");
      }
   }
   else {
      // Use empty MessageSource to be able to accept getMessage calls.
      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 + "]");
      }
   }
}

六、初始化事件派发器及监听

8.initApplicationEventMulticaster(); 初始化事件派发器

（1）获取BeanFactory

（2）从BeanFactory获取id为applicationEventMulticaster的类型为ApplicationEventMulticaster的组件。

（3）如果上一步没有配置，创建一个SimpleApplicationEventMulticaster。

（4）将创建的ApplicationEventMulticaster组件注入到容器中，添加到BeanFactory，以后其他组件直接自动注入。

// org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster
protected void initApplicationEventMulticaster() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   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 {
      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 + "]");
      }
   }
}

9.onRefresh();

（1）默认是空方法，留给子类。

（2）子类重写这个方法，在容器刷新的时候，再自定义逻辑。

10.registerListeners();给容器中将项目里面的ApplicationListener注册进来

（1）从容器中拿到所有的ApplicationListener组件。

（2）将每个监听器添加到事件派发器中。

（3）派发之前步骤产生的事件。

// org.springframework.context.support.AbstractApplicationContext#registerListeners
protected void registerListeners() {
   // Register statically specified listeners first.
   for (ApplicationListener listener : getApplicationListeners()) {
      getApplicationEventMulticaster().addApplicationListener(listener);
   }

   // Do not initialize FactoryBeans here: We need to leave all regular beans
   // uninitialized to let post-processors apply to them!
   String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
   for (String listenerBeanName : listenerBeanNames) {
      getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
   }

   // Publish early application events now that we finally have a multicaster...
   Set earlyEventsToProcess = this.earlyApplicationEvents;
   this.earlyApplicationEvents = null;
   if (earlyEventsToProcess != null) {
      for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
         getApplicationEventMulticaster().multicastEvent(earlyEvent);
      }
   }
}

七、初始化所有剩下的单实例bean

11.finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean

（1）beanFactory.preInstantiateSingletons();初始化剩下的单实例bean。

    1）获取容器中的所有bean，依次进行初始化和创建对象。

    2）获取bean的定义信息，

    3）bean不是抽象的、是单实例的、不是懒加载的

        ① 判断是否是FactoryBean，是否是实现FactoryBean接口的bean，通过工厂创建bean。

        ② 如果不是FactoryBean，利用getBean(beanName)创建对象。

        ③ 所有bean都利用getBean创建完成以后，来检查所有的bean是否是SmartInitializingSingleton接口的，如果是，就执行afterSingletonsInstantiated()方法。

getBean(beanName)的执行步骤

（1）调用doGetBean(name, null, null, false);

（2）先获取缓存中保存的单实例bean，如果能获取到，说明这个bean之前被创建过（所创建过的单实例bean都会被缓存起来）。

    从这里获取的：private final Map singletonObjects = new ConcurrentHashMap(256);

（3）缓存中获取不到，就开始bean的创建对象流程。

（4）标记当前bean已经被创建（防止多线程bean重复创建）。

（5）获取bean的定义信息。

（6）获取当前bean依赖的其他bean。如果有，按照getBean的方式先把依赖的bean创建出来。

（7）启动单实例bean的创建流程。

    1）createBean(beanName, mbd, args);

    2）Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

        让BeanPostProcessor先拦截返回代理对象。

        InstantiationAwareBeanPostProcessor：提前执行的逻辑。

        先触发postProcessBeforeInstantiation();

        如果有返回值，触发postProcessAfterInstantiation();

    3）如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象

    4）调用Object beanInstance = doCreateBean(beanName, mbdToUse, args); 创建bean

        ① 创建Bean实例createBeanInstance(beanName, mbd, args);

            利用工厂方法或者对象构造器创建出Bean实例。

        ② applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

            调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);

        ③ populateBean(beanName, mbd, instanceWrapper); 为bean的属性赋值。

            赋值之前，拿到InstantiationAwareBeanPostProcessor后置处理器，执行postProcessAfterInstantiation方法。

            拿到InstantiationAwareBeanPostProcessor后置处理器，执行postProcessPropertyValues();方法

            applyPropertyValues(beanName, mbd, bw, pvs);为属性利用setter方法等进行赋值。

        ④ initializeBean(beanName, exposedObject, mbd); bean初始化

            invokeAwareMethods(beanName, bean); 执行xxxAware接口的方法。【BeanNameAware、BeanClassLoaderAware、BeanFactoryAware】

            applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 执行后置处理器初始化之前的方法。【BeanPostProcessor.postProcessBeforeInitialization();】

            invokeInitMethods(beanName, wrappedBean, mbd); 执行初始化方法。【是否是InitializingBean接口的实现，执行接口规定的初始化、是否自定义初始化方法】

            applyBeanPostProcessorsAfterInitialization执行后置处理器初始化之后的postProcessAfterInstantiation方法。

        ⑤ registerDisposableBeanIfNecessary(beanName, bean, mbd); 注册bean的销毁方法。

    5）将创建的bean添加到缓存（Map）中。

ioc容器就是这些Map，很多的Map里面保存了很多的单实例bean、环境信息等等等等。

// org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // Initialize conversion service for this context.
   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));
   }

   // Register a default embedded value resolver if no bean post-processor
   // (such as a PropertyPlaceholderConfigurer bean) registered any before:
   // at this point, primarily for resolution in annotation attribute values.
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
         @Override
         public String resolveStringValue(String strVal) {
            return getEnvironment().resolvePlaceholders(strVal);
         }
      });
   }

   // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
   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);

   // Allow for caching all bean definition metadata, not expecting further changes.
   beanFactory.freezeConfiguration();

   // Instantiate all remaining (non-lazy-init) singletons.
   beanFactory.preInstantiateSingletons();
}

// org.springframework.beans.factory.support.DefaultListableBeanFactory#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.
   List beanNames = new ArrayList(this.beanDefinitionNames);

   // Trigger initialization of all non-lazy singleton beans...
   for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         if (isFactoryBean(beanName)) {
            final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
               isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
                  @Override
                  public Boolean run() {
                     return ((SmartFactoryBean) factory).isEagerInit();
                  }
               }, getAccessControlContext());
            }
            else {
               isEagerInit = (factory instanceof SmartFactoryBean &&
                     ((SmartFactoryBean) factory).isEagerInit());
            }
            if (isEagerInit) {
               getBean(beanName);
            }
         }
         else {
            getBean(beanName);
         }
      }
   }

   // Trigger post-initialization callback for all applicable beans...
   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