基于spring5.0源码解析

入口：

spring启动的入口类为配置在web.xml中的监听器在ContextLoaderListener.java这个类里面：

@Override
public void contextInitialized(ServletContextEvent event) {
   // 初始化web应用程序上下文
   initWebApplicationContext(event.getServletContext());
}

进入initWebApplicationContext里面：

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
   // 判断web上下文是否已经存在  web上下文文件放在servlet里面  目录是WebApplicationContext.root
   if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
      ......
   }
    ......

   try {
      // 初始化web上下文  将上下文存储在本地实例变量中，以确保在ServletContext关闭时可用。
      if (this.context == null) {
         this.context = createWebApplicationContext(servletContext);
      }
      if (this.context instanceof ConfigurableWebApplicationContext) {
         ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
         if (!cwac.isActive()) {
            // 上下文尚未刷新->提供服务，例如设置父上下文，设置应用程序上下文ID等
            if (cwac.getParent() == null) {
               // 在没有显式父项的情况下注入了上下文实例-> 确定根Web上下文的父项（如果有）。
               ApplicationContext parent = loadParentContext(servletContext);
               cwac.setParent(parent);
            }
            // 配置和刷新Web上下文
            configureAndRefreshWebApplicationContext(cwac, servletContext);
         }
      }
      // 把web上下文放进servlet里面
      servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);


......
}

initWebApplicationContext

可以看出initWebApplicationContext这个方法主要做三个步骤：
1.检验
2.初始化web上下文
3.把web上下文放进servlet里面
这里可以看出，主要的初始化过程在configureAndRefreshWebApplicationContext里面，进入

configureAndRefreshWebApplicationContext：

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
   if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
      // 应用程序上下文ID仍设置为其原始默认值->根据可用信息分配一个更有用的I
      // 配置上下文id
      String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
      if (idParam != null) {
         wac.setId(idParam);
      }
      else {
         // Generate default id...  生成id
         wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
               ObjectUtils.getDisplayString(sc.getContextPath()));
      }
   }

   wac.setServletContext(sc);
   String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
   if (configLocationParam != null) {
      wac.setConfigLocation(configLocationParam);
   }

   // 无论何时刷新上下文，都会调用wac环境的#initPropertySources；在此处急切地执行此操作，以确保servlet属性源
   // 用于#refresh之前的任何后处理或初始化中
   ConfigurableEnvironment env = wac.getEnvironment();
   if (env instanceof ConfigurableWebEnvironment) {
      ((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
   }
   // 刷新子类上下文
   customizeContext(sc, wac);
   // 上下文刷新
   wac.refresh();
}

可以看出，这个方法里面，主要是准备一些参数为wac.refresh()刷新做准备。

进入wac.refresh()里面：

public void refresh() throws BeansException, IllegalStateException {
   // 门面模式 加锁->这里刷新和销毁必须是同步的
   synchronized (this.startupShutdownMonitor) {
      // 准备刷新
      prepareRefresh();
      
      // 获取bean工厂
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      
      // 为bean工厂做预备工作
      prepareBeanFactory(beanFactory);

      try {
         // BeanFactory创建后的后置处理器
         postProcessBeanFactory(beanFactory);

         // 执行BeanFactory后置处理器
         invokeBeanFactoryPostProcessors(beanFactory);

         // 注册bean后置处理器
         registerBeanPostProcessors(beanFactory);

         // 初始化MessageSource组件
         initMessageSource();

         // 初始化事件派发器
         initApplicationEventMulticaster();
         
         // 在特定上下文子类中初始化其他特殊bean。 子类可以自定义实现
         onRefresh();

         // 检查和注册监听器的bean
         registerListeners();

         // 注册剩下的bean（非懒加载）
         finishBeanFactoryInitialization(beanFactory);

         // 发布事件
         finishRefresh();
      } catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // 销毁避免资源浪费
         destroyBeans();

         cancelRefresh(ex);.
         throw ex;
      } finally {
          // 清除初始化自缓存数据。
         resetCommonCaches();
      }
   }
}

可以看到，这里使用门面模式，步骤很清晰，我们一个一个分析：

prepareRefresh()：准备刷新

为刷新bean工厂做一些前置的工作。
1.标记为活跃状态，该状态在容器操作中用来判断一些执行条件
2.初始化属性设置
3.检验这些属性设置是否合法
4.预刷新ApplicationListeners
5.保存容器中的一些早期的事件

protected void prepareRefresh() {
   // Switch to active.
   this.startupDate = System.currentTimeMillis();
   this.closed.set(false);
   // 标记为活跃状态，该状态在容器操作中用来判断一些执行条件
   this.active.set(true);

   if (logger.isDebugEnabled()) {
      if (logger.isTraceEnabled()) {
         logger.trace("Refreshing " + this);
      } else {
         logger.debug("Refreshing " + getDisplayName());
      }
   }

   // Initialize any placeholder property sources in the context environment.
   // 初始化属性设置
   initPropertySources();

   // Validate that all properties marked as required are resolvable:
   // see ConfigurablePropertyResolver#setRequiredProperties
   // 检验这些属性设置是否合法
   getEnvironment().validateRequiredProperties();

   // Store pre-refresh ApplicationListeners...
   // 预刷新ApplicationListeners
   if (this.earlyApplicationListeners == null) {
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
   } else {
      // Reset local application listeners to pre-refresh state.
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
   }

   // Allow for the collection of early ApplicationEvents,
   // to be published once the multicaster is available...
   // 用于保存容器中的一些早期的事情
   this.earlyApplicationEvents = new LinkedHashSet<>();
}

obtainFreshBeanFactory():获取bean工厂

这里主要通过ConfigurableListableBeanFactory #refreshBeanFactory里面获的

ConfigurableListableBeanFactory 主要做了两件事情：

1.调用refreshBeanFactory方法进行工厂刷新
2.返回bean工厂

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   // 刷新bean工厂
   refreshBeanFactory();
   // 返回bean工厂
   return getBeanFactory();
}

refreshBeanFactory 主要做了两件事情：

1.如果bean工厂存在 则销毁
2.创建新的beanFactory
3.定义上下文的内部bean工厂规则
4.加载bean定义

@Override
protected final void refreshBeanFactory() throws BeansException {
   // 如果bean工厂存在 则销毁
   if (hasBeanFactory()) {
      // 销毁bean
      destroyBeans();
      // 清除bean工厂
      closeBeanFactory();
   }
   try {
      // 创建新的beanFactory
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      // bean工厂序列化id
      beanFactory.setSerializationId(getId());
      // 定义上下文的内部bean工厂规则
      customizeBeanFactory(beanFactory);
      // 加载bean定义  默认使用XmlBeanDefinitionReader
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   } catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

loadBeanDefinitions(beanFactory)：加载bean定义

主要通过XmlBeanDefinitionReader来读取META-INF/spring.schemas下面的dtd。

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
   // Create a new XmlBeanDefinitionReader for the given BeanFactory.
   // 给bean工厂创建XmlBeanDefinitionReader
   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

   // Configure the bean definition reader with this context's
   // resource loading environment.
   // 使用此上下文的资源加载环境配置bean定义阅读器。
   beanDefinitionReader.setEnvironment(this.getEnvironment());
   beanDefinitionReader.setResourceLoader(this);
   // 解析器回去解析META-INF/spring.schemas下面的dtd
   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

   // Allow a subclass to provide custom initialization of the reader,
   // then proceed with actually loading the bean definitions.
   // 初始化bean定义
   initBeanDefinitionReader(beanDefinitionReader);
   // 加载bean 定义
   loadBeanDefinitions(beanDefinitionReader);
}

bean定义解析器。我们可以从ResourceEntityResolver-》DelegatingEntityResolver-》PluggableSchemaResolver里面看到。

......
public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";
......
public PluggableSchemaResolver(@Nullable ClassLoader classLoader) {
   this.classLoader = classLoader;
   this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION;
}

prepareBeanFactory(beanFactory):为bean工厂做预备工作

主要是加个加载器，解析器，编译器进行提前加载
1.设置类加载器，表达式解析器、属性编辑器
2.提前加载需要用到的bean

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.
   // 添加一些在bean生命周期中可能要用到的东西，如ApplicationContextAwareProcessor，
   // 在bean初始化的时候判断该bean是否实现了各种类型的Aware接口
   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.
   // 注册默认环境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());
   }
}

postProcessBeanFactory(beanFactory):BeanFactory创建后的后置处理器

这个是给一些子类实现的，比如设置ServletContextAwareProcessor处理器或者定制化容器的初始化设置等

invokeBeanFactoryPostProcessors(beanFactory)：执行BeanFactory后置处理器

这里面主要的逻辑在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()));
   }
}

invokeBeanFactoryPostProcessors：初始化事件派发器

这个方法主要做了初始化几种bean的后置处理器
1.排序
2.先处理实现了PriorityOrdered的BeanDefinitionRegistryPostProcessor类型
3.接下来执行实现了Ordered接口的BeanDefinitionRegistryPostProcessors
4.最后处理剩余的BeanDefinitionRegistryPostProcessors
5.重新排序
6.再按之前的顺序执行BeanFactoryPostProcessor类型的处理器

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

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

   if (beanFactory instanceof BeanDefinitionRegistry) {
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
      // 将俩种处理器分别取出
      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<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

      // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
      // 先处理实现了PriorityOrdered的BeanDefinitionRegistryPostProcessor类型
      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);
      //执行处理器postProcessBeanDefinitionRegistry方法
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      currentRegistryProcessors.clear();

      // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
      // 接下来执行实现了Ordered接口的BeanDefinitionRegistryPostProcessors
      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.
      // 最后处理剩余的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();
      }

      // 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<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   List<String> orderedPostProcessorNames = new ArrayList<>();
   List<String> 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<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   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<>(nonOrderedPostProcessorNames.size());
   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();
}

registerBeanPostProcessors(beanFactory):注册bean后置处理器

这个方法主要逻辑在PostProcessorRegistrationDelegate.registerBeanPostProcessors()里面，主要的功能也是对几个后置器进行初始化：

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

PostProcessorRegistrationDelegate.registerBeanPostProcessors()：

1.分开四个需要处理的 PriorityOrdered Ordered BeanPostProcessors 和 剩余普通的
2.首先处理实现PriorityOrdered的Bean后处理器
3.其次是实现了Ordered的Bean后处理器
4.然后实现所有常规Bean后处理器
5.然后 重新注册所有的内部Bean后处理器
6.最后注册一个ApplicationListeners 然后把他放入所有处理器后面

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.
   // 分开四个需要处理的 PriorityOrdered   Ordered  BeanPostProcessors 和 剩余普通的
   List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
   List<String> orderedPostProcessorNames = new ArrayList<>();
   List<String> 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.
   // 首先处理实现PriorityOrdered的Bean后处理器
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // Next, register the BeanPostProcessors that implement Ordered.
   // 其次是实现了Ordered的Bean后处理器
   List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   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.
   // 然后实现所有常规Bean后处理器
   List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
   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.
   // 然后 重新注册所有的内部Bean后处理器
   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).
   // 最后注册一个ApplicationListeners 然后把他放入所有处理器后面
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

initMessageSource()：初始化MessageSource组件

内容不复杂，就是判断bean工厂有没有消息源，没有就给它注册一个。
1.如果BeanFactory中注册了id为messageSource的bean，获取该实例
2.尝试给该消息源设置父消息源
3.如果BeanFactory中没有注册消息源，创建一个空的消息源，保证容器可以提供getMessage方法给其他地方调用
4.这个新建的空消息源也会注册到BeanFactory里面去

protected void initMessageSource() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 判断bean工厂是否注册了messageSource
   if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
      this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
      // Make MessageSource aware of parent MessageSource.
      // 有注册 为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.isTraceEnabled()) {
         logger.trace("Using MessageSource [" + this.messageSource + "]");
      }
   } else {
      // Use empty MessageSource to be able to accept getMessage calls.
      // 没有注册 注册一个空的消息源 并放进bean工厂中
      DelegatingMessageSource dms = new DelegatingMessageSource();
      dms.setParentMessageSource(getInternalParentMessageSource());
      this.messageSource = dms;
      beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
      if (logger.isTraceEnabled()) {
         logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
      }
   }
}

initApplicationEventMulticaster()：初始化事件派发器

判断有没有注册事件派发器，有就获取，没有就注册一个。
如果BeanFactory中注册了id为applicationEventMulticaster的bean，获取该实例
如果不存在，创建SimpleApplicationEventMulticaster
将该实例注册到BeanFactory中

protected void initApplicationEventMulticaster() {
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   // 判断bean工厂是否注册了applicationEventMulticaster  有就获取 没有就创建一个新的
   if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
      this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
      if (logger.isTraceEnabled()) {
         logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
      }
   } else {
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
      if (logger.isTraceEnabled()) {
         logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
               "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
      }
   }
}

onRefresh()：子容器实现

空方法，用于子类自己调用，例如StaticWebApplicationContext

protected void onRefresh() throws BeansException {
   // For subclasses: do nothing by default.
}

registerListeners()：检查和注册bean的监听器

用于检查和注册bean的监听器。
1.首先 注册静态监听器
2.获取实现了ApplicationListener接口的监听器并注册进来
3.注册早期监听器

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!
   // 获取实现了ApplicationListener接口的监听器并注册进来
   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<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
   this.earlyApplicationEvents = null;
   if (earlyEventsToProcess != null) {
      for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
         getApplicationEventMulticaster().multicastEvent(earlyEvent);
      }
   }
}

finishBeanFactoryInitialization(beanFactory)：注册剩下的bean（非懒加载）

1.初始化转换器
2.如果之前没有任何bean后处理器,则注册一个默认的值解析器，用来处理替换注解中的值
3.注册早期的LoadTimeWeaverAware
4.注册剩余的非懒加载单实例bean

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.
   // 如果之前没有任何bean后处理器,则注册一个默认的值解析器，用来处理替换注解中的值
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
   // 注册早期的LoadTimeWeaverAware
   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.
   // 注册剩余的非懒加载单实例bean
   beanFactory.preInstantiateSingletons();
}

finishRefresh()：发布事件

protected void finishRefresh() {
   // Clear context-level resource caches (such as ASM metadata from scanning).
   // 清除容器级别的Resource缓存
   clearResourceCaches();

   // Initialize lifecycle processor for this context.
   // 初始化生命周期有关的后置处理器
   initLifecycleProcessor();

   // Propagate refresh to lifecycle processor first.
   // 将容器refresh这件事情传播给生命周期相关的处理器
   getLifecycleProcessor().onRefresh();

   // Publish the final event.
   // 布容器刷新完成事件
   publishEvent(new ContextRefreshedEvent(this));

   // Participate in LiveBeansView MBean, if active.
   LiveBeansView.registerApplicationContext(this);
}

destroyBeans()和cancelRefresh(ex)：回收资源

如果中间出现问题，会进行资源回收。

protected void destroyBeans() {
   getBeanFactory().destroySingletons();
}
public void destroySingletons() {
   super.destroySingletons();
   // 更新工厂内部的单例集（map）
   updateManualSingletonNames(Set::clear, set -> !set.isEmpty());
   // 清除单例集(map)
   clearByTypeCache();
}


protected void cancelRefresh(BeansException ex) {
   this.active.set(false);
}

resetCommonCaches():

清除初始化自缓存数据。

protected void resetCommonCaches() {
   ReflectionUtils.clearCache();
   AnnotationUtils.clearCache();
   ResolvableType.clearCache();
   CachedIntrospectionResults.clearClassLoader(getClassLoader());
}

总结：

spring源码还是相对友善的，命名方法和注释都很丰富，作者看源码只是按照自己的理解看的，可能有出入，别介意。我建议如果你要看源码，还是去下载官方的代码进行阅读，不然看文章理解还是比较难的，而且源码用到了很对设计模式，比如工厂模式，静态模式，门面模式，模版方法模式等都是可以学习的。我后续会啊源码上传上去，有需要可以去下载，GitHub上面下载网速慢的蛋疼。
参考：https://blog.csdn.net/q649381130/article/details/88600021
https://www.jianshu.com/p/38782c5fc9a7