【從入門到放棄-SpringBoot】SpringBoot源碼分析-啟動

前言

上一篇我們一起簡單了解了

【從入門到放棄-MySQL】資料庫連接配接過程分析-用戶端

，寫完之後通讀一遍，感覺分析的不是很透徹。有很多地方都沒搞通，是以決定從Springboot源碼開始從頭研究下。

main 入口分析

package com.springboot.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scheduling.annotation.EnableScheduling;

@MapperScan("com.springboot.demo.repository.dao")
@SpringBootApplication
@EnableScheduling
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}
           

• 一個簡單的springboot項目啟動檔案中 一行代碼就能搞定。

  我們從這一行代碼開始看起。

SpringApplication::SpringApplication

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    setInitializers((Collection) getSpringFactoriesInstances(
            ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = deduceMainApplicationClass();
}           

• 主要是初始化成員變量，比如參數清單，應用類型、監聽器等。

getSpringFactoriesInstances

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
        Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    Set<String> names = new LinkedHashSet<>(
            SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
            classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}           

這個方法主要是根據type類型擷取配置中預設的類清單，并進行初始化。

• loadFactoryNames：從META-INF/spring.factories中擷取type對應的配置類名稱清單。
• createSpringFactoriesInstances：校驗擷取到的類是否是parameterTypes類的子類，并将擷取到的類通過反射機制執行個體化，

SpringApplication::run

/**
 * Run the Spring application, creating and refreshing a new
 * {@link ApplicationContext}.
 * @param args the application arguments (usually passed from a Java main method)
 * @return a running {@link ApplicationContext}
 */
public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners,
                applicationArguments);
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);
        context = createApplicationContext();
        exceptionReporters = getSpringFactoriesInstances(
                SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        prepareContext(context, environment, listeners, applicationArguments,
                printedBanner);
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass)
                    .logStarted(getApplicationLog(), stopWatch);
        }
        listeners.started(context);
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}           

StopWatch

是一個計時器工具類，這裡先記錄了項目的啟動時間

變量初始化

各種變量初始化，用法在後面具體分析

configureHeadlessProperty

設定系統java.awt.headless屬性，為true的話是告知系統不要指望顯示器、滑鼠、鍵盤等可以正常運作，這是一個服務端程式，用到這些外設的時候需要靠自己模拟

getRunListeners

擷取SpringApplicationRunListeners各項監聽器并執行個體化，這些監聽器配置在spring.factories資源檔案中。

prepareEnvironment

配置環境，如配置檔案、系統變量等并通過監聽器廣播環境變量準備完畢事件。

printBanner

列印啟動顯示的banner。

createApplicationContext

根據webApplicationType初始化spring上下文

exceptionReporters

初始化配置的異常報告類

prepareContext

private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    context.setEnvironment(environment);
    postProcessApplicationContext(context);
    applyInitializers(context);
    listeners.contextPrepared(context);
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }
    // Add boot specific singleton beans
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    if (beanFactory instanceof DefaultListableBeanFactory) {
        ((DefaultListableBeanFactory) beanFactory)
                .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    // Load the sources
    Set<Object> sources = getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    load(context, sources.toArray(new Object[0]));
    listeners.contextLoaded(context);
}           

• setEnvironment：設定上下文環境
• postProcessApplicationContext：上下文後置處理，預設沒做什麼事。
• applyInitializers：調用之前執行個體化的幾個ApplicationContextInitializer類的initialize方法
• contextPrepared：向listeners發送上下文已準備完畢的通知。
• load：BeanDefinitionLoader可以加載各種bean，比如注解、XML、package等多種類型的bean，在後面利用BeanDefinitionLoader将這些beans都加載進上下文中。
• contextLoaded：向listeners發送上下文已加載完畢的通知。

refreshContext

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

• prepareRefresh：一些準備工作，比如設定啟動時間、初始化資源、必須屬性校驗等。
• obtainFreshBeanFactory：通知子類重新整理内置的beanFactory
• prepareBeanFactory：對容器的beanFactory做一些準備工作，比如設定classloader、設定&取消設定一些類的bean
• invokeBeanFactoryPostProcessors：
  • 主要看invokeBeanDefinitionRegistryPostProcessors方法，會調用ConfigurationClassPostProcessor::processConfigBeanDefinitions。

  public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
      List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
      String[] candidateNames = registry.getBeanDefinitionNames();
  
      for (String beanName : candidateNames) {
          BeanDefinition beanDef = registry.getBeanDefinition(beanName);
          if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
                  ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
              if (logger.isDebugEnabled()) {
                  logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
              }
          }
          else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
              configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
          }
      }
  
      // Return immediately if no @Configuration classes were found
      if (configCandidates.isEmpty()) {
          return;
      }
  
      // Sort by previously determined @Order value, if applicable
      configCandidates.sort((bd1, bd2) -> {
          int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
          int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
          return Integer.compare(i1, i2);
      });
  
      // Detect any custom bean name generation strategy supplied through the enclosing application context
      SingletonBeanRegistry sbr = null;
      if (registry instanceof SingletonBeanRegistry) {
          sbr = (SingletonBeanRegistry) registry;
          if (!this.localBeanNameGeneratorSet) {
              BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
              if (generator != null) {
                  this.componentScanBeanNameGenerator = generator;
                  this.importBeanNameGenerator = generator;
              }
          }
      }
  
      if (this.environment == null) {
          this.environment = new StandardEnvironment();
      }
  
      // Parse each @Configuration class
      ConfigurationClassParser parser = new ConfigurationClassParser(
              this.metadataReaderFactory, this.problemReporter, this.environment,
              this.resourceLoader, this.componentScanBeanNameGenerator, registry);
  
      Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
      Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
      do {
          parser.parse(candidates);
          parser.validate();
  
          Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
          configClasses.removeAll(alreadyParsed);
  
          // Read the model and create bean definitions based on its content
          if (this.reader == null) {
              this.reader = new ConfigurationClassBeanDefinitionReader(
                      registry, this.sourceExtractor, this.resourceLoader, this.environment,
                      this.importBeanNameGenerator, parser.getImportRegistry());
          }
          this.reader.loadBeanDefinitions(configClasses);
          alreadyParsed.addAll(configClasses);
  
          candidates.clear();
          if (registry.getBeanDefinitionCount() > candidateNames.length) {
              String[] newCandidateNames = registry.getBeanDefinitionNames();
              Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
              Set<String> alreadyParsedClasses = new HashSet<>();
              for (ConfigurationClass configurationClass : alreadyParsed) {
                  alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
              }
              for (String candidateName : newCandidateNames) {
                  if (!oldCandidateNames.contains(candidateName)) {
                      BeanDefinition bd = registry.getBeanDefinition(candidateName);
                      if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                              !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                          candidates.add(new BeanDefinitionHolder(bd, candidateName));
                      }
                  }
              }
              candidateNames = newCandidateNames;
          }
      }
      while (!candidates.isEmpty());
  
      // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
      if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
          sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
      }
  
      if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
          // Clear cache in externally provided MetadataReaderFactory; this is a no-op
          // for a shared cache since it'll be cleared by the ApplicationContext.
          ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
      }
  }           

  ConfigurationClassParser：處理@Configuration/@Component等注解，掃描、注冊包下的類

  ConfigurationClassBeanDefinitionReader：處理@Import/@ImportResource/@Bean等注解。

  将所有掃描到的bean都裝載至registry

  • invokeBeanDefinitionRegistryPostProcessors：執行invokeBeanDefinitionRegistryPostProcessors回調
  • invokeBeanFactoryPostProcessors：執行invokeBeanFactoryPostProcessors回調
• registerBeanPostProcessors：注冊攔截建立bean的bean處理器
• initMessageSource：初始化消息源
• initApplicationEventMulticaster：初始化事件廣播
• onRefresh：對一些特殊子類上下文中初始化一些特殊的bean，比如在ServletWebServerApplicationContext中就做了createWebServer的操作
• registerListeners：注冊bean監聽器
• finishBeanFactoryInitialization：執行個體化所有單例bean，比如我們之前分析的 dataSource就是在這一步執行個體化的。

finishRefresh

結束上下文更新，并釋出事件。

callRunners

如果有ApplicationRunner或者CommandLineRunner類型的bean，則觸發run函數，啟動任務。

總結

至此，springboot就已經啟動完畢。概述下主要的啟動過程就是

• 初始化環境
• 初始化預設配置
• 初始化各類監聽器、事件
• 建立上下文
• 在上下文中添加預設的bean
• 掃描檔案、注解等各種類型的bean添加在上下文中
• 執行個體化各個bean
• 啟動完畢

更多文章見： https://nc2era.com