Spring容器啟動流程是什么

本篇內容介紹了“Spring容器啟動流程是什么”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

源碼解析

考慮到直接看源碼是一個非常枯燥無味的過程，而且 Spring  的代碼設計非常優秀規范，這會導致在翻開源碼時，類與類之間的跳躍會非常頻繁，不熟悉的同學可能直接暈菜，所以每一個重要流程前我都會先準備一個流程圖，建議大家先通過流程圖了解一下整體步驟，然后再對代碼硬擼，這樣能夠降低不少難度。

相信每一個使用過 Spring 技術的同學都知道 Spring 在初始化過程中有一個非常重要的步驟，即 Spring  容器的刷新，這個步驟固然重要，但是刷新前的初始化流程也非常重要。

本篇文章將整個啟動過程分為了兩個部分，即容器的初始化與刷新，下面正式開始。

初始化流程

流程分析

因為是基于 java-config 技術分析源碼，所以這里的入口是 AnnotationConfigApplicationContext ，如果是使用  xml 分析，那么入口即為 ClassPathXmlApplicationContext ，它們倆的共同特征便是都繼承了  AbstractApplicationContext 類，而大名鼎鼎的 refresh 方法便是在這個類中定義的，現在就不劇透了，我們接著分析  AnnotationConfigApplicationContext 類，可以繪制成如下流程圖：

看完流程圖，我們應該思考一下：如果讓你去設計一個 IOC  容器，你會怎么做?首先我肯定會提供一個入口(AnnotationConfigApplicationContext  )給用戶使用，然后需要去初始化一系列的工具組件：

①：如果我想生成 bean 對象，那么就需要一個 beanFactory 工廠(DefaultListableBeanFactory);

②：如果我想對加了特定注解(如 @Service、@Repository)的類進行讀取轉化成 BeanDefinition  對象(BeanDefinition 是 Spring 中極其重要的一個概念，它存儲了 bean  對象的所有特征信息，如是否單例，是否懶加載，factoryBeanName  等)，那么就需要一個注解配置讀取器(AnnotatedBeanDefinitionReader);

③：如果我想對用戶指定的包目錄進行掃描查找 bean  對象，那么還需要一個路徑掃描器(ClassPathBeanDefinitionScanner)。

通過上面的思考，是不是上面的圖理解起來就輕而易舉呢?

ps：圖中的黃色備注可以不看，只是在這里明確展示出來 Spring  的部分內置組件是何時何地添加到容器中的，關于組件的作用在后面的系列文章中會詳細分析。

核心代碼剖析

考慮到要是對所有代碼都進行解析，那么文章篇幅會過長，因此這里只對核心內容進行源碼層面的分析，凡是圖中標注了  ①、②、③等字樣的步驟，都可以理解為是一個比較重要的步驟，下面開始進行詳細分析。

org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors

根據上圖分析，代碼運行到這里時候，Spring 容器已經構造完畢，那么就可以為容器添加一些內置組件了，其中最主要的組件便是  ConfigurationClassPostProcessor 和 AutowiredAnnotationBeanPostProcessor ，前者是一個  beanFactory 后置處理器，用來完成 bean 的掃描與注入工作，后者是一個 bean 后置處理器，用來完成 @AutoWired 自動注入。

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(   BeanDefinitionRegistry registry, @Nullable Object source) {   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);  if (beanFactory != null) {   if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {    beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);   }   if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {    beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());   }  }   Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);  // 向 beanDefinitionMap 中注冊【BeanFactoryPostProcessor】：【ConfigurationClassPostProcessor】  if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {   RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);   def.setSource(source);   beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));  }  // 向 beanDefinitionMap 中注冊【BeanPostProcessor】：【AutowiredAnnotationBeanPostProcessor】  if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {   RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);   def.setSource(source);   beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));  }   // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.  // 向 beanDefinitionMap 中注冊【BeanPostProcessor】：【CommonAnnotationBeanPostProcessor】  if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {   RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);   def.setSource(source);   beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));  }   // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.  // 向 beanDefinitionMap 中注冊【BeanPostProcessor】：【PersistenceAnnotationBeanPostProcessor】，前提條件是在 jpa 環境下  if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {   RootBeanDefinition def = new RootBeanDefinition();   try {    def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,      AnnotationConfigUtils.class.getClassLoader()));   }   catch (ClassNotFoundException ex) {    throw new IllegalStateException(      "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);   }   def.setSource(source);   beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));  }  // 向 beanDefinitionMap 中注冊【BeanFactoryPostProcessor】：【EventListenerMethodProcessor】  if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {   RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);   def.setSource(source);   beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));  }  // 向 beanDefinitionMap 中注冊組件：【DefaultEventListenerFactory】  if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {   RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);   def.setSource(source);   beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));  }   return beanDefs; }

org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean

這個步驟主要是用來解析用戶傳入的 Spring 配置類，其實也是解析成一個 BeanDefinition 然后注冊到容器中，沒有什么好說的。

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,   @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {  // 解析傳入的配置類，實際上這個方法既可以解析配置類，也可以解析 Spring bean 對象  AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);  // 判斷是否需要跳過，判斷依據是此類上有沒有 @Conditional 注解  if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {   return;  }   abd.setInstanceSupplier(instanceSupplier);  ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);  abd.setScope(scopeMetadata.getScopeName());  String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));  // 處理類上的通用注解  AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);  if (qualifiers != null) {   for (Class<? extends Annotation> qualifier : qualifiers) {    if (Primary.class == qualifier) {     abd.setPrimary(true);    }    else if (Lazy.class == qualifier) {     abd.setLazyInit(true);    }    else {     abd.addQualifier(new AutowireCandidateQualifier(qualifier));    }   }  }  // 封裝成一個 BeanDefinitionHolder  for (BeanDefinitionCustomizer customizer : definitionCustomizers) {   customizer.customize(abd);  }  BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);  // 處理 scopedProxyMode  definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);   // 把 BeanDefinitionHolder 注冊到 registry  BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); }

刷新流程

流程分析

下面這一段代碼則是 Spring 中最為重要的一個步驟：容器刷新，同樣先看圖再分析。

看完流程圖，我們也先思考一下：在 3.1 中我們知道了如何去初始化一個 IOC 容器，那么接下來就是讓這個 IOC  容器真正起作用的時候了：即先掃描出要放入容器的 bean，將其包裝成 BeanDefinition 對象，然后通過反射創建 bean，并完成賦值操作，這個就是  IOC 容器最簡單的功能了。

但是看完上圖，明顯 Spring 的初始化過程比這個多的多，下面我們就詳細分析一下這樣設計的意圖：

如果用戶想在掃描完 bean 之后做一些自定義的操作：假設容器中包含了 a 和 b，那么就動態向容器中注入 c，不滿足就注入 d，這種騷操作 Spring  也是支持的，得益于它提供的 BeanFactoryPostProcessor 后置處理器，對應的是上圖中的  invokeBeanFactoryPostProcessors 操作。

如果用戶還想在 bean 的初始化前后做一些操作呢?比如生成代理對象，修改對象屬性等，Spring 為我們提供了 BeanPostProcessor  后置處理器，實際上 Spring 容器中的大多數功能都是通過 Bean 后置處理器完成的，Spring 也是給我們提供了添加入口，對應的是上圖中的  registerBeanPostProcessors 操作。

整個容器創建過程中，如果用戶想監聽容器啟動、刷新等事件，根據這些事件做一些自定義的操作呢?Spring  也早已為我們考慮到了，提供了添加監聽器接口和容器事件通知接口，對應的是上圖中的 registerListeners 操作。

此時再看上圖，是不是就覺得簡單很多呢，下面就一些重要代碼進行分析。

核心代碼剖析

org.springframework.context.support.AbstractApplicationContext#refresh

這個方法是對上圖中的具體代碼實現，可劃分為12個步驟，其中比較重要的步驟下面會有詳細說明。

在這里，我們需要記住：Spring 中的每一個容器都會調用 refresh 方法進行刷新，無論是 Spring 的父子容器，還是 Spring Cloud  Feign 中的 feign 隔離容器，每一個容器都會調用這個方法完成初始化。

public void refresh() throws BeansException, IllegalStateException {  synchronized (this.startupShutdownMonitor) {   // Prepare this context for refreshing.   // 1. 刷新前的預處理   prepareRefresh();    // Tell the subclass to refresh the internal bean factory.   // 2. 獲取 beanFactory，即前面創建的【DefaultListableBeanFactory】   ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();    // Prepare the bean factory for use in this context.   // 3. 預處理 beanFactory，向容器中添加一些組件   prepareBeanFactory(beanFactory);    try {    // Allows post-processing of the bean factory in context subclasses.    // 4. 子類通過重寫這個方法可以在 BeanFactory 創建并與準備完成以后做進一步的設置    postProcessBeanFactory(beanFactory);     // Invoke factory processors registered as beans in the context.    // 5. 執行 BeanFactoryPostProcessor 方法，beanFactory 后置處理器    invokeBeanFactoryPostProcessors(beanFactory);     // Register bean processors that intercept bean creation.    // 6. 注冊 BeanPostProcessors，bean 后置處理器    registerBeanPostProcessors(beanFactory);     // Initialize message source for this context.    // 7. 初始化 MessageSource 組件（做國際化功能；消息綁定，消息解析）    initMessageSource();     // Initialize event multicaster for this context.    // 8. 初始化事件派發器，在注冊監聽器時會用到    initApplicationEventMulticaster();     // Initialize other special beans in specific context subclasses.    // 9. 留給子容器（子類），子類重寫這個方法，在容器刷新的時候可以自定義邏輯，web 場景下會使用    onRefresh();     // Check for listener beans and register them.    // 10. 注冊監聽器，派發之前步驟產生的一些事件（可能沒有）    registerListeners();     // Instantiate all remaining (non-lazy-init) singletons.    // 11. 初始化所有的非單實例 bean    finishBeanFactoryInitialization(beanFactory);     // Last step: publish corresponding event.    // 12. 發布容器刷新完成事件    finishRefresh();   }    ...     } }

org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory

顧名思義，這個接口是為 beanFactory 工廠添加一些內置組件，預處理過程。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {  // Tell the internal bean factory to use the context's class loader etc.  // 設置 classLoader  beanFactory.setBeanClassLoader(getClassLoader());  //設置 bean 表達式解析器  beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));  beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));   // Configure the bean factory with context callbacks.  // 添加一個 BeanPostProcessor【ApplicationContextAwareProcessor】  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.  // 添加一個 BeanPostProcessor【ApplicationListenerDetector】  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));   // Detect a LoadTimeWeaver and prepare for weaving, if found.  // 添加編譯時的 AspectJ  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.  // 注冊 environment 組件，類型是【ConfigurableEnvironment】  if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {   beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());  }  // 注冊 systemProperties 組件，類型是【Map<String, Object>】  if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {   beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());  }  // 注冊 systemEnvironment 組件，類型是【Map<String, Object>】  if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {   beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());  } }

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

前文我們說過，Spring 在掃描完所有的 bean 轉成 BeanDefinition 時候，我們是可以做一些自定義操作的，這得益于 Spring  為我們提供的 BeanFactoryPostProcessor 接口。

其中 BeanFactoryPostProcessor 又有一個子接口 BeanDefinitionRegistryPostProcessor ，前者會把  ConfigurableListableBeanFactory 暴露給我們使用，后者會把 BeanDefinitionRegistry  注冊器暴露給我們使用，一旦獲取到注冊器，我們就可以按需注入了，例如搞定這種需求：假設容器中包含了 a 和 b，那么就動態向容器中注入 c，不滿足就注入  d。

熟悉 Spring 的同學都知道，Spring 中的同類型組件是允許我們控制順序的，比如在 AOP 中我們常用的 @Order 注解，這里的  BeanFactoryPostProcessor 接口當然也是提供了順序，最先被執行的是實現了 PriorityOrdered 接口的實現類，然后再到實現了  Ordered 接口的實現類，最后就是剩下來的常規 BeanFactoryPostProcessor 類。

此時再看上圖，是不是發現和喝水一般簡單，首先會回調 postProcessBeanDefinitionRegistry() 方法，然后再回調  postProcessBeanFactory() 方法，最后注意順序即可，下面一起看看具體的代碼實現吧。

public static void invokeBeanFactoryPostProcessors(   ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {  // beanFactoryPostProcessors 這個參數是指用戶通過 AnnotationConfigApplicationContext.addBeanFactoryPostProcessor() 方法手動傳入的 BeanFactoryPostProcessor，沒有交給 spring 管理  // Invoke BeanDefinitionRegistryPostProcessors first, if any.  // 代表執行過的 BeanDefinitionRegistryPostProcessor  Set<String> processedBeans = new HashSet<>();   if (beanFactory instanceof BeanDefinitionRegistry) {   BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;   // 常規后置處理器集合，即實現了 BeanFactoryPostProcessor 接口   List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();   // 注冊后置處理器集合，即實現了 BeanDefinitionRegistryPostProcessor 接口   List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();   // 處理自定義的 beanFactoryPostProcessors（指調用 context.addBeanFactoryPostProcessor() 方法），一般這里都沒有   for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {    if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {     BeanDefinitionRegistryPostProcessor registryProcessor =       (BeanDefinitionRegistryPostProcessor) postProcessor;     // 調用 postProcessBeanDefinitionRegistry 方法     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.   // 定義一個變量 currentRegistryProcessors，表示當前要處理的 BeanFactoryPostProcessors   List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();    // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.   // 首先，從容器中查找實現了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 類型，這里只會查找出一個【ConfigurationClassPostProcessor】   String[] postProcessorNames =     beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);   for (String ppName : postProcessorNames) {    // 判斷是否實現了 PriorityOrdered 接口    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {     // 添加到 currentRegistryProcessors     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));     // 添加到 processedBeans，表示已經處理過這個類了     processedBeans.add(ppName);    }   }   // 設置排列順序   sortPostProcessors(currentRegistryProcessors, beanFactory);   // 添加到 registry 中   registryProcessors.addAll(currentRegistryProcessors);   // 執行 [postProcessBeanDefinitionRegistry] 回調方法   invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);   // 將 currentRegistryProcessors 變量清空，下面會繼續用到   currentRegistryProcessors.clear();    // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.   // 接下來，從容器中查找實現了 Ordered 接口的 BeanDefinitionRegistryPostProcessors 類型，這里可能會查找出多個   // 因為【ConfigurationClassPostProcessor】已經完成了 postProcessBeanDefinitionRegistry() 方法，已經向容器中完成掃描工作，所以容器會有很多個組件   postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);   for (String ppName : postProcessorNames) {    // 判斷 processedBeans 是否處理過這個類，且是否實現 Ordered 接口    if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));     processedBeans.add(ppName);    }   }   // 設置排列順序   sortPostProcessors(currentRegistryProcessors, beanFactory);   // 添加到 registry 中   registryProcessors.addAll(currentRegistryProcessors);   // 執行 [postProcessBeanDefinitionRegistry] 回調方法   invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);   // 將 currentRegistryProcessors 變量清空，下面會繼續用到   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) {     // 判斷 processedBeans 是否處理過這個類     if (!processedBeans.contains(ppName)) {      // 添加到 currentRegistryProcessors      currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));      // 添加到 processedBeans，表示已經處理過這個類了      processedBeans.add(ppName);      // 將標識設置為 true，繼續循環查找，可能隨時因為防止下面調用了 invokeBeanDefinitionRegistryPostProcessors() 方法引入新的后置處理器      reiterate = true;     }    }    // 設置排列順序    sortPostProcessors(currentRegistryProcessors, beanFactory);    // 添加到 registry 中    registryProcessors.addAll(currentRegistryProcessors);    // 執行 [postProcessBeanDefinitionRegistry] 回調方法    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);    // 將 currentRegistryProcessors 變量清空，因為下一次循環可能會用到    currentRegistryProcessors.clear();   }    // Now, invoke the postProcessBeanFactory callback of all processors handled so far.   // 現在執行 registryProcessors 的 [postProcessBeanFactory] 回調方法   invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);   // 執行 regularPostProcessors 的 [postProcessBeanFactory] 回調方法，也包含用戶手動調用 addBeanFactoryPostProcessor() 方法添加的 BeanFactoryPostProcessor   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!  // 從容器中查找實現了 BeanFactoryPostProcessor 接口的類  String[] postProcessorNames =    beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,  // Ordered, and the rest.  // 表示實現了 PriorityOrdered 接口的 BeanFactoryPostProcessor  List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();  // 表示實現了 Ordered 接口的 BeanFactoryPostProcessor  List<String> orderedPostProcessorNames = new ArrayList<>();  // 表示剩下來的常規的 BeanFactoryPostProcessors  List<String> nonOrderedPostProcessorNames = new ArrayList<>();  for (String ppName : postProcessorNames) {   // 判斷是否已經處理過，因為 postProcessorNames 其實包含了上面步驟處理過的 BeanDefinitionRegistry 類型   if (processedBeans.contains(ppName)) {    // skip - already processed in first phase above   }   // 判斷是否實現了 PriorityOrdered 接口   else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {    priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));   }   // 判斷是否實現了 Ordered 接口   else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {    orderedPostProcessorNames.add(ppName);   }   // 剩下所有常規的   else {    nonOrderedPostProcessorNames.add(ppName);   }  }   // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.  // 先將 priorityOrderedPostProcessors 集合排序  sortPostProcessors(priorityOrderedPostProcessors, beanFactory);  // 執行 priorityOrderedPostProcessors 的 [postProcessBeanFactory] 回調方法  invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.  // 接下來，把 orderedPostProcessorNames 轉成 orderedPostProcessors 集合  List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();  for (String postProcessorName : orderedPostProcessorNames) {   orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));  }  // 將 orderedPostProcessors 集合排序  sortPostProcessors(orderedPostProcessors, beanFactory);  // 執行 orderedPostProcessors 的 [postProcessBeanFactory] 回調方法  invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);   // Finally, invoke all other BeanFactoryPostProcessors.  // 最后把 nonOrderedPostProcessorNames 轉成 nonOrderedPostProcessors 集合，這里只有一個，myBeanFactoryPostProcessor  List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();  for (String postProcessorName : nonOrderedPostProcessorNames) {   nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));  }  // 執行 nonOrderedPostProcessors 的 [postProcessBeanFactory] 回調方法  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();

org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors

這一步是向容器中注入 BeanPostProcessor  ，注意這里僅僅是向容器中注入而非使用。參考上面的步驟和下面的代碼，讀者自行分析即可，應該不是很困難。

關于 BeanPostProcessor ，它的作用在后續 Spring 創建 bean 流程文章里我會詳細分析一下，當然不可能分析全部的  BeanPostProcessor 組件，那樣可能得寫好幾篇續文，這里我們只需要簡單明白這個組件會干預 Spring 初始化 bean  的流程，從而完成代理、自動注入、循環依賴等各種功能。

public static void registerBeanPostProcessors(   ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {   // 從容器中獲取 BeanPostProcessor 類型  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;  // 向容器中添加【BeanPostProcessorChecker】，主要是用來檢查是不是有 bean 已經初始化完成了，  // 如果沒有執行所有的 beanPostProcessor（用數量來判斷），如果有就會打印一行 info 日志  beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));   // Separate between BeanPostProcessors that implement PriorityOrdered,  // Ordered, and the rest.  // 存放實現了 PriorityOrdered 接口的 BeanPostProcessor  List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();  // 存放 MergedBeanDefinitionPostProcessor 類型的 BeanPostProcessor  List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();  // 存放實現了 Ordered 接口的 BeanPostProcessor 的 name  List<String> orderedPostProcessorNames = new ArrayList<>();  // 存放剩下來普通的 BeanPostProcessor 的 name  List<String> nonOrderedPostProcessorNames = new ArrayList<>();  // 從 beanFactory 中查找 postProcessorNames 里的 bean，然后放到對應的集合中  for (String ppName : postProcessorNames) {   // 判斷有無實現 PriorityOrdered 接口   if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);    priorityOrderedPostProcessors.add(pp);    // 如果實現了 PriorityOrdered 接口，且屬于 MergedBeanDefinitionPostProcessor    if (pp instanceof MergedBeanDefinitionPostProcessor) {     // 把 MergedBeanDefinitionPostProcessor 類型的添加到 internalPostProcessors 集合中     internalPostProcessors.add(pp);    }   }   else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {    orderedPostProcessorNames.add(ppName);   }   else {    nonOrderedPostProcessorNames.add(ppName);   }  }   // First, register the BeanPostProcessors that implement PriorityOrdered.  // 給 priorityOrderedPostProcessors 排序  sortPostProcessors(priorityOrderedPostProcessors, beanFactory);  // 先注冊實現了 PriorityOrdered 接口的 beanPostProcessor  registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);   // Next, register the BeanPostProcessors that implement Ordered.  // 從 beanFactory 中查找 orderedPostProcessorNames 里的 bean，然后放到對應的集合中  List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();  for (String ppName : orderedPostProcessorNames) {   BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);   orderedPostProcessors.add(pp);   if (pp instanceof MergedBeanDefinitionPostProcessor) {    internalPostProcessors.add(pp);   }  }  // 給 orderedPostProcessors 排序  sortPostProcessors(orderedPostProcessors, beanFactory);  // 再注冊實現了 Ordered 接口的 beanPostProcessor  registerBeanPostProcessors(beanFactory, orderedPostProcessors);   // Now, register all regular BeanPostProcessors.  List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();  for (String ppName : nonOrderedPostProcessorNames) {   BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);   nonOrderedPostProcessors.add(pp);   if (pp instanceof MergedBeanDefinitionPostProcessor) {    internalPostProcessors.add(pp);   }  }  // 再注冊常規的 beanPostProcessor  registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);   // Finally, re-register all internal BeanPostProcessors.  // 排序 MergedBeanDefinitionPostProcessor 這種類型的 beanPostProcessor  sortPostProcessors(internalPostProcessors, beanFactory);  // 最后注冊 MergedBeanDefinitionPostProcessor 類型的 beanPostProcessor  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).  // 給容器中添加【ApplicationListenerDetector】 beanPostProcessor，判斷是不是監聽器，如果是就把 bean 放到容器中保存起來  // 此時容器中默認會有 6 個內置的 beanPostProcessor   // 0 = {ApplicationContextAwareProcessor@1632}   // 1 = {ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor@1633}   // 2 = {PostProcessorRegistrationDelegate$BeanPostProcessorChecker@1634}   // 3 = {CommonAnnotationBeanPostProcessor@1635}   // 4 = {AutowiredAnnotationBeanPostProcessor@1636}   // 5 = {ApplicationListenerDetector@1637}  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); }

org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster

前文我們說到，在整個容器創建過程中，Spring 會發布很多容器事件，如容器啟動、刷新、關閉等，這個功能的實現得益于這里的  ApplicationEventMulticaster 廣播器組件，通過它來派發事件通知。

在這里 Spring 也為我們提供了擴展，SimpleApplicationEventMulticaster  默認是同步的，如果我們想改成異步的，只需要在容器里自定義一個 name 為 applicationEventMulticaster  的容器即可，類似的思想在后續的 Spring Boot 中會有更多的體現，這里不再贅述。

protected void initApplicationEventMulticaster() {  // 獲取 beanFactory  ConfigurableListableBeanFactory beanFactory = getBeanFactory();  // 看看容器中是否有自定義的 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 {   // 沒有，就創建一個 SimpleApplicationEventMulticaster   this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);   // 將創建的 ApplicationEventMulticaster 添加到 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() + "]");   }  } }

org.springframework.context.support.AbstractApplicationContext#registerListeners

如果用戶想監聽容器事件，那么就必須按照規范實現 ApplicationListener 接口并放入到容器中，在這里會被 Spring 掃描到，添加到  ApplicationEventMulticaster 廣播器里，以后就可以發布事件通知，對應的 Listener 就會收到消息進行處理。

protected void registerListeners() {  // Register statically specified listeners first.  // 獲取之前步驟中保存的 ApplicationListener  for (ApplicationListener<?> listener : getApplicationListeners()) {   // getApplicationEventMulticaster() 就是獲取之前步驟初始化的 applicationEventMulticaster   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...  // 派發之前步驟產生的 application events  Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;  this.earlyApplicationEvents = null;  if (earlyEventsToProcess != null) {   for (ApplicationEvent earlyEvent : earlyEventsToProcess) {    getApplicationEventMulticaster().multicastEvent(earlyEvent);   }  } }

org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons

在上面的步驟中，Spring 的大多數組件都已經初始化完畢了，剩下來的這個步驟就是初始化所有剩余的單實例 bean，在 Spring 中初始化一個  bean 對象是非常復雜的，如循環依賴、bean 后置處理器運用、aop 代理等，這些內容都不在此展開贅述了，后面的系列文章會具體探究，這里我們只需要明白  Spring 是通過這個方法把容器中的 bean 都初始化完畢即可。

public void preInstantiateSingletons() throws BeansException {  if (logger.isTraceEnabled()) {   logger.trace("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.  // 獲取容器中的所有 beanDefinitionName  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);   // Trigger initialization of all non-lazy singleton beans...  // 循環進行初始化和創建對象  for (String beanName : beanNames) {   // 獲取 RootBeanDefinition，它表示自己的 BeanDefinition 和可能存在父類的 BeanDefinition 合并后的對象   RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);   // 如果是非抽象的，且單實例，非懶加載   if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {    // 如果是 factoryBean，利用下面這種方法創建對象    if (isFactoryBean(beanName)) {     // 如果是 factoryBean，則 加上 &，先創建工廠 bean     Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);     if (bean instanceof FactoryBean) {      final FactoryBean<?> factory = (FactoryBean<?>) bean;      boolean isEagerInit;      if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {       isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)           ((SmartFactoryBean<?>) factory)::isEagerInit,         getAccessControlContext());      }      else {       isEagerInit = (factory instanceof SmartFactoryBean &&         ((SmartFactoryBean<?>) factory).isEagerInit());      }      if (isEagerInit) {       getBean(beanName);      }     }    }    else {     // 不是工廠 bean，用這種方法創建對象     getBean(beanName);    }   }  }   // Trigger post-initialization callback for all applicable beans...  for (String beanName : beanNames) {   Object singletonInstance = getSingleton(beanName);   // 檢查所有的 bean 是否是 SmartInitializingSingleton 接口   if (singletonInstance instanceof SmartInitializingSingleton) {    final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;    if (System.getSecurityManager() != null) {     AccessController.doPrivileged((PrivilegedAction<Object>) () -> {      smartSingleton.afterSingletonsInstantiated();      return null;     }, getAccessControlContext());    }    else {     // 回調 afterSingletonsInstantiated() 方法，可以在回調中做一些事情     smartSingleton.afterSingletonsInstantiated();    }   }  } }

org.springframework.context.support.AbstractApplicationContext#finishRefresh

整個容器初始化完畢之后，會在這里進行一些掃尾工作，如清理緩存，初始化生命周期處理器，發布容器刷新事件等。

protected void finishRefresh() {  // Clear context-level resource caches (such as ASM metadata from scanning).  // 清理緩存  clearResourceCaches();   // Initialize lifecycle processor for this context.  // 初始化和生命周期有關的后置處理器  initLifecycleProcessor();   // Propagate refresh to lifecycle processor first.  // 拿到前面定義的生命周期處理器【LifecycleProcessor】回調 onRefresh() 方法  getLifecycleProcessor().onRefresh();   // Publish the final event.  // 發布容器刷新完成事件  publishEvent(new ContextRefreshedEvent(this));   // Participate in LiveBeansView MBean, if active.  LiveBeansView.registerApplicationContext(this); }

“Spring容器啟動流程是什么”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！