springcloud/springboot整合NACOS 做註冊和配置中心以及nacos原始碼分析

一、SpringCloud 簡介

Spring Cloud 是一系列框架的有序集合如服務發現註冊、配置中心、訊息匯流排、負載均衡、熔斷器、資料監控等。

SpringCloud 將多個服務框架組合起來，透過Spring Boot進行再封裝，遮蔽掉了複雜的配置和實現原理，最終給開發者提供了一套簡單易懂、易部署和易維護的分散式系統開發工具包。

 Spring Cloud是一個基於SpringBoot實現的微服務開發方案，Spring boot 是 Spring 的一套快速配置框架。可以基於spring boot 快速開發單個微服務。

二、NACOS簡介

一個更易於構建雲原生應用的動態服務發現、配置管理和服務管理平臺。

Nacos 致力於幫助您發現、配置和管理微服務。Nacos 提供了一組簡單易用的特性集，幫助您快速實現動態服務發現、服務配置、服務後設資料及流量管理。

Nacos 幫助您更敏捷和容易地構建、交付和管理微服務平臺。 Nacos 是構建以“服務”為中心的現代應用架構 (例如微服務正規化、雲原生正規化) 的服務基礎設施。

1、Nacos中的概念

地域

物理的資料中心，資源建立成功後不能更換。

可用區

同一地域內，電力和網路互相獨立的物理區域。同一可用區內，例項的網路延遲較低。

接入點

地域的某個服務的入口域名。

名稱空間

用於進行租戶粒度的配置隔離。不同的名稱空間下，可以存在相同的 Group 或 Data ID 的配置。Namespace 的常用場景之一是不同環境的配置的區分隔離，例如開發測試環境和生產環境的資源（如配置、服務）隔離等。

配置

在系統開發過程中，開發者通常會將一些需要變更的引數、變數等從程式碼中分離出來獨立管理，以獨立的配置檔案的形式存在。目的是讓靜態的系統工件或者交付物（如 WAR，JAR 包等）更好地和實際的物理執行環境進行適配。配置管理一般包含在系統部署的過程中，由系統管理員或者運維人員完成。配置變更是調整系統執行時的行為的有效手段。

配置管理

系統配置的編輯、儲存、分發、變更管理、歷史版本管理、變更審計等所有與配置相關的活動。

配置項

一個具體的可配置的引數與其值域，通常以 param-key=param-value 的形式存在。例如我們常配置系統的日誌輸出級別（logLevel=INFO|WARN|ERROR） 就是一個配置項。

配置集

一組相關或者不相關的配置項的集合稱為配置集。在系統中，一個配置檔案通常就是一個配置集，包含了系統各個方面的配置。例如，一個配置集可能包含了資料來源、執行緒池、日誌級別等配置項。

配置集 ID

Nacos 中的某個配置集的 ID。配置集 ID 是組織劃分配置的維度之一。Data ID 通常用於組織劃分系統的配置集。一個系統或者應用可以包含多個配置集，每個配置集都可以被一個有意義的名稱標識。Data ID 通常採用類 Java 包（如 com.taobao.tc.refund.log.level）的命名規則保證全域性唯一性。此命名規則非強制。

配置分組

Nacos 中的一組配置集，是組織配置的維度之一。透過一個有意義的字串（如 Buy 或 Trade ）對配置集進行分組，從而區分 Data ID 相同的配置集。當您在 Nacos 上建立一個配置時，如果未填寫配置分組的名稱，則配置分組的名稱預設採用 DEFAULT_GROUP 。配置分組的常見場景：不同的應用或元件使用了相同的配置型別，如 database_url 配置和 MQ_topic 配置。

配置快照

Nacos 的客戶端 SDK 會在本地生成配置的快照。當客戶端無法連線到 Nacos Server 時，可以使用配置快照顯示系統的整體容災能力。配置快照類似於 Git 中的本地 commit，也類似於快取，會在適當的時機更新，但是並沒有快取過期（expiration）的概念。

服務

透過預定義介面網路訪問的提供給客戶端的軟體功能。

服務名

服務提供的標識，透過該標識可以唯一確定其指代的服務。

服務註冊中心

儲存服務例項和服務負載均衡策略的資料庫。

服務發現

在計算機網路上，（通常使用服務名）對服務下的例項的地址和後設資料進行探測，並以預先定義的介面提供給客戶端進行查詢。

元資訊

Nacos資料（如配置和服務）描述資訊，如服務版本、權重、容災策略、負載均衡策略、鑑權配置、各種自定義標籤 (label)，從作用範圍來看，分為服務級別的元資訊、叢集的元資訊及例項的元資訊。

應用

用於標識服務提供方的服務的屬性。

服務分組

不同的服務可以歸類到同一分組。

虛擬叢集

同一個服務下的所有服務例項組成一個預設叢集, 叢集可以被進一步按需求劃分，劃分的單位可以是虛擬叢集。

例項

提供一個或多個服務的具有可訪問網路地址（IP:Port）的程式。

權重

例項級別的配置。權重為浮點數。權重越大，分配給該例項的流量越大。

健康檢查

以指定方式檢查服務下掛載的例項 (Instance) 的健康度，從而確認該例項 (Instance) 是否能提供服務。根據檢查結果，例項 (Instance) 會被判斷為健康或不健康。對服務發起解析請求時，不健康的例項 (Instance) 不會返回給客戶端。

健康保護閾值

為了防止因過多例項 (Instance) 不健康導致流量全部流向健康例項 (Instance) ，繼而造成流量壓力把健康例項 (Instance) 壓垮並形成雪崩效應，應將健康保護閾值定義為一個 0 到 1 之間的浮點數。當域名健康例項數 (Instance) 佔總服務例項數 (Instance) 的比例小於該值時，無論例項 (Instance) 是否健康，都會將這個例項 (Instance) 返回給客戶端。這樣做雖然損失了一部分流量，但是保證了叢集中剩餘健康例項 (Instance) 能正常工作。

2、Nacos 架構

基礎架構如下：

 邏輯架構及元件如下：

 

• 服務管理：實現服務CRUD，域名CRUD，服務健康狀態檢查，服務權重管理等功能
• 配置管理：實現配置管CRUD，版本管理，灰度管理，監聽管理，推送軌跡，聚合資料等功能
• 後設資料管理：提供後設資料CURD 和打標能力
• 外掛機制：實現三個模組可分可合能力，實現擴充套件點SPI機制
• 事件機制：實現非同步化事件通知，sdk資料變化非同步通知等邏輯
• 日誌模組：管理日誌分類，日誌級別，日誌可移植性（尤其避免衝突），日誌格式，異常碼+幫助文件
• 回撥機制：sdk通知資料，透過統一的模式回撥使用者處理。介面和資料結構需要具備可擴充套件性
• 定址模式：解決ip，域名，nameserver、廣播等多種定址模式，需要可擴充套件
• 推送通道：解決server與儲存、server間、server與sdk間推送效能問題
• 容量管理：管理每個租戶，分組下的容量，防止儲存被寫爆，影響服務可用性
• 流量管理：按照租戶，分組等多個維度對請求頻率，長連結個數，報文大小，請求流控進行控制
• 快取機制：容災目錄，本地快取，server快取機制。容災目錄使用需要工具
• 啟動模式：按照單機模式，配置模式，服務模式，dns模式，或者all模式，啟動不同的程式+UI
• 一致性協議：解決不同資料，不同一致性要求情況下，不同一致性機制
• 儲存模組：解決資料持久化、非持久化儲存，解決資料分片問題
• Nameserver：解決namespace到clusterid的路由問題，解決使用者環境與nacos物理環境對映問題
• CMDB：解決後設資料儲存，與三方cmdb系統對接問題，解決應用，人，資源關係
• Metrics：暴露標準metrics資料，方便與三方監控系統打通
• Trace：暴露標準trace，方便與SLA系統打通，日誌白平化，推送軌跡等能力，並且可以和計量計費系統打通
• 接入管理：相當於阿里雲開通服務，分配身份、容量、許可權過程
• 使用者管理：解決使用者管理，登入，sso等問題
• 許可權管理：解決身份識別，訪問控制，角色管理等問題
• 審計系統：擴充套件介面方便與不同公司審計系統打通
• 通知系統：核心資料變更，或者操作，方便透過SMS系統打通，通知到對應人資料變更
• OpenAPI：暴露標準Rest風格HTTP介面，簡單易用，方便多語言整合
• Console：易用控制檯，做服務管理、配置管理等操作
• SDK：多語言sdk
• Agent：dns-f類似模式，或者與mesh等方案整合
• CLI：命令列對產品進行輕量化管理，像git一樣好用

 部署架構如下：

 nacos 官網以及幫助文件和部署手冊：https://nacos.io/zh-cn/index.html

nacos github:   https://github.com/alibaba/nacos

三、NACOS原始碼分析

1、Nacos註冊原始碼分析-Clinet端

cosumer啟動的時候，從nacos server上讀取指定服務名稱的例項列表，快取到本地記憶體中。

開啟一個定時任務，每隔10s去nacos server上拉取服務列表

nacos的push機制：

透過心跳檢測發現服務提供者出現心態超時的時候，推送一個push訊息到consumer，更新本地的快取資料。

客戶端Client

我們自己的專案在配置了nacos作為註冊中心後，至少要配置這麼一個屬性

spring.cloud.nacos.discovery.server-addr=ip地址:8848
# 從邏輯上看，這個是透過grpc去註冊還是透過http去註冊。false-http1.x註冊  true-gRPC註冊，預設是true，也就是透過gRPC去註冊，畢竟gRPC的效能上要比http1.x高很多
spring.cloud.nacos.discovery.ephemeral=false

這個屬性會讓應用找到nacos的server地址去註冊。如果不配置的話，會一直報錯

springboot的@EnableAutoConfiguration這裡就不再講解了。都到nacos的原始碼了，springboot預設是熟悉的。

我們再去開啟NacosServiceRegistryAutoConfiguration這個類。

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
@ConditionalOnNacosDiscoveryEnabled
@ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled",
        matchIfMissing = true)
@AutoConfigureAfter({ AutoServiceRegistrationConfiguration.class,
        AutoServiceRegistrationAutoConfiguration.class,
        NacosDiscoveryAutoConfiguration.class })
public class NacosServiceRegistryAutoConfiguration {

    @Bean
    public NacosServiceRegistry nacosServiceRegistry(
            NacosServiceManager nacosServiceManager,
            NacosDiscoveryProperties nacosDiscoveryProperties) {
        return new NacosServiceRegistry(nacosServiceManager, nacosDiscoveryProperties);
    }

    @Bean
    @ConditionalOnBean(AutoServiceRegistrationProperties.class)
    public NacosRegistration nacosRegistration(
            ObjectProvider<List<NacosRegistrationCustomizer>> registrationCustomizers,
            NacosDiscoveryProperties nacosDiscoveryProperties,
            ApplicationContext context) {
        return new NacosRegistration(registrationCustomizers.getIfAvailable(),
                nacosDiscoveryProperties, context);
    }

    @Bean
    @ConditionalOnBean(AutoServiceRegistrationProperties.class)
    public NacosAutoServiceRegistration nacosAutoServiceRegistration(
            NacosServiceRegistry registry,
            AutoServiceRegistrationProperties autoServiceRegistrationProperties,
            NacosRegistration registration) {
        return new NacosAutoServiceRegistration(registry,
                autoServiceRegistrationProperties, registration);
    }

}

其中第三個類NacosAutoServiceRegistration實現了一個抽象類AbstractAutoServiceRegistration.

public abstract class AbstractAutoServiceRegistration<R extends Registration>
        implements AutoServiceRegistration, ApplicationContextAware,
        ApplicationListener<WebServerInitializedEvent> {
    
    @Override
    @SuppressWarnings("deprecation")
    public void onApplicationEvent(WebServerInitializedEvent event) {
        bind(event);
    }

    @Deprecated
    public void bind(WebServerInitializedEvent event) {
        ApplicationContext context = event.getApplicationContext();
        if (context instanceof ConfigurableWebServerApplicationContext) {
            if ("management".equals(((ConfigurableWebServerApplicationContext) context)
                    .getServerNamespace())) {
                return;
            }
        }
        this.port.compareAndSet(0, event.getWebServer().getPort());
        this.start();
    }
    public void start() {
        if (!isEnabled()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Discovery Lifecycle disabled. Not starting");
            }
            return;
        }

        // only initialize if nonSecurePort is greater than 0 and it isn't already running
        // because of containerPortInitializer below
        if (!this.running.get()) {
            this.context.publishEvent(
                    new InstancePreRegisteredEvent(this, getRegistration()));
            register();
            if (shouldRegisterManagement()) {
                registerManagement();
            }
            this.context.publishEvent(
                    new InstanceRegisteredEvent<>(this, getConfiguration()));
            this.running.compareAndSet(false, true);
        }

    }
}

這裡有實現一個ApplicationListener<WebServerInitializedEvent>的類，這個類是spring的一個監聽事件（觀察者模式），而這個事件就是webserver初始化的時候去觸發的。onApplicationEvent方法呼叫了bind()方法。而bind()中又呼叫了start().

start()中有一個register()。而這個register就是NacosServiceRegistry中的register()。

public class NacosServiceRegistry implements ServiceRegistry<Registration> {

    @Override
    public void register(Registration registration) {

        if (StringUtils.isEmpty(registration.getServiceId())) {
            log.warn("No service to register for nacos client...");
            return;
        }

        NamingService namingService = namingService();
        String serviceId = registration.getServiceId();
        String group = nacosDiscoveryProperties.getGroup();

        Instance instance = getNacosInstanceFromRegistration(registration);

        try {
            namingService.registerInstance(serviceId, group, instance);
            log.info("nacos registry, {} {} {}:{} register finished", group, serviceId,
                    instance.getIp(), instance.getPort());
        }
        catch (Exception e) {
            if (nacosDiscoveryProperties.isFailFast()) {
                log.error("nacos registry, {} register failed...{},", serviceId,
                        registration.toString(), e);
                rethrowRuntimeException(e);
            }
            else {
                log.warn("Failfast is false. {} register failed...{},", serviceId,
                        registration.toString(), e);
            }
        }
    }
}

• getNacosInstanceFromRegistration 獲取註冊的例項資訊。

private Instance getNacosInstanceFromRegistration(Registration registration) {
    Instance instance = new Instance();
    instance.setIp(registration.getHost());
    instance.setPort(registration.getPort());
    instance.setWeight(nacosDiscoveryProperties.getWeight());
    instance.setClusterName(nacosDiscoveryProperties.getClusterName());
    instance.setEnabled(nacosDiscoveryProperties.isInstanceEnabled());
    instance.setMetadata(registration.getMetadata());
    instance.setEphemeral(nacosDiscoveryProperties.isEphemeral());
    return instance;
}

• namingService.registerInstance(serviceId, group, instance);

clientProxy有3個實現類，NamingClientProxyDelegate、NamingGrpcClientProxy、NamingHttpClientProxy。

這個類的構造方法中有個init(properties)方法，這個方法中給clientProxy賦值了。走的是NamingClientProxyDelegate方法。一般情況下，帶有delegate的方法都是委派模式。

public NacosNamingService(String serverList) throws NacosException {
    Properties properties = new Properties();
    properties.setProperty(PropertyKeyConst.SERVER_ADDR, serverList);
    init(properties);
}

public NacosNamingService(Properties properties) throws NacosException {
    init(properties);
}

private void init(Properties properties) throws NacosException {
    ValidatorUtils.checkInitParam(properties);
    this.namespace = InitUtils.initNamespaceForNaming(properties);
    InitUtils.initSerialization();
    InitUtils.initWebRootContext(properties);
    initLogName(properties);

    this.changeNotifier = new InstancesChangeNotifier();
    NotifyCenter.registerToPublisher(InstancesChangeEvent.class, 16384);
    NotifyCenter.registerSubscriber(changeNotifier);
    this.serviceInfoHolder = new ServiceInfoHolder(namespace, properties);
    this.clientProxy = new NamingClientProxyDelegate(this.namespace, serviceInfoHolder, properties, changeNotifier);
}
@Override
public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
    NamingUtils.checkInstanceIsLegal(instance);
    clientProxy.registerService(serviceName, groupName, instance);
}

基於http1.x協議註冊

• NamingClientProxyDelegate.registerService

  委派這裡做了一個可執行的判斷

@Override
public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
    getExecuteClientProxy(instance).registerService(serviceName, groupName, instance);
}

NamingClientProxyDelegate.getExecuteClientProxy

做了一個判斷，配置ephemeral=false就走http，否則grpc。這裡請注意，如果nacos-server還是用的1.x.x版本的話，會報錯的。因為2.x.x增加一個grpc的支援，會額外的多增加一個埠，預設對外提供埠為8848和9848

private NamingClientProxy getExecuteClientProxy(Instance instance) {
    return instance.isEphemeral() ? grpcClientProxy : httpClientProxy;
}

• NamingHttpClientProxy.registerService

  這裡的clientProxy=NamingHttpClientProxy

@Override
public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {

    NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance: {}", namespaceId, serviceName,
                       instance);
    String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
    if (instance.isEphemeral()) {
        BeatInfo beatInfo = beatReactor.buildBeatInfo(groupedServiceName, instance);
        beatReactor.addBeatInfo(groupedServiceName, beatInfo);
    }
    final Map<String, String> params = new HashMap<String, String>(32);
    params.put(CommonParams.NAMESPACE_ID, namespaceId);
    params.put(CommonParams.SERVICE_NAME, groupedServiceName);
    params.put(CommonParams.GROUP_NAME, groupName);
    params.put(CommonParams.CLUSTER_NAME, instance.getClusterName());
    params.put(IP_PARAM, instance.getIp());
    params.put(PORT_PARAM, String.valueOf(instance.getPort()));
    params.put(WEIGHT_PARAM, String.valueOf(instance.getWeight()));
    params.put(REGISTER_ENABLE_PARAM, String.valueOf(instance.isEnabled()));
    params.put(HEALTHY_PARAM, String.valueOf(instance.isHealthy()));
    params.put(EPHEMERAL_PARAM, String.valueOf(instance.isEphemeral()));
    params.put(META_PARAM, JacksonUtils.toJson(instance.getMetadata()));

    reqApi(UtilAndComs.nacosUrlInstance, params, HttpMethod.POST);

}

NamingHttpClientProxy.reqApi

public String reqApi(String api, Map<String, String> params, String method) throws NacosException {
    return reqApi(api, params, Collections.EMPTY_MAP, method);
}

public String reqApi(String api, Map<String, String> params, Map<String, String> body, String method)
    throws NacosException {
    return reqApi(api, params, body, serverListManager.getServerList(), method);
}

public String reqApi(String api, Map<String, String> params, Map<String, String> body, List<String> servers,
                     String method) throws NacosException {

    params.put(CommonParams.NAMESPACE_ID, getNamespaceId());

    if (CollectionUtils.isEmpty(servers) && !serverListManager.isDomain()) {
        throw new NacosException(NacosException.INVALID_PARAM, "no server available");
    }

    NacosException exception = new NacosException();

    if (serverListManager.isDomain()) {
        String nacosDomain = serverListManager.getNacosDomain();
        for (int i = 0; i < maxRetry; i++) {
            try {
                return callServer(api, params, body, nacosDomain, method);
            } catch (NacosException e) {
                exception = e;
                if (NAMING_LOGGER.isDebugEnabled()) {
                    NAMING_LOGGER.debug("request {} failed.", nacosDomain, e);
                }
            }
        }
    } else {
        Random random = new Random(System.currentTimeMillis());
        int index = random.nextInt(servers.size());

        for (int i = 0; i < servers.size(); i++) {
            String server = servers.get(index);
            try {
                return callServer(api, params, body, server, method);
            } catch (NacosException e) {
                exception = e;
                if (NAMING_LOGGER.isDebugEnabled()) {
                    NAMING_LOGGER.debug("request {} failed.", server, e);
                }
            }
            index = (index + 1) % servers.size();
        }
    }

    NAMING_LOGGER.error("request: {} failed, servers: {}, code: {}, msg: {}", api, servers, exception.getErrCode(),
                        exception.getErrMsg());

    throw new NacosException(exception.getErrCode(),
                             "failed to req API:" + api + " after all servers(" + servers + ") tried: " + exception.getMessage());

}

serverListManager.isDomain()這個判斷是配置了幾個nacos server的值，如果是一個的話，走if邏輯，如果多餘1個的話，走else邏輯。

else中的servers就是nacos server服務列表，透過Ramdom拿到一個隨機數，然後去callServer()，如果發現其中的一個失敗，那麼index+1 獲取下一個服務節點再去callServer。如果所有的都失敗的話，則丟擲錯誤。

NamingHttpClientProxy.callServer

前邊的判斷支線省略，拼接url，拼好了後，進入try邏輯塊中，這裡封裝了一個nacosRestTemplate類。請求完成後，返回一個restResult，拿到了請求結果後，把請求結果code放入了一個交MetricsMonitor的類中了，從程式碼上看很明顯是監控相關的類，點選進去果然發現是prometheus相關的。這裡我們不擴充套件了，繼續回到主線。

如果返回結果是200的話，把result.content返回去。

public String callServer(String api, Map<String, String> params, Map<String, String> body, String curServer,
            String method) throws NacosException {
    long start = System.currentTimeMillis();
    long end = 0;
    String namespace = params.get(CommonParams.NAMESPACE_ID);
    String group = params.get(CommonParams.GROUP_NAME);
    String serviceName = params.get(CommonParams.SERVICE_NAME);
    params.putAll(getSecurityHeaders(namespace, group, serviceName));
    Header header = NamingHttpUtil.builderHeader();

    String url;
    if (curServer.startsWith(HTTPS_PREFIX) || curServer.startsWith(HTTP_PREFIX)) {
        url = curServer + api;
    } else {
        if (!InternetAddressUtil.containsPort(curServer)) {
            curServer = curServer + InternetAddressUtil.IP_PORT_SPLITER + serverPort;
        }
        url = NamingHttpClientManager.getInstance().getPrefix() + curServer + api;
    }

    try {
        HttpRestResult<String> restResult = nacosRestTemplate
            .exchangeForm(url, header, Query.newInstance().initParams(params), body, method, String.class);
        end = System.currentTimeMillis();

        MetricsMonitor.getNamingRequestMonitor(method, url, String.valueOf(restResult.getCode()))
            .observe(end - start);

        if (restResult.ok()) {
            return restResult.getData();
        }
        if (HttpStatus.SC_NOT_MODIFIED == restResult.getCode()) {
            return StringUtils.EMPTY;
        }
        throw new NacosException(restResult.getCode(), restResult.getMessage());
    } catch (Exception e) {
        NAMING_LOGGER.error("[NA] failed to request", e);
        throw new NacosException(NacosException.SERVER_ERROR, e);
    }
}

• NacosRestTemplate.exchangeForm

  關鍵方法：this.requestClient().execute()

• public <T> HttpRestResult<T> exchangeForm(String url, Header header, Query query, Map<String, String> bodyValues,
                                            String httpMethod, Type responseType) throws Exception {
      RequestHttpEntity requestHttpEntity = new RequestHttpEntity(
          header.setContentType(MediaType.APPLICATION_FORM_URLENCODED), query, bodyValues);
      return execute(url, httpMethod, requestHttpEntity, responseType);
  }
  
  private <T> HttpRestResult<T> execute(String url, String httpMethod, RequestHttpEntity requestEntity,
                                        Type responseType) throws Exception {
      URI uri = HttpUtils.buildUri(url, requestEntity.getQuery());
      if (logger.isDebugEnabled()) {
          logger.debug("HTTP method: {}, url: {}, body: {}", httpMethod, uri, requestEntity.getBody());
      }
  
      ResponseHandler<T> responseHandler = super.selectResponseHandler(responseType);
      HttpClientResponse response = null;
      try {
          response = this.requestClient().execute(uri, httpMethod, requestEntity);
          return responseHandler.handle(response);
      } finally {
          if (response != null) {
              response.close();
          }
      }
  }

  private final HttpClientRequest requestClient;
      
  private final List<HttpClientRequestInterceptor> interceptors = new ArrayList<HttpClientRequestInterceptor>();
  
  public NacosRestTemplate(Logger logger, HttpClientRequest requestClient) {
      super(logger);
      this.requestClient = requestClient;
  }
  private HttpClientRequest requestClient() {
      if (CollectionUtils.isNotEmpty(interceptors)) {
          if (logger.isDebugEnabled()) {
              logger.debug("Execute via interceptors :{}", interceptors);
          }
          return new InterceptingHttpClientRequest(requestClient, interceptors.iterator());
      }
      return requestClient;
  }

  HttpClientBeanHolder.getNacosRestTemplate

  典型的雙重檢查鎖。

• public static NacosRestTemplate getNacosRestTemplate(HttpClientFactory httpClientFactory) {
      if (httpClientFactory == null) {
          throw new NullPointerException("httpClientFactory is null");
      }
      String factoryName = httpClientFactory.getClass().getName();
      NacosRestTemplate nacosRestTemplate = SINGLETON_REST.get(factoryName);
      if (nacosRestTemplate == null) {
          synchronized (SINGLETON_REST) {
              nacosRestTemplate = SINGLETON_REST.get(factoryName);
              if (nacosRestTemplate != null) {
                  return nacosRestTemplate;
              }
              nacosRestTemplate = httpClientFactory.createNacosRestTemplate();
              SINGLETON_REST.put(factoryName, nacosRestTemplate);
          }
      }
      return nacosRestTemplate;
  }

  而NamingHttpClientFactory是一個AbstractHttpClientFactory的實現類，由於NamingHttpClientProxy沒有重寫createNacosRestTemplate方法。所以最終引用的也就是AbstractHttpClientFactory的createNacosRestTemplate方法。

  private static final HttpClientFactory HTTP_CLIENT_FACTORY = new NamingHttpClientFactory();
  public NacosRestTemplate getNacosRestTemplate() {
      return HttpClientBeanHolder.getNacosRestTemplate(HTTP_CLIENT_FACTORY);
  }
  
  private static class NamingHttpClientFactory extends AbstractHttpClientFactory {
          
      @Override
      protected HttpClientConfig buildHttpClientConfig() {
          return HttpClientConfig.builder().setConTimeOutMillis(CON_TIME_OUT_MILLIS)
              .setReadTimeOutMillis(READ_TIME_OUT_MILLIS).setMaxRedirects(MAX_REDIRECTS).build();
      }
  
      @Override
      protected Logger assignLogger() {
          return NAMING_LOGGER;
      }
  }

  AbstractHttpClientFactory.createNacosRestTemplate

  @Override
  public NacosRestTemplate createNacosRestTemplate() {
      HttpClientConfig httpClientConfig = buildHttpClientConfig();
      final JdkHttpClientRequest clientRequest = new JdkHttpClientRequest(httpClientConfig);
  
      // enable ssl
      initTls(new BiConsumer<SSLContext, HostnameVerifier>() {
          @Override
          public void accept(SSLContext sslContext, HostnameVerifier hostnameVerifier) {
              clientRequest.setSSLContext(loadSSLContext());
              clientRequest.replaceSSLHostnameVerifier(hostnameVerifier);
          }
      }, new TlsFileWatcher.FileChangeListener() {
          @Override
          public void onChanged(String filePath) {
              clientRequest.setSSLContext(loadSSLContext());
          }
      });
  
      return new NacosRestTemplate(assignLogger(), clientRequest);
  }

  JdkHttpClientRequest clientRequest = new JdkHttpClientRequest(httpClientConfig);

  可以看到這裡定義了一個JdkHttpClientRequest 。

  再往下跟就到java.net.HttpURLConnection的呼叫，去請求nacos-server的地址，再往下的就不做分析了，進入了http的通訊層了。

  最終返回了一個結果，如果是200的話，就註冊成功了。失敗了就會丟擲異常。

  基於gRPC http2.0的註冊

  這裡同樣的從gRPC和http的委派來進行分析

  NamingClientProxyDelegate.registerService

  程式碼上邊已經分析過，我們直接進入gRPC的實現。

  @Override
  public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
      getExecuteClientProxy(instance).registerService(serviceName, groupName, instance);
  }

  • NamingGrpcClientProxy.registerService

    redoService.cacheInstanceForRedo 這個從名稱上看應該是重試機制，

  • @Override
    public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
        NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance {}", namespaceId, serviceName,
                           instance);
        redoService.cacheInstanceForRedo(serviceName, groupName, instance);
        doRegisterService(serviceName, groupName, instance);
    }

    • NamingGrpcRedoService.cacheInstanceForRedo

      這裡看起來只是給ConcurrentMap中存放一個redoData，並沒有其他的邏輯，後續可能會用到這個。回到主線，繼續往下走。

    • private final ConcurrentMap<String, InstanceRedoData> registeredInstances = new ConcurrentHashMap<>();
      public void cacheInstanceForRedo(String serviceName, String groupName, Instance instance) {
          String key = NamingUtils.getGroupedName(serviceName, groupName);
          InstanceRedoData redoData = InstanceRedoData.build(serviceName, groupName, instance);
          synchronized (registeredInstances) {
              registeredInstances.put(key, redoData);
          }
      }

      • NamingGrpcClientProxy.doRegisterService

        request是根據建構函式封裝的一個例項，requestToServer去進行註冊。

      • public void doRegisterService(String serviceName, String groupName, Instance instance) throws NacosException {
            InstanceRequest request = new InstanceRequest(namespaceId, serviceName, groupName,
                                                          NamingRemoteConstants.REGISTER_INSTANCE, instance);
            requestToServer(request, Response.class);
            redoService.instanceRegistered(serviceName, groupName);
        }

        NamingGrpcClientProxy.requestToServer

        request.putAllHeader推測是跟許可權校驗相關的，我搭建的沒有設定鑑權，所以都是空的。

        然後根據rpcClient去呼叫request方法。根據超時時間判斷的，這2個分支最終都會進入一個方法，預設是3s的超時時間。

        最終返回一個response結果。

        private <T extends Response> T requestToServer(AbstractNamingRequest request, Class<T> responseClass)
            throws NacosException {
            try {
                request.putAllHeader(
                    getSecurityHeaders(request.getNamespace(), request.getGroupName(), request.getServiceName()));
                Response response =
                    requestTimeout < 0 ? rpcClient.request(request) : rpcClient.request(request, requestTimeout);
                if (ResponseCode.SUCCESS.getCode() != response.getResultCode()) {
                    throw new NacosException(response.getErrorCode(), response.getMessage());
                }
                if (responseClass.isAssignableFrom(response.getClass())) {
                    return (T) response;
                }
                NAMING_LOGGER.error("Server return unexpected response '{}', expected response should be '{}'",
                                    response.getClass().getName(), responseClass.getName());
            } catch (Exception e) {
                throw new NacosException(NacosException.SERVER_ERROR, "Request nacos server failed: ", e);
            }
            throw new NacosException(NacosException.SERVER_ERROR, "Server return invalid response");
        }

        • RpcClient.request

        這裡的校驗暫且不看，直切主線， response = this.currentConnection.request(request, timeoutMills);

        再進入到request方法。

      • public Response request(Request request, long timeoutMills) throws NacosException {
            int retryTimes = 0;
            Response response;
            Exception exceptionThrow = null;
            long start = System.currentTimeMillis();
            while (retryTimes < RETRY_TIMES && System.currentTimeMillis() < timeoutMills + start) {
                boolean waitReconnect = false;
                try {
                    if (this.currentConnection == null || !isRunning()) {
                        waitReconnect = true;
                        throw new NacosException(NacosException.CLIENT_DISCONNECT,
                                                 "Client not connected, current status:" + rpcClientStatus.get());
                    }
                    response = this.currentConnection.request(request, timeoutMills);
                    if (response == null) {
                        throw new NacosException(SERVER_ERROR, "Unknown Exception.");
                    }
                    if (response instanceof ErrorResponse) {
                        if (response.getErrorCode() == NacosException.UN_REGISTER) {
                            synchronized (this) {
                                waitReconnect = true;
                                if (rpcClientStatus.compareAndSet(RpcClientStatus.RUNNING, RpcClientStatus.UNHEALTHY)) {
                                    LoggerUtils.printIfErrorEnabled(LOGGER,
                                                                    "Connection is unregistered, switch server, connectionId = {}, request = {}",
                                                                    currentConnection.getConnectionId(), request.getClass().getSimpleName());
                                    switchServerAsync();
                                }
                            }
        
                        }
                        throw new NacosException(response.getErrorCode(), response.getMessage());
                    }
                    // return response.
                    lastActiveTimeStamp = System.currentTimeMillis();
                    return response;
        
                } catch (Exception e) {
                    if (waitReconnect) {
                        try {
                            // wait client to reconnect.
                            Thread.sleep(Math.min(100, timeoutMills / 3));
                        } catch (Exception exception) {
                            // Do nothing.
                        }
                    }
        
                    LoggerUtils.printIfErrorEnabled(LOGGER, "Send request fail, request = {}, retryTimes = {}, errorMessage = {}",
                                                    request, retryTimes, e.getMessage());
        
                    exceptionThrow = e;
        
                }
                retryTimes++;
        
            }
        
            if (rpcClientStatus.compareAndSet(RpcClientStatus.RUNNING, RpcClientStatus.UNHEALTHY)) {
                switchServerAsyncOnRequestFail();
            }
        
            if (exceptionThrow != null) {
                throw (exceptionThrow instanceof NacosException) ? (NacosException) exceptionThrow
                    : new NacosException(SERVER_ERROR, exceptionThrow);
            } else {
                throw new NacosException(SERVER_ERROR, "Request fail, unknown Error");
            }
        }

        • GrpcConnection.request

        這裡的就是封裝的rpc請求，和服務端進行互動的邏輯。在這裡封裝了一個PayLoad類

      • @Override
        public Response request(Request request, long timeouts) throws NacosException {
            Payload grpcRequest = GrpcUtils.convert(request);
            ListenableFuture<Payload> requestFuture = grpcFutureServiceStub.request(grpcRequest);
            Payload grpcResponse;
            try {
                grpcResponse = requestFuture.get(timeouts, TimeUnit.MILLISECONDS);
            } catch (Exception e) {
                throw new NacosException(NacosException.SERVER_ERROR, e);
            }
        
            return (Response) GrpcUtils.parse(grpcResponse);
        }

        2、Nacos註冊原始碼分析-Server端

      • 接收註冊

        客戶端和服務端之間進行互動的話，一定需要建立一個網路連線。這裡的grpc的原始碼相對來說比較複雜，就簡單分析nacos相關的。

        工程名稱是nacos-console。

        BaseGrpcServer在啟動的時候會繫結很多的Handler。

      • 

         而基於grpc的通訊，會進入server端的InstanceRequestHandler

        InstanceRequestHandler.handle

        從handle方法中可以根據type走到registerInstance中。

        最終進入到EphemeralClientOperationServiceImpl.registerInstance

        public class InstanceRequestHandler extends RequestHandler<InstanceRequest, InstanceResponse> {
            
            private final EphemeralClientOperationServiceImpl clientOperationService;
            
            public InstanceRequestHandler(EphemeralClientOperationServiceImpl clientOperationService) {
                this.clientOperationService = clientOperationService;
            }
            
            @Override
            @Secured(action = ActionTypes.WRITE)
            public InstanceResponse handle(InstanceRequest request, RequestMeta meta) throws NacosException {
                Service service = Service
                        .newService(request.getNamespace(), request.getGroupName(), request.getServiceName(), true);
                switch (request.getType()) {
                    case NamingRemoteConstants.REGISTER_INSTANCE:
                        // 註冊
                        return registerInstance(service, request, meta);
                    case NamingRemoteConstants.DE_REGISTER_INSTANCE:
                        // 取消註冊
                        return deregisterInstance(service, request, meta);
                    default:
                        throw new NacosException(NacosException.INVALID_PARAM,
                                String.format("Unsupported request type %s", request.getType()));
                }
            }
            
            private InstanceResponse registerInstance(Service service, InstanceRequest request, RequestMeta meta)
                    throws NacosException {
                // 註冊例項
                clientOperationService.registerInstance(service, request.getInstance(), meta.getConnectionId());
                NotifyCenter.publishEvent(new RegisterInstanceTraceEvent(System.currentTimeMillis(),
                        meta.getClientIp(), true, service.getNamespace(), service.getGroup(), service.getName(),
                        request.getInstance().getIp(), request.getInstance().getPort()));
                return new InstanceResponse(NamingRemoteConstants.REGISTER_INSTANCE);
            }
            
            private InstanceResponse deregisterInstance(Service service, InstanceRequest request, RequestMeta meta) {
                clientOperationService.deregisterInstance(service, request.getInstance(), meta.getConnectionId());
                NotifyCenter.publishEvent(new DeregisterInstanceTraceEvent(System.currentTimeMillis(),
                        meta.getClientIp(), true, DeregisterInstanceReason.REQUEST, service.getNamespace(),
                        service.getGroup(), service.getName(), request.getInstance().getIp(), request.getInstance().getPort()));
                return new InstanceResponse(NamingRemoteConstants.DE_REGISTER_INSTANCE);
            }
        }

        EphemeralClientOperationServiceImpl.registerInstance

        這裡的clientManager.getClient(client)說明跳轉到下邊的建立長連線

      • @Override
        public void registerInstance(Service service, Instance instance, String clientId) throws NacosException {
            NamingUtils.checkInstanceIsLegal(instance);
            // 獲取一個單例的Service，也就是註冊的例項
            Service singleton = ServiceManager.getInstance().getSingleton(service);
            if (!singleton.isEphemeral()) {
                throw new NacosRuntimeException(NacosException.INVALID_PARAM,
                                                String.format("Current service %s is persistent service, can't register ephemeral instance.",
                                                              singleton.getGroupedServiceName()));
            }
            // 這裡的Client是客戶端的長連線，會進入到ClientManagerDelegate的一個委託，最終進入到connectionBasedClientManager中
            Client client = clientManager.getClient(clientId);
            if (!clientIsLegal(client, clientId)) {
                return;
            }
            InstancePublishInfo instanceInfo = getPublishInfo(instance);
            // 對這個例項進行註冊
            client.addServiceInstance(singleton, instanceInfo);
            client.setLastUpdatedTime();
            client.recalculateRevision();
            NotifyCenter.publishEvent(new ClientOperationEvent.ClientRegisterServiceEvent(singleton, clientId));
            NotifyCenter
                .publishEvent(new MetadataEvent.InstanceMetadataEvent(singleton, instanceInfo.getMetadataId(), false));
        }

        AbstractClient.addServiceInstance

      • // 這個ConcurrentHashMap就是儲存例項和釋出資訊關係的
        protected final ConcurrentHashMap<Service, InstancePublishInfo> publishers = new ConcurrentHashMap<>(16, 0.75f, 1);
        @Override
        public boolean addServiceInstance(Service service, InstancePublishInfo instancePublishInfo) {
            if (null == publishers.put(service, instancePublishInfo)) {
                if (instancePublishInfo instanceof BatchInstancePublishInfo) {
                    MetricsMonitor.incrementIpCountWithBatchRegister(instancePublishInfo);
                } else {
                    MetricsMonitor.incrementInstanceCount();
                }
            }
            // 這裡有一個事件，ClientChangeEvent
            NotifyCenter.publishEvent(new ClientEvent.ClientChangedEvent(this));
            Loggers.SRV_LOG.info("Client change for service {}, {}", service, getClientId());
            return true;
        }

        ClientServiceIndexesManager

      • // 應用Service和clientId的對映，一個應用Service有多個服務，所以會建立多個長連線，用Set來儲存clientId
        private final ConcurrentMap<Service, Set<String>> publisherIndexes = new ConcurrentHashMap<>();
        // 應用Service和訂閱者clientId的關係
        private final ConcurrentMap<Service, Set<String>> subscriberIndexes = new ConcurrentHashMap<>();
        @Override
        public void onEvent(Event event) {
            if (event instanceof ClientEvent.ClientDisconnectEvent) {
                handleClientDisconnect((ClientEvent.ClientDisconnectEvent) event);
            } else if (event instanceof ClientOperationEvent) {
                handleClientOperation((ClientOperationEvent) event);
            }
        }
        
        private void handleClientOperation(ClientOperationEvent event) {
            Service service = event.getService();
            String clientId = event.getClientId();
            if (event instanceof ClientOperationEvent.ClientRegisterServiceEvent) {
                // 註冊
                addPublisherIndexes(service, clientId);
            } else if (event instanceof ClientOperationEvent.ClientDeregisterServiceEvent) {
                // 取消註冊
                removePublisherIndexes(service, clientId);
            } else if (event instanceof ClientOperationEvent.ClientSubscribeServiceEvent) {
                // 訂閱
                addSubscriberIndexes(service, clientId);
            } else if (event instanceof ClientOperationEvent.ClientUnsubscribeServiceEvent) {
                // 取消訂閱
                removeSubscriberIndexes(service, clientId);
            }
        }

        建立長連線（這裡的過程比較難一些，還在持續學習中）

        GrpcBiStreamRequestAcceptor這個類是建立連線的。

        每一個grpc請求過來後，都會進入到GrpcBiStreamRequestAcceptor.requestBiStream的方法中。

        而會話的長連線id就是這裡的ConnectionId。

        @Service
        public class GrpcBiStreamRequestAcceptor extends BiRequestStreamGrpc.BiRequestStreamImplBase {
             @Autowired
            ConnectionManager connectionManager;
            
            private void traceDetailIfNecessary(Payload grpcRequest) {
                String clientIp = grpcRequest.getMetadata().getClientIp();
                String connectionId = CONTEXT_KEY_CONN_ID.get();
                try {
                    if (connectionManager.traced(clientIp)) {
                        Loggers.REMOTE_DIGEST.info("[{}]Bi stream request receive, meta={},body={}", connectionId,
                                grpcRequest.getMetadata().toByteString().toStringUtf8(),
                                grpcRequest.getBody().toByteString().toStringUtf8());
                    }
                } catch (Throwable throwable) {
                    Loggers.REMOTE_DIGEST.error("[{}]Bi stream request error,payload={},error={}", connectionId,
                            grpcRequest.toByteString().toStringUtf8(), throwable);
                }
                
            }
            @Override
            public StreamObserver<Payload> requestBiStream(StreamObserver<Payload> responseObserver) {
                
                StreamObserver<Payload> streamObserver = new StreamObserver<Payload>() {
                    
                    final String connectionId = CONTEXT_KEY_CONN_ID.get();
                    
                    final Integer localPort = CONTEXT_KEY_CONN_LOCAL_PORT.get();
                    
                    final int remotePort = CONTEXT_KEY_CONN_REMOTE_PORT.get();
                    
                    String remoteIp = CONTEXT_KEY_CONN_REMOTE_IP.get();
                    
                    String clientIp = "";
                    
                    @Override
                    public void onNext(Payload payload) {
                        
                        clientIp = payload.getMetadata().getClientIp();
                        traceDetailIfNecessary(payload);
                        
                        Object parseObj;
                        try {
                            parseObj = GrpcUtils.parse(payload);
                        } catch (Throwable throwable) {
                            Loggers.REMOTE_DIGEST
                                    .warn("[{}]Grpc request bi stream,payload parse error={}", connectionId, throwable);
                            return;
                        }
                        
                        if (parseObj == null) {
                            Loggers.REMOTE_DIGEST
                                    .warn("[{}]Grpc request bi stream,payload parse null ,body={},meta={}", connectionId,
                                            payload.getBody().getValue().toStringUtf8(), payload.getMetadata());
                            return;
                        }
                        if (parseObj instanceof ConnectionSetupRequest) {
                            ConnectionSetupRequest setUpRequest = (ConnectionSetupRequest) parseObj;
                            Map<String, String> labels = setUpRequest.getLabels();
                            String appName = "-";
                            if (labels != null && labels.containsKey(Constants.APPNAME)) {
                                appName = labels.get(Constants.APPNAME);
                            }
                            
                            ConnectionMeta metaInfo = new ConnectionMeta(connectionId, payload.getMetadata().getClientIp(),
                                    remoteIp, remotePort, localPort, ConnectionType.GRPC.getType(),
                                    setUpRequest.getClientVersion(), appName, setUpRequest.getLabels());
                            metaInfo.setTenant(setUpRequest.getTenant());
                            Connection connection = new GrpcConnection(metaInfo, responseObserver, CONTEXT_KEY_CHANNEL.get());
                            connection.setAbilities(setUpRequest.getAbilities());
                            boolean rejectSdkOnStarting = metaInfo.isSdkSource() && !ApplicationUtils.isStarted();
                            // 這裡會有一個connectionManager.register
                            if (rejectSdkOnStarting || !connectionManager.register(connectionId, connection)) {
                                //Not register to the connection manager if current server is over limit or server is starting.
                                try {
                                    Loggers.REMOTE_DIGEST.warn("[{}]Connection register fail,reason:{}", connectionId,
                                            rejectSdkOnStarting ? " server is not started" : " server is over limited.");
                                    connection.request(new ConnectResetRequest(), 3000L);
                                    connection.close();
                                } catch (Exception e) {
                                    //Do nothing.
                                    if (connectionManager.traced(clientIp)) {
                                        Loggers.REMOTE_DIGEST
                                                .warn("[{}]Send connect reset request error,error={}", connectionId, e);
                                    }
                                }
                            }
                            
                        } else if (parseObj instanceof Response) {
                            Response response = (Response) parseObj;
                            if (connectionManager.traced(clientIp)) {
                                Loggers.REMOTE_DIGEST
                                        .warn("[{}]Receive response of server request  ,response={}", connectionId, response);
                            }
                            RpcAckCallbackSynchronizer.ackNotify(connectionId, response);
                            connectionManager.refreshActiveTime(connectionId);
                        } else {
                            Loggers.REMOTE_DIGEST
                                    .warn("[{}]Grpc request bi stream,unknown payload receive ,parseObj={}", connectionId,
                                            parseObj);
                        }
                        
                    }
                    
                    @Override
                    public void onError(Throwable t) {
                        if (connectionManager.traced(clientIp)) {
                            Loggers.REMOTE_DIGEST.warn("[{}]Bi stream on error,error={}", connectionId, t);
                        }
                        
                        if (responseObserver instanceof ServerCallStreamObserver) {
                            ServerCallStreamObserver serverCallStreamObserver = ((ServerCallStreamObserver) responseObserver);
                            if (serverCallStreamObserver.isCancelled()) {
                                //client close the stream.
                            } else {
                                try {
                                    serverCallStreamObserver.onCompleted();
                                } catch (Throwable throwable) {
                                    //ignore
                                }
                            }
                        }
                        
                    }
                    
                    @Override
                    public void onCompleted() {
                        if (connectionManager.traced(clientIp)) {
                            Loggers.REMOTE_DIGEST.warn("[{}]Bi stream on completed", connectionId);
                        }
                        if (responseObserver instanceof ServerCallStreamObserver) {
                            ServerCallStreamObserver serverCallStreamObserver = ((ServerCallStreamObserver) responseObserver);
                            if (serverCallStreamObserver.isCancelled()) {
                                //client close the stream.
                            } else {
                                try {
                                    serverCallStreamObserver.onCompleted();
                                } catch (Throwable throwable) {
                                    //ignore
                                }
                                
                            }
                        }
                    }
                };
                
                return streamObserver;
            }
        }

        • ConnectionManager.register

          這裡的connections是用來管理所有的長連線的

        • Map<String, Connection> connections = new ConcurrentHashMap<>();
          
          public synchronized boolean register(String connectionId, Connection connection) {
          
              if (connection.isConnected()) {
                  String clientIp = connection.getMetaInfo().clientIp;
                  if (connections.containsKey(connectionId)) {
                      return true;
                  }
                  if (checkLimit(connection)) {
                      return false;
                  }
                  if (traced(clientIp)) {
                      connection.setTraced(true);
                  }
                  connections.put(connectionId, connection);
                  if (!connectionForClientIp.containsKey(clientIp)) {
                      connectionForClientIp.put(clientIp, new AtomicInteger(0));
                  }
                  connectionForClientIp.get(clientIp).getAndIncrement();
          
                  clientConnectionEventListenerRegistry.notifyClientConnected(connection);
          
                  LOGGER.info("new connection registered successfully, connectionId = {},connection={} ", connectionId,
                              connection);
                  return true;
          
              }
              return false;
          }