Nacos 提供用于存储配置和其他元数据的 key/value 存储，为分布式系统中的外部化配置提供服务器端
和客户端支持。使用 Spring Cloud Alibaba Nacos Config，您可以在 Nacos Server 集中管理你 Spring
Cloud 应用的外部属性配置。
Spring Cloud Alibaba Nacos Config 是 Config Server 和 Client 的替代方案，客户端和服务器上的概念
与 Spring Environment 和 PropertySource 有着一致的抽象，在特殊的 bootstrap 阶段，配置被加载
到 Spring 环境中。当应用程序通过部署管道从开发到测试再到生产时，您可以管理这些环境之间的配
置，并确保应用程序具有迁移时需要运行的所有内容。

配置管理

可以在Nacos控制台配置项目的配置数据，先打开Nacos控制台，在 命名空间 中添加 新建命名空
间 ，如下图

在配置列表中展示在 配置管理>配置列表 中添加，如下图：

再将项目中的配置内容拷贝到如下表单中，比如我们可以把原来在代码里面的application.properties中的配置填
写到下面表单中，如下图：

注意 Data ID 和服务名字保持一致，作为程序默认加载配置。
工程中先引入依赖包

 <properties>
        <java.version>11</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
        <spring-cloud-alibaba.version>2.2.2.RELEASE</spring-cloud-alibaba.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
      <!--配置中心-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-dubbo</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.yehui.springcloudnacosdemo.SpringCloudNacosDemoApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

配置文件中添加配置中心地址，在项目中 的 bootstrap.properties. 中添加如下配置：

# nacos设置配置中心服务端地址
spring.cloud.nacos.config.server-addr=localhost:8848
#Nacos中命名空间的ID
spring.cloud.nacos.config.namespace=6f7b53f3-c083-4230-82a2-26d4e7c85a5d
# Nacos 配置中心的namespace。需要注意，如果使用 public 的 namcespace ，请不要填写这个值，直接留空即可
# spring.cloud.nacos.config.namespace=
spring.cloud.nacos.discovery.server-addr=localhost:8848
#Nacos中命名空间的ID
spring.cloud.nacos.discovery.namespace=6f7b53f3-c083-4230-82a2-26d4e7c85a5d
#Nacos中配置文件的后缀为yaml
spring.cloud.nacos.config.file-extension=properties

@RestController
public class NacosControllerTest {
    @Value("${name}")
    private String name;
    @RequestMapping("/index")
    public String index(){
        return name+"nacos配置中心测试";
    }
}

启动 hailtaxi-driver 服务，默认加载 ${spring.application.name}.${fileextension:properties} 配置，加载完成后，配置数据会生效，并访问
http://localhost:8082/index 测试，效果如下：

如果此时配置文件名字如果和当前服务名字不一致，可以使用 name 属性来指定配置文件名字：

# nacos设置配置中心服务端地址
spring.cloud.nacos.config.server-addr=localhost:8848
#Nacos中命名空间的ID
spring.cloud.nacos.config.namespace=6f7b53f3-c083-4230-82a2-26d4e7c85a5d
# Nacos 配置中心的namespace。需要注意，如果使用 public 的 namcespace ，请不要填写这个值，直接留空即可
# spring.cloud.nacos.config.namespace=
spring.cloud.nacos.discovery.server-addr=localhost:8848
#Nacos中命名空间的ID
spring.cloud.nacos.discovery.namespace=6f7b53f3-c083-4230-82a2-26d4e7c85a5d
#Nacos中配置文件的后缀为yaml
spring.cloud.nacos.config.file-extension=properties
##指定配置文件名字
spring.cloud.nacos.config.name=dataIdTest.properties

Nacos 中的Namespace和Group

在nacos中提供了namespace和group命名空间和分组的机制。，它是Nacos提供的一种数据模型，也
就是我们要去定位到一个配置，需要基于namespace- > group ->dataid来实现。
namespace可以解决多环境以及多租户数据的隔离问题。比如在多套环境下，可以根据指定环境创建
不同的namespace，实现多环境隔离。或者在多租户的场景中，每个用户可以维护自己的
namespace，实现每个用户的配置数据和注册数据的隔离。

group是分组机制，它的纬度是实现服务注册信息或者DataId的分组管理机制，对于group的用法，没
有固定的规则，它也可以实现不同环境下的分组，也可以实现同一个应用下不同配置类型或者不同业务
类型的分组。

官方建议是，namespace用来区分不同环境，group可以专注在业务层面的数据分组。实际上在
使用过程中，最重要的是提前定要统一的口径和规定，避免不同的项目团队混用导致后期维护混
乱的问题。

自定义namespace

在没有明确指定 ${spring.cloud.nacos.config.namespace} 配置的情况下， 默认使用的是 Nacos
上 Public 这个namespae。如果需要使用自定义的命名空间，可以通过以下配置来实现：

spring.cloud.nacos.config.namespace=b3404bc0-d7dc-4855-b519-570ed34b62d7

该配置必须放在 bootstrap.properties 文件中。此外
spring.cloud.nacos.config.namespace 的值是 namespace 对应的 id，id 值可以在 Nacos
的控制台获取。并且在添加配置时注意不要选择其他的 namespae，否则将会导致读取不到正确
的配置。

自定义group

在没有明确指定 ${spring.cloud.nacos.config.group} 配置的情况下， 默认使用的是DEFAULT_GROUP 。如果需要自定义自己的 Group，可以通过以下配置来实现：

spring.cloud.nacos.config.group=DEVELOP_GROUP

该配置必须放在 bootstrap.properties 文件中。并且在添加配置时 Group 的值一定要和
spring.cloud.nacos.config.group 的配置值一致

自定义扩展的DataId

Spring Cloud Alibaba Nacos Config 从 0.2.1 版本后，可支持自定义 Data Id 的配置。关于这部分详细
的设计可参考 这里。 一个完整的配置案例如下所示：

spring.application.name=opensource-service-provider
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
# config external configuration
# 1、Data Id 在默认的组 DEFAULT_GROUP,不支持配置的动态刷新
spring.cloud.nacos.config.extension-configs[0].data-id=ext-configcommon01.properties
# 2、Data Id 不在默认的组，不支持动态刷新
spring.cloud.nacos.config.extension-configs[1].data-id=ext-configcommon02.properties
spring.cloud.nacos.config.extension-configs[1].group=GLOBALE_GROUP
# 3、Data Id 既不在默认的组，也支持动态刷新
spring.cloud.nacos.config.extension-configs[2].data-id=ext-configcommon03.properties
spring.cloud.nacos.config.extension-configs[2].group=REFRESH_GROUP
spring.cloud.nacos.config.extension-configs[2].refresh=true

可以看到:

1. 通过 spring.cloud.nacos.config.extension-configs[n].data-id 的配置方式来支持多个Data Id 的配置。
2. 通过 spring.cloud.nacos.config.extension-configs[n].group 的配置方式自定义 Data Id所在的组，不明确配置的话，默认是 DEFAULT_GROUP。
3. 通过 spring.cloud.nacos.config.extension-configs[n].refresh 的配置方式来控制该Data Id 在配置变更时，是否支持应用中可动态刷新， 感知到最新的配置值。默认是不支持的。

多个 Data Id 同时配置时，他的优先级关系是 spring.cloud.nacos.config.extensionconfigs[n].data-id 其中 n 的值越大，优先级越高。
Note spring.cloud.nacos.config.extension-configs[n].data-id 的值必须带文件扩展名，文件扩展名既可支持 properties，又可以支持 yaml/yml。 此时spring.cloud.nacos.config.file-extension 的配置对自定义扩展配置的 Data Id 文件扩展名没有影响。

通过自定义扩展的 Data Id 配置，既可以解决多个应用间配置共享的问题，又可以支持一个应用有多个
配置文件。
为了更加清晰的在多个应用间配置共享的 Data Id ，你可以通过以下的方式来配置：
通过自定义扩展的 Data Id 配置，既可以解决多个应用间配置共享的问题，又可以支持一个应用有多个
配置文件。
为了更加清晰的在多个应用间配置共享的 Data Id ，你可以通过以下的方式来配置：

# 配置支持共享的 Data Id
spring.cloud.nacos.config.shared-configs[0].data-id=common.yaml
# 配置 Data Id 所在分组，缺省默认 DEFAULT_GROUP
spring.cloud.nacos.config.shared-configs[0].group=GROUP_APP1
# 配置Data Id 在配置变更时，是否动态刷新，缺省默认 false
spring.cloud.nacos.config.shared-configs[0].refresh=true

可以看到：

1. 通过 spring.cloud.nacos.config.shared-configs[n].data-id 来支持多个共享 Data Id 的配置。
2. 通过 spring.cloud.nacos.config.shared-configs[n].group 来配置自定义 Data Id 所在的

组，不明确配置的话，默认是 DEFAULT_GROUP。

1. 通过 spring.cloud.nacos.config.shared-configs[n].refresh 来控制该Data Id在配置变更

时，是否支持应用中动态刷新，默认false。

配置的优先级

Spring Cloud Alibaba Nacos Config 目前提供了三种配置能力从 Nacos 拉取相关的配置。

1. A: 通过 spring.cloud.nacos.config.shared-configs[n].data-id 支持多个共享 Data Id 的配置
2. B: 通过 spring.cloud.nacos.config.extension-configs[n].data-id 的方式支持多个扩展Data Id 的配置
3. C: 通过内部相关规则(应用名、应用名+ Profile )自动生成相关的 Data Id 配置

当三种方式共同使用时，他们的一个优先级关系是:A < B < C

多环境切换

spring-cloud-starter-alibaba-nacos-config 在加载配置的时候，不仅仅加载了以 dataid 为
${spring.application.name}.${file-extension:properties} 为前缀的基础配置，还加载了dataid为 ${spring.application.name}-${profile}.${file-extension:properties} 的基础配置。在日常开发中如果遇到多套环境下的不同配置，可以通过Spring 提供的${spring.profiles.active} 这个配置项来配置。
比如开发环境我们可以在nacos中创建 spring-cloud-nacos-demo-dev.properties ，测试环境可以在配置中创建
spring-cloud-nacos-demo-test.properties ，创建如下：
spring-cloud-nacos-demo-test.properties

spring-cloud-nacos-demo-dev.properties

修改bootstrap.properties配置文件,如下

# nacos设置配置中心服务端地址
spring.cloud.nacos.config.server-addr=localhost:8848
#Nacos中命名空间的ID
spring.cloud.nacos.config.namespace=6f7b53f3-c083-4230-82a2-26d4e7c85a5d
# Nacos 配置中心的namespace。需要注意，如果使用 public 的 namcespace ，请不要填写这个值，直接留空即可
# spring.cloud.nacos.config.namespace=
spring.cloud.nacos.discovery.server-addr=localhost:8848
#Nacos中命名空间的ID
spring.cloud.nacos.discovery.namespace=6f7b53f3-c083-4230-82a2-26d4e7c85a5d
#Nacos中配置文件的后缀为yaml
spring.cloud.nacos.config.file-extension=properties
#Nacos激活配置   对应spring-cloud-nacos-demo-dev.properties
spring.profiles.active=dev
server.port=8082

测试代码

@RestController
public class NacosControllerTest {
    @Value("${ip}")
    private String ip;
    @RequestMapping("/index")
    public String index(){
        return ip+"nacos配置中心测试";
    }
}

测试http://localhost:8082/index 效果如下：

将 active 换成test,效果如下：

多/共享配置

在实际的业务场景中应用和共享配置间的关系可能， Spring Cloud Alibaba Nacos Config 从 0.2.1
版本后，可支持自定义 Data Id 的配置，通过它可以解决配置共享问题。
我们可以先创建一个配置 datasource.properties用于模拟配置数据库连接，如下图：

在 bootstrap.properties中引入配置需要使用 extension-configs 属性，配置如下：

这里 extension-configs[n] 中n值越大，优先级越高，它既能解决一个应用多个配置，同时还能解决
配置共享问题。

测试代码

@RestController
public class NacosControllerTest {
    @Value("${ip}")
    private String ip;
    @RequestMapping("/index")
    public String index(){
        return ip+"nacos配置中心测试";
    }
}

测试http://localhost:8082/index 效果如下：

配置中心刷新

配置自动刷新对程序来说非常重要，Nacos支持配置自动刷新，并且提供了多种刷新机制。

Environment自动刷新

spring-cloud-starter-alibaba-nacos-config 支持配置的动态更新，Environment能实时更新到最
新的配置信息，启动 Spring Boot 应用测试的代码如下：

@SpringBootApplication
@EnableDiscoveryClient
public class SpringCloudNacosDemoApplication {
    public static void main(String[] args) throws InterruptedException {
        ApplicationContext applicationContext = SpringApplication.run(SpringCloudNacosDemoApplication.class, args);
        while (true){
            //当动态刷新时，会更新到Environment中，因此这里每隔5s中从Enviroment中获取配置
            String ip = applicationContext.getEnvironment().getProperty("ip");
            System.out.println("ip:"+ip);
            TimeUnit.SECONDS.sleep(5);
        }
    }
}

测试数据如下:

ip:192.168.211.112
ip:192.168.211.113

注意

@Value刷新

程序中如果写了 @Value 注解，可以采用 @RefreshScope 实现刷新，只需要在指定类上添加该注解即
可，如下代码：

@RestController
@RefreshScope
public class NacosControllerTest {
    @Value("${ip}")
    private String ip;
    @RequestMapping("/index")
    public String index(){
        return ip+"nacos配置中心测试";
    }
}

灰度发布

灰度配置指的是指定部分客户端IP进行新配置的下发，其余客户端配置保持不变，用以验证新配置对客
户端的影响，保证配置的平稳发布。灰度配置是生产环境中一个比较重要的功能，对于保证生产环境的
稳定性非常重要。在1.1.0中，Nacos支持了以IP为粒度的灰度配置，具体使用步骤如下：
在配置列表页面，点击某个配置的“编辑配置”按钮,勾选“Beta发布”，在文本框里填入要下发配置配置的
IP，多个IP用逗号分隔，操作如下：

修改配置内容，点击“发布Beta”按钮，即可完成灰度配置的发布，点击“发布Beta”后，“发布Beta”按钮
变灰，此时可以选择“停止Beta”或者“发布”。“停止Beta”表示取消停止灰度发布，当前灰度发布配置的IP
列表和配置内容都会删除，页面回到正常发布的样式。“发布”表示将灰度配置在所有客户端生效，之前
的配置也会被覆盖，同时页面回到正常发布的样式：

源码分析

源码入口

在jar下面spring-cloud-starter-alibaba-nacos-config-2.2.6.RELEASE.jar下的spring.factories文件下面找到自动配置类

NacosConfigBootstrapConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(name = "spring.cloud.nacos.config.enabled", matchIfMissing = true)
public class NacosConfigBootstrapConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public NacosConfigProperties nacosConfigProperties() {
        return new NacosConfigProperties();
    }
    @Bean
    @ConditionalOnMissingBean
    public NacosConfigManager nacosConfigManager(
            NacosConfigProperties nacosConfigProperties) {
        return new NacosConfigManager(nacosConfigProperties);
    }
    @Bean
    public NacosPropertySourceLocator nacosPropertySourceLocator(
            NacosConfigManager nacosConfigManager) {
        return new NacosPropertySourceLocator(nacosConfigManager);
    }
}

springcloud 整合nacos文件加载流程

NacosPropertySourceLocator

public class NacosPropertySourceLocator implements PropertySourceLocator {}

有代码可以看到NacosPropertySourceLocator实现了PropertySourceLocator接口,PropertySourceLocator接口的代码如下:

在看一下类的关系图

此时要关注一下NacosPropertySourceLocator在哪里进行初始化的，在NacosPropertySourceLocator.locate方法入口进行的debug，启动spring boot 观察一下调用链路

SpringApplication.run

由调用链路可以知道，在spring boot项目启动时，有一个prepareContext的方法，它会回调所有实现了
ApplicationContextInitializer的实例，来做一些初始化工作。

ApplicationContextInitializer是Spring？框架原有的东西，它的主要作用就是在，ConfigurableApplicationContext类型（或者子类型）的ApplicationContext做refresh之前，允许我们对ConfiurableApplicationContext的实例做进一步的设置和处理。 它可以用在需要对应用程序上下文进行编程初始化的wb应用程序中，比如根据上下文环境来注册propertySource，或者配置文件。而Config的这个配置中心的需求合好需要这样一个机制来完成。

    public ConfigurableApplicationContext run(String... args) {
        //省略代码...
         this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        //省略代码
    }

PropertySourceBootstrapConfiguration.initialize

其中，PropertySourceBootstrapConfiguration就实现了ApplicationContextInitializer，initialize方法代a码如下。

   public void initialize(ConfigurableApplicationContext applicationContext) {
        List<PropertySource<?>> composite = new ArrayList();
       //对propertySourceLocators数组进行排序，根据默认的AnnotationAwareOrderComparator
        AnnotationAwareOrderComparator.sort(this.propertySourceLocators);
        boolean empty = true;
       //获取运行的环境上下文
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        Iterator var5 = this.propertySourceLocators.iterator();
        while(true) {
            Collection source;
            do {
                do {
                    if (!var5.hasNext()) {
                        if (!empty) {
                            //获取当前Environment中的所有PropertySources.
                            MutablePropertySources propertySources = environment.getPropertySources();
                            String logConfig = environment.resolvePlaceholders("${logging.config:}");
                            LogFile logFile = LogFile.get(environment);
                            // 遍历移除bootstrapProperty的相关属性
                            Iterator var15 = environment.getPropertySources().iterator();
                            while(var15.hasNext()) {
                                PropertySource<?> p = (PropertySource)var15.next();
                                if (p.getName().startsWith("bootstrapProperties")) {
                                    propertySources.remove(p.getName());
                                }
                            }
                            //把前面获取到的PropertySource，插入到Environment中的PropertySources中。
                            this.insertPropertySources(propertySources, composite);
                            this.reinitializeLoggingSystem(environment, logConfig, logFile);
                            this.setLogLevels(applicationContext, environment);
                            this.handleIncludedProfiles(environment);
                        }
                        return;
                    }
                     //回调所有实现PropertySourceLocator接口实例的locate方法，并收集到source这个集合中。
                    PropertySourceLocator locator = (PropertySourceLocator)var5.next();
                    source = locator.locateCollection(environment);
                } while(source == null);
            } while(source.size() == 0);
            //遍历source，把PropertySource包装成BootstrapPropertySource加入到sourceList中。
            List<PropertySource<?>> sourceList = new ArrayList();
            Iterator var9 = source.iterator();
            while(var9.hasNext()) {
                PropertySource<?> p = (PropertySource)var9.next();
                if (p instanceof EnumerablePropertySource) {
                    EnumerablePropertySource<?> enumerable = (EnumerablePropertySource)p;
                    sourceList.add(new BootstrapPropertySource(enumerable));
                } else {
                    sourceList.add(new SimpleBootstrapPropertySource(p));
                }
            }
            logger.info("Located property source: " + sourceList);
            //将source添加到数组
            composite.addAll(sourceList);
            //表示propertysource不为空
            empty = false;
        }
    }

上述代码逻辑说明如下。

1. 首先this.propertySourceLocators，表示所有实现了PropertySourceLocators接口的实现类，其中就包括我们前面自定义的GpJsonPropertySourceLocator。
2. 根据默认的 AnnotationAwareOrderComparator 排序规则对 propertySourceLocators数组进行排序。
3. 获取运行的环境上下文ConfigurableEnvironment
4. 遍历propertySourceLocators时
   1. 调用 locate 方法，传入获取的上下文environment
   2. 将source添加到PropertySource的链表中
   3. 设置source是否为空的标识标量empty
5. source不为空的情况，才会设置到environment中
   1. 返回Environment的可变形式，可进行的操作如addFirst、addLast
   2. 移除propertySources中的bootstrapProperties
   3. 根据config server覆写的规则，设置propertySources
   4. 处理多个active profiles的配置信息

注意：this.propertySourceLocatorsi这个集合中的PropertySourceLocator，是通过自动装配机制完成注入的，具体的实现在BootstrapImportSelector这个类中。

NacosPropertySourceLocator

理解了上述基本原理后，再来思考第二个问题。如何从远程服务器上加载配置到Spring的Environment中。 顺着前面的分析思路，很自然的去找PropertySourceLocator的实现类，发现除了 自定义的GpJsonPropertySourceLocator以外，还有另外一个实现类 NacosPropertySourceLocator . 于是，直接来看NacosPropertySourceLocator中的locate方法，代码如下。

public PropertySource<?> locate(Environment env) {
        nacosConfigProperties.setEnvironment(env);
       //nacosConfigManager是NacosConfigBootstrapConfiguration配置类里面实例化
        ConfigService configService = nacosConfigManager.getConfigService();
        if (null == configService) {
            log.warn("no instance of config service found, can't load config from nacos");
            return null;
        }
    //获取客户端配置的超时时间
        long timeout = nacosConfigProperties.getTimeout();
        nacosPropertySourceBuilder = new NacosPropertySourceBuilder(configService,
                timeout);
    //获取name属性，
        String name = nacosConfigProperties.getName();
        //在Spring Cloud中，默认的name=spring.application.name。
        String dataIdPrefix = nacosConfigProperties.getPrefix();
        if (StringUtils.isEmpty(dataIdPrefix)) {
            dataIdPrefix = name;
        }
        if (StringUtils.isEmpty(dataIdPrefix)) {
            //获取spring.application.name赋值给dataIdPrefix
            dataIdPrefix = env.getProperty("spring.application.name");
        }
        //创建composite属性源，可以包含多个PropertySource
        CompositePropertySource composite = new CompositePropertySource(
                NACOS_PROPERTY_SOURCE_NAME);
        //加载共享配置
        loadSharedConfiguration(composite);
    //加载扩展配置
        loadExtConfiguration(composite);
    //加载自身的配置
        loadApplicationConfiguration(composite, dataIdPrefix, nacosConfigProperties, env);
        return composite;
    }

上述代码的实现不难理解

1. 获取nacos客户端的配置属性，并生成dataId（这个很重要，要定位nacos的配置）
2. 分别调用三个方法从加载配置属性源，保存到composite组合属性源中

loadApplicationConfiguration

可以先不管加载共享配置、扩展配置的方法，最终本质上都是去远程服务上读取配置，只是传入的参数不一样。

• fileExtension，表示配置文件的扩展名
• nacosGroup表示分组。
• 加载dataid=项目名称的配置。

• 加载dataid=项目名称+扩展名的配置遍历当前配置的激活点（profile），分别循环加载带有profile的dataid配置

    private void loadApplicationConfiguration(
            CompositePropertySource compositePropertySource, String dataIdPrefix,
            NacosConfigProperties properties, Environment environment) {
        //默认的扩展名为： properties
        String fileExtension = properties.getFileExtension();
         //获取group
        String nacosGroup = properties.getGroup();
        //加载`dataid=项目名称`的配置
        loadNacosDataIfPresent(compositePropertySource, dataIdPrefix, nacosGroup,
                fileExtension, true);
        //加载`dataid=项目名称+扩展名`的配置
        loadNacosDataIfPresent(compositePropertySource,
                dataIdPrefix + DOT + fileExtension, nacosGroup, fileExtension, true);
        // 遍历profile（可以有多个），根据profile加载配置
        for (String profile : environment.getActiveProfiles()) {
            String dataId = dataIdPrefix + SEP1 + profile + DOT + fileExtension;
            loadNacosDataIfPresent(compositePropertySource, dataId, nacosGroup,
                    fileExtension, true);
        }
    }

  loadNacosDataIfPresent

  调用loadNacosPropertySource加载存在的配置信息。把加载之后的配置属性保存CompositePropertySourcer中。

    private void loadNacosDataIfPresent(final CompositePropertySource composite,
            final String dataId, final String group, String fileExtension,
            boolean isRefreshable) {
        //如果dataId为空，或者group为空，则直接跳过
        if (null == dataId || dataId.trim().length() < 1) {
            return;
        }
        if (null == group || group.trim().length() < 1) {
            return;
        }
        //从nacos中获取属性源
        NacosPropertySource propertySource = this.loadNacosPropertySource(dataId, group,
                fileExtension, isRefreshable);
        //把属性源保存到compositePropertySource中
        this.addFirstPropertySource(composite, propertySource, false);
    }

  loadNacosPropertySource

  �

    private NacosPropertySource loadNacosPropertySource(final String dataId,
            final String group, String fileExtension, boolean isRefreshable) {
        if (NacosContextRefresher.getRefreshCount() != 0) {
             //是否支持自动刷新，// 如果不支持自动刷新配置则自动从缓存获取返回(不从远程服务器加载)
            if (!isRefreshable) {
                return NacosPropertySourceRepository.getNacosPropertySource(dataId,
                        group);
            }
        }
        //构造器从配置中心获取数据
        return nacosPropertySourceBuilder.build(dataId, group, fileExtension,
                isRefreshable);
    }

  上述代码，是Spring Cloud 集成Nacos实现远程配置加载并保存到NacosPropertySource 中的。 其中，会根据NacosContextRefresher.getRefreshCount来判断是否要从本地读取配置。

1. NacosContextRefresher.getRefreshCount() 这个表示Nacos上下文中设置的动态刷 新的监听数量，如果大于0，说明有配置发生了变更，则需要进一步判断是否需要获取最 新配置项

2. isRefreshable ， 这个是对应properties文件中的 spring.cloud.nacos.config.refresh-enabled=false这个属性。如果设置为 false，表示不会从远程服务去获取最新的值。

   动态刷新到本地

   NacosContextRefresher

   在Spring Cloud Nacos中，设置了一个本地缓存 NacosPropertySourceRepository，它会缓存所有配置项对应的NacosPropertySource实 例。那么这个缓存是在哪里更新的呢？ 在com.alibaba.cloud.nacos.refresh这个包中，有一个NacosContextRefresher 上下 文刷新对象，它在启动时，会监听ApplicationReadyEvent事件

   public class NacosContextRefresher
        implements ApplicationListener<ApplicationReadyEvent>, ApplicationContextAware {

   NacosContextRefresher.onApplicationEvent

   �

   public void onApplicationEvent(ApplicationReadyEvent event) {
        // many Spring context
        if (this.ready.compareAndSet(false, true)) {//cas占位
            this.registerNacosListenersForApplications(); //针对应用列表建立Nacos监听
        }
    }

   registerNacosListenersForApplications

    private void registerNacosListenersForApplications() {
        if (isRefreshEnabled()) {//开启自动配置
            for (NacosPropertySource propertySource : NacosPropertySourceRepository
                    .getAll()) {
                if (!propertySource.isRefreshable()) {
                    continue;
                }
                String dataId = propertySource.getDataId();
                registerNacosListener(propertySource.getGroup(), dataId);
            }
        }
    }

   �该方法是注册应用监听的具体实现。

3. 如果当前的自动刷新机制是开启状态，则遍历本地缓存中的所有NacosPropertySource

4. 针对每个PropertySource，判断是否开启了自动刷新，如果没有则退出
5. 否则，针对该dataId注册监听

registerNacosListener

    private void registerNacosListener(final String groupKey, final String dataKey) {
        String key = NacosPropertySourceRepository.getMapKey(dataKey, groupKey);
        Listener listener = listenerMap.computeIfAbsent(key,
                lst -> new AbstractSharedListener() {
                    @Override
                    public void innerReceive(String dataId, String group,
                            String configInfo) {//针对该key绑定监听事件
                        refreshCountIncrement(); //递增刷新数量的原子变量（表示当前有数据变更）
                        nacosRefreshHistory.addRefreshRecord(dataId, group, configInfo); //添加
到刷新的历史记录中，提供了EndPoint访问
             //发布一个刷新事件，用来同步@Value注解的值
                        applicationContext.publishEvent(
                                new RefreshEvent(this, null, "Refresh Nacos config"));
                        if (log.isDebugEnabled()) {
                            log.debug(String.format(
                                    "Refresh Nacos config group=%s,dataId=%s,configInfo=%s",
                                    group, dataId, configInfo));
                        }
                    }
                });
        try {
            //注册事件监听
            configService.addListener(dataKey, groupKey, listener);
        }
        catch (NacosException e) {
            log.warn(String.format(
                    "register fail for nacos listener ,dataId=[%s],group=[%s]", dataKey,
                    groupKey), e);
        }
    }

RefreshEventListener

当收到Nacos数据变更事件后，在spring-cloud-context这个包下的 RefreshEventListener就会收到RefreshEvent事件。 这个事件不用猜测也能知道，一定是要修改Environment中的PropertySource属性值，以及 刷新@Value注解的值

public class RefreshEventListener implements SmartApplicationListener {
      public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationReadyEvent) {
            this.handle((ApplicationReadyEvent)event);
        } else if (event instanceof RefreshEvent) {
            this.handle((RefreshEvent)event);
        }
    }
}

开始处理RefreshEvent事件

   public void handle(RefreshEvent event) {
        if (this.ready.get()) {
            log.debug("Event received " + event.getEventDesc());
            Set<String> keys = this.refresh.refresh();
            log.info("Refresh keys changed: " + keys);
        }
    }

ContextRefresher.refresh

ContextRefresher刷新方通过构建上下文context获取最新的环境配置和处理@RefreshScope

1. 这个方法需要做两个事情
   1. 刷新Environment中的上下文属性配置。
   2. 刷新bean中属性对应的@Value值

  public synchronized Set<String> refresh() {
      // 1.构建一个上下文Context刷新Environment配置数据
        Set<String> keys = this.refreshEnvironment();
      // 2.调用RefreshScope 处理注解@RefreshScope 
        this.scope.refreshAll();
        return keys;
    }

Context刷新Environment配置数据

SpringBoot项目启动的时候会创建一个上下文Context，同时NacosConfig的配置也会从远程服务读取加载到本地。
所以这里模拟了SpringBoot的启动，通过SpringApplicationBuilder构建一个上下文帮助获取最新的配置
执行链：refreshEnvironment()->this.addConfigFilesToEnvironment()

addConfigFilesToEnvironment

ConfigurableApplicationContext addConfigFilesToEnvironment() {
// 创建一个新的上下文
        ConfigurableApplicationContext capture = null;
        boolean var15 = false;
        try {
            var15 = true;
    // 拷贝现有的Environment用来构建新的上下文
            StandardEnvironment environment = this.copyEnvironment(this.context.getEnvironment());
   // 上下文构建器
            SpringApplicationBuilder builder = (new SpringApplicationBuilder(new Class[]{ContextRefresher.Empty.class})).bannerMode(Mode.OFF).web(WebApplicationType.NONE).environment(environment);
// 添加启动监听器
            builder.application().setListeners(Arrays.asList(new BootstrapApplicationListener(), new ConfigFileApplicationListener()));
// 启动上下文
            capture = builder.run(new String[0]);
            if (environment.getPropertySources().contains("refreshArgs")) {
                environment.getPropertySources().remove("refreshArgs");
            }
// 获取最新的配置信息
            MutablePropertySources target = this.context.getEnvironment().getPropertySources();
        } finally {
// 最终关闭临时的上下文
            if (var15) {
                for(ConfigurableApplicationContext closeable = capture; closeable != null; closeable = (ConfigurableApplicationContext)closeable.getParent()) {
                    try {
                        closeable.close();
                    } catch (Exception var16) {
                    }
                    if (!(closeable.getParent() instanceof ConfigurableApplicationContext)) {
                        break;
                    }
                }
            }
        }
        for(ConfigurableApplicationContext closeable = capture; closeable != null; closeable = (ConfigurableApplicationContext)closeable.getParent()) {
            try {
                closeable.close();
            } catch (Exception var17) {
            }
            if (!(closeable.getParent() instanceof ConfigurableApplicationContext)) {
                break;
            }
        }
        return capture;
    }

通过新的上下文capture获取Environment再合并到现有的Environment，并关闭capture。

ConfigurationPropertiesRebinder

EnvironmentChangeEvent事件监听的实现，在ConfigurationPropertiesRebinder中，代码如下

public class ConfigurationPropertiesRebinder implements ApplicationContextAware, ApplicationListener<EnvironmentChangeEvent> {
     public void onApplicationEvent(EnvironmentChangeEvent event) {
        if (this.applicationContext.equals(event.getSource()) || event.getKeys().equals(event.getSource())) {
            this.rebind();
        }
    }
}

rebind

遍历所有的属性类，重新绑定所有的配置属性对象的属性值

   public void rebind() {
        this.errors.clear();
        Iterator var1 = this.beans.getBeanNames().iterator();
        while(var1.hasNext()) {
            String name = (String)var1.next();
            this.rebind(name);
        }
    }

rebind

可以看到它的处理逻辑，就是把其内部存储的 ConfigurationPropertiesBeans 依次执行销毁逻辑，再执行初始化逻辑实现属性的重新绑定。

public boolean rebind(String name) {
        if (!this.beans.getBeanNames().contains(name)) {
            return false;
        } else {
            if (this.applicationContext != null) {
                try {
                    Object bean = this.applicationContext.getBean(name);
                    if (AopUtils.isAopProxy(bean)) {
                        bean = ProxyUtils.getTargetObject(bean);
                    }
                    if (bean != null) {
                        if (this.getNeverRefreshable().contains(bean.getClass().getName())) {
                            return false;
                        }
                        this.applicationContext.getAutowireCapableBeanFactory().destroyBean(bean);//执行销毁
                        this.applicationContext.getAutowireCapableBeanFactory().initializeBean(bean, name);
                        //初始化bean，重新绑定新的属性
                        return true;
                    }
                } catch (RuntimeException var3) {
                    this.errors.put(name, var3);
                    throw var3;
                } catch (Exception var4) {
                    this.errors.put(name, var4);
                    throw new IllegalStateException("Cannot rebind to " + name, var4);
                }
            }
            return false;
        }
    }

RefreshAll

 public void refreshAll() {
        super.destroy();
        this.context.publishEvent(new RefreshScopeRefreshedEvent());
    }

销毁所有@RefreshScope注解修饰的bean对象。

    public void destroy() {
        List<Throwable> errors = new ArrayList();
        Collection<GenericScope.BeanLifecycleWrapper> wrappers = this.cache.clear();
        Iterator var3 = wrappers.iterator();
        while(var3.hasNext()) {
            GenericScope.BeanLifecycleWrapper wrapper = (GenericScope.BeanLifecycleWrapper)var3.next();
            try {
                Lock lock = ((ReadWriteLock)this.locks.get(wrapper.getName())).writeLock();
                lock.lock();
                try {
                    wrapper.destroy();
                } finally {
                    lock.unlock();
                }
            } catch (RuntimeException var10) {
                errors.add(var10);
            }
        }
        if (!errors.isEmpty()) {
            throw wrapIfNecessary((Throwable)errors.get(0));
        } else {
            this.errors.clear();
        }
    }

NacosPropertySourceBuilder.build

NacosPropertySource build(String dataId, String group, String fileExtension,
            boolean isRefreshable) {
    //调用loadNacosData加载远程数据
        List<PropertySource<?>> propertySources = loadNacosData(dataId, group,
                fileExtension);
    //构造NacosPropertySource(这个是Nacos自定义扩展的PropertySource，和前面演示的自定义
PropertySource类似)。
    // 相当于把从远程服务器获取的数据保存到NacosPropertySource中。
        NacosPropertySource nacosPropertySource = new NacosPropertySource(propertySources,
                group, dataId, new Date(), isRefreshable);
    //把属性缓存到本地缓存
        NacosPropertySourceRepository.collectNacosPropertySource(nacosPropertySource);
        return nacosPropertySource;
    }

NacosPropertySourceBuilder.loadNacosData

这个方法，就是连接远程服务器去获取配置数据的实现，关键代码是 configService.getConfig

    private List<PropertySource<?>> loadNacosData(String dataId, String group,
            String fileExtension) {
        String data = null;
        try {
            data = configService.getConfig(dataId, group, timeout);
            if (StringUtils.isEmpty(data)) {
                log.warn(
                        "Ignore the empty nacos configuration and get it based on dataId[{}] & group[{}]",
                        dataId, group);
                return Collections.emptyList();
            }
            if (log.isDebugEnabled()) {
                log.debug(String.format(
                        "Loading nacos data, dataId: '%s', group: '%s', data: %s", dataId,
                        group, data));
            }
            //对加载的数据进行解析，保存到List<PropertySource>集合。
            return NacosDataParserHandler.getInstance().parseNacosData(dataId, data,
                    fileExtension);
        }
        catch (NacosException e) {
            log.error("get data from Nacos error,dataId:{} ", dataId, e);
        }
        catch (Exception e) {
            log.error("parse data from Nacos error,dataId:{},data:{}", dataId, data, e);
        }
        return Collections.emptyList();
    }

阶段性总结

通过上述分析，知道了Spring Cloud集成Nacos时的关键路径，并且知道在启动时， Spring Cloud会从Nacos Server中加载动态数据保存到Environment集合。 从而实现动态配置的自动注入。

Nacos客户端的数据的加载流程

配置数据的最终加载，是基于configService.getConfig，Nacos提供的SDK来实现的。

public String getConfig(String dataId, String group, long timeoutMs) throws
NacosException

关于Nacos SDK的使用教程： https://nacos.io/zh-cn/docs/sdk.html

也就是说，接下来我们的源码分析，直接进入到Nacos这个范畴。

NacosConfigService.getConfig

  public String getConfig(String dataId, String group, long timeoutMs) throws NacosException {
        return getConfigInner(namespace, dataId, group, timeoutMs);
    }

NacosConfigService.getConfigInner

    private String getConfigInner(String tenant, String dataId, String group, long timeoutMs) throws NacosException {
       //获取group，如果为空，则为default-group
        group = this.blank2defaultGroup(group);
        //校验参数
        ParamUtils.checkKeyParam(dataId, group);
        //设置响应结果
        ConfigResponse cr = new ConfigResponse();
        cr.setDataId(dataId);
        cr.setTenant(tenant);
        cr.setGroup(group);
        //使用本地缓存
        String content = LocalConfigInfoProcessor.getFailover(this.agent.getName(), dataId, group, tenant);
         //如果本地缓存中的内容不为空
        String encryptedDataKey;
        if (content != null) {
            LOGGER.warn("[{}] [get-config] get failover ok, dataId={}, group={}, tenant={}, config={}", new Object[]{this.agent.getName(), dataId, group, tenant, ContentUtils.truncateContent(content)});
            cr.setContent(content); //把内容设置到cr中。
//获取容灾配置的encryptedDataKey
            encryptedDataKey = LocalEncryptedDataKeyProcessor.getEncryptDataKeyFailover(this.agent.getName(), dataId, group, tenant);
            cr.setEncryptedDataKey(encryptedDataKey); //保存到cr
            this.configFilterChainManager.doFilter((IConfigRequest)null, cr); //执行过滤(目前好像没有实现)
            content = cr.getContent();//返回文件content
            return content;
        } else {
            try {
                //如果本地文件中不存在相关内容，则发起远程调用
                ConfigResponse response = this.worker.getServerConfig(dataId, group, tenant, timeoutMs);
               //把响应内容返回
                cr.setContent(response.getContent());
                cr.setEncryptedDataKey(response.getEncryptedDataKey());
                this.configFilterChainManager.doFilter((IConfigRequest)null, cr);
                content = cr.getContent();
                return content;
            } catch (NacosException var9) {
                if (403 == var9.getErrCode()) {
                    throw var9;
                } else {
                    //如果出现NacosException，且不是403异常，则尝试通过本地的快照文件去获取配置进行返回。
                    LOGGER.warn("[{}] [get-config] get from server error, dataId={}, group={}, tenant={}, msg={}", new Object[]{this.agent.getName(), dataId, group, tenant, var9.toString()});
                    LOGGER.warn("[{}] [get-config] get snapshot ok, dataId={}, group={}, tenant={}, config={}", new Object[]{this.agent.getName(), dataId, group, tenant, ContentUtils.truncateContent(content)});
                    content = LocalConfigInfoProcessor.getSnapshot(this.agent.getName(), dataId, group, tenant);
                    cr.setContent(content);
                    encryptedDataKey = LocalEncryptedDataKeyProcessor.getEncryptDataKeyFailover(this.agent.getName(), dataId, group, tenant);
                    cr.setEncryptedDataKey(encryptedDataKey);
                    this.configFilterChainManager.doFilter((IConfigRequest)null, cr);
                    content = cr.getContent();
                    return content;
                }
            }
        }
    }

getConfigInner方法，主要有几个逻辑

1. 先从本地磁盘中加载配置，因为应用在启动时，会加载远程配置缓存到本地，如果本地文件的内容

不为空，直接返回。

1. 如果本地文件的内容为空，则调用worker.getServerConfig加载远程配置
2. 如果出现异常，则调用本地快照文件加载配置
   

   本地文件缓存读取配置

   默认情况下，nacos先从本地缓存的配置中读取文件：
   C:\Users\mayn\nacos\config\fixed-192.168.8.133_8848-6a382560-ed4c-414c-
   a5e2-9d72c48f1a0e_nacos
   如果本地缓存内容存在，则返回内容数据，否则返回空值。

  public static String getFailover(String serverName, String dataId, String group, String tenant) {
        File localPath = getFailoverFile(serverName, dataId, group, tenant);
        if (localPath.exists() && localPath.isFile()) {
            try {
                return readFile(localPath);
            } catch (IOException var6) {
                LOGGER.error("[" + serverName + "] get failover error, " + localPath, var6);
                return null;
            }
        } else {
            return null;
        }
    }

从指定文件目录下读取文件内容。

 static File getFailoverFile(String serverName, String dataId, String group, String tenant) {
        File tmp = new File(LOCAL_SNAPSHOT_PATH, serverName + "_nacos");
        tmp = new File(tmp, "data");
        if (StringUtils.isBlank(tenant)) {
            tmp = new File(tmp, "config-data");
        } else {
            tmp = new File(tmp, "config-data-tenant");
            tmp = new File(tmp, tenant);
        }
        return new File(new File(tmp, group), dataId);
    }

ClientWorker.getServerConfig

ClientWorker，表示客户端的一个工作类，它负责和服务端交互
通过agent.httpGet发起http请求，获取远程服务的配置。

    public ConfigResponse getServerConfig(String dataId, String group, String tenant, long readTimeout) throws NacosException {
        ConfigResponse configResponse = new ConfigResponse();
        if (StringUtils.isBlank(group)) {//如果group为空，则返回默认group
            group = "DEFAULT_GROUP";
        }
        HttpRestResult result = null;
        String encryptedDataKey;
        try {
            //构建参数
            Map<String, String> params = new HashMap(3);
            if (StringUtils.isBlank(tenant)) {
                params.put("dataId", dataId);
                params.put("group", group);
            } else {
                params.put("dataId", dataId);
                params.put("group", group);
                params.put("tenant", tenant);
            }
//发起远程调用
            result = this.agent.httpGet("/v1/cs/configs", (Map)null, params, this.agent.getEncode(), readTimeout);
        } catch (Exception var10) {
            encryptedDataKey = String.format("[%s] [sub-server] get server config exception, dataId=%s, group=%s, tenant=%s", this.agent.getName(), dataId, group, tenant);
            LOGGER.error(encryptedDataKey, var10);
            throw new NacosException(500, var10);
        }
        //根据响应结果实现不同的处理
        switch(result.getCode()) {
        case 200: //如果响应成功，保存快照到本地，并返回响应内容
            LocalConfigInfoProcessor.saveSnapshot(this.agent.getName(), dataId, group, tenant, (String)result.getData());
            configResponse.setContent((String)result.getData());
            String configType;
                //配置文件的类型，如text、json、yaml等
            if (result.getHeader().getValue("Config-Type") != null) {
                configType = result.getHeader().getValue("Config-Type");
            } else {
                configType = ConfigType.TEXT.getType();
            }
//设置到configResponse中，后续要根据文件类型实现不同解析策略
//获取加密数据的key
            configResponse.setConfigType(configType);
            encryptedDataKey = result.getHeader().getValue("Encrypted-Data-Key");
            //保存
            LocalEncryptedDataKeyProcessor.saveEncryptDataKeySnapshot(this.agent.getName(), dataId, group, tenant, encryptedDataKey);
            configResponse.setEncryptedDataKey(encryptedDataKey);
            return configResponse;
        case 403: //如果返回404， 清空本地快照
            LOGGER.error("[{}] [sub-server-error] no right, dataId={}, group={}, tenant={}", new Object[]{this.agent.getName(), dataId, group, tenant});
            throw new NacosException(result.getCode(), result.getMessage());
        case 404:
            LocalConfigInfoProcessor.saveSnapshot(this.agent.getName(), dataId, group, tenant, (String)null);
            LocalEncryptedDataKeyProcessor.saveEncryptDataKeySnapshot(this.agent.getName(), dataId, group, tenant, (String)null);
            return configResponse;
        case 409:
            LOGGER.error("[{}] [sub-server-error] get server config being modified concurrently, dataId={}, group={}, tenant={}", new Object[]{this.agent.getName(), dataId, group, tenant});
            throw new NacosException(409, "data being modified, dataId=" + dataId + ",group=" + group + ",tenant=" + tenant);
        default:
            LOGGER.error("[{}] [sub-server-error]  dataId={}, group={}, tenant={}, code={}", new Object[]{this.agent.getName(), dataId, group, tenant, result.getCode()});
            throw new NacosException(result.getCode(), "http error, code=" + result.getCode() + ",dataId=" + dataId + ",group=" + group + ",tenant=" + tenant);
        }
    }

在NacosConfigService的构造方法中，当这个类被实例化以后，有做一些事情

1. 初始化一个HttpAgent，这里又用到了装饰起模式，实际工作的类是ServerHttpAgent,

MetricsHttpAgent内部也是调用了ServerHttpAgent的方法，增加了监控统计的信息

1. ClientWorker， 客户端的一个工作类，agent作为参数传入到clientworker，可以基本猜测到里面

会用到agent做一些远程相关的事情

  public NacosConfigService(Properties properties) throws NacosException {
        ValidatorUtils.checkInitParam(properties);
        String encodeTmp = properties.getProperty(PropertyKeyConst.ENCODE);
        if (StringUtils.isBlank(encodeTmp)) {
            this.encode = Constants.ENCODE;
        } else {
            this.encode = encodeTmp.trim();
        }
        initNamespace(properties);
        //agent远程通信代理
        this.agent = new MetricsHttpAgent(new ServerHttpAgent(properties));
        this.agent.start();
        this.worker = new ClientWorker(this.agent, this.configFilterChainManager, properties);
    }

MetricsHttpAgent.httpGet

�发起远程调用实现

    public HttpRestResult<String> httpGet(String path, Map<String, String> headers, Map<String, String> paramValues, String encode, long readTimeoutMs) throws Exception {
        Timer timer = MetricsMonitor.getConfigRequestMonitor("GET", path, "NA");
        HttpRestResult result;
        try {
            result = this.httpAgent.httpGet(path, headers, paramValues, encode, readTimeoutMs);
        } catch (IOException var13) {
            throw var13;
        } finally {
            timer.observeDuration();
        }
        return result;
    }

ServerHttpAgent.httpGet

  public HttpRestResult<String> httpGet(String path, Map<String, String> headers, Map<String, String> paramValues, String encode, long readTimeoutMs) throws Exception {
        long endTime = System.currentTimeMillis() + readTimeoutMs;
      //注入安全信息
        this.injectSecurityInfo(paramValues);
      //获取当前服务器地址
        String currentServerAddr = this.serverListMgr.getCurrentServerAddr();
      //获取最大重试次数，默认3次
        int maxRetry = this.maxRetry;
      //配置HttpClient的属性，默认的readTimeOut超时时间是3s
        HttpClientConfig httpConfig = HttpClientConfig.builder().setReadTimeOutMillis(Long.valueOf(readTimeoutMs).intValue()).setConTimeOutMillis(ConfigHttpClientManager.getInstance().getConnectTimeoutOrDefault(100)).build();
        do {
            try {
                //设置header
                Header newHeaders = this.getSpasHeaders(paramValues, encode);
                if (headers != null) {
                    newHeaders.addAll(headers);
                }
                //构建query查询条件
                Query query = Query.newInstance().initParams(paramValues);
                //发起http请求，http://192.168.8.133:8848/nacos/v1/cs/configs
                HttpRestResult<String> result = NACOS_RESTTEMPLATE.get(this.getUrl(currentServerAddr, path), httpConfig, newHeaders, query, String.class);
                if (!this.isFail(result)) { //如果请求失败，
                    this.serverListMgr.updateCurrentServerAddr(currentServerAddr);
                    return result;
                }
                LOGGER.error("[NACOS ConnectException] currentServerAddr: {}, httpCode: {}", this.serverListMgr.getCurrentServerAddr(), result.getCode());
            } catch (ConnectException var15) {
                LOGGER.error("[NACOS ConnectException httpGet] currentServerAddr:{}, err : {}", this.serverListMgr.getCurrentServerAddr(), var15.getMessage());
            } catch (SocketTimeoutException var16) {
                LOGGER.error("[NACOS SocketTimeoutException httpGet] currentServerAddr:{}， err : {}", this.serverListMgr.getCurrentServerAddr(), var16.getMessage());
            } catch (Exception var17) {
                LOGGER.error("[NACOS Exception httpGet] currentServerAddr: " + this.serverListMgr.getCurrentServerAddr(), var17);
                throw var17;
            }
            //如果服务端列表有多个，并且当前请求失败，则尝试用下一个地址进行重试
            if (this.serverListMgr.getIterator().hasNext()) {
                currentServerAddr = (String)this.serverListMgr.getIterator().next();
            } else {
                --maxRetry; //重试次数递减
                if (maxRetry < 0) {
                    throw new ConnectException("[NACOS HTTP-GET] The maximum number of tolerable server reconnection errors has been reached");
                }
                this.serverListMgr.refreshCurrentServerAddr();
            }
        } while(System.currentTimeMillis() <= endTime);
        LOGGER.error("no available server");
        throw new ConnectException("no available server");
    }

Nacos Server端的配置获取

客户端向服务端加载配置，调用的接口是：/nacos/v1/cs/configs，于是，在Nacos的源码中找到该接口

定位到Nacos源码中的ConfigController.getConfig中的方法，代码如下：

 @GetMapping
    @Secured(action = ActionTypes.READ, parser = ConfigResourceParser.class)
    public void getConfig(HttpServletRequest request, HttpServletResponse response,
            @RequestParam("dataId") String dataId, @RequestParam("group") String group,
            @RequestParam(value = "tenant", required = false, defaultValue = StringUtils.EMPTY) String tenant,
            @RequestParam(value = "tag", required = false) String tag)
            throws IOException, ServletException, NacosException {
        // check tenant
        ParamUtils.checkTenant(tenant);
         //租户，也就是namespaceid
        tenant = NamespaceUtil.processNamespaceParameter(tenant);
        //检查请求参数是否为空
        ParamUtils.checkParam(dataId, group, "datumId", "content");
        ParamUtils.checkParam(tag);
        final String clientIp = RequestUtil.getRemoteIp(request);
         //加载配置
        inner.doGetConfig(request, response, dataId, group, tenant, tag, clientIp);
    }