### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

- 在文章[《Spring Cloud原始碼分析之Eureka篇第四章：服務註冊是如何發起的 》](http://blog.itpub.net/70017844/viewspace-2904968/)的分析中，我們知道了作為Eureka Client的應用啟動時，在com.netflix.discovery.DiscoveryClient類的initScheduledTasks方法中，會做以下幾件事： 
1. 週期性更新服務列表； 
2. 週期性的服務續約； 
3. 服務註冊邏輯；

- 本章學習的是**週期性的服務續約**的相關程式碼，對應用如何將自身資訊註冊到Eureka進行深入瞭解

### 概覽
- 以下圖片來自Netflix官方，圖中顯示Eureka Client會發起Renew向註冊中心做週期性續約，這樣其他Eureka client透過Get Registry請求就能獲取到新註冊應用的相關資訊：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220710/1657411217517852076.png)

### 關於原始碼版本
- 本次分析的Spring Cloud版本為Edgware.RELEASE，對應的eureka-client版本為1.7.0；

### 來自官方文件的指導資訊
- 最準確的說明資訊來自Netflix的官方文件，地址：https://github.com/Netflix/eureka/wiki/Understanding-eureka-client-server-communication#renew
- 學習原始碼之前先看文件可以確定大方向，不會因為陷入原始碼細節導致偏離學習目標，如下圖所示：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220710/1657411232452559344.png)

- 我的理解：
1. Eureka client每隔三十秒傳送一次心跳到Eureka server，這就是續約；
2. Eureka client續約的目的是告訴Eureka server自己還活著；
3. Eureka server若90秒內未收到心跳，就從自己的服務列表中剔除該Eureka client；
4. 建議不要改變心跳間隔，因為Eureka server是透過心跳來判斷Eureka client是否正常；

### 原始碼分析
- 首先回顧com.netflix.discovery.DiscoveryClient類的initScheduledTasks方法，Eureka client在啟動的時侯都會執行此方法，如下方所示，已經略去了週期性更新服務列表相關的程式碼：

```java
private void initScheduledTasks() {
        //略去獲取服務列表相關程式碼
        ...

if (clientConfig.shouldRegisterWithEureka()) {
            //心跳間隔
            int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
            //週期性任務執行超時的時候，會將超時時間翻倍，但不會超過最大時間，這個最大時間是由expBackOffBound決定的
            int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
            logger.info("Starting heartbeat executor: " + "renew interval is: " + renewalIntervalInSecs);

//啟動心跳的週期性任務
            scheduler.schedule(
                    new TimedSupervisorTask(
                            "heartbeat",
                            scheduler,
                            heartbeatExecutor,
                            renewalIntervalInSecs,
                            TimeUnit.SECONDS,
                            expBackOffBound,
                            new HeartbeatThread()
                    ),
                    renewalIntervalInSecs, TimeUnit.SECONDS);
                    
        //略去服務註冊相關程式碼
        ...
```
- 上述程式碼可以看出，續租邏輯在HeartbeatThread例項中，交給TimedSupervisorTask例項進行週期性呼叫，有關TimedSupervisorTask的功能和細節，請參考[《Eureka的TimedSupervisorTask類（自動調節間隔的週期性任務）》](http://blog.itpub.net/70017844/viewspace-2901427/)；

- HeartbeatThread類中，透過呼叫renew方法實現續租，如下程式碼所示，方法註釋已說明是Restfult請求來實現的，對應Eureka server的返回資訊httpResponse，除了檢查返回碼是否等於200就沒有任何作用了，想想也是如此，30秒一次的心跳，不論是請求還是響應都應該儘量簡潔，降低伺服器和網路的壓力：

```java
/**
     * Renew with the eureka service by making the appropriate REST call
     */
    boolean renew() {
        EurekaHttpResponse<instanceinfo> httpResponse;
        try {
            //發Restful請求，即心跳
            httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);
            logger.debug("{} - Heartbeat status: {}", PREFIX + appPathIdentifier, httpResponse.getStatusCode());
            //404錯誤會觸發註冊邏輯
            if (httpResponse.getStatusCode() == 404) {
                REREGISTER_COUNTER.increment();
                logger.info("{} - Re-registering apps/{}", PREFIX + appPathIdentifier, instanceInfo.getAppName());
                return register();
            }
            //返回碼200表示心跳成功
            return httpResponse.getStatusCode() == 200;
        } catch (Throwable e) {
            logger.error("{} - was unable to send heartbeat!", PREFIX + appPathIdentifier, e);
            return false;
        }
    }
```

- 繼續展開上面程式碼段中的**eurekaTransport.registrationClient.sendHeartBeat**方法，原始碼在EurekaHttpClientDecorator類中：

```java
@Override
    public EurekaHttpResponse<instanceinfo> sendHeartBeat(final String appName,
                                                          final String id,
                                                          final InstanceInfo info,
                                                          final InstanceStatus overriddenStatus) {
        return execute(new RequestExecutor<instanceinfo>() {
            @Override
            public EurekaHttpResponse<instanceinfo> execute(EurekaHttpClient delegate) {
                //網路處理委託給代理類完成
                return delegate.sendHeartBeat(appName, id, info, overriddenStatus);
            }

@Override
            public RequestType getRequestType() {
                //請求型別為心跳
                return RequestType.SendHeartBeat;
            }
        });
    }
```

- 繼續展開delegate.sendHeartBeat，多層呼叫一路展開，最終由JerseyApplicationClient類來完成操作，對應原始碼在父類AbstractJerseyEurekaHttpClient中，如下所示，主要工作是利用jersey庫的Restful Api將自身的資訊PUT到Eureka server，注意：這裡不是POST，也不是GET，而是PUT：

```java
    @Override
    public EurekaHttpResponse<instanceinfo> sendHeartBeat(String appName, String id, InstanceInfo info, InstanceStatus overriddenStatus) {
        String urlPath = "apps/" + appName + '/' + id;
        ClientResponse response = null;
        try {
            //請求引數有兩個：Eureka client自身狀態、自身關鍵資訊（狀態、後設資料等）最後一次變化的時間
            WebResource webResource = jerseyClient.resource(serviceUrl)
                    .path(urlPath)
                    .queryParam("status", info.getStatus().toString())
                    .queryParam("lastDirtyTimestamp", info.getLastDirtyTimestamp().toString());
            if (overriddenStatus != null) {
                webResource = webResource.queryParam("overriddenstatus", overriddenStatus.name());
            }
            Builder requestBuilder = webResource.getRequestBuilder();
            addExtraHeaders(requestBuilder);
            //注意：這裡不是POST，也不是GET，而是PUT
            response = requestBuilder.put(ClientResponse.class);
            EurekaHttpResponseBuilder<instanceinfo> eurekaResponseBuilder = anEurekaHttpResponse(response.getStatus(), InstanceInfo.class).headers(headersOf(response));
            if (response.hasEntity()) {
                eurekaResponseBuilder.entity(response.getEntity(InstanceInfo.class));
            }
            return eurekaResponseBuilder.build();
        } finally {
            if (logger.isDebugEnabled()) {
                logger.debug("Jersey HTTP PUT {}/{}; statusCode={}", serviceUrl, urlPath, response == null ? "N/A" : response.getStatus());
            }
            if (response != null) {
                response.close();
            }
        }
    }
```

- 至此，Eureka client向服務續租的原始碼就分析完畢了，過程相對簡單，DiscoveryClient、TimedSupervisorTask、JerseyApplicationClient等例項各司其職，定時傳送PUT請求到Eureka server；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</instanceinfo></instanceinfo></instanceinfo></instanceinfo></instanceinfo></instanceinfo>

Spring Cloud原始碼分析之Eureka篇第七章：續約

相關文章