天天看点
返回

微服务架构 | *2.3 Spring Cloud 启动及加载配置文件源码分析（以 Nacos 为例）

目录

  • 前言
  • 1. Spring Cloud 什么时候加载配置文件
  • 2. 准备 Environment 配置环境
    • 2.1 配置 Environment 环境 SpringApplication.prepareEnvironment()
    • 2.2 使用事件主控器创建并发布事件 SimpleApplicationEventMulticaster.multicastEvent()
    • 2.3 BootstrapApplicationListener 处理事件，自动导入一些配置类
  • 3. 刷新应用上下文
    • 3.1 刷新上下文 SpringApplication.prepareContext()
    • 3.2 初始化上下文的额外操作 SpringApplication.applyInitializers()
    • 3.3 读取 Nacos 服务器里的配置 NacosPropertySourceLocator.locate()
    • 3.4 初始化完成，发布 ApplicationContextInitializedEvent 事件
    • 3.5 配置加载完成，将监听器添加进上下文环境
  • 4. 程序运行事件
  • 5. Spring Cloud 启动及加载配置文件源码结构图小结
  • 最后

参考资料：

《Spring Microservices in Action》

《Spring Cloud Alibaba 微服务原理与实战》

《B站 尚硅谷 SpringCloud 框架开发教程 周阳》

Spring Cloud 要实现统一配置管理，需要解决两个问题：如何获取远程服务器配置和如何动态更新配置；在这之前，我们先要知道 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>

  • 我们进入

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

  • 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；
微服务架构 | *2.3 Spring Cloud 启动及加载配置文件源码分析（以 Nacos 为例）
  • 注意，这里需要遍历到后面才是 ApplicationEnvironmentPreparedEvent 事件，前面可能是其他事件；

  • 发布事件后被 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 里会提到，用来加载额外配置的）；

  • 我们回到

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

  • 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);
    }
}

  • 我们 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;
}

  • 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.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));
}
微服务架构 | *2.3 Spring Cloud 启动及加载配置文件源码分析（以 Nacos 为例）

  • 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));
}

  • 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 为例）
config 微服务架构 分布式 spring cloud alibaba spring cloud
上一篇: 基于cygwin构建u-boot（三）make错误忽视
下一篇: 痛苦的版本对齐(3) cygwin下的路径引用(sed解决篇）

继续阅读