SpringCloud 源碼系列（1）—— 注冊中心 Eureka（上）

SpringCloud 源碼系列（1）—— 注冊中心 Eureka（上）

SpringCloud 源碼系列（2）—— 注冊中心 Eureka（中）

SpringCloud 源碼系列（3）—— 注冊中心 Eureka（下）

 

Eureka 是 Netflix 公司開源的一個服務注冊與發現的組件，和其他 Netflix 公司的服務組件（例如負載均衡、熔斷器、網關等）一起，被 Spring Cloud 整合為 Spring Cloud Netflix 模塊。不過 Eureka 2.0 開始閉源了，但 1.x 還在繼續維護中，可以繼續使用。這篇文章就來深入學習下 Eureka 注冊中心，便於我們更好的使用和調優注冊中心。

關於版本：本文章使用的 Spring cloud 版本為 Hoxton.SR8，Spring boot 版本為 2.3.3.RELEASE，依賴的 eureka 版本則為 1.9.25。

一、Eureka 初體驗

Eureka 分為 Eureka Server 和 Eureka Client，Eureka Server 為 Eureka 注冊中心，Eureka Client 為 Eureka 客戶端。這節先通過demo把注冊中心的架子搭起來，看看注冊中心的基礎架構。

1、Eureka Server

① 創建注冊中心服務：sunny-register

首先創建一個 maven 工程，服務名稱為 sunny-register，並在 pom.xml 中引入注冊中心服務端的依賴。

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

② 添加配置文件

在 resources 下添加 application.yml 配置文件，並添加注冊中心相關配置。

server:
  port: 8000
spring:
  application:
    name: sunny-register

eureka:
  instance:
    hostname: dev.lyyzoo.com
  client:
    # 是否向注冊中心注冊自己
    register-with-eureka: false
    # 是否檢索服務
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

③ 添加啟動類

添加啟動類，並在啟動類上加上 @EnableEurekaServer 注解，啟用注冊中心。

package com.lyyzoo.sunny.register;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@EnableEurekaServer
@SpringBootApplication
public class RegisterApplication {

    public static void main(String[] args) {
        SpringApplication.run(RegisterApplication.class, args);
    }
}

④ 啟動注冊中心

啟動注冊中心后，訪問 http://dev.lyyzoo.com:8000/，就可以看到注冊中心的頁面了，現在還沒有實例注冊上來。（dev.lyyzoo.com 在本地 hosts 文件中映射到 127.0.0.1）

2、Eureka Client

創建兩個 demo 服務，demo-producer 服務作為生產者提供一個接口，demo-consumer 服務作為消費者去調用 demo-producer 的接口。

① 創建客戶端服務：demo-producer

創建maven工程，服務名稱為 demo-producer，在 pom.xml 中引入注冊中心客戶端的依賴，並添加了 web 的依賴。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

② 添加配置文件

在 resouces 下添加 application.yml 配置文件，添加注冊中心客戶端相關的配置。

server:
  port: 8010
spring:
  application:
    name: demo-producer

eureka:
  client:
    serviceUrl:
      defaultZone: ${EUREKA_DEFAULT_ZONE:http://dev.lyyzoo.com:8000/eureka}

③ 添加啟動類

添加啟動類，並在啟動類上加上 @EnableEurekaClient 注解，啟用客戶端。

@EnableEurekaClient
@SpringBootApplication
public class ProducerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class, args);
    }
}

④ 添加一個 rest 接口

添加一個接口用於測試調用：

@RestController
public class DemoController {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @GetMapping("/v1/uuid")
    public ResponseEntity<String> getUUID() {
        String uuid = UUID.randomUUID().toString();
        logger.info("generate uuid: {}", uuid);
        return ResponseEntity.ok(uuid);
    }
}

⑤  創建客戶端服務：demo-consumer

類似的方式，再創建消費者服務：demo-producer，這個服務中添加一個消費者接口，通過 RestTemplate 負載均衡的方式來調用 demo-producer 的接口。

因此需要先配置一個帶有負載均衡的 RestTemplate：

@EnableEurekaClient
@SpringBootApplication
public class ConsumerApplication {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

添加消費者接口，注意這里 url 是寫的服務名稱，並不是具體的 ip 地址或端口，在微服務場景下，服務間調用也不可能寫死某個具體的地址。

@RestController
public class DemoController {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/v1/id")
    public ResponseEntity<String> getId() {
        ResponseEntity<String> result = restTemplate.getForEntity("http://demo-producer/v1/uuid", String.class);
        String uuid = result.getBody();
        logger.info("request id: {}", uuid);
        return ResponseEntity.ok(uuid);
    }
}

⑥ 啟動注冊中心客戶端

以兩個不同的端口啟動 demo-producer，可以通過環境變量的方式制定端口。然后再啟動 demo-consumer。

啟動完成之后，就可以在注冊中心看到注冊上來的兩個 demo-producer 實例和一個 demo-consumer 實例，並且狀態都為 UP。

⑦ 測試接口

調用消費者服務的接口，多次訪問 http://dev.lyyzoo.com:8020/v1/id 接口，會發現生產者服務 demo-consumer 兩個實例的控制台會交替的輸出日志信息。這就說明消費者客戶端通過服務名稱訪問到生產者了。

3、Eureka 基礎架構

通過前面的體驗，可以發現，服務間調用只需知道某個服務的名稱就可以調用這個服務的api了，而不需要指定具體的ip地址和端口，那這是怎么做到的呢？

不難看出，Eureka 的基礎架構包含三種角色：

• 服務注冊中心：Eureka Server，提供服務注冊和發現的功能
• 服務提供者：Eureka Client，提供服務（本身也可以作為消費者）
• 服務消費者：Eureka Client，消費服務（本身也可以作為提供者）

首先需要一個服務注冊中心，客戶端則向注冊中心注冊，將自己的信息（比如服務名、服務的 IP 地址和端口信息等）提交給注冊中心。客戶端向注冊中心獲取一份服務注冊列表的信息，該列表包含了所有向注冊中心注冊的服務信息。獲取服務注冊列表信息之后，客戶端服務就可以根據服務名找到服務的所有實例，然后通過負載均衡選擇其中一個實例，根據其 IP 地址和端口信息，就可以調用服務的API接口了。

這就是注冊中心最基礎的架構和功能了，提供服務注冊和發現，為各個客戶端提供服務注冊列表信息。但為了完成這些工作，Eureka 有很多的機制來實現以及保證其高可用，如服務注冊、服務續約、獲取服務注冊列表、服務下線、服務剔除等等。Eureka 也提供了很多參數讓我們可以根據實際的場景來優化它的一些功能和配置，比如維持心跳的時間、拉取注冊表的間隔時間、自我保護機制等等。下面我們就從 eureka 的源碼層面來分析下 eureka 的這些功能以及參數，理解其原理，學習它的一些設計。

二、Eureka 源碼准備

雖然我們在 pom.xml 中依賴的是 spring-cloud-starter-netflix-eureka-server 和 spring-cloud-starter-netflix-eureka-client，但 spring-cloud-starter-netflix 只是對 eureka 做了封裝，使得其可以通過 springboot 的方式來啟動和初始化，其底層其實是 netflix 的 eureka-core、eureka-client 等。所以我們先分析 netflix eureka 的源碼，最后再看看 spring-cloud-starter-netflix 的源碼。

1、源碼環境准備

① 下載源碼

Netflix Eureka：https://github.com/Netflix/eureka

Spring Cloud Netflix：https://github.com/spring-cloud/spring-cloud-netflix

克隆 eureka 的源碼到本地：

$ git clone https://github.com/Netflix/eureka.git

由於我們依賴的是 1.9.25 版本，將代碼克隆到本地后，將其切換到 1.9.25：

$ git checkout -b 1.9.25

然后到 eureka 根目錄下執行構建的命令：

$ ./gradlew clean build -x test

② IDEA 打開源碼

由於 eureka 使用 gradle 管理依賴，所以本地需要先安裝 gradle，之后 IDEA 中也需要安裝 gradle 的插件，跟 maven 都是類似的，安裝教程可自行百度。

2、Eureka 工程結構

Eureka 主要包含如下模塊：

• eureka-client：eureka 客戶端
• eureka-core：eureka 服務端，注冊中心的核心功能
• eureka-resources：基於jsp的eureka控制台，可以查看注冊了哪些服務實例
• eureka-server：注冊中心，集成了 eureka-client、eureka-core、eureka-resources，因為依賴了 eureka-client，因此 eureka-server 也是一個客戶端，在 eureka server 集群模式下，eureka-server 也會作為客戶端注冊到其它注冊中心上
• eureka-examples：eureka 例子
• eureka-test-utils：eureka 單元測試工具
• eureka-core|client-jersey2：對 jersey 框架的封裝，jersey 類似於 spring mvc，支持 http restful 請求，eureka-client 和 eureka-server 之間的通信就是基於 jersey 框架來的

三、Eureka Server 啟動初始化

首先要看的是 eureka-server，注冊中心啟起來之后，客戶端才能來注冊服務和發現服務。

1、eureka-server 模塊

① eureka-server 目錄

• resources 目錄中主要是 eureka client 和 server 的配置文件
• webapp 下有一個 web.xml 配置文件，這里面就配置了啟動初始化的入口，從這也可以看出，eureka-server 會被打包成 war 包來運行
• test 下有個單元測試類 EurekaClientServerRestIntegrationTest，這里面就包含了服務注冊、續約、下線等單元測試，我們就可以運行這些單元測試來調試代碼

② web.xml

web.xml 的內容：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <!-- eureka 啟動初始化類 -->
  <listener>
    <listener-class>com.netflix.eureka.EurekaBootStrap</listener-class>
  </listener>

  <!-- 狀態過濾器 -->
  <filter>
    <filter-name>statusFilter</filter-name>
    <filter-class>com.netflix.eureka.StatusFilter</filter-class>
  </filter>

  <!-- 認證過濾器 -->
  <filter>
    <filter-name>requestAuthFilter</filter-name>
    <filter-class>com.netflix.eureka.ServerRequestAuthFilter</filter-class>
  </filter>

  <!-- 限流過濾器 -->
  <filter>
    <filter-name>rateLimitingFilter</filter-name>
    <filter-class>com.netflix.eureka.RateLimitingFilter</filter-class>
  </filter>
  <filter>
    <filter-name>gzipEncodingEnforcingFilter</filter-name>
    <filter-class>com.netflix.eureka.GzipEncodingEnforcingFilter</filter-class>
  </filter>

  <!-- jersey 容器 -->
  <filter>
    <filter-name>jersey</filter-name>
    <filter-class>com.sun.jersey.spi.container.servlet.ServletContainer</filter-class>
    <init-param>
      <param-name>com.sun.jersey.config.property.WebPageContentRegex</param-name>
      <param-value>/(flex|images|js|css|jsp)/.*</param-value>
    </init-param>
    <init-param>
      <param-name>com.sun.jersey.config.property.packages</param-name>
      <param-value>com.sun.jersey;com.netflix</param-value>
    </init-param>

    <!-- GZIP content encoding/decoding -->
    <init-param>
      <param-name>com.sun.jersey.spi.container.ContainerRequestFilters</param-name>
      <param-value>com.sun.jersey.api.container.filter.GZIPContentEncodingFilter</param-value>
    </init-param>
    <init-param>
      <param-name>com.sun.jersey.spi.container.ContainerResponseFilters</param-name>
      <param-value>com.sun.jersey.api.container.filter.GZIPContentEncodingFilter</param-value>
    </init-param>
  </filter>

  <filter-mapping>
    <filter-name>statusFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <filter-mapping>
    <filter-name>requestAuthFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- Uncomment this to enable rate limiter filter.
  <filter-mapping>
    <filter-name>rateLimitingFilter</filter-name>
    <url-pattern>/v2/apps</url-pattern>
    <url-pattern>/v2/apps/*</url-pattern>
  </filter-mapping>
  -->

  <filter-mapping>
    <filter-name>gzipEncodingEnforcingFilter</filter-name>
    <url-pattern>/v2/apps</url-pattern>
    <url-pattern>/v2/apps/*</url-pattern>
  </filter-mapping>

  <filter-mapping>
    <filter-name>jersey</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- 歡迎頁 -->
  <welcome-file-list>
    <welcome-file>jsp/status.jsp</welcome-file>
  </welcome-file-list>

</web-app>

web.xml 中可以得知如下信息：

• eureka server 啟動時首先通過 com.netflix.eureka.EurekaBootStrap 類來進行啟動初始化相關的工作
• 配置了 StatusFilter（server 狀態過濾器）、ServerRequestAuthFilter（認證過濾器）、RateLimitingFilter（限流過濾器） 等過濾器，但 RateLimitingFilter 默認沒有啟用
• 配置了 jersey 的 servlet 容器，其實就跟 springframework 的 DispatcherServlet 是類似的，用來攔截處理 http restful 請求，這塊我們不用過於關注
• 最后還配置了 eureka server 的歡迎頁為 jsp/status.jsp 頁面，這個頁面在 eureka-resources 模塊下，也就是前面看到的 eureka 控制台頁面

③ 單元測試類 EurekaClientServerRestIntegrationTest

首先看 setUp 方法，每個測試用例運行之前都會先運行 setUp 方法來初始化運行環境。

@BeforeClass
public static void setUp() throws Exception {
    // 初始化 eureka 配置
    injectEurekaConfiguration();
    // 啟動 eureka server，會找 build/libs 目錄下的 eureka-server.*.war 包來運行
    // 這一步啟動時，就會加載 web.xm 配置文件，然后進入 EurekaBootStrap 初始化類
    startServer();
    // eureka server 配置
    createEurekaServerConfig();

    // 創建 jersey 客戶端，使用 jersey 客戶端來調用資源
    httpClientFactory = JerseyEurekaHttpClientFactory.newBuilder()
            .withClientName("testEurekaClient")
            .withConnectionTimeout(1000)
            .withReadTimeout(1000)
            .withMaxConnectionsPerHost(1)
            .withMaxTotalConnections(1)
            .withConnectionIdleTimeout(1000)
            .build();

    jerseyEurekaClient = httpClientFactory.newClient(new DefaultEndpoint(eurekaServiceUrl));

    ServerCodecs serverCodecs = new DefaultServerCodecs(eurekaServerConfig);
    jerseyReplicationClient = JerseyReplicationClient.createReplicationClient(
            eurekaServerConfig,
            serverCodecs,
            eurekaServiceUrl
    );
}

這個類提供了如下的一些測試用例，我們可以運行這些測試用例來進行調試。

2、EurekaBootStrap 初始化

EurekaBootStrap 是監聽器的入口，實現了 ServletContextListener 接口，主要完成了 eureka server 的啟動初始化。

從 contextInitialized 方法進去，整體上來說，分為 eureka 環境初始化和 eureka server 上下文初始化。

@Override
public void contextInitialized(ServletContextEvent event) {
    try {
        // eureka 環境初始化
        initEurekaEnvironment();
        // eureka server 上下文初始化
        initEurekaServerContext();

        ServletContext sc = event.getServletContext();
        sc.setAttribute(EurekaServerContext.class.getName(), serverContext);
    } catch (Throwable e) {
        logger.error("Cannot bootstrap eureka server :", e);
        throw new RuntimeException("Cannot bootstrap eureka server :", e);
    }
}

① eureka環境初始化

initEurekaEnvironment 方法內主要是設置數據中心和運行環境參數：

• archaius.deployment.datacenter = default
• archaius.deployment.environment = test

② eureka server 上下文初始化

initEurekaServerContext 上下文初始化則包含了很多階段：

• 構造 eureka 注冊中心配置：EurekaServerConfig
• 構造 eureka 實例配置：EurekaInstanceConfig
• 構造實例信息：InstanceInfo
• 構造實例管理器：ApplicationInfoManager 
• 構造 eureka 客戶端配置：EurekaClientConfig
• 創建 eureka 客戶端：EurekaClient（DiscoveryClient）
• 創建注冊表（可以感知eureka集群的注冊表）：PeerAwareInstanceRegistry
• 創建集群：PeerEurekaNodes
• 將信息封裝到eureka上下文：EurekaServerContext
• 將eureka上下文放到一個全局容器中：EurekaServerContextHolder
• 初始化eureka上下文
• 同步eureka server的注冊表
• 開啟追蹤
• 注冊監控統計

protected void initEurekaServerContext() throws Exception {
    // 1、eureka 注冊中心配置
    EurekaServerConfig eurekaServerConfig = new DefaultEurekaServerConfig();

    // For backward compatibility
    JsonXStream.getInstance().registerConverter(new V1AwareInstanceInfoConverter(), XStream.PRIORITY_VERY_HIGH);
    XmlXStream.getInstance().registerConverter(new V1AwareInstanceInfoConverter(), XStream.PRIORITY_VERY_HIGH);

    logger.info("Initializing the eureka client...");
    logger.info(eurekaServerConfig.getJsonCodecName());
    ServerCodecs serverCodecs = new DefaultServerCodecs(eurekaServerConfig);

    ApplicationInfoManager applicationInfoManager = null;

    if (eurekaClient == null) {
        // 2、eureka 實例配置
        EurekaInstanceConfig instanceConfig = isCloud(ConfigurationManager.getDeploymentContext())
                ? new CloudInstanceConfig()
                : new MyDataCenterInstanceConfig();

        // 3、構造 InstanceInfo 實例信息
        // 4、構造 ApplicationInfoManager 應用管理器
        applicationInfoManager = new ApplicationInfoManager(
                instanceConfig, new EurekaConfigBasedInstanceInfoProvider(instanceConfig).get());

        // 5、eureka 客戶端配置
        EurekaClientConfig eurekaClientConfig = new DefaultEurekaClientConfig();
        // 6、構造 EurekaClient，DiscoveryClient 封裝了客戶端相關的操作
        eurekaClient = new DiscoveryClient(applicationInfoManager, eurekaClientConfig);
    } else {
        applicationInfoManager = eurekaClient.getApplicationInfoManager();
    }

    PeerAwareInstanceRegistry registry;
    if (isAws(applicationInfoManager.getInfo())) {
        registry = new AwsInstanceRegistry(
                eurekaServerConfig,
                eurekaClient.getEurekaClientConfig(),
                serverCodecs,
                eurekaClient
        );
        awsBinder = new AwsBinderDelegate(eurekaServerConfig, eurekaClient.getEurekaClientConfig(), registry, applicationInfoManager);
        awsBinder.start();
    } else {
        // 7、構造感知eureka集群的注冊表
        registry = new PeerAwareInstanceRegistryImpl(
                eurekaServerConfig,
                eurekaClient.getEurekaClientConfig(),
                serverCodecs,
                eurekaClient
        );
    }

    // 8、構造eureka-server集群信息
    PeerEurekaNodes peerEurekaNodes = getPeerEurekaNodes(
            registry,
            eurekaServerConfig,
            eurekaClient.getEurekaClientConfig(),
            serverCodecs,
            applicationInfoManager
    );

    // 9、基於前面構造的對象創建 EurekaServerContext
    serverContext = new DefaultEurekaServerContext(
            eurekaServerConfig,
            serverCodecs,
            registry,
            peerEurekaNodes,
            applicationInfoManager
    );

    // 將 serverContext 放到 EurekaServerContextHolder 上下文中，
    // 這樣其它地方都可以通過 EurekaServerContextHolder 拿到 EurekaServerContext
    EurekaServerContextHolder.initialize(serverContext);

    // 10、初始化eureka-server上下文
    serverContext.initialize();
    logger.info("Initialized server context");

    // 11、從相鄰的eureka-server同步注冊表
    int registryCount = registry.syncUp();
    ///12、啟動注冊表，啟動一些定時任務
    registry.openForTraffic(applicationInfoManager, registryCount);

    ///13、注冊監控統計
    EurekaMonitors.registerAllStats();
}

3、面向接口的配置讀取

初始化中有三個配置接口，EurekaServerConfig、EurekaInstanceConfig、EurekaClientConfig，分別對應了注冊中心、eureka實例、eureka客戶端的配置獲取。

從它們默認實現類的構造方法進去可以看到，EurekaServerConfig 是讀取的 eureka-server.properties 配置文件，命名前綴是 eureka.server；EurekaInstanceConfig、EurekaClientConfig 是讀取的 eureka-client.properties 配置文件，命名前綴分別是 eureka.instance、eureka.client。

這里可以看到，eureka 在代碼中獲取配置的方式是通過接口方法的形式來獲取的，在其默認的實現類里通過硬編碼的方式定義了配置的編碼以及默認值。這種基於接口的配置讀取方式是可以借鑒的，這種方式讀取配置更易於維護，不用維護一堆常量，如果配置編碼變了只需更改實現類即可。

例如下面的配置：

@Override
public int getExpectedClientRenewalIntervalSeconds() {
    final int configured = configInstance.getIntProperty(
            namespace + "expectedClientRenewalIntervalSeconds",
            30).get();
    return configured > 0 ? configured : 30;
}

@Override
public double getRenewalPercentThreshold() {
    return configInstance.getDoubleProperty(
            namespace + "renewalPercentThreshold", 0.85).get();
}

@Override
public boolean shouldEnableReplicatedRequestCompression() {
    return configInstance.getBooleanProperty(
            namespace + "enableReplicatedRequestCompression", false).get();
}

4、基於建造者模式構造服務實例

看 new EurekaConfigBasedInstanceInfoProvider(instanceConfig).get() 這段代碼，在 get 方法中完成了服務實例信息的構造。它這里主要用到了建造者設計模式來構建 LeaseInfo 和 InstanceInfo，以 InstanceInfo 為例，它的內部有一個靜態的 Builder 類，通過 newBuilder() 方法創建了 InstanceInfo 對象，然后可以調用 Builder 的屬性設置方法來設置屬性，在設置這些屬性的時候，會做一些關聯性的校驗，在設置完成后，就調用 build() 方法返回對象，也可以在 build 方法中再做一些最終的校驗。建造者模式就很適合用於構建這種復雜的對象。

public synchronized InstanceInfo get() {
    if (instanceInfo == null) {
        // 續約信息：主要有續約間隔時間（默認30秒）和續約過期時間（默認90秒）
        LeaseInfo.Builder leaseInfoBuilder = LeaseInfo.Builder.newBuilder()
                .setRenewalIntervalInSecs(config.getLeaseRenewalIntervalInSeconds())
                .setDurationInSecs(config.getLeaseExpirationDurationInSeconds());

        if (vipAddressResolver == null) {
            vipAddressResolver = new Archaius1VipAddressResolver();
        }

        // 基於建造者模式來創建 InstanceInfo
        InstanceInfo.Builder builder = InstanceInfo.Builder.newBuilder(vipAddressResolver);

        // set the appropriate id for the InstanceInfo, falling back to datacenter Id if applicable, else hostname
        String instanceId = config.getInstanceId();
        if (instanceId == null || instanceId.isEmpty()) {
            DataCenterInfo dataCenterInfo = config.getDataCenterInfo();
            if (dataCenterInfo instanceof UniqueIdentifier) {
                instanceId = ((UniqueIdentifier) dataCenterInfo).getId();
            } else {
                instanceId = config.getHostName(false);
            }
        }

        String defaultAddress;
        if (config instanceof RefreshableInstanceConfig) {
            // Refresh AWS data center info, and return up to date address
            defaultAddress = ((RefreshableInstanceConfig) config).resolveDefaultAddress(false);
        } else {
            defaultAddress = config.getHostName(false);
        }

        // fail safe
        if (defaultAddress == null || defaultAddress.isEmpty()) {
            defaultAddress = config.getIpAddress();
        }

        // 設置屬性
        builder.setNamespace(config.getNamespace())
                .setInstanceId(instanceId)
                .setAppName(config.getAppname())
                .setAppGroupName(config.getAppGroupName())
                .setDataCenterInfo(config.getDataCenterInfo())
                .setIPAddr(config.getIpAddress())
                .setHostName(defaultAddress)
                .setPort(config.getNonSecurePort())
                .enablePort(PortType.UNSECURE, config.isNonSecurePortEnabled())
                .setSecurePort(config.getSecurePort())
                .enablePort(PortType.SECURE, config.getSecurePortEnabled())
                .setVIPAddress(config.getVirtualHostName())
                .setSecureVIPAddress(config.getSecureVirtualHostName())
                .setHomePageUrl(config.getHomePageUrlPath(), config.getHomePageUrl())
                .setStatusPageUrl(config.getStatusPageUrlPath(), config.getStatusPageUrl())
                .setASGName(config.getASGName())
                .setHealthCheckUrls(config.getHealthCheckUrlPath(),
                        config.getHealthCheckUrl(), config.getSecureHealthCheckUrl());


        // Start off with the STARTING state to avoid traffic
        if (!config.isInstanceEnabledOnit()) {
            InstanceStatus initialStatus = InstanceStatus.STARTING;
            LOG.info("Setting initial instance status as: {}", initialStatus);
            builder.setStatus(initialStatus);
        } else {
            LOG.info("Setting initial instance status as: {}. This may be too early for the instance to advertise "
                     + "itself as available. You would instead want to control this via a healthcheck handler.",
                     InstanceStatus.UP);
        }

        // Add any user-specific metadata information
        for (Map.Entry<String, String> mapEntry : config.getMetadataMap().entrySet()) {
            String key = mapEntry.getKey();
            String value = mapEntry.getValue();
            // only add the metadata if the value is present
            if (value != null && !value.isEmpty()) {
                builder.add(key, value);
            }
        }

        // 調用 build 方法做屬性校驗並創建 InstanceInfo 實例
        instanceInfo = builder.build();
        instanceInfo.setLeaseInfo(leaseInfoBuilder.build());
    }
    return instanceInfo;
}

LeaseInfo 就是續約信息，可以看到主要的兩個配置就是續約間隔時間和多久未續約認為實例過期，實例過期就會被剔除。然后就是基於 config 設置 InstanceInfo，就是實例信息，包含了實例ID、主機名稱、端口、LeaseInfo 等等。

5、注冊中心構造客戶端 DiscoveryClient

在集群模式下，eureka server 也會作為客戶端注冊到其它注冊中心，此時，它本身就是一個 eureka client。因此會去構建 EurekaClient，其默認實現類是 DiscoveryClient。DiscoveryClient 包含了 eureka 客戶端的大部分核心功能，比如服務注冊、續約、維持心跳、拉取注冊表等。

一步步進入到DiscoveryClient最復雜的那個構造方法，我們先整體分析下做了哪些事情，抓大放小，很多組件的細節等后面分析具體功能的時候再來看。

• 將 EurekaClientConfig、EurekaInstanceConfig、EurekaTransportConfig、InstanceInfo、ApplicationInfoManager 等保存到本地變量中
• 如果要獲取注冊表，就創建一個注冊表狀態度量器
• 如果要注冊到注冊中心，就創建一個心跳狀態度量器
• 如果不獲取注冊表且不注冊到注冊中心，就不會創建調度器、心跳線程池這些了，釋放一些資源
• 如果要注冊到注冊中心且要抓取注冊表，就初始化一些調度的資源：
  • 創建了支持調度的線程池，有兩個核心線程，從后面可以看出，主要就是處理心跳和緩存刷新的任務
  • 創建了維持心跳的線程池，核心線程數為1，最大線程數配置默認為5
  • 創建了刷新緩存的線程池，核心線程數為1，最大線程數配置默認為5
  • 創建了eureka client 與 eureka server 進行網絡通信的組件 EurekaTransport，並進行了一些初始化 。EurekaTransport 里的客戶端主要就是封裝了對 server 的 api 調用接口，便於調用
  • 接着，如果要抓取注冊表，就會抓取注冊表了，fetchRegistry 里面可以看到是分為全量抓取和增量抓取的，第一次啟動的時候就是全量抓取注冊表
• 開始初始化調度任務：
  • 如果要抓取注冊表，就創建刷新緩存的任務，並開始調度，默認每隔30秒抓取一次注冊表
  • 如果要注冊到注冊中心，就創建發送心跳的任務，並開始調度，默認每隔30秒發送一次心跳
  • 如果要注冊到注冊中心，還會創建實例副本傳播器（內部也是一個定時調度任務）、實例狀態變更的監聽器

DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
                Provider<BackupRegistry> backupRegistryProvider, EndpointRandomizer endpointRandomizer) {
    if (args != null) {
        this.healthCheckHandlerProvider = args.healthCheckHandlerProvider;
        this.healthCheckCallbackProvider = args.healthCheckCallbackProvider;
        this.eventListeners.addAll(args.getEventListeners());
        this.preRegistrationHandler = args.preRegistrationHandler;
    } else {
        this.healthCheckCallbackProvider = null;
        this.healthCheckHandlerProvider = null;
        this.preRegistrationHandler = null;
    }

    // 將實例信息、配置信息保存到本地
    this.applicationInfoManager = applicationInfoManager;
    InstanceInfo myInfo = applicationInfoManager.getInfo();
    clientConfig = config;
    staticClientConfig = clientConfig;
    transportConfig = config.getTransportConfig();
    instanceInfo = myInfo;
    if (myInfo != null) {
        appPathIdentifier = instanceInfo.getAppName() + "/" + instanceInfo.getId();
    } else {
        logger.warn("Setting instanceInfo to a passed in null value");
    }

    this.backupRegistryProvider = backupRegistryProvider;
    this.endpointRandomizer = endpointRandomizer;
    this.urlRandomizer = new EndpointUtils.InstanceInfoBasedUrlRandomizer(instanceInfo);
    localRegionApps.set(new Applications());


    fetchRegistryGeneration = new AtomicLong(0);
    remoteRegionsToFetch = new AtomicReference<String>(clientConfig.fetchRegistryForRemoteRegions());
    // 從遠程拉取注冊表的地址數組，使用的原子類，在運行中可能會動態更新地址
    remoteRegionsRef = new AtomicReference<>(remoteRegionsToFetch.get() == null ? null : remoteRegionsToFetch.get().split(","));

    // 如果要獲取注冊表，就會注冊狀態監視器
    if (config.shouldFetchRegistry()) {
        this.registryStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRY_PREFIX + "lastUpdateSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
    } else {
        this.registryStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
    }

    // 如果要注冊到 eureka-server，就會創建心跳狀態監視器
    if (config.shouldRegisterWithEureka()) {
        this.heartbeatStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRATION_PREFIX + "lastHeartbeatSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
    } else {
        this.heartbeatStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
    }

    logger.info("Initializing Eureka in region {}", clientConfig.getRegion());

    // 如果不注冊到注冊中心，且不拉取注冊表，就不創建調度器、線程池等資源了
    if (!config.shouldRegisterWithEureka() && !config.shouldFetchRegistry()) {
        logger.info("Client configured to neither register nor query for data.");
        scheduler = null;
        heartbeatExecutor = null;
        cacheRefreshExecutor = null;
        eurekaTransport = null;
        instanceRegionChecker = new InstanceRegionChecker(new PropertyBasedAzToRegionMapper(config), clientConfig.getRegion());

        // This is a bit of hack to allow for existing code using DiscoveryManager.getInstance()
        // to work with DI'd DiscoveryClient
        DiscoveryManager.getInstance().setDiscoveryClient(this);
        DiscoveryManager.getInstance().setEurekaClientConfig(config);

        initTimestampMs = System.currentTimeMillis();
        initRegistrySize = this.getApplications().size();
        registrySize = initRegistrySize;
        logger.info("Discovery Client initialized at timestamp {} with initial instances count: {}",
                initTimestampMs, initRegistrySize);

        return;  // no need to setup up an network tasks and we are done
    }

    try {
        // 創建定時調度器，默認有2個核心線程，主要處理心跳任務和緩存刷新任務
        scheduler = Executors.newScheduledThreadPool(2,
                new ThreadFactoryBuilder()
                        .setNameFormat("DiscoveryClient-%d")
                        .setDaemon(true)
                        .build());

        // 維持心跳的線程池，一個核心線程，最大線程數默認5。
        // 注意其使用的隊列是 SynchronousQueue 隊列，這個隊列只能放一個任務，一個線程將任務取走后，才能放入下一個任務，否則只能阻塞。
        heartbeatExecutor = new ThreadPoolExecutor(
                1, clientConfig.getHeartbeatExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(),
                new ThreadFactoryBuilder()
                        .setNameFormat("DiscoveryClient-HeartbeatExecutor-%d")
                        .setDaemon(true)
                        .build()
        );  // use direct handoff

        // 刷新緩存的線程池，一個核心線程，最大線程數據默認為5
        cacheRefreshExecutor = new ThreadPoolExecutor(
                1, clientConfig.getCacheRefreshExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(),
                new ThreadFactoryBuilder()
                        .setNameFormat("DiscoveryClient-CacheRefreshExecutor-%d")
                        .setDaemon(true)
                        .build()
        );  // use direct handoff

        // eureka http 調用客戶端，支持 eureka client 與 eureka server 之間的通信
        eurekaTransport = new EurekaTransport();
        // 初始化 eurekaTransport
        scheduleServerEndpointTask(eurekaTransport, args);

        AzToRegionMapper azToRegionMapper;
        if (clientConfig.shouldUseDnsForFetchingServiceUrls()) {
            azToRegionMapper = new DNSBasedAzToRegionMapper(clientConfig);
        } else {
            azToRegionMapper = new PropertyBasedAzToRegionMapper(clientConfig);
        }
        if (null != remoteRegionsToFetch.get()) {
            azToRegionMapper.setRegionsToFetch(remoteRegionsToFetch.get().split(","));
        }
        instanceRegionChecker = new InstanceRegionChecker(azToRegionMapper, clientConfig.getRegion());
    } catch (Throwable e) {
        throw new RuntimeException("Failed to initialize DiscoveryClient!", e);
    }

    if (clientConfig.shouldFetchRegistry()) {
        try {
            // 拉取注冊表：全量抓取和增量抓取
            boolean primaryFetchRegistryResult = fetchRegistry(false);
            if (!primaryFetchRegistryResult) {
                logger.info("Initial registry fetch from primary servers failed");
            }
            boolean backupFetchRegistryResult = true;
            if (!primaryFetchRegistryResult && !fetchRegistryFromBackup()) {
                backupFetchRegistryResult = false;
                logger.info("Initial registry fetch from backup servers failed");
            }
            if (!primaryFetchRegistryResult && !backupFetchRegistryResult && clientConfig.shouldEnforceFetchRegistryAtInit()) {
                throw new IllegalStateException("Fetch registry error at startup. Initial fetch failed.");
            }
        } catch (Throwable th) {
            logger.error("Fetch registry error at startup: {}", th.getMessage());
            throw new IllegalStateException(th);
        }
    }

    // call and execute the pre registration handler before all background tasks (inc registration) is started
    if (this.preRegistrationHandler != null) {
        this.preRegistrationHandler.beforeRegistration();
    }

    if (clientConfig.shouldRegisterWithEureka() && clientConfig.shouldEnforceRegistrationAtInit()) {
        try {
            if (!register() ) {
                throw new IllegalStateException("Registration error at startup. Invalid server response.");
            }
        } catch (Throwable th) {
            logger.error("Registration error at startup: {}", th.getMessage());
            throw new IllegalStateException(th);
        }
    }

    // 初始化一些調度任務：刷新緩存的調度任務、發送心跳的調度任務、實例副本傳播器
    initScheduledTasks();

    try {
        Monitors.registerObject(this);
    } catch (Throwable e) {
        logger.warn("Cannot register timers", e);
    }

    // This is a bit of hack to allow for existing code using DiscoveryManager.getInstance()
    // to work with DI'd DiscoveryClient
    DiscoveryManager.getInstance().setDiscoveryClient(this);
    DiscoveryManager.getInstance().setEurekaClientConfig(config);

    // 初始化的時間
    initTimestampMs = System.currentTimeMillis();
    initRegistrySize = this.getApplications().size();
    registrySize = initRegistrySize;
    logger.info("Discovery Client initialized at timestamp {} with initial instances count: {}",
            initTimestampMs, initRegistrySize);
}

////////////////////////////////////////////////////////////////////

private void initScheduledTasks() {
    if (clientConfig.shouldFetchRegistry()) {
        // 抓取注冊表的間隔時間，默認30秒
        int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
        // 刷新緩存調度器延遲時間擴大倍數，在任務超時的時候，將擴大延遲時間
        // 這在出現網絡抖動、eureka-sever 不可用時，可以避免頻繁發起無效的調度
        int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        // 注冊表刷新的定時任務
        cacheRefreshTask = new TimedSupervisorTask(
                "cacheRefresh",
                scheduler,
                cacheRefreshExecutor,
                registryFetchIntervalSeconds,
                TimeUnit.SECONDS,
                expBackOffBound,
                new CacheRefreshThread() // 刷新注冊表的任務
        );
        // 30秒后開始調度刷新注冊表的任務
        scheduler.schedule(
                cacheRefreshTask,
                registryFetchIntervalSeconds, TimeUnit.SECONDS);
    }

    if (clientConfig.shouldRegisterWithEureka()) {
        // 續約間隔時間，默認30秒
        int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
        // 心跳調度器的延遲時間擴大倍數，默認10
        int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
        logger.info("Starting heartbeat executor: " + "renew interval is: {}", renewalIntervalInSecs);

        // 心跳的定時任務
        heartbeatTask = new TimedSupervisorTask(
                "heartbeat",
                scheduler,
                heartbeatExecutor,
                renewalIntervalInSecs,
                TimeUnit.SECONDS,
                expBackOffBound,
                new HeartbeatThread()
        );
        // 30秒后開始調度心跳的任務
        scheduler.schedule(
                heartbeatTask,
                renewalIntervalInSecs, TimeUnit.SECONDS);

        // 實例副本傳播器，用於定時更新自己狀態
        instanceInfoReplicator = new InstanceInfoReplicator(
                this,
                instanceInfo,
                clientConfig.getInstanceInfoReplicationIntervalSeconds(),
                2); // burstSize

        // 實例狀態變更的監聽器
        statusChangeListener = new ApplicationInfoManager.StatusChangeListener() {
            @Override
            public String getId() {
                return "statusChangeListener";
            }

            @Override
            public void notify(StatusChangeEvent statusChangeEvent) {
                if (statusChangeEvent.getStatus() == InstanceStatus.DOWN) {
                    logger.error("Saw local status change event {}", statusChangeEvent);
                } else {
                    logger.info("Saw local status change event {}", statusChangeEvent);
                }
                instanceInfoReplicator.onDemandUpdate();
            }
        };

        // 向 ApplicationInfoManager 注冊監聽器
        if (clientConfig.shouldOnDemandUpdateStatusChange()) {
            applicationInfoManager.registerStatusChangeListener(statusChangeListener);
        }

        // 啟動副本傳播器，默認延遲時間40秒
        instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }
}

6、定時任務監管器的設計

可以看到，eureka client 為了定時發送心跳以及定時抓取注冊表，使用了定時任務和調度器，我覺得它這里的定時調度的設計思想是可以參考和借鑒的。

以心跳任務的這段代碼為例：

if (clientConfig.shouldFetchRegistry()) {
    // 抓取注冊表的間隔時間，默認30秒
    int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
    // 刷新緩存調度器延遲時間擴大倍數，在任務超時的時候，將擴大延遲時間
    // 這在出現網絡抖動、eureka-sever 不可用時，可以避免頻繁發起無效的調度
    int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
    // 注冊表刷新的定時任務
    cacheRefreshTask = new TimedSupervisorTask(
            "cacheRefresh",
            scheduler,
            cacheRefreshExecutor,
            registryFetchIntervalSeconds,
            TimeUnit.SECONDS,
            expBackOffBound,
            new CacheRefreshThread() // 刷新注冊表的任務
    );
    // 30秒后開始調度刷新注冊表的任務
    scheduler.schedule(
            cacheRefreshTask,
            registryFetchIntervalSeconds, TimeUnit.SECONDS);
}

上面這段代碼其實並不復雜，主要就是創建了一個定時任務，然后使用調度器在一定的延遲之后開始調度。但它這里並不是直接使用調度器調度任務（CacheRefreshThread），也不是以一個固定的頻率調度（每隔30秒）。它定義了一個任務的監管器 TimedSupervisorTask，在創建這個監管器的時候，傳入了調度器、要執行的任務、以及間隔時間等參數，然后調度器調度 TimedSupervisorTask。

看 TimedSupervisorTask 的構造方法，主要有以下幾個點：

• 任務的超時時間等於間隔時間，也就是默認30秒的超時時間，然后延遲時間默認等於超時時間  如果 eureka server down 了，或者網絡問題，就有可能出現超時
• 設置了最大的延遲時間，默認在超時時間的基礎上擴大10倍，即300秒
• 最后創建了一些計數器，分別統計成功、超時、拒絕、異常的次數，可以看到，它這里對任務的調度是有做統計的

public TimedSupervisorTask(String name, ScheduledExecutorService scheduler, ThreadPoolExecutor executor,
                           int timeout, TimeUnit timeUnit, int expBackOffBound, Runnable task) {
    this.name = name;
    this.scheduler = scheduler;
    this.executor = executor;
    // 任務超時時間就等於任務調度的間隔時間
    this.timeoutMillis = timeUnit.toMillis(timeout);
    this.task = task;
    // 延遲時間默認為超時時間
    this.delay = new AtomicLong(timeoutMillis);
    // 最大延遲時間，默認在超時時間的基礎上擴大10倍
    this.maxDelay = timeoutMillis * expBackOffBound;

    // 初始化計數器並注冊
    successCounter = Monitors.newCounter("success");
    timeoutCounter = Monitors.newCounter("timeouts");
    rejectedCounter = Monitors.newCounter("rejectedExecutions");
    throwableCounter = Monitors.newCounter("throwables");
    threadPoolLevelGauge = new LongGauge(MonitorConfig.builder("threadPoolUsed").build());
    Monitors.registerObject(name, this);
}

再看 TimedSupervisorTask 的 run 方法：

• 1）首先將任務異步提交到線程池去執行，它這里並不是直接運行任務，而是異步提交到線程池中，這樣可以實現超時等待，不影響主任務
• 2）任務如果超時，比如出現網絡延遲、eureka server 不可用等情況，超時了，它這個時候就會認為如果還是30秒后調度，可能 eureka server 還是不可用的狀態，那么就增大延遲時間，那么第一次超時就會在300秒后再調度。如果300秒內 eureka server 可用了，然后有新的服務實例注冊上去了，那這個客戶端就不能及時感知到了，因此我覺得可以將 getCacheRefreshExecutorExponentialBackOffBound 對應的參數適當設置小一點（默認10倍）。
• 3）如果任務沒有超時，在調度成功后，就會重置延遲時間為默認的超時時間。最后在 finally 中進行下一次的調度。

public void run() {
    Future<?> future = null;
    try {
        // 提交任務到線程池
        future = executor.submit(task);
        threadPoolLevelGauge.set((long) executor.getActiveCount());
        // 阻塞直到任務完成或超時
        future.get(timeoutMillis, TimeUnit.MILLISECONDS);
        // 任務完成后，重置延遲時間為超時時間，即30秒
        delay.set(timeoutMillis);
        threadPoolLevelGauge.set((long) executor.getActiveCount());
        // 成功次數+1
        successCounter.increment();
    } catch (TimeoutException e) {
        logger.warn("task supervisor timed out", e);
        // 超時次數+1
        timeoutCounter.increment();

        // 如果任務超時了，就會增大延遲時間，當前延遲時間*2，然后取一個最大值
        long currentDelay = delay.get();
        long newDelay = Math.min(maxDelay, currentDelay * 2);
        // 設置為最大的一個延遲時間
        delay.compareAndSet(currentDelay, newDelay);

    } catch (RejectedExecutionException e) {
        if (executor.isShutdown() || scheduler.isShutdown()) {
            logger.warn("task supervisor shutting down, reject the task", e);
        } else {
            logger.warn("task supervisor rejected the task", e);
        }

        rejectedCounter.increment();
    } catch (Throwable e) {
        if (executor.isShutdown() || scheduler.isShutdown()) {
            logger.warn("task supervisor shutting down, can't accept the task");
        } else {
            logger.warn("task supervisor threw an exception", e);
        }

        throwableCounter.increment();
    } finally {
        if (future != null) {
            future.cancel(true);
        }

        if (!scheduler.isShutdown()) {
            // 延遲 delay 時間后，繼續調度任務
            scheduler.schedule(this, delay.get(), TimeUnit.MILLISECONDS);
        }
    }
}

總結一下這塊設計：

• 1）首先在遠程調用的時候要考慮到網絡不可用、server 端 down 了等情況導致調用超時，可以使用線程池異步提交任務，實現等待超時機制。
• 2）超時之后，可以假想服務恢復可用狀態可能需要一定的時間，如果還是按原來的時間間隔調度，可能還是會超時，因此增大延遲時間。如果調用成功，說明已經恢復了，則重置延遲時間。
• 3）定時任務的調度以一定的延遲時間來循環調度（schedule），延遲時間可以根據實際情況變化，而不是一開始就按一個固定的頻率來調度（scheduleAtFixedRate）。
• 4）定時任務、線程池里的任務，最好做好任務執行狀態的統計，便於觀察任務的調度情況。

7、構造注冊表

接着構造 PeerAwareInstanceRegistry，從命名來看，這是一個可以感知 eureka 集群的注冊表，就是在集群模式下，eureka server 從其它 server 節點拉取注冊表。它的默認實現類是 PeerAwareInstanceRegistryImpl，繼承自 AbstractInstanceRegistry，就是實例注冊表。

① 構造 PeerAwareInstanceRegistry

進入 PeerAwareInstanceRegistryImpl 的構造方法：

• 首先是將前面構造的 EurekaServerConfig、EurekaClientConfig、EurekaClient 等傳入構造方法來構造 PeerAwareInstanceRegistry
• 調用了 super 的構造方法，主要初始化了如下幾個東西：
  • 保存最近下線實例的循環隊列
  • 保存最近注冊實例的循環隊列
  • 最近一分鍾續約次數的計數器
  • 定時任務剔除 recentlyChangedQueue 中的實例
• 然后創建了一個最近一分鍾集群同步次數的計數器 numberOfReplicationsLastMin。MeasuredRate 我們到后面再來分析它的設計。

public PeerAwareInstanceRegistryImpl(
        EurekaServerConfig serverConfig,
        EurekaClientConfig clientConfig,
        ServerCodecs serverCodecs,
        EurekaClient eurekaClient
) {
    super(serverConfig, clientConfig, serverCodecs);
    this.eurekaClient = eurekaClient;
    // 最近一分鍾集群同步的次數計數器
    this.numberOfReplicationsLastMin = new MeasuredRate(1000 * 60 * 1);
    // We first check if the instance is STARTING or DOWN, then we check explicit overrides,
    // then we check the status of a potentially existing lease.
    this.instanceStatusOverrideRule = new FirstMatchWinsCompositeRule(new DownOrStartingRule(),
            new OverrideExistsRule(overriddenInstanceStatusMap), new LeaseExistsRule());
}


///////////////////////////////////////////////


protected AbstractInstanceRegistry(EurekaServerConfig serverConfig, EurekaClientConfig clientConfig, ServerCodecs serverCodecs) {
    this.serverConfig = serverConfig;
    this.clientConfig = clientConfig;
    this.serverCodecs = serverCodecs;
    // 最近下線的循環隊列
    this.recentCanceledQueue = new CircularQueue<Pair<Long, String>>(1000);
    // 最近注冊的循環隊列
    this.recentRegisteredQueue = new CircularQueue<Pair<Long, String>>(1000);

    // 最近一分鍾續約的計數器
    this.renewsLastMin = new MeasuredRate(1000 * 60 * 1);
    // 一個定時調度任務，定時剔除最近改變隊列中過期的實例
    this.deltaRetentionTimer.schedule(getDeltaRetentionTask(),
            serverConfig.getDeltaRetentionTimerIntervalInMs(),
            serverConfig.getDeltaRetentionTimerIntervalInMs());
}

這塊的具體細節等后面分析具體功能的時候再來看，我們先知道有這些隊列、計數器就行了。

② 循環隊列 CircularQueue 的設計

從構造方法可以看到，它使用了循環隊列來保存最近下線和最近注冊的實例信息，容量固定為1000，這樣就把最近的實例數量控制在1000以內。

CircularQueue 是它自定義的一個循環隊列，繼承自 AbstractQueue。其內部其實就是代理了 ArrayBlockingQueue，然后重寫了入隊的 offer 方法，當隊列滿了，就取出頭部的一個元素，然后再放到隊列尾部。

static class CircularQueue<E> extends AbstractQueue<E> {
    private final ArrayBlockingQueue<E> delegate;
    private final int capacity;

    public CircularQueue(int capacity) {
        this.capacity = capacity;
        this.delegate = new ArrayBlockingQueue<>(capacity);
    }

    @Override
    public Iterator<E> iterator() {
        return delegate.iterator();
    }

    @Override
    public int size() {
        return delegate.size();
    }

    @Override
    public boolean offer(E e) {
        // 如果隊列滿了，就取出頭部的一個元素，然后再放到尾部
        while (!delegate.offer(e)) {
            delegate.poll();
        }
        return true;
    }

    @Override
    public E poll() {
        return delegate.poll();
    }

    @Override
    public E peek() {
        return delegate.peek();
    }
}

8、創建 Eureka Server 上下文並初始化

接下來先是創建了 PeerEurekaNodes，應該就是代表 eureka 集群的。然后基於前面創建的一些東西創建 eureka server 上下文 EurekaServerContext，從 DefaultEurekaServerContext 構造方法進去可以看到，只是將前面構造的東西封裝起來，便於全局使用。然后將 serverContext 放到 EurekaServerContextHolder 中，這樣其它地方就可以通過這個 holder 獲取 serverContext 了。

接着就是初始化eureka server上下文：

• 啟動 eureka 集群：
  • 主要是啟動一個定時任務（間隔時間默認10分鍾）更新 eureka 集群節點的信息，根據配置的 eureka server 地址更新 PeerEurekaNode，這樣當有 eureka server 下線或上線后，就可以及時感知到其它 server 節點。PeerEurekaNode 主要就是用於集群節點間的數據同步，這塊后面分析集群的時候再具體分析。
• 注冊表初始化：
  • 首先啟動了前面創建的計數器：numberOfReplicationsLastMin
  • 初始化響應緩存，eureka server 構造了一個多級緩存來響應客戶端抓取注冊表的請求，這個多級緩存的設計就是響應頻繁抓取注冊表請求的核心所在，等后面分析客戶端抓取注冊表的時候再具體分析
  • 定時調度任務更新續約閾值，主要就是更新 numberOfRenewsPerMinThreshold 這個值，即每分鍾續約次數，等分析續約的時候再來分析
  • 初始化 RemoteRegionRegistry，猜測是跟 eureka 多個區域（region）部署有關的

public void initialize() {
    logger.info("Initializing ...");
    // 啟動eureka集群
    peerEurekaNodes.start();
    try {
        // 注冊表初始化
        registry.init(peerEurekaNodes);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    logger.info("Initialized");
}

PeerEurekaNodes 的 start 方法：

public void start() {
    // 單個線程的線程池
    taskExecutor = Executors.newSingleThreadScheduledExecutor(
            new ThreadFactory() {
                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = new Thread(r, "Eureka-PeerNodesUpdater");
                    thread.setDaemon(true);
                    return thread;
                }
            }
    );
    try {
        // 根據集群地址更新 PeerEurekaNode，PeerEurekaNode 就包含了調度其它注冊中心的客戶端
        updatePeerEurekaNodes(resolvePeerUrls());
        Runnable peersUpdateTask = new Runnable() {
            @Override
            public void run() {
                try {
                    updatePeerEurekaNodes(resolvePeerUrls());
                } catch (Throwable e) {
                    logger.error("Cannot update the replica Nodes", e);
                }

            }
        };
        // 定時跟新集群信息 PeerEurekaNode，如果有eureka-server不可用了，就可以及時下線，或者新上線了eureka-server，可以及時感知到
        taskExecutor.scheduleWithFixedDelay(
                peersUpdateTask,
                serverConfig.getPeerEurekaNodesUpdateIntervalMs(),
                serverConfig.getPeerEurekaNodesUpdateIntervalMs(),
                TimeUnit.MILLISECONDS
        );
    } catch (Exception e) {
        throw new IllegalStateException(e);
    }
    for (PeerEurekaNode node : peerEurekaNodes) {
        logger.info("Replica node URL:  {}", node.getServiceUrl());
    }
}

PeerAwareInstanceRegistryImpl 的 init 方法：

public void init(PeerEurekaNodes peerEurekaNodes) throws Exception {
    // 啟動計數器
    this.numberOfReplicationsLastMin.start();
    this.peerEurekaNodes = peerEurekaNodes;
    // 初始化響應緩存，eureka server 構造了一個多級緩存來響應客戶端抓取注冊表的請求
    initializedResponseCache();
    // 定時調度任務更新續約閥值，主要就是更新 numberOfRenewsPerMinThreshold 這個值，即每分鍾續約次數
    scheduleRenewalThresholdUpdateTask();
    // 初始化 RemoteRegionRegistry
    initRemoteRegionRegistry();

    try {
        Monitors.registerObject(this);
    } catch (Throwable e) {
        logger.warn("Cannot register the JMX monitor for the InstanceRegistry :", e);
    }
}

9、完成 Eureka Server 初始化

接下來看最后幾步：

• 首先調用 registry.syncUp() 將 EurekaClient 本地的實例同步到注冊表，在集群模式下，eureka server 也是一個客戶端，因此會獲取到其它注冊中心的注冊表同步到當前 server 的注冊表中。它默認會重試5次，每次間隔30秒。在單機模式下，應該將重試次數設置為 0。
• 然后調用 registry.openForTraffic 做最后的一些初始化：
  • 更新每分鍾續約閾值
  • 設置實例狀態
  • 啟動統計最近一分鍾續約次數的計數器
  • 啟動定時任務剔除下線的實例，定時任務默認每隔60秒調度一次
• 最后一步就是注冊 eureka 自身的一些監控統計

syncUp 方法：

public int syncUp() {
    // Copy entire entry from neighboring DS node
    int count = 0;

    // 注冊表同步重試次數，默認5次
    for (int i = 0; ((i < serverConfig.getRegistrySyncRetries()) && (count == 0)); i++) {
        if (i > 0) {
            try {
                // 同步重試時間，默認30秒
                Thread.sleep(serverConfig.getRegistrySyncRetryWaitMs());
            } catch (InterruptedException e) {
                logger.warn("Interrupted during registry transfer..");
                break;
            }
        }
        Applications apps = eurekaClient.getApplications();
        for (Application app : apps.getRegisteredApplications()) {
            for (InstanceInfo instance : app.getInstances()) {
                try {
                    if (isRegisterable(instance)) {
                        // 注冊實例
                        register(instance, instance.getLeaseInfo().getDurationInSecs(), true);
                        count++;
                    }
                } catch (Throwable t) {
                    logger.error("During DS init copy", t);
                }
            }
        }
    }
    return count;
}

openForTraffic 方法：

@Override
public void openForTraffic(ApplicationInfoManager applicationInfoManager, int count) {
    // 期望的客戶端每分鍾的續約次數
    this.expectedNumberOfClientsSendingRenews = count;
    // 更新每分鍾續約閥值
    updateRenewsPerMinThreshold();
    logger.info("Got {} instances from neighboring DS node", count);
    logger.info("Renew threshold is: {}", numberOfRenewsPerMinThreshold);
    this.startupTime = System.currentTimeMillis();
    if (count > 0) {
        this.peerInstancesTransferEmptyOnStartup = false;
    }
    DataCenterInfo.Name selfName = applicationInfoManager.getInfo().getDataCenterInfo().getName();
    boolean isAws = Name.Amazon == selfName;
    if (isAws && serverConfig.shouldPrimeAwsReplicaConnections()) {
        logger.info("Priming AWS connections for all replicas..");
        primeAwsReplicas(applicationInfoManager);
    }
    logger.info("Changing status to UP");
    // 設置實例狀態為已啟動
    applicationInfoManager.setInstanceStatus(InstanceStatus.UP);
    super.postInit();
}

///////////////////////////////////////

protected void postInit() {
    // 啟動 統計最近一分鍾續約次數的計數器
    renewsLastMin.start();
    if (evictionTaskRef.get() != null) {
        evictionTaskRef.get().cancel();
    }
    // 定時剔除任務
    evictionTaskRef.set(new EvictionTask());
    evictionTimer.schedule(evictionTaskRef.get(),
            serverConfig.getEvictionIntervalTimerInMs(),
            serverConfig.getEvictionIntervalTimerInMs());
}

10、Eureka Server 啟動流程圖

下面通過一張圖來展示下 eureka server 的啟動初始化流程。

四、Eureka Client 啟動初始化

eureka client 的啟動初始化我們看 eureka-examples 模塊下的 ExampleEurekaClient 這個類，它的 main 方法中就模擬了作為一個 eureka client 啟動初始化，並向注冊中心發送請求。

eureka server 的初始化中其實已經包含了客戶端的初始化，可以看出，客戶端的初始化主要有如下的一些東西：

• 讀取 eureka-client.properties 配置文件，創建 EurekaInstanceConfig
• 基於 InstanceConfig 創建實例信息 InstanceInfo
• 基於 InstanceConfig 和 InstanceInfo 創建應用實例管理器 ApplicationInfoManager
• 讀取 eureka-client.properties 配置文件，創建 EurekaClientConfig
• 基於應用實例管理器和 clientConfig 創建 EurekaClient（DiscoveryClient），初始化流程跟 eureka server 初始化流程中 DiscoveryClient 的創建是一樣的

public static void main(String[] args) {
    ExampleEurekaClient sampleClient = new ExampleEurekaClient();

    // 基於實例配置和實例信息創建應用實例管理器
    ApplicationInfoManager applicationInfoManager = initializeApplicationInfoManager(new MyDataCenterInstanceConfig());
    // 基於應用實例管理器和客戶端配置創建 EurekaClient（DiscoveryClient）
    EurekaClient client = initializeEurekaClient(applicationInfoManager, new DefaultEurekaClientConfig());

    // use the client
    sampleClient.sendRequestToServiceUsingEureka(client);

    // shutdown the client
    eurekaClient.shutdown();
}