springboot集成nacos读取nacos配置数据的原理

迷南。 2023-10-11 22:10 116阅读 0赞

先前我们说了springboot应用集成nacos配置中心的过程，只需要引入一个jar包并在业务系统的配置文件中添加相关的nacos配置项，我们的系统就能获取到nacos服务上面维护的配置数据，那这个获取配置数据的原理是啥呢？接下来咱们就来聊聊这一块~

1、Nacos config springboot starter包

我们在springboot应用中集成nacos配置中心时，添加了以下依赖：

  1. xml复制代码        <dependency>
  2.             <groupId>com.alibaba.boot</groupId>
  3.             <artifactId>nacos-config-spring-boot-starter</artifactId>
  4.             <version>0.2.11</version>
  5.         </dependency>

它会自动导入nacos-config-spring-boot-autoconfigure包和其他nacos客户端jar包。

看到nacos-config-spring-boot-autoconfigure这种自动配置包，我们要先打开这个jar包，看下包目录下的/META-INF/spring.factories文件，里面有如下内容：

  1. ini复制代码org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  2.   com.alibaba.boot.nacos.config.autoconfigure.NacosConfigAutoConfiguration
  3. #org.springframework.context.ApplicationContextInitializer=\
  4. #  com.alibaba.boot.nacos.config.autoconfigure.NacosConfigApplicationContextInitializer
  5. org.springframework.boot.env.EnvironmentPostProcessor=\
  6.   com.alibaba.boot.nacos.config.autoconfigure.NacosConfigEnvironmentProcessor
  7. org.springframework.context.ApplicationListener=\
  8.   com.alibaba.boot.nacos.config.logging.NacosLoggingListener

本次我们关注的重点是org.springframework.boot.env.EnvironmentPostProcessor这个配置项的值，它只有一个值：

  1. arduino复制代码com.alibaba.boot.nacos.config.autoconfigure.NacosConfigEnvironmentProcessor

我们来看下NacosConfigEnvironmentProcessor这个类，它有如下定义：

  1. ini复制代码public class NacosConfigEnvironmentProcessor
  2.         implements EnvironmentPostProcessor, Ordered {
  4.        。。。。省略部分代码
  6.         @Override
  7.     public void postProcessEnvironment(ConfigurableEnvironment environment,
  8.             SpringApplication application) {
  9.         application.addInitializers(new NacosConfigApplicationContextInitializer(this));
  10.         nacosConfigProperties = NacosConfigPropertiesUtils
  11.                 .buildNacosConfigProperties(environment);
  12.         if (enable()) {
  13.             System.out.println(
  14.                     "[Nacos Config Boot] : The preload log configuration is enabled");
  15.             loadConfig(environment);
  16.             NacosConfigLoader nacosConfigLoader = NacosConfigLoaderFactory.getSingleton(nacosConfigProperties, environment, builder);
  17.             LogAutoFreshProcess.build(environment, nacosConfigProperties, nacosConfigLoader, builder).process();
  18.         }
  19.     }
  21. }

NacosConfigEnvironmentProcessor就做了一件事，往spring容器中添加了NacosConfigApplicationContextInitializer初始化器，后续由它完成从nacos配置中心加载数据的操作。

1.1、重要的NacosConfigEnvironmentProcessor是在哪执行的

这个问题等我们看完下面的代码就有了答案了~

1.2、重要的NacosConfigApplicationContextInitializer是在哪执行的

这个问题等我们看完下面的代码也会有答案了~

2、应用的启动过程

我们从以下的启动类入手。

  1. typescript复制代码@SpringBootApplication
  2. public class App {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(App.class, args);
  6.     }
  7. }

2.1、SpringApplication的构造方法做了啥

跟踪上面SpringApplication的run方法，SpringApplication.run方法内部会先创建一个SpringApplication对象，然后再调用该对象的另一个run实例方法。我们先进入SpringApplication的构造方法：

  1. ini复制代码public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  2.         this.resourceLoader = resourceLoader;
  3.         Assert.notNull(primarySources, "PrimarySources must not be null");
  4.         this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  5.         this.webApplicationType = WebApplicationType.deduceFromClasspath();
  6.         this.bootstrapRegistryInitializers = new ArrayList<>(
  7.                 getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
  8.         //从类路径下面的META-INF/spring.factories文件中根据ApplicationContextInitializer配置值来初始化ApplicationContextInitializer实例
  9.         setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  10.     //从类路径下面的META-INF/spring.factories文件中根据ApplicationListener配置值来初始化ApplicationListener实例
  11.         setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  12.         this.mainApplicationClass = deduceMainApplicationClass();
  13.     }

其中getSpringFactoriesInstances方法用于从类路径下面的META-INF/spring.factories文件中获取指定配置项对应的类的全路径名列表（多个类的全路径名之间用英文逗号隔开），根据类的全路径名创建相应的对象。

2.1.1、构造方法中的setInitializers方法

setInitializers方法用于设置容器的初始化器对象集合，它的参数来源于getSpringFactoriesInstances(ApplicationContextInitializer.class)的执行结果。getSpringFactoriesInstances方法从类路径下面的META-INF/spring.factories文件中获取ApplicationContextInitializer对应的类的全路径名列表，根据类的全路径名创建相应的对象。

2.1.2、构造方法中的setListeners方法

setListeners方法用于设置容器的ApplicationListener监听器对象,它的参数来源于getSpringFactoriesInstances(ApplicationListener.class)的执行结果。getSpringFactoriesInstances方法从类路径下面的META-INF/spring.factories文件中获取ApplicationListener对应的类的全路径名列表，根据类的全路径名创建相应的对象。spring的监听器就是监听器模式的一种实现，它可以设置自己感兴趣的事件，并且在相应事情发生时能接到通知并对该事件进行处理。我们在spring-boot.jar包下的META-INF/spring.factories可以看到如下的内容：

  1. ini复制代码# Application Listeners
  2. org.springframework.context.ApplicationListener=\
  3. org.springframework.boot.ClearCachesApplicationListener,\
  4. org.springframework.boot.builder.ParentContextCloserApplicationListener,\
  5. org.springframework.boot.context.FileEncodingApplicationListener,\
  6. org.springframework.boot.context.config.AnsiOutputApplicationListener,\
  7. org.springframework.boot.context.config.DelegatingApplicationListener,\
  8. org.springframework.boot.context.logging.LoggingApplicationListener,\
  9. org.springframework.boot.env.EnvironmentPostProcessorApplicationListener

这些监听器类都会被实例化，并存入spring容器的ApplicationListener监听器列表中。

2.1.3、重要的EnvironmentPostProcessorApplicationListener出现了

经过了2.1.2部分的代码观摩，我们知道容器的ApplicationListener监听器列表中已经有了EnvironmentPostProcessorApplicationListener对象，EnvironmentPostProcessorApplicationListener很重要，它能监听到ApplicationEnvironmentPreparedEvent类型的事件，并且会触发EnvironmentPostProcessor实例的执行。我们在第1部分讲到的NacosConfigEnvironmentProcessor就是个EnvironmentPostProcessor的实现类。此处我们先打个标记，后面我们会说下1.1小节的NacosConfigEnvironmentProcessor实例对象是在哪执行的。

2.2、SpringAppLication的run方法执行流程

完成2.1节的构造方法后，会执行如下的run方法(本方法很重要)：

  1. ini复制代码    public ConfigurableApplicationContext run(String... args) {
  2.         long startTime = System.nanoTime();
  3.         DefaultBootstrapContext bootstrapContext = createBootstrapContext();
  4.         ConfigurableApplicationContext context = null;
  5.         configureHeadlessProperty();
  6.         SpringApplicationRunListeners listeners = getRunListeners(args);
  7.         listeners.starting(bootstrapContext, this.mainApplicationClass);
  8.         try {
  9.             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  10.             //准备环境信息（读取应用系统需要的所有配置项）
  11.             ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
  12.             configureIgnoreBeanInfo(environment);
  13.             Banner printedBanner = printBanner(environment);
  14.             context = createApplicationContext();
  15.             context.setApplicationStartup(this.applicationStartup);
  16.             //准备容器上下文
  17.             prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
  18.             //刷新容器上下文(内部就是执行出名的refresh方法)
  19.             refreshContext(context);
  20.             。。。省略部分代码
  21.             callRunners(context, applicationArguments);
  22.         }
  23.         。。省略部分代码
  25.         return context;
  26.     }

结合我们本篇要说读取nacos配置中心的原理，本次我们主要关注getRunListeners、prepareEnvironment方法和prepareContext这三个方法，我们先按照代码的执行顺序来依次看下这几个方法。

2.2.1、getRunListeners方法

getRunListeners方法如下：

  1. arduino复制代码private SpringApplicationRunListeners getRunListeners(String[] args) {
  2.    Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
  3.    return new SpringApplicationRunListeners(logger,
  4.          getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
  5.          this.applicationStartup);
  6. }

它会读取类路径下面的META-INF/spring.factories文件中SpringApplicationRunListener配置项对应的值，并创建相应的实例对象，赋值给SpringApplicationRunListeners的listeners属性（List类型），并返回SpringApplicationRunListeners对象。由于spring-boot包的META-INF/spring.factories文件有如下内容：

  1. ini复制代码# Run Listeners
  2. org.springframework.boot.SpringApplicationRunListener=\
  3. org.springframework.boot.context.event.EventPublishingRunListener

所以SpringApplicationRunListeners的listeners属性中就包含了EventPublishingRunListener实例对象，而且实际上只有这一个对象。

2.2.2、prepareEnvironment方法开始执行

prepareEnvironment方法内容如下：

  1. scss复制代码private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
  2.             DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
  3.         // Create and configure the environment
  4.         ConfigurableEnvironment environment = getOrCreateEnvironment();
  5.         configureEnvironment(environment, applicationArguments.getSourceArgs());
  6.         ConfigurationPropertySources.attach(environment);
  7.         //通过监听器通知环境信息已准备好，触发EnvironmentPostProcessor的执行
  8.         listeners.environmentPrepared(bootstrapContext, environment);
  9.         DefaultPropertiesPropertySource.moveToEnd(environment);
  10.         Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
  11.                 "Environment prefix cannot be set via properties.");
  12.         bindToSpringApplication(environment);
  13.         if (!this.isCustomEnvironment) {
  14.             EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
  15.             environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
  16.         }
  17.         ConfigurationPropertySources.attach(environment);
  18.         return environment;
  19.     }

此处划重点，在执行listeners.environmentPrepared方法之前，我们的操作系统环境变量、jvm系统属性和业务系统的application.properties（以及其他的配置文件）的配置项信息都被填充到了容器的environment对象中。

2.2.1部分的getRunListeners方法返回的SpringApplicationRunListeners对象会作为参数传递给prepareEnvironment方法的listeners参数，而listeners.environmentPrepared就是执行SpringApplicationRunListeners的environmentPrepared方法，方法内容如下：

  1. scss复制代码//SpringApplicationRunListeners类
  2. void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
  3.         doWithListeners("spring.boot.application.environment-prepared",
  4.                 (listener) -> listener.environmentPrepared(bootstrapContext, environment));
  5.     }

里面的doWithListeners方法最后会执行到重载的doWithListeners方法：

  1. arduino复制代码//SpringApplicationRunListeners类
  2. private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction,
  3.             Consumer<StartupStep> stepAction) {
  4.         StartupStep step = this.applicationStartup.start(stepName);
  5.         this.listeners.forEach(listenerAction);
  6.         if (stepAction != null) {
  7.             stepAction.accept(step);
  8.         }
  9.         step.end();
  10.     }

前面2.2.1部分我们说了，listeners对象就是个list，此处它只有一个元素，是EventPublishingRunListener类型的实例对象。

listenerAction对象接收的是前面environmentPrepared方法内部传递的lambda表达式：

  1. scss复制代码(listener) -> listener.environmentPrepared(bootstrapContext, environment)

当执行this.listeners.forEach(listenerAction)时，就会进入EventPublishingRunListener类的environmentPrepared方法：

  1. typescript复制代码//EventPublishingRunListener类
  2. public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
  3.             ConfigurableEnvironment environment) {
  4.         this.initialMulticaster.multicastEvent(
  5.                 new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
  6.     }

此处会调用SimpleApplicationEventMulticaster类的multicastEvent方法，并传递ApplicationEnvironmentPreparedEvent事件进行广播。

  1. ini复制代码//另外此处要先说明下：当spring创建EventPublishingRunListener对象的时候，就已经将SpringApplication对象的ApplicationListener对象列表添加到了EventPublishingRunListener对象的initialMulticaster属性的监听器列表中，EventPublishingRunListener构造函数代码如下：
  2. public EventPublishingRunListener(SpringApplication application, String[] args) {
  3.         this.application = application;
  4.         this.args = args;
  5.         this.initialMulticaster = new SimpleApplicationEventMulticaster();
  6.         for (ApplicationListener<?> listener : application.getListeners()) {
  7.             this.initialMulticaster.addApplicationListener(listener);
  8.         }
  9.     }

然后我们继续进入SimpleApplicationEventMulticaster类的multicastEvent方法：

  1. less复制代码//SimpleApplicationEventMulticaster类
  2. public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
  3.         ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
  4.         Executor executor = getTaskExecutor();
  5.         for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
  6.             if (executor != null) {
  7.                 executor.execute(() -> invokeListener(listener, event));
  8.             }
  9.             else {
  10.                 //会直接调用监听器
  11.                 invokeListener(listener, event);
  12.             }
  13.         }
  14.     }

这里的getApplicationListeners(event, type)会根据事件类型获取对该事件感兴趣的监听器列表，然后挨个调用监听器对象，也就是触发各个监听器的处理流程。由于此处的event参数是接收了ApplicationEnvironmentPreparedEvent对象，那么getApplicationListeners方法就会获取到EnvironmentPostProcessorApplicationListener对象（2.1.3部分咱们提到过它）。为啥呢？我们进入EnvironmentPostProcessorApplicationListener类，它有如下的supportsEventType方法：

  1. arduino复制代码//EnvironmentPostProcessorApplicationListener类
  2. @Override
  3.     public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
  4.         return ApplicationEnvironmentPreparedEvent.class.isAssignableFrom(eventType)
  5.                 || ApplicationPreparedEvent.class.isAssignableFrom(eventType)
  6.                 || ApplicationFailedEvent.class.isAssignableFrom(eventType);
  7.     }

supportsEventType方法就说明了该类支持处理的事件类型，里面很明确表达了它支持ApplicationEnvironmentPreparedEvent事件，所以getApplicationListeners就能把它筛选到。

我们接着上面的invokeListener方法往下看，invokeListener内部最后会直接调用监听器的onApplicationEvent方法。

  1. csharp复制代码private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
  2.         try {
  3.             listener.onApplicationEvent(event);
  4.         }
  5.         。。省略部分代码
  6. }

此处我们假定当前的listener已经是EnvironmentPostProcessorApplicationListener实例对象，那我们去看看EnvironmentPostProcessorApplicationListener类的onApplicationEvent方法：

  1. scss复制代码    @Override
  2.     public void onApplicationEvent(ApplicationEvent event) {
  3.         if (event instanceof ApplicationEnvironmentPreparedEvent) {
  4.             onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
  5.         }
  6.         if (event instanceof ApplicationPreparedEvent) {
  7.             onApplicationPreparedEvent();
  8.         }
  9.         if (event instanceof ApplicationFailedEvent) {
  10.             onApplicationFailedEvent();
  11.         }
  12.     }
  14.     private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
  15.         ConfigurableEnvironment environment = event.getEnvironment();
  16.         SpringApplication application = event.getSpringApplication();
  17.         //重点，获取所有的EnvironmentPostProcessor实例对象
  18.         for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
  19.                 event.getBootstrapContext())) {
  20.             postProcessor.postProcessEnvironment(environment, application);
  21.         }
  22.     }

上面就又出现了重点部分，这里会获取所有的EnvironmentPostProcessor实例，并且挨个执行它们的postProcessEnvironment方法，所以此时NacosConfigEnvironmentProcessor对象的postProcessEnvironment方法也就要被执行了。

2.2.3、重要的NacosConfigEnvironmentProcessor对象终于要被执行了

经过了一番探索，我们在1.1小节提出的问题在此处终于有了答案~

我们来看下NacosConfigEnvironmentProcessor的postProcessEnvironment方法：

  1. scss复制代码//NacosConfigEnvironmentProcessor类
  2. @Override
  3.     public void postProcessEnvironment(ConfigurableEnvironment environment,
  4.             SpringApplication application) {
  5.         //重点，往容器中添加了NacosConfigApplicationContextInitializer对象
  6.         application.addInitializers(new NacosConfigApplicationContextInitializer(this));
  7.         nacosConfigProperties = NacosConfigPropertiesUtils
  8.                 .buildNacosConfigProperties(environment);
  9.         //此方法内部逻辑可以先忽略
  10.         if (enable()) {
  11.             System.out.println(
  12.                     "[Nacos Config Boot] : The preload log configuration is enabled");
  13.             loadConfig(environment);
  14.             NacosConfigLoader nacosConfigLoader = NacosConfigLoaderFactory.getSingleton(nacosConfigProperties, environment, builder);
  15.             LogAutoFreshProcess.build(environment, nacosConfigProperties, nacosConfigLoader, builder).process();
  16.         }
  17.     }

上述代码主要就做了一件事，往spring容器中添加了NacosConfigApplicationContextInitializer初始化器。

2.2.4、NacosConfigApplicationContextInitializer终于被加入到了spring容器中

2.1.1部分我们看到spring容器中已经有了一批ApplicationInitializer对象。刚才2.2.3部分的NacosConfigEnvironmentProcessor又往容器中添加了一个NacosConfigApplicationContextInitializer对象。这些实现了ApplicationInitializer接口的对象，它们会在执行ApplicationContext的refresh方法之前得到调用。我们继续往下看。

2.2.5、prepareEnvironment方法执行完成

此处只是做个标记，咱们继续往下看~

2.2.6、prepareContext方法开始执行

紧接着我们就来到了run方法内部的prepareContext方法，它的内容如下：

  1. scss复制代码    private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
  2.             ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
  3.             ApplicationArguments applicationArguments, Banner printedBanner) {
  4.         context.setEnvironment(environment);
  5.         postProcessApplicationContext(context);
  6.         //执行初始化器
  7.         applyInitializers(context);
  8.         。。。。省略部分代码
  9.  }

其中applyInitializers方法的代码如下，它会挨个调用每个ApplicationContextInitializer实例的initialize方法，完成应用上下文的初始化操作：

  1. typescript复制代码/**
  2.      * Apply any {@link ApplicationContextInitializer}s to the context before it is
  3.      * refreshed.
  4.      * @param context the configured ApplicationContext (not refreshed yet)
  5.      * @see ConfigurableApplicationContext#refresh()
  6.      */
  7.     @SuppressWarnings({ "rawtypes", "unchecked" })
  8.     protected void applyInitializers(ConfigurableApplicationContext context) {
  9.         for (ApplicationContextInitializer initializer : getInitializers()) {
  10.             Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
  11.                     ApplicationContextInitializer.class);
  12.             Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
  13.             //执行初始化器的初始化方法
  14.             initializer.initialize(context);
  15.         }
  16.     }

我们注意到ApplicationContextInitializer实例是从getInitializers()方法获取的，而getInitializers()方法就是返回了容器中所有的ApplicationContextInitializer对象，当然也包括NacosConfigApplicationContextInitializer对象。

2.2.7、重要的NacosConfigApplicationContextInitializer对象终于要被执行了

我们看下NacosConfigApplicationContextInitializer类的initialize方法：

  1. ini复制代码    @Override
  2.     public void initialize(ConfigurableApplicationContext context) {
  3.         singleton.setApplicationContext(context);
  4.         environment = context.getEnvironment();
  5.         nacosConfigProperties = NacosConfigPropertiesUtils
  6.                 .buildNacosConfigProperties(environment);
  7.         final NacosConfigLoader configLoader = NacosConfigLoaderFactory.getSingleton(
  8.                 nacosConfigProperties, environment, builder);
  9.         if (!enable()) {
  10.             logger.info("[Nacos Config Boot] : The preload configuration is not enabled");
  11.         }
  12.         else {
  14.             // If it opens the log level loading directly will cache
  15.             // DeferNacosPropertySource release
  17.             if (processor.enable()) {
  18.                 processor.publishDeferService(context);
  19.                 configLoader
  20.                         .addListenerIfAutoRefreshed(processor.getDeferPropertySources());
  21.             }
  22.             else {
  23.                 //远程访问nacos配置中心读取配置数据
  24.                 configLoader.loadConfig();
  25.                 //设置监听器来监听nacos配置中心数据的变更并更新到本地
  26.                 configLoader.addListenerIfAutoRefreshed();
  27.             }
  28.         }
  30.         final ConfigurableListableBeanFactory factory = context.getBeanFactory();
  31.         if (!factory
  32.                 .containsSingleton(NacosBeanUtils.GLOBAL_NACOS_PROPERTIES_BEAN_NAME)) {
  33.             factory.registerSingleton(NacosBeanUtils.GLOBAL_NACOS_PROPERTIES_BEAN_NAME,
  34.                     configLoader.getGlobalProperties());
  35.         }
  36.     }

下面展示下NacosConfigLoader类的loadConfig方法，内部实现比较易懂，就是根据我们配置的nacos的访问地址读取指定的dataId的数据，并将其封装为一个属性源存放到environment对象中。

  1. scss复制代码//NacosConfigLoader类 
  2. public void loadConfig() {
  3.         MutablePropertySources mutablePropertySources = environment.getPropertySources();
  4.         List<NacosPropertySource> sources = reqGlobalNacosConfig(globalProperties,
  5.                 nacosConfigProperties.getType());
  6.         for (NacosConfigProperties.Config config : nacosConfigProperties.getExtConfig()) {
  7.             List<NacosPropertySource> elements = reqSubNacosConfig(config,
  8.                     globalProperties, config.getType());
  9.             sources.addAll(elements);
  10.         }
  11.        //如果远程nacos的配置数据比本地配置数据的优先级高，则执行以下方法
  12.         if (nacosConfigProperties.isRemoteFirst()) {
  13.             for (ListIterator<NacosPropertySource> itr = sources.listIterator(sources.size()); itr.hasPrevious();) {
  14.                 //这里是个关键点，可以确保远程的配置数据会被优先使用
  15.                 mutablePropertySources.addAfter(
  16.                         StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, itr.previous());
  17.             }
  18.         } else {
  19.             for (NacosPropertySource propertySource : sources) {
  20.                 mutablePropertySources.addLast(propertySource);
  21.             }
  22.         }
  23.     }

nacos属性源被添加到容器的environment对象中的代码如下：

  1. ini复制代码MutablePropertySources mutablePropertySources = environment.getPropertySources();
  2. 。。。省略部分代码
  3. mutablePropertySources.addAfter(
  4.                         StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, itr.previous());

到此为止，spring启动所需的所有的配置项数据都已准备完毕，后面spring在初始化各个bean对象的时候也能根据我们在nacos上面配置的数据来创建各个实例对象，比如dataSource对象~

2.2.8、prepareContext方法执行完成

到此，容器的应用上下文都准备完毕，紧接着就会执行大名鼎鼎的refresh方法来完成spring容器的整体创建过程，此处就不再赘述了。

  1. scss复制代码refreshContext(context);

发表评论

表情：
评论列表 （有 0 条评论，116人围观）

还没有评论，来说两句吧...

相关阅读

    相关 SpringBoot集成Nacos

    目录 简介 依赖 配置文件 代码 测试 简介： Nacos 是阿里巴巴的新开源项目，其核心定位是 “一个更易于帮助构建云原生应用的集注册中心与配置中心于一体的

    Dear 丶Dear 丶/ 0 赞/ 134 阅读