微服務架構 | *2.3 Spring Cloud 啟動及載入配置檔案原始碼分析（以 Nacos 為例）

多氯環己烷發表於2022-01-23
微服務架構SpringCloud原始碼

目錄

前言

參考資料：
《Spring Microservices in Action》
《Spring Cloud Alibaba 微服務原理與實戰》
《B站 尚矽谷 SpringCloud 框架開發教程 周陽》

Spring Cloud 要實現統一配置管理，需要解決兩個問題：如何獲取遠端伺服器配置和如何動態更新配置；在這之前，我們先要知道 Spring Cloud 什麼時候給我們載入配置檔案；

1. Spring Cloud 什麼時候載入配置檔案

  • 首先，Spring 抽象了一個 Environment 來表示 Spring 應用程式環境配置，整合了各種各樣的外部環境，並且提供統一訪問的方法 getProperty()；
  • 在 Spring 應用程式啟動時，會把配置載入到 Environment 中。當建立一個 Bean 時可以從 Environment 中把一些屬性值通過 @Value 的形式注入業務程式碼；
  • Spring Cloud 是基於 Spring 的發展而來，因此也是在啟動時載入配置檔案，而 Spring Cloud 的啟動程式是主程式類 XxxApplication，我們斷點進入主程式類；
@EnableDiscoveryClient
@SpringBootApplication
public class ProviderApplication {
	public static void main(String[] args) {
	    //【斷點步入】主啟動方法
		SpringApplication.run(ProviderApplication.class, args);
	}
}
  • 在 SpringApplication.run() 執行方法裡會準備 Environment 環境；
public ConfigurableApplicationContext run(String... args) {
        //初始化StopWatch，呼叫 start 方法開始計時
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        //設定系統屬性java.awt.headless，這裡為true，表示執行在伺服器端，在沒有顯示器和滑鼠鍵盤的模式下工作，模擬輸入輸出裝置功能
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        //SpringApplicationRunListeners 監聽器工作--->釋出 ApplicationStartingEvent 事件
        listeners.starting();

        Collection exceptionReporters;
    
    try {
        //持有著 args 引數
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        
        //【斷點步入 2.】準備 Environment 環境--->釋出 ApplicationEnvironmentPreparedEvent 事件
        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
        this.configureIgnoreBeanInfo(environment);
        //列印 banner
        Banner printedBanner = this.printBanner(environment);
        //建立 SpringBoot 上下文
        context = this.createApplicationContext();
        exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
        
        //【斷點步入 3.】準備應用上下文--->釋出 ApplicationEnvironmentPreparedEvent 事件
        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        //重新整理上下文--->釋出 ContextRefreshedEvent 事件
        this.refreshContext(context);
        //在容器完成重新整理後，依次呼叫註冊的Runners
        this.afterRefresh(context, applicationArguments);
        //停止計時
        stopWatch.stop();
        if (this.logStartupInfo) {
            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
        }
        //SpringApplicationRunListeners 監聽器工作--->釋出 ApplicationStartedEvent 事件
        listeners.started(context);
        this.callRunners(context, applicationArguments);
    } catch (Throwable var10) {
        this.handleRunFailure(context, var10, exceptionReporters, listeners);
        throw new IllegalStateException(var10);
    }
    
    try {
        //【斷點步入 4.】SpringApplicationRunListeners 監聽程式執行事件--->釋出ApplicationReadyEvent事件
        listeners.running(context);
        return context;
    } catch (Throwable var9) {
        this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
        throw new IllegalStateException(var9);
    }
}
  • 注意，有些同學可能 debug 進不了這裡的 try 語句，可能是因為引入了以下這個依賴，去掉這個依賴即可；
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

2. 準備 Environment 配置環境

2.1 配置 Environment 環境 SpringApplication.prepareEnvironment()

  • 我們進入 SpringApplication.prepareEnvironment() 方法裡，該方法主要是根據一些資訊配置 Environment 環境，然後呼叫 SpringApplicationRunListeners（Spring 應用執行監聽器） 監聽器工作；
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
    //獲取可配置的環境
    ConfigurableEnvironment environment = this.getOrCreateEnvironment();
    //根據可配置的環境，配置 Environment 環境
    this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
    //【斷點步入】告訴監聽者 Environment 環境已經準備完畢
    listeners.environmentPrepared((ConfigurableEnvironment)environment);
    this.bindToSpringApplication((ConfigurableEnvironment)environment);
    if (!this.isCustomEnvironment) {
        environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
    }
  • 進入 SpringApplicationRunListeners.environmentPrepared() 方法，該方法的作用是遍歷每一個監聽者，並對這些監聽者進行操作；
public void environmentPrepared(ConfigurableEnvironment environment) {
    //使用迭代器遍歷監聽者
    Iterator var2 = this.listeners.iterator();
    while(var2.hasNext()) {
        SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
        //【斷點步入】對每一個監聽者進行操作
        listener.environmentPrepared(environment);
    }
}

2.2 使用事件主控器建立併發布事件 SimpleApplicationEventMulticaster.multicastEvent()

  • 進入 EventPublishingRunListener.environmentPrepared() 方法，發現對每一個監聽者實現的操作是：使用 SimpleApplicationEventMulticaster（事件主控器） 釋出了一個 ApplicationEnvironmentPreparedEvent（應用程式環境準備完成事件）；
public void environmentPrepared(ConfigurableEnvironment environment) {
    //【斷點步入】使用事件主控器釋出事件
    this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args, environment));
}
  • 進入 SimpleApplicationEventMulticaster.multicastEvent() 方法
public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {
    //解析出事件型別
    ResolvableType type = eventType != null ? eventType : this.resolveDefaultEventType(event);
    //獲得事件執行者
    Executor executor = this.getTaskExecutor();
    //獲得監聽者迭代器
    Iterator var5 = this.getApplicationListeners(event, type).iterator();

    while(var5.hasNext()) {
        ApplicationListener<?> listener = (ApplicationListener)var5.next();
        //如果有執行者，就通過執行者釋出事件
        if (executor != null) {
            executor.execute(() -> {
                this.invokeListener(listener, event);
            });
        } else {
        //【斷點步入 1.2】沒有執行者就直接發事件
            this.invokeListener(listener, event);
        }
    }
}
  • 總結來說就是 Spring Cloud 在配置完 Environment 環境後會釋出一個 ApplicationEnvironmentPreparedEvent（應用程式環境準備完成事件） 告訴所有監聽者，Environment 環境已經配置完畢了；
  • 所有對 ApplicationEnvironmentPreparedEvent 事件感興趣的 Listener 都會監聽這個事件。其中包括 BootstrapApplicationListener；

BootstrapApplicationListener 監聽者監聽 ApplicationEnvironmentPreparedEvent 事件

  • 注意，這裡需要遍歷到後面才是 ApplicationEnvironmentPreparedEvent 事件，前面可能是其他事件；

2.3 BootstrapApplicationListener 處理事件，自動匯入一些配置類

  • 釋出事件後被 BootstrapApplicationListener（Bootstrap 監聽器） 監聽到，呼叫 BootstrapApplicationListener.onApplicationEvent() 方法處理事件：
public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
    //獲取當前 Environment 環境
    ConfigurableEnvironment environment = event.getEnvironment();
    //如果環境可用
    if ((Boolean)environment.getProperty("spring.cloud.bootstrap.enabled", Boolean.class, true)) {
        //如果環境來源不包含 bootstrap
        if (!environment.getPropertySources().contains("bootstrap")) {
            ConfigurableApplicationContext context = null;
            String configName = environment.resolvePlaceholders("${spring.cloud.bootstrap.name:bootstrap}");
            Iterator var5 = event.getSpringApplication().getInitializers().iterator();

            while(var5.hasNext()) {
                ApplicationContextInitializer<?> initializer = (ApplicationContextInitializer)var5.next();
                if (initializer instanceof ParentContextApplicationContextInitializer) {
                    context = this.findBootstrapContext((ParentContextApplicationContextInitializer)initializer, configName);
                }
            }

            if (context == null) {
                //【斷點步入】將不是 bootstrap 來源的配置新增進 bootstrap 上下文
                context = this.bootstrapServiceContext(environment, event.getSpringApplication(), configName);
                event.getSpringApplication().addListeners(new ApplicationListener[]{new BootstrapApplicationListener.CloseContextOnFailureApplicationListener(context)});
            }

            this.apply(context, event.getSpringApplication(), environment);
        }
    }
}
  • 進入 BootstrapApplicationListener.bootstrapServiceContext() 方法，發現其主要做的是配置自動匯入的實現；
private ConfigurableApplicationContext bootstrapServiceContext(ConfigurableEnvironment environment, final SpringApplication application, String configName) {

    //省略其他程式碼
    //配置自動裝配的實現
    builder.sources(new Class[]{BootstrapImportSelectorConfiguration.class});
    return context;
}
  • 我們搜尋 BootstrapImportSelectorConfiguration（Bootstrap選擇匯入配置類） 類，發現其使用 BootstrapImportSelector（Bootstrap匯入選擇器） 進行自動配置；
@Configuration
@Import({BootstrapImportSelector.class}) //使用BootstrapImportSelector類進行自動配置
public class BootstrapImportSelectorConfiguration {
    public BootstrapImportSelectorConfiguration() {
    }
}
  • BootstrapImportSelector（Bootstrap 匯入選擇器） 類的 selectImports() 方法使用 Spring 中的 SPI 機制；
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    
    //省略其他程式碼
    
    List<String> names = new ArrayList(SpringFactoriesLoader.loadFactoryNames(BootstrapConfiguration.class, classLoader));
}
  • 可到 classpath 路徑下查詢 META-INF/spring.factories 預定義的一些擴充套件點，其中 key 為 BootstrapConfiguration；
  • 可以得知給我們匯入了一些，其中有兩個配置類 PropertySourceBootstrapConfiguration 和 NacosConfigBootstrapConfiguration（這兩個類在本篇 3.2 和 3.3 裡會提到，用來載入額外配置的）；

3. 重新整理應用上下文

3.1 重新整理上下文 SpringApplication.prepareContext()

  • 我們回到 SpringApplication.run() 方法裡，在準備完 Environment 環境後，會呼叫 SpringApplication.prepareContext() 方法重新整理應用上下文。我們進入該方法；
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
    //設定上下文的 Environment 環境
    context.setEnvironment(environment);
    this.postProcessApplicationContext(context);
    //【斷點步入 3.2】初始化上下文
    this.applyInitializers(context);
    //【斷點步入 3.4】釋出上下文初始化完畢事件 ApplicationContextInitializedEvent 
    listeners.contextPrepared(context);
    
    //後面程式碼省略

    //【斷點步入 3.5】這是該方法的最後一條語句，釋出 
    listeners.contextLoaded(context);
}

3.2 初始化上下文的額外操作 SpringApplication.applyInitializers()

  • 進入 SpringApplication.applyInitializers() 方法，在應用程式上下文初始化時做一些額外操作；
  • 即執行非 Spring Cloud 官方提供的額外的操作，這裡指 Nacos 自己的操作；
protected void applyInitializers(ConfigurableApplicationContext context) {
    Iterator var2 = this.getInitializers().iterator();

    while(var2.hasNext()) {
        ApplicationContextInitializer initializer = (ApplicationContextInitializer)var2.next();
        Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class);
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        //【斷點步入】遍歷迭代器，初始化上下文
        initializer.initialize(context);
    }
}
  • 這裡的 .initialize() 方法最終呼叫的是 PropertySourceBootstrapConfiguration（Bootstrap 屬性源配置類） ，而這個類就是 1.2 裡準備 Environment 環境時給我們自動匯入的。我們進入 PropertySourceBootstrapConfiguration.initialize() 方法，得出最後結論：
public void initialize(ConfigurableApplicationContext applicationContext) {

    //省略其他程式碼
 
    Iterator var5 = this.propertySourceLocators.iterator();

    while(var5.hasNext()) {
        //PropertySourceLocator 介面的主要作用是實現應用外部化配置可動態載入
        PropertySourceLocator locator = (PropertySourceLocator)var5.next();
        PropertySource<?> source = null;
        //【斷點步入】讀取 Nacos 伺服器裡的配置
        source = locator.locate(environment);
    }
}

3.3 讀取 Nacos 伺服器裡的配置 NacosPropertySourceLocator.locate()

  • 我們 1.2 裡準備的 Environment 環境中引入的配置類 NacosPropertySourceLocator 實現了該介面，因此最後呼叫的是 NacosPropertySourceLocator.locate() 方法；
  • 該方法將讀取 Nacos 伺服器裡的配置，把結構存到 PropertySource 的例項裡返回；
  • NacosPropertySourceLocator.locate() 方法原始碼如下：
@Override
public PropertySource<?> locate(Environment env) {
    //獲取配置伺服器例項，這是Nacos客戶端提供的用於訪問實現配置中心基本操作的類
	ConfigService configService = nacosConfigProperties.configServiceInstance();
	if (null == configService) {
		log.warn("no instance of config service found, can't load config from nacos");
		return null;
	}
	long timeout = nacosConfigProperties.getTimeout();
	//Nacos 屬性源生成器
	nacosPropertySourceBuilder = new NacosPropertySourceBuilder(configService, timeout);
	String name = nacosConfigProperties.getName();

    //DataId 字首
	String dataIdPrefix = nacosConfigProperties.getPrefix();
	if (StringUtils.isEmpty(dataIdPrefix)) {
		dataIdPrefix = name;
	}
    //沒有配置 DataId 字首則用 spring.application.name 屬性的值
	if (StringUtils.isEmpty(dataIdPrefix)) {
		dataIdPrefix = env.getProperty("spring.application.name");
	}
    //建立複合屬性源
	CompositePropertySource composite = new CompositePropertySource(NACOS_PROPERTY_SOURCE_NAME);

    //載入共享配置
	loadSharedConfiguration(composite);
	//載入外部配置
	loadExtConfiguration(composite);
	//載入 Nacos 伺服器上應用程式名對應的的配置
	loadApplicationConfiguration(composite, dataIdPrefix, nacosConfigProperties, env);

	return composite;
}

3.4 初始化完成，釋出 ApplicationContextInitializedEvent 事件

  • 進入 SpringApplicationRunListeners.contextPrepared() 釋出事件；
public void contextPrepared(ConfigurableApplicationContext context) {
    //構造迭代器
    Iterator var2 = this.listeners.iterator();
    while(var2.hasNext()) {
        SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
        //【斷點步入】釋出事件
        listener.contextPrepared(context);
    }
}
  • 進入 EventPublishingRunListener.contextPrepared()，通過 multicastEvent 釋出事件；
public void contextPrepared(ConfigurableApplicationContext context) {
    //釋出 ApplicationContextInitializedEvent 事件
    this.initialMulticaster.multicastEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));
}

3.5 配置載入完成，將監聽器新增進上下文環境

  • 注意與 3.4 裡的方法不同；
  • 進入 SpringApplicationRunListeners.contextLoaded() 配置載入完成；
public void contextLoaded(ConfigurableApplicationContext context) {
    Iterator var2 = this.listeners.iterator();

    while(var2.hasNext()) {
        SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
        //【斷點步入】
        listener.contextLoaded(context);
    }
}
  • 進入 EventPublishingRunListener.contextLoaded() 將監聽器新增進上下文環境；
public void contextLoaded(ConfigurableApplicationContext context) {
    ApplicationListener listener;
    //遍歷每一個監聽器（一共有13個，如下圖），將除最後一個監聽器外的監聽器新增進 context 上下文
    for(Iterator var2 = this.application.getListeners().iterator(); var2.hasNext(); context.addApplicationListener(listener)) {
        listener = (ApplicationListener)var2.next();
        if (listener instanceof ApplicationContextAware) {
            //第10個 ParentContextCloseApplicationListener 會進來
            ((ApplicationContextAware)listener).setApplicationContext(context);
        }
    }
    //釋出 ApplicationPreparedEvent 事件
    this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
}

有 13 個監聽器


4. 程式執行事件

  • 進入 SpringApplicationRunListeners.running() 方法，它對每一個監聽器操作；
public void running(ConfigurableApplicationContext context) {
    Iterator var2 = this.listeners.iterator();
    while(var2.hasNext()) {
        SpringApplicationRunListener listener = (SpringApplicationRunListener)var2.next();
        //【斷點步入】操作監聽器，其中就有 EventPublishingRunListener
        listener.running(context);
    }
}
  • 進入 EventPublishingRunListener.running() 方法，釋出 ApplicationReadyEvent 事件；
public void running(ConfigurableApplicationContext context) {
    context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));
}

5. Spring Cloud 啟動及載入配置檔案原始碼結構圖小結

  • SpringApplication.run()：載入配置上下文；
    • stopWatch.start()：初始化StopWatch，呼叫 start 方法開始計時；
    • SpringApplicationRunListeners.starting()：釋出 ApplicationStartingEvent 事件；
    • SpringApplication.prepareEnvironment()：準備 Environment 環境；
      • SpringApplicationRunListeners.environmentPrepared()：監聽環境準備事件；
        • EventPublishingRunListener.environmentPrepared()：對每一個進行操作；
          • SimpleApplicationEventMulticaster.multicastEvent()：使用事件主控器釋出 ApplicationEnvironmentPreparedEvent 事件；
          • BootstrapApplicationListener.onApplicationEvent()：bootstrap 監聽器處理事件；
            • BootstrapApplicationListener.bootstrapServiceContext()：給我們自動匯入一些配置類；
    • SpringApplication.printBanner()：列印 Banner；
    • printBanner.createApplicationContext()：建立 Spring Boot 上下文；
    • SpringApplication.prepareContext()：重新整理應用上下文；
      • SpringApplication.applyInitializers()：初始化上下文的額外操作；
        • PropertySourceBootstrapConfiguration.initialize()：外部化配置；
          • NacosPropertySourceLocator.locate()：讀取 Nacos 伺服器裡的配置；
      • SpringApplicationRunListeners.contextPrepared()：配置初始化完成；
        • EventPublishingRunListener.contextPrepared()：釋出 ApplicationContextInitializedEvent 事件；
      • SpringApplicationRunListeners.contextPrepared()：配置載入完成
        • EventPublishingRunListener.contextLoaded()：將監聽器新增進上下文環境；
    • StopWatch.stop()：停止計時；
    • SpringApplicationRunListeners.started()：釋出 ApplicationStartedEvent 事件；
    • SpringApplicationRunListeners.running()：監聽程式執行事件；
      • EventPublishingRunListener.running()：釋出 ApplicationReadyEvent 事件；

最後

新人制作，如有錯誤，歡迎指出，感激不盡！
歡迎關注公眾號，會分享一些更日常的東西！
如需轉載，請標註出處！
微服務架構 | *2.3 Spring Cloud 啟動及載入配置檔案原始碼分析（以 Nacos 為例）

相關文章