SpringCloud 源码系列（3）—— 注册中心 Eureka（下）

SpringCloud 源码系列（1）—— 注册中心 Eureka（上）

SpringCloud 源码系列（2）—— 注册中心 Eureka（中）

SpringCloud 源码系列（3）—— 注册中心 Eureka（下）

十一、Eureka Server 集群

在实际的生产环境中，可能有几十个或者几百个的微服务实例，Eureka Server 承担了非常高的负载，而且为了保证注册中心高可用，一般都要部署成集群的，下面就来看看 eureka server 的集群。

1、搭建 Eureka Server 集群

首先来搭建一个三个节点的 eureka-server 集群，看看效果。

① 集群配置

首先在本地 hosts 文件中配置如下映射：

127.0.0.1 peer1
127.0.0.1 peer2
127.0.0.1 peer3

更改注册中心的 application.yml 配置文件，增加三个 profile，分别对应三个 eureka-server 的客户端配置。

eureka-server 在集群中作为客户端就需要抓取注册表，并配置 eureka-server 的地址。

spring:
  application:
    name: sunny-register

---
spring:
  profiles: peer1
server:
  port: 8001

eureka:
  instance:
    hostname: peer1
  client:
    # 是否向注册中心注册自己
    register-with-eureka: false
    # 是否抓取注册表
    fetch-registry: true
    service-url:
      defaultZone: http://peer1:8001/eureka,http://peer2:8002/eureka,http://peer3:8003/eureka


---
spring:
  profiles: peer2
server:
  port: 8002

eureka:
  instance:
    hostname: peer2
  client:
    # 是否向注册中心注册自己
    register-with-eureka: false
    # 是否抓取注册表
    fetch-registry: true
    service-url:
      defaultZone: http://peer1:8001/eureka,http://peer2:8002/eureka,http://peer3:8003/eureka

---
spring:
  profiles: peer3
server:
  port: 8003

eureka:
  instance:
    hostname: peer3
  client:
    # 是否向注册中心注册自己
    register-with-eureka: false
    # 是否抓取注册表
    fetch-registry: true
    service-url:
      defaultZone: http://peer1:8001/eureka,http://peer2:8002/eureka,http://peer3:8003/eureka

② 启动集群

分别启动三个注册中心，环境变量 spring.profiles.active 激活对应的集群配置。

启动之后访问 http://peer1:8001/ 进入 peer1 这个注册中心，就可以看到另外两个分片 peer2、peer3，说明集群中有3个节点了。

③ 启动客户端

首先客户端配置增加集群地址：

eureka:
  client:
    serviceUrl:
      defaultZone: http://peer1:8001/eureka,http://peer2:8002/eureka,http://peer3:8003/eureka

启动几个客户端实例，过一会 之后，会发现三个 eureka-server 上都注册上去了：

到此 eureka-server 集群就搭建起来了，可以看到注册中心的实例会互相同步，每隔注册注册都可以接收注册、续约、下线等请求，它们是对等的。

2、Eureka Server 集群架构

一般来说，分布式系统的数据在多个副本之间的复制方式，可分为主从复制和对等复制。

① 主从复制

主从复制就是 Master-Slave 模式，即一个主副本，其它副本都为从副本。所有对数据的写操作都提交到主副本，然后再由主副本同步到从副本。

对于主从复制模式来说，写操作的压力都在主副本上，它是整个系统的瓶颈，而从副本则可以帮助主副本分担读请求。

② 对等复制

对等复制就是 Peer to Peer 的模式，副本之间不分主从，任何副本都可以接收写操作，每个副本之间相互进行数据更新同步。

Peer to Peer 模式每个副本之间都可以接收写请求，不存在写操作压力瓶颈。但是由于每个副本都可以进行写操作，各个副本之间的数据同步及冲突处理是一个棘手的问题。

③ Eureka Server 集群架构

Eureka Server 采用的就是 Peer to Peer 的复制模式，比如一个客户端实例随机向其中一个server注册，然后它就会同步到其它节点中。

3、Eureka Server 启动时抓取注册表

前面已经分析过了，在 eureka server 启动初始化的时候，即 EurekaBootStrap 初始化类，先初始化了 DiscoveryClient，DiscoveryClient 会向注册中心全量抓取注册表到本地。

初始化的最后调用了 registry.syncUp() 来同步注册表，就是将 DiscoveryClient 缓存的实例注册到 eureka-server 的注册表里去。

需要注意的是 eureka 配置的注册表同步重试次数默认为5，springcloud 中默认为 0，因此需要添加如下配置来开启注册表同步。

eureka:
  server:
    registry-sync-retries: 5

将 DiscoveryClient 本地的实例注册到注册表中：

4、集群节点同步

① 注册、续约、下线

前面也分析过了，在客户端注册、续约、下线的时候，都会同步到集群其它节点。可以看到都调用了 replicateToPeers 方法来复制到其它集群。

/////////////////////// 注册 ///////////////////////
public void register(final InstanceInfo info, final boolean isReplication) {
    int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;
    // 如果实例中没有周期的配置，就设置为默认的 90 秒
    if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) {
        leaseDuration = info.getLeaseInfo().getDurationInSecs();
    }
    // 注册实例
    super.register(info, leaseDuration, isReplication);
    // 复制到集群其它 server 节点
    replicateToPeers(Action.Register, info.getAppName(), info.getId(), info, null, isReplication);
}


/////////////////////// 下线 ///////////////////////
public boolean cancel(final String appName, final String id,
                      final boolean isReplication) {
    if (super.cancel(appName, id, isReplication)) {
        replicateToPeers(Action.Cancel, appName, id, null, null, isReplication);

        return true;
    }
    return false;
}


/////////////////////// 续约 ///////////////////////
public boolean renew(final String appName, final String id, final boolean isReplication) {
    // 调用父类（AbstractInstanceRegistry）的 renew 续约
    if (super.renew(appName, id, isReplication)) {
        // 续约完成后同步到集群其它节点
        replicateToPeers(Action.Heartbeat, appName, id, null, null, isReplication);
        return true;
    }
    return false;
}

② 同步到其它节点

来看看 replicateToPeers 方法：

• 首先判断 isReplication 参数，如果是集群复制操作，最近一分钟复制次数 numberOfReplicationsLastMin + 1。isReplication 是在请求头中指定的，请求头为 PeerEurekaNode.HEADER_REPLICATION（x-netflix-discovery-replication）。
• 接着遍历集群列表，复制实例操作到集群节点中。前面也分析过了，PeerEurekaNode 就代表了一个 eureka-server，PeerEurekaNodes 就代表了 eureka-server 集群。
• 复制实例操作到集群的方法 replicateInstanceActionsToPeers 就是根据不同的操作类型调用集群 PeerEurekaNode 对应的方法完成操作复制。

private void replicateToPeers(Action action, String appName, String id,
                              InstanceInfo info /* optional */,
                              InstanceStatus newStatus /* optional */, boolean isReplication) {
    Stopwatch tracer = action.getTimer().start();
    try {
        if (isReplication) {
            // 如果是来自其它server节点的注册请求，则最近一分钟集群同步次数+1
            numberOfReplicationsLastMin.increment();
        }
        // If it is a replication already, do not replicate again as this will create a poison replication
        if (peerEurekaNodes == Collections.EMPTY_LIST || isReplication) {
            return;
        }

        // 如果是来自客户端的注册请求，就同步到集群中其它server节点
        for (final PeerEurekaNode node : peerEurekaNodes.getPeerEurekaNodes()) {
            // If the url represents this host, do not replicate to yourself.
            if (peerEurekaNodes.isThisMyUrl(node.getServiceUrl())) {
                continue;
            }

            replicateInstanceActionsToPeers(action, appName, id, info, newStatus, node);
        }
    } finally {
        tracer.stop();
    }
}

private void replicateInstanceActionsToPeers(Action action, String appName,
                                             String id, InstanceInfo info, InstanceStatus newStatus,
                                             PeerEurekaNode node) {
    try {
        InstanceInfo infoFromRegistry;
        CurrentRequestVersion.set(Version.V2);
        switch (action) {
            case Cancel:
                // 下线
                node.cancel(appName, id);
                break;
            case Heartbeat:
                InstanceStatus overriddenStatus = overriddenInstanceStatusMap.get(id);
                infoFromRegistry = getInstanceByAppAndId(appName, id, false);
                // 续约
                node.heartbeat(appName, id, infoFromRegistry, overriddenStatus, false);
                break;
            case Register:
                // 注册
                node.register(info);
                break;
            case StatusUpdate:
                infoFromRegistry = getInstanceByAppAndId(appName, id, false);
                node.statusUpdate(appName, id, newStatus, infoFromRegistry);
                break;
            case DeleteStatusOverride:
                infoFromRegistry = getInstanceByAppAndId(appName, id, false);
                node.deleteStatusOverride(appName, id, infoFromRegistry);
                break;
        }
    } catch (Throwable t) {
        logger.error("Cannot replicate information to {} for action {}", node.getServiceUrl(), action.name(), t);
    } finally {
        CurrentRequestVersion.remove();
    }
}

③ isReplication

PeerEurekaNode 与 eureka-server 通信的组件是 JerseyReplicationClient，这个类重写了 addExtraHeaders 方法，并添加了请求头 PeerEurekaNode.HEADER_REPLICATION，设置为 true。

这样其它 eureka-server 收到这个复制操作后，就知道是来自集群节点的同步操作，就不会再同步给其它节点了，从而避免死循环。

@Override
protected void addExtraHeaders(Builder webResource) {
    webResource.header(PeerEurekaNode.HEADER_REPLICATION, "true");
}

十二、集群同步机制

Eureka Server 集群间同步机制还是比较复杂的，试想如果每次客户端的请求一过来，比如注册、心跳，然后 eureka-server 就立马同步给集群中其它 server 节点，那 eureka-server 这种 Peer to Peer 的模式实际上就无法分担客户端的写操作压力，相当于每个 eureka-server 接收到的请求量都是一样的。那 eureka server 为了避免这种情况，底层采用了三层队列，加批量任务的方式来进行集群间的同步。简单来说就是先将客户端操作放入队列中，然后从队列中取出一批操作，然后将这一批操作发送给其它 Server 节点，Server节点接收到之后再将这批操作解析到本地。下面就来详细看看是如何实现的。

1、集群节点 PeerEurekaNode

之前分析 eureka-server 启动初始化的时候，EurekaBootStrap 初始化了代表集群的 PeerEurekaNodes，它里面又根据配置的注册中心地址构造了 PeerEurekaNode，集群间同步核心的组件就是这个 PeerEurekaNode 了。下面以客户端注册为例来看下是如何同步的。

① 注册同步

replicateInstanceActionsToPeers 中调用了 PeerEurekaNode 的 register 方法来同步注册操作到集群。

node.register 方法：

• 可以看到先计算了过期时间，为当前时间 + 租约间隔时间（默认90秒）
• 然后调用了 batchingDispatcher 批量任务分发器来处理任务，提交了一个 InstanceReplicationTask 的实例，其 execute 方法中调用了 replicationClient 来向这个 server 注册同步。

public void register(final InstanceInfo info) throws Exception {
    // 过期时间：当前时间 + 租约时间（默认90秒）
    long expiryTime = System.currentTimeMillis() + getLeaseRenewalOf(info);
    batchingDispatcher.process(
            taskId("register", info),
            new InstanceReplicationTask(targetHost, Action.Register, info, null, true) {
                public EurekaHttpResponse<Void> execute() {
                    return replicationClient.register(info);
                }
            },
            expiryTime
    );
}

再看下 getLeaseRenewalOf 这个方法，这里应该是有bug的，这个方法返回的是毫秒数，可以看到它的卫语句的else部分是乘以 1000 了的，而 if 部分则没有，返回的是 90，不过这里 info.getLeaseInfo() 应该都不会为 null。

private static int getLeaseRenewalOf(InstanceInfo info) {
    // bug : Lease.DEFAULT_DURATION_IN_SECS * 1000
    return (info.getLeaseInfo() == null ? Lease.DEFAULT_DURATION_IN_SECS : info.getLeaseInfo().getRenewalIntervalInSecs()) * 1000;
}

② PeerEurekaNode 的构造

batchingDispatcher 是在 PeerEurekaNode 的构造方法中初始化的，来看下它的构造方法：

• registry：本地注册表
• targetHost：eureka-server host
• replicationClient：基于 jersey 的集群复制客户端通信组件，它在请求头中设置了 PeerEurekaNode.HEADER_REPLICATION 为 true
• serviceUrl：eureka-server 地址
• maxProcessingDelayMs：最大处理延迟毫秒数，默认为30000毫秒，即30秒，在下线的时候有用到
• batcherName：批处理器名称
• taskProcessor：复制任务处理器，它封装了 targetHost 和 replicationClient，主要就是 ReplicationTaskProcessor 在处理批量任务的提交
• batchingDispatcher：批量任务分发器，它会将任务打成一个批次提交到 eureka-server，避免多次请求eureka-server，注册时就是先用这个分发器提交的任务
• nonBatchingDispatcher：非批量任务分发器，就是一个任务一个任务的提交

public PeerEurekaNode(PeerAwareInstanceRegistry registry, String targetHost, String serviceUrl, HttpReplicationClient replicationClient, EurekaServerConfig config) {
    this(registry, targetHost, serviceUrl, replicationClient, config, BATCH_SIZE, MAX_BATCHING_DELAY_MS, RETRY_SLEEP_TIME_MS, SERVER_UNAVAILABLE_SLEEP_TIME_MS);
}

PeerEurekaNode(PeerAwareInstanceRegistry registry, String targetHost, String serviceUrl,
                                 HttpReplicationClient replicationClient, EurekaServerConfig config,
                                 int batchSize, long maxBatchingDelayMs,
                                 long retrySleepTimeMs, long serverUnavailableSleepTimeMs) {
    this.registry = registry;
    // 集群节点 host
    this.targetHost = targetHost;
    this.replicationClient = replicationClient;

    // 集群节点地址
    this.serviceUrl = serviceUrl;
    this.config = config;
    // 最大延迟时间 默认30秒
    this.maxProcessingDelayMs = config.getMaxTimeForReplication();

    // 批处理器名称
    String batcherName = getBatcherName();

    // 复制任务处理器
    ReplicationTaskProcessor taskProcessor = new ReplicationTaskProcessor(targetHost, replicationClient);
    // 批量任务分发器
    this.batchingDispatcher = TaskDispatchers.createBatchingTaskDispatcher(
            batcherName,
            // 复制池里最大容量，默认 10000
            config.getMaxElementsInPeerReplicationPool(),
            batchSize, // 250
            // 同步使用的最大线程数 默认 20
            config.getMaxThreadsForPeerReplication(),
            maxBatchingDelayMs, // 500
            serverUnavailableSleepTimeMs, // 1000
            retrySleepTimeMs, // 100
            taskProcessor
    );
    // 单个任务分发器
    this.nonBatchingDispatcher = TaskDispatchers.createNonBatchingTaskDispatcher(
            targetHost,
            config.getMaxElementsInStatusReplicationPool(),
            config.getMaxThreadsForStatusReplication(),
            maxBatchingDelayMs,
            serverUnavailableSleepTimeMs,
            retrySleepTimeMs,
            taskProcessor
    );
}

2、批量分发器 TaskDispatcher

创建 batchingDispatcher 时调用了 TaskDispatchers.createBatchingTaskDispatcher 方法创建了 batchingDispatcher。

首先看下 createBatchingTaskDispatcher 的参数及默认值，后面分析代码的时候会用到这些参数：

• id：批量分发器的名称
• maxBufferSize：缓存池最大数量，默认 10000
• workloadSize：工作负载数量，即一个批次最多多少任务，默认 250
• workerCount：工作者数量，这个是线程池线程工作线程的数量，默认20
• maxBatchingDelay：批量任务最大延迟毫秒数，默认为 500 毫秒
• congestionRetryDelayMs：阻塞重试延迟毫秒数，默认为 1000 毫秒
• networkFailureRetryMs：网络失败重试延迟毫秒数，默认为 100 毫秒
• taskProcessor：任务处理器，即 ReplicationTaskProcessor

再看下这个方法：

• 首先创建了一个接收者执行器 AcceptorExecutor，主要的参数是缓存、时间相关的
• 再创建了一个任务处理器 TaskExecutors，主要的参数是工作线程数、任务处理器以及接收者执行器，可以猜测这应该就是最终执行批量任务提交的执行器
• 最后创建了任务分发器 TaskDispatcher，从它的 process 方法可以看出，分发器提交的任务实际上又提交给了 AcceptorExecutor

从这里可以知道，前面注册时 batchingDispatcher.process() 提交的任务其实就是分发到 acceptorExecutor 这个接收者执行器了。创建的这个分发器 TaskDispatcher 主要有接收者执行器 AcceptorExecutor 和 任务处理器 TaskExecutors 这两个组件，核心的分发功能就在这两个组件中。

public static <ID, T> TaskDispatcher<ID, T> createBatchingTaskDispatcher(String id, int maxBufferSize, int workloadSize,
                                                                         int workerCount, long maxBatchingDelay, long congestionRetryDelayMs,
                                                                         long networkFailureRetryMs, TaskProcessor<T> taskProcessor) {
    // 接收者执行器 AcceptorExecutor
    final AcceptorExecutor<ID, T> acceptorExecutor = new AcceptorExecutor<>(
            id, maxBufferSize, workloadSize, maxBatchingDelay, congestionRetryDelayMs, networkFailureRetryMs
    );

    // 任务处理器 TaskExecutors， workerCount = 20
    final TaskExecutors<ID, T> taskExecutor = TaskExecutors.batchExecutors(id, workerCount, taskProcessor, acceptorExecutor);

    return new TaskDispatcher<ID, T>() {
        @Override
        public void process(ID id, T task, long expiryTime) {
            // 任务由 acceptorExecutor 处理
            acceptorExecutor.process(id, task, expiryTime);
        }

        @Override
        public void shutdown() {
            acceptorExecutor.shutdown();
            taskExecutor.shutdown();
        }
    };
}

3、接收者执行器 AcceptorExecutor

先看下创建 AcceptorExecutor 的构造方法：

• 根据 congestionRetryDelayMs、networkFailureRetryMs 创建了一个时间调整器 TrafficShaper，应该主要就是用来调整补偿时间的
• 然后创建了一个后台线程 acceptorThread，它运行的任务是 AcceptorRunner，主要就是将任务转成批量任务的
• 最后就是注册了一些监控统计之类的

AcceptorExecutor(String id,
                 int maxBufferSize,
                 int maxBatchingSize,
                 long maxBatchingDelay,
                 long congestionRetryDelayMs,
                 long networkFailureRetryMs) {
    // 批处理器名称
    this.id = id;
    // 最大缓冲数：10000
    this.maxBufferSize = maxBufferSize;
    // 每批最大数量：250
    this.maxBatchingSize = maxBatchingSize;
    // 最大延迟时间：500 ms
    this.maxBatchingDelay = maxBatchingDelay;
    // 时间调整器
    // congestionRetryDelayMs 阻塞重试延迟时间，1000ms
    // networkFailureRetryMs 网络异常重试时间，100ms
    this.trafficShaper = new TrafficShaper(congestionRetryDelayMs, networkFailureRetryMs);

    // 接收者后台处理线程
    ThreadGroup threadGroup = new ThreadGroup("eurekaTaskExecutors");
    this.acceptorThread = new Thread(threadGroup, new AcceptorRunner(), "TaskAcceptor-" + id);
    this.acceptorThread.setDaemon(true);
    this.acceptorThread.start();

    // 监控统计相关
    final double[] percentiles = {50.0, 95.0, 99.0, 99.5};
    final StatsConfig statsConfig = new StatsConfig.Builder()
            .withSampleSize(1000)
            .withPercentiles(percentiles)
            .withPublishStdDev(true)
            .build();
    final MonitorConfig config = MonitorConfig.builder(METRIC_REPLICATION_PREFIX + "batchSize").build();
    this.batchSizeMetric = new StatsTimer(config, statsConfig);
    try {
        Monitors.registerObject(id, this);
    } catch (Throwable e) {
        logger.warn("Cannot register servo monitor for this object", e);
    }
}

然后看看 AcceptorExecutor 的属性，它定义了几个队列以及容器来处理批量任务，我们先知道有这些东西，后面再来看看都怎么使用的。

然后可以看到 AcceptorExecutor 大量使用了并发包下的一些类，以及队列的特性，这里我们需要了解下这些类的特性：

• LinkedBlockingQueue：基于链表的单端阻塞队列，就是队尾入队，队首出队
• Deque：双端队列，就是队首、队尾都可以入队、出队
• Semaphore：信号量，需要通过 acquire（或 tryAcquire） 获取到许可证之后才可以进入临界区，通过 release 释放许可证。只要能拿到许可证，Semaphore 是可以允许多个线程进入临界区的。另外注意它这里设置的许可证数量是0，说明要先调用了 release 放入一个许可证，才有可能调用 acquire 获取到许可证。

// 接收任务的队列
private final BlockingQueue<TaskHolder<ID, T>> acceptorQueue = new LinkedBlockingQueue<>();
// 重试任务的队列
private final BlockingDeque<TaskHolder<ID, T>> reprocessQueue = new LinkedBlockingDeque<>();
// 后台接收者线程
private final Thread acceptorThread;
// 待处理任务容器
private final Map<ID, TaskHolder<ID, T>> pendingTasks = new HashMap<>();
// 处理中的队列
private final Deque<ID> processingOrder = new LinkedList<>();

// 单项队列请求的信号量
private final Semaphore singleItemWorkRequests = new Semaphore(0);
// 单项任务队列
private final BlockingQueue<TaskHolder<ID, T>> singleItemWorkQueue = new LinkedBlockingQueue<>();

// 批量队列请求的信号量
private final Semaphore batchWorkRequests = new Semaphore(0);
// 批量任务队列
private final BlockingQueue<List<TaskHolder<ID, T>>> batchWorkQueue = new LinkedBlockingQueue<>();
// 时间调整器
private final TrafficShaper trafficShaper;

TaskDispatcher 调用 acceptorExecutor.process 将任务转给 AcceptorExecutor，可以看到就是将任务添加到接收者队列 acceptorQueue 的队尾了。

void process(ID id, T task, long expiryTime) {
    acceptorQueue.add(new TaskHolder<ID, T>(id, task, expiryTime));
    acceptedTasks++;
}

4、接收者任务 AcceptorRunner

任务添加到 acceptorQueue 了，那任务在哪处理的呢？这就是在 AcceptorRunner 这个任务里去处理的了，这个任务比较复杂，我先把整个代码放出来，再来分析。

class AcceptorRunner implements Runnable {
    @Override
    public void run() {
        long scheduleTime = 0;
        while (!isShutdown.get()) {
            try {
                // 排出输入队列的任务：将 reprocessQueue、acceptorQueue 队列的任务转移到 pendingTasks
                drainInputQueues();

                // 待处理的数量
                int totalItems = processingOrder.size();

                long now = System.currentTimeMillis();
                if (scheduleTime < now) {
                    // 时间补偿，正常情况下 transmissionDelay() 返回 0
                    scheduleTime = now + trafficShaper.transmissionDelay();
                }
                if (scheduleTime <= now) {
                    // 分配批量工作任务：将 pendingTasks 的任务分一批到（最多250个） batchWorkQueue 队列中
                    assignBatchWork();
                    // 分配单项工作任务：pendingTasks 如果还有剩余任务，将没有过期的转移到 singleItemWorkQueue 队列中
                    assignSingleItemWork();
                }

                // If no worker is requesting data or there is a delay injected by the traffic shaper,
                // sleep for some time to avoid tight loop.
                if (totalItems == processingOrder.size()) {
                    Thread.sleep(10);
                }
            } catch (InterruptedException ex) {
                // Ignore
            } catch (Throwable e) {
                // Safe-guard, so we never exit this loop in an uncontrolled way.
                logger.warn("Discovery AcceptorThread error", e);
            }
        }
    }

    private boolean isFull() {
        // 待处理的任务 >= 10000，也就是说 pendingTasks 最多放 10000 个任务
        return pendingTasks.size() >= maxBufferSize;
    }

    private void drainInputQueues() throws InterruptedException {
        do {
            // 排出 reprocessQueue，将 reprocessQueue 队列的任务转移到 pendingTasks
            drainReprocessQueue();
            // 排出 acceptorQueue，将 acceptorQueue 队列的任务转移到 pendingTasks
            drainAcceptorQueue();

            if (isShutdown.get()) {
                break;
            }
            // If all queues are empty, block for a while on the acceptor queue
            if (reprocessQueue.isEmpty() && acceptorQueue.isEmpty() && pendingTasks.isEmpty()) {
                // 等待任务放入 acceptorQueue，等待 10 毫秒
                TaskHolder<ID, T> taskHolder = acceptorQueue.poll(10, TimeUnit.MILLISECONDS);
                if (taskHolder != null) {
                    // 放入之后 acceptorQueue、pendingTasks 就不为空了
                    appendTaskHolder(taskHolder);
                }
            }
            // pendingTasks 为空、acceptorQueue 不为空、reprocessQueue不为空时，就会一直循环
            // 如果所有任务都处理完了，reprocessQueue、acceptorQueue、pendingTasks 都是空的，
            // 这时就会循环等待任务进入 acceptorQueue，每次等待 10 毫秒
        } while (!reprocessQueue.isEmpty() || !acceptorQueue.isEmpty() || pendingTasks.isEmpty());
    }

    private void drainAcceptorQueue() {
        while (!acceptorQueue.isEmpty()) {
            // 将 acceptorQueue 的任务转移到 pendingTasks
            appendTaskHolder(acceptorQueue.poll());
        }
    }

    private void drainReprocessQueue() {
        long now = System.currentTimeMillis();
        while (!reprocessQueue.isEmpty() && !isFull()) {
            // 从 reprocessQueue 队尾取出任务
            TaskHolder<ID, T> taskHolder = reprocessQueue.pollLast();
            ID id = taskHolder.getId();
            if (taskHolder.getExpiryTime() <= now) {
                // 任务过期
                expiredTasks++;
            } else if (pendingTasks.containsKey(id)) {
                // pendingTasks 已存在
                overriddenTasks++;
            } else {
                // 将 reprocessQueue 队列的任务放到 pendingTasks
                pendingTasks.put(id, taskHolder);
                // 添加到 processingOrder 队列的头部，reprocessQueue 是失败重试的队列，所以优先级高一些
                processingOrder.addFirst(id);
            }
        }
        if (isFull()) {
            queueOverflows += reprocessQueue.size();
            // pendingTasks 满了，就清空 reprocessQueue
            reprocessQueue.clear();
        }
    }

    private void appendTaskHolder(TaskHolder<ID, T> taskHolder) {
        if (isFull()) {
            // pendingTasks 满了就移除一个元素
            pendingTasks.remove(processingOrder.poll());
            queueOverflows++;
        }
        // 将 acceptorQueue 里的任务放到 pendingTasks
        TaskHolder<ID, T> previousTask = pendingTasks.put(taskHolder.getId(), taskHolder);
        if (previousTask == null) {
            // 原本不存在，将任务ID添加到 processingOrder 队列的最后
            processingOrder.add(taskHolder.getId());
        } else {
            // 已经存在了，就是覆盖
            overriddenTasks++;
        }
    }

    void assignSingleItemWork() {
        if (!processingOrder.isEmpty()) {
            if (singleItemWorkRequests.tryAcquire(1)) {
                long now = System.currentTimeMillis();
                while (!processingOrder.isEmpty()) {
                    ID id = processingOrder.poll();
                    TaskHolder<ID, T> holder = pendingTasks.remove(id);
                    if (holder.getExpiryTime() > now) {
                        // 将 pendingTasks 的任务移到 singleItemWorkQueue
                        singleItemWorkQueue.add(holder);
                        return;
                    }
                    expiredTasks++;
                }
                singleItemWorkRequests.release();
            }
        }
    }

    void assignBatchWork() {
        // 有足够的任务做一个批处理
        if (hasEnoughTasksForNextBatch()) {
            if (batchWorkRequests.tryAcquire(1)) {
                long now = System.currentTimeMillis();
                // 一批任务最多 250 个
                int len = Math.min(maxBatchingSize, processingOrder.size());
                List<TaskHolder<ID, T>> holders = new ArrayList<>(len);
                // 将 pendingTasks 中的任务移动一批到 holders 中
                // 也就是说，如果队列中有500个任务，这一批任务最多也是250个
                while (holders.size() < len && !processingOrder.isEmpty()) {
                    ID id = processingOrder.poll();
                    TaskHolder<ID, T> holder = pendingTasks.remove(id);
                    if (holder.getExpiryTime() > now) {
                        holders.add(holder);
                    } else {
                        expiredTasks++;
                    }
                }
                if (holders.isEmpty()) {
                    batchWorkRequests.release();
                } else {
                    batchSizeMetric.record(holders.size(), TimeUnit.MILLISECONDS);
                    // 添加到批量队列中
                    batchWorkQueue.add(holders);
                }
            }
        }
    }

    // 是否有足够的任务做一个批处理
    private boolean hasEnoughTasksForNextBatch() {
        if (processingOrder.isEmpty()) {
            return false;
        }
        if (pendingTasks.size() >= maxBufferSize) {
            return true;
        }

        // 从 processingOrder 队首取一个任务ID，然后从 pendingTasks 读取这个任务。注意 peek() 只是取出元素，并不会移除队首的元素
        TaskHolder<ID, T> nextHolder = pendingTasks.get(processingOrder.peek());
        // 判断任务提交到现在的时间差是否超过最大批任务延迟时间（500毫秒）
        long delay = System.currentTimeMillis() - nextHolder.getSubmitTimestamp();
        return delay >= maxBatchingDelay;
    }
}

先看它的 run 方法：

① 队列中的任务转移到待处理容器中

drainInputQueues 将输入队列（reprocessQueue、acceptorQueue）的任务转移到 pendingTasks 这个待处理容器中。

先是 drainReprocessQueue 将重处理队列 reprocessQueue 中的任务转移到 pendingTasks：

• 如果 pendingTasks 已满（超过10000），就直接清空了 reprocessQueue。任务丢弃会不会有影响呢？
• 否则，如果 reprocessQueue 非空，就从 reprocessQueue 队尾一个个取出来：
  • 如果过期了就丢掉这个任务，说明已经超过续约周期了（90秒）。比如实例注册，如果多次同步失败后，然后就直接丢弃，那不是其它 server 永远无法知道注册的这个实例？后面再分析这个问题。
  • 如果 pendingTasks 已经存在了，也丢弃这个重试任务
  • 否则就添加到 pendingTasks 中，并且往 processingOrder 的头部添加了任务ID
  • 注意它这里是从 reprocessQueue 队尾一个个取出，放入 processingOrder 头部，最终任务在 processingOrder 中的顺序跟 reprocessQueue 是一样的

然后是 drainAcceptorQueue 将接收者队列 acceptorQueue 中的任务转移到 pendingTasks：

• 只要 acceptorQueue 非空，就从队首取出任务
• 如果 pendingTasks 已满，则从 processingOrder 队首取出第一个任务的ID，并从 pendingTasks 中移除这个任务
• 否则就将任务添加到 pendingTasks，如果之前不存在相同ID的任务，就将任务ID添加到 processingOrder 队尾
• 注意它这里是从 acceptorQueue 队首取出任务，放到 processingOrder 队尾，最终任务在 processingOrder 中的顺序跟 acceptorQueue 是一样的

从这段任务转移以及后面的使用来看，processingOrder 将决定任务的处理顺序，最前面的将最先处理，也说明了 reprocessQueue 的优先级比 acceptorQueue 更高。而 pendingTasks 是一个 key-value 的队列，便于快速通过ID读取任务。

private void drainAcceptorQueue() {
    while (!acceptorQueue.isEmpty()) {
        // 将 acceptorQueue 的任务转移到 pendingTasks
        appendTaskHolder(acceptorQueue.poll());
    }
}

private void drainReprocessQueue() {
    long now = System.currentTimeMillis();
    while (!reprocessQueue.isEmpty() && !isFull()) {
        // 从 reprocessQueue 队尾取出任务
        TaskHolder<ID, T> taskHolder = reprocessQueue.pollLast();
        ID id = taskHolder.getId();
        if (taskHolder.getExpiryTime() <= now) {
            // 任务过期
            expiredTasks++;
        } else if (pendingTasks.containsKey(id)) {
            // pendingTasks 已存在
            overriddenTasks++;
        } else {
            // 将 reprocessQueue 队列的任务放到 pendingTasks
            pendingTasks.put(id, taskHolder);
            // 添加到 processingOrder 队列的头部，reprocessQueue 是失败重试的队列，所以优先级高一些
            processingOrder.addFirst(id);
        }
    }
    if (isFull()) {
        queueOverflows += reprocessQueue.size();
        // pendingTasks 满了，就清空 reprocessQueue
        reprocessQueue.clear();
    }
}

private void appendTaskHolder(TaskHolder<ID, T> taskHolder) {
    if (isFull()) {
        // pendingTasks 满了就移除一个元素
        pendingTasks.remove(processingOrder.poll());
        queueOverflows++;
    }
    // 将 acceptorQueue 里的任务放到 pendingTasks
    TaskHolder<ID, T> previousTask = pendingTasks.put(taskHolder.getId(), taskHolder);
    if (previousTask == null) {
        // 原本不存在，将任务ID添加到 processingOrder 队列的最后
        processingOrder.add(taskHolder.getId());
    } else {
        // 已经存在了，就是覆盖
        overriddenTasks++;
    }
}

② 接下来通过 trafficShaper 获取了一个补偿时间，它主要是在发生阻塞或网络异常导致任务提交失败后，在任务调度周期内做一个时间补偿，这块等分析到提交任务失败的时候再回来看看。

long now = System.currentTimeMillis();
if (scheduleTime < now) {
    // 时间补偿，正常情况下 transmissionDelay() 返回 0
    scheduleTime = now + trafficShaper.transmissionDelay();
}

③ 任务打包

接着看 assignBatchWork ，它就是将任务打包成一个批次：

• 首先调用 hasEnoughTasksForNextBatch 判断是否有足够的任务来打成一个批次，注意它判断了最新提交的任务的时间是否超过了延迟时间 maxBatchingDelay（500ms），也就是说批次任务每隔500毫秒运行一次。
• 能够打包后，要获取 batchWorkRequests 信号量的一个许可证，因为许可证默认数量是 0，那一定是先有地方调用了 batchWorkRequests.release() 放入许可证，否则这里就不会打包了。
• 然后可以看出，一个批次的任务数量最多是250个
• 它从 processingOrder 的队首取出这个批次的任务ID，并从 pendingTasks 中取出任务，如果是过期的任务就直接丢弃了。
• 然后如果这个批次并没有任务，他才调用 batchWorkRequests.release() 释放了许可证，否则就把这个批次任务添加到批量工作队列 batchWorkQueue 中，注意并没有释放许可证。

void assignBatchWork() {
    // 有足够的任务做一个批处理
    if (hasEnoughTasksForNextBatch()) {
        // 获取许可证
        if (batchWorkRequests.tryAcquire(1)) {
            long now = System.currentTimeMillis();
            // 一批任务最多 250 个
            int len = Math.min(maxBatchingSize, processingOrder.size());
            List<TaskHolder<ID, T>> holders = new ArrayList<>(len);
            // 将 pendingTasks 中的任务移动一批到 holders 中
            // 也就是说，如果队列中有500个任务，这一批任务最多也是250个
            while (holders.size() < len && !processingOrder.isEmpty()) {
                ID id = processingOrder.poll();
                TaskHolder<ID, T> holder = pendingTasks.remove(id);
                if (holder.getExpiryTime() > now) {
                    holders.add(holder);
                } else {
                    expiredTasks++;
                }
            }
            if (holders.isEmpty()) {
                batchWorkRequests.release();
            } else {
                batchSizeMetric.record(holders.size(), TimeUnit.MILLISECONDS);
                // 添加到批量队列中
                batchWorkQueue.add(holders);
            }
        }
    }
}

// 是否有足够的任务做一个批处理
private boolean hasEnoughTasksForNextBatch() {
    if (processingOrder.isEmpty()) {
        return false;
    }
    if (pendingTasks.size() >= maxBufferSize) {
        return true;
    }

    // 从 processingOrder 队首取一个任务ID，然后从 pendingTasks 读取这个任务。注意 peek() 只是取出元素，并不会移除队首的元素
    TaskHolder<ID, T> nextHolder = pendingTasks.get(processingOrder.peek());
    // 判断任务提交到现在的时间差是否超过最大批任务延迟时间（500毫秒）
    long delay = System.currentTimeMillis() - nextHolder.getSubmitTimestamp();
    return delay >= maxBatchingDelay;
}

接着看分配单项任务的方法 assignSingleItemWork：

• 如果 processingOrder 非空且获取到了 singleItemWorkRequests 信号量的许可证，就将 processingOrder 队列剩余的任务都取出来，放入单项工作队列 singleItemWorkQueue 中
• 也就是前面已经打了一批任务（250个）之后，processingOrder 中还有任务，就全部取出来放到 singleItemWorkQueue 队列中

void assignSingleItemWork() {
    if (!processingOrder.isEmpty()) {
        if (singleItemWorkRequests.tryAcquire(1)) {
            long now = System.currentTimeMillis();
            while (!processingOrder.isEmpty()) {
                ID id = processingOrder.poll();
                TaskHolder<ID, T> holder = pendingTasks.remove(id);
                if (holder.getExpiryTime() > now) {
                    // 将 pendingTasks 的任务移到 singleItemWorkQueue
                    singleItemWorkQueue.add(holder);
                    return;
                }
                expiredTasks++;
            }
            singleItemWorkRequests.release();
        }
    }
}

5、任务处理器 TaskExecutors

batchWorkQueue 中的批量任务以及 singleItemWorkQueue 中的单项任务都已经准备好了，那是在哪里发送到集群节点的呢，那就是任务执行器 TaskExecutors 了。

① 创建 TaskExecutors

从创建 TaskExecutors 的方法中可以看出：

• 批量处理任务的类是 BatchWorkerRunnable，它主要就是处理批量任务队列 batchWorkQueue 中的任务
• 处理单项任务的类是 SingleTaskWorkerRunnable，它主要就是处理单项任务队列 singleItemWorkQueue 中的任务
• TaskExecutors 创建了一个线程池，batchExecutors 默认有20个工作线程（不太理解他为什么不用JDK现成的线程池。。），singleItemExecutors 默认只有一个工作线程。

static <ID, T> TaskExecutors<ID, T> singleItemExecutors(final String name, int workerCount, final TaskProcessor<T> processor, final AcceptorExecutor<ID, T> acceptorExecutor) {
    final AtomicBoolean isShutdown = new AtomicBoolean();
    final TaskExecutorMetrics metrics = new TaskExecutorMetrics(name);
    registeredMonitors.put(name, metrics);
    // workerCount = 1
    return new TaskExecutors<>(idx -> new SingleTaskWorkerRunnable<>("TaskNonBatchingWorker-" + name + '-' + idx, isShutdown, metrics, processor, acceptorExecutor), workerCount, isShutdown);
}

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

static <ID, T> TaskExecutors<ID, T> batchExecutors(final String name, int workerCount, final TaskProcessor<T> processor, final AcceptorExecutor<ID, T> acceptorExecutor) {
    final AtomicBoolean isShutdown = new AtomicBoolean();
    final TaskExecutorMetrics metrics = new TaskExecutorMetrics(name);
    registeredMonitors.put(name, metrics);
    // BatchWorkerRunnable 批量任务处理
    return new TaskExecutors<>(idx -> new BatchWorkerRunnable<>("TaskBatchingWorker-" + name + '-' + idx, isShutdown, metrics, processor, acceptorExecutor), workerCount, isShutdown);
}

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

private final List<Thread> workerThreads;

TaskExecutors(WorkerRunnableFactory<ID, T> workerRunnableFactory, int workerCount, AtomicBoolean isShutdown) {
    this.isShutdown = isShutdown;
    // 工作线程集合
    this.workerThreads = new ArrayList<>();

    // 创建20个线程，相当于是搞了一个线程池
    ThreadGroup threadGroup = new ThreadGroup("eurekaTaskExecutors");
    for (int i = 0; i < workerCount; i++) {
        WorkerRunnable<ID, T> runnable = workerRunnableFactory.create(i);
        Thread workerThread = new Thread(threadGroup, runnable, runnable.getWorkerName());
        workerThreads.add(workerThread);
        workerThread.setDaemon(true);
        workerThread.start();
    }
}

② BatchWorkerRunnable

看批量处理的任务：

• 首先 getWork 获取批量任务，它调用 taskDispatcher.requestWorkItems()，实际就是返回了 taskDispatcher 的 batchWorkQueue，并且调用 batchWorkRequests.release() 往信号量放入一个许可证，这样前面 AcceptorRunner 就可以得到许可证然后去打包批量任务了
• 如果 batchWorkQueue 中没有批量任务，可以看到是一直在 while 循环等待的，直到拿到一个批量任务。它这个 BatchWorkerRunnable 任务和前面的 AcceptorRunner 任务，感觉通过信号量的方式就形成了一个等待通知的机制，BatchWorkerRunnable 放入一个许可证，让 AcceptorRunner 拿到这个许可证去打个批次的任务过来。
• 拿到这个批次任务后，就调用 processor（ReplicationTaskProcessor）来处理任务。
• 如果任务处理结果是 Congestion（阻塞）、TransientError（传输失败）就要重处理，调用了 taskDispatcher.reprocess 将这个批次的任务提交到重处理队列 reprocessQueue 中。

static class BatchWorkerRunnable<ID, T> extends WorkerRunnable<ID, T> {

    BatchWorkerRunnable(String workerName, AtomicBoolean isShutdown, TaskExecutorMetrics metrics, TaskProcessor<T> processor, AcceptorExecutor<ID, T> acceptorExecutor) {
        super(workerName, isShutdown, metrics, processor, acceptorExecutor);
    }

    @Override
    public void run() {
        try {
            while (!isShutdown.get()) {
                // 获取一个批量任务
                List<TaskHolder<ID, T>> holders = getWork();
                metrics.registerExpiryTimes(holders);
                // TaskHolder 提取 ReplicationTask
                List<T> tasks = getTasksOf(holders);
                // processor => 任务复制处理器 ReplicationTaskProcessor
                ProcessingResult result = processor.process(tasks);
                switch (result) {
                    case Success:
                        break;
                    case Congestion:
                    case TransientError:
                        // 阻塞或网络失败就重新处理这批任务
                        taskDispatcher.reprocess(holders, result);
                        break;
                    case PermanentError:
                        logger.warn("Discarding {} tasks of {} due to permanent error", holders.size(), workerName);
                }
                metrics.registerTaskResult(result, tasks.size());
            }
        } catch (InterruptedException e) {
            // Ignore
        } catch (Throwable e) {
            // Safe-guard, so we never exit this loop in an uncontrolled way.
            logger.warn("Discovery WorkerThread error", e);
        }
    }

    private List<TaskHolder<ID, T>> getWork() throws InterruptedException {
        // 获取批量队列 batchWorkQueue
        BlockingQueue<List<TaskHolder<ID, T>>> workQueue = taskDispatcher.requestWorkItems();
        List<TaskHolder<ID, T>> result;
        do {
            result = workQueue.poll(1, TimeUnit.SECONDS);
            // 循环等待，直到取到一个批量任务
        } while (!isShutdown.get() && result == null);
        return (result == null) ? new ArrayList<>() : result;
    }

    private List<T> getTasksOf(List<TaskHolder<ID, T>> holders) {
        List<T> tasks = new ArrayList<>(holders.size());
        for (TaskHolder<ID, T> holder : holders) {
            tasks.add(holder.getTask());
        }
        return tasks;
    }
}

BlockingQueue<TaskHolder<ID, T>> requestWorkItem() {
    singleItemWorkRequests.release();
    return singleItemWorkQueue;
}

BlockingQueue<List<TaskHolder<ID, T>>> requestWorkItems() {
    batchWorkRequests.release();
    return batchWorkQueue;
}

③ 任务重处理

可以看到处理失败后，就是将这批任务添加到重处理队列 reprocessQueue 中去，然后向时间调整期注册失败，这就和前面 AcceptorRunner 处理 reprocessQueue 对应起来了。

void reprocess(List<TaskHolder<ID, T>> holders, ProcessingResult processingResult) {
    // 添加到重处理队列 reprocessQueue
    reprocessQueue.addAll(holders);
    replayedTasks += holders.size();
    // 时间调整器注册失败
    trafficShaper.registerFailure(processingResult);
}

④ TrafficShaper 

还记得前面 AcceptorRunner 中又这样一段代码，可以看到是通过 trafficShaper 计算了一个延迟时间，这里就来看看是如何计算的。

long now = System.currentTimeMillis();
if (scheduleTime < now) {
    // 时间补偿，正常情况下 transmissionDelay() 返回 0
    scheduleTime = now + trafficShaper.transmissionDelay();
}
if (scheduleTime <= now) {
    // 分配批量工作任务：将 pendingTasks 的任务分一批到（最多250个） batchWorkQueue 队列中
    assignBatchWork();
    // 分配单项工作任务：pendingTasks 如果还有剩余任务，将没有过期的转移到 singleItemWorkQueue 队列中
    assignSingleItemWork();
}

时间调整器 TrafficShaper：

• registerFailure 就是设置了失败的最后时间
• 然后看 transmissionDelay，以阻塞为例，如果上一次阻塞失败到现在 500 毫秒，那么 transmissionDelay 返回 500，那么 transmissionDelay 就大于 now 了，就不会打包任务了。
• 总结下来就是如果上一次阻塞导致批量任务提交失败，就延迟1000毫秒后执行。如果上一次网络导致批量任务提交失败，就延迟100毫秒执行。

TrafficShaper(long congestionRetryDelayMs, long networkFailureRetryMs) {
    // 1000
    this.congestionRetryDelayMs = Math.min(MAX_DELAY, congestionRetryDelayMs);
    // 100
    this.networkFailureRetryMs = Math.min(MAX_DELAY, networkFailureRetryMs);
}

void registerFailure(ProcessingResult processingResult) {
    if (processingResult == ProcessingResult.Congestion) {
        // 最后一次阻塞导致提交批处理失败的时间
        lastCongestionError = System.currentTimeMillis();
    } else if (processingResult == ProcessingResult.TransientError) {
        // 最后一次网络原因导致提交批处理失败的时间
        lastNetworkFailure = System.currentTimeMillis();
    }
}

// 计算传输延迟的时间
long transmissionDelay() {
    if (lastCongestionError == -1 && lastNetworkFailure == -1) {
        return 0;
    }

    long now = System.currentTimeMillis();
    if (lastCongestionError != -1) {
        // 阻塞延迟时间
        long congestionDelay = now - lastCongestionError;
        if (congestionDelay >= 0 && congestionDelay < congestionRetryDelayMs) {
            return congestionRetryDelayMs - congestionDelay;
        }
        lastCongestionError = -1;
    }

    if (lastNetworkFailure != -1) {
        // 网络延迟时间
        long failureDelay = now - lastNetworkFailure;
        if (failureDelay >= 0 && failureDelay < networkFailureRetryMs) {
            return networkFailureRetryMs - failureDelay;
        }
        lastNetworkFailure = -1;
    }
    return 0;
}

⑤ SingleTaskWorkerRunnable

单项任务处理跟批量任务处理的流程是类似的，只不过是一个个的发送同步操作，处理失败同样也会放入重处理队列中。

一个批量任务250个对于大部分场景来说其实不会触发单项任务的处理，如果微服务集群中有很多的实例，eureka 通过不断的轮询也能尽量使用批量处理，我觉得单项任务处理更像是对批量任务处理的一种补充。

6、复制任务处理器 ReplicationTaskProcessor

批量任务最终是提交到 ReplicationTaskProcessor 去处理的，可以看到，就是调用了 replicationClient 提交了批量任务，提交的接口是 POST peerreplication/batch，那我们就可以从这个入口去看 eureka-server 如何接收批量任务的。

public ProcessingResult process(List<ReplicationTask> tasks) {
    // 任务封装到 ReplicationList
    ReplicationList list = createReplicationListOf(tasks);
    try {
        // 提交批量任务：POST peerreplication/batch/
        EurekaHttpResponse<ReplicationListResponse> response = replicationClient.submitBatchUpdates(list);
        int statusCode = response.getStatusCode();
        if (!isSuccess(statusCode)) {
            if (statusCode == 503) {
                logger.warn("Server busy (503) HTTP status code received from the peer {}; rescheduling tasks after delay", peerId);
                return ProcessingResult.Congestion;
            } else {
                // Unexpected error returned from the server. This should ideally never happen.
                logger.error("Batch update failure with HTTP status code {}; discarding {} replication tasks", statusCode, tasks.size());
                return ProcessingResult.PermanentError;
            }
        } else {
            // 处理批量任务结果
            handleBatchResponse(tasks, response.getEntity().getResponseList());
        }
    } catch (Throwable e) {
        if (maybeReadTimeOut(e)) {
            //read timeout exception is more Congestion then TransientError, return Congestion for longer delay
            return ProcessingResult.Congestion;
        } else if (isNetworkConnectException(e)) {
            logNetworkErrorSample(null, e);
            return ProcessingResult.TransientError;
        } else {
            logger.error("Not re-trying this exception because it does not seem to be a network exception", e);
            return ProcessingResult.PermanentError;
        }
    }
    return ProcessingResult.Success;
}

7、接收复制同步请求

很容易找到批量任务提交的接口在 PeerReplicationResource 的 batchReplication 方法中。

可以看到，其实遍历批量任务，然后根据不同的操作类型，调用 XxxResource 接口进行对应的操作。比如注册，就是调用 applicationResource.addInstance 完成实例的注册。

@Path("/{version}/peerreplication")
@Produces({"application/xml", "application/json"})
public class PeerReplicationResource {

    private static final Logger logger = LoggerFactory.getLogger(PeerReplicationResource.class);

    private static final String REPLICATION = "true";

    private final EurekaServerConfig serverConfig;
    private final PeerAwareInstanceRegistry registry;

    @Inject
    PeerReplicationResource(EurekaServerContext server) {
        this.serverConfig = server.getServerConfig();
        this.registry = server.getRegistry();
    }

    public PeerReplicationResource() {
        this(EurekaServerContextHolder.getInstance().getServerContext());
    }

    @Path("batch")
    @POST
    public Response batchReplication(ReplicationList replicationList) {
        try {
            ReplicationListResponse batchResponse = new ReplicationListResponse();
            for (ReplicationInstance instanceInfo : replicationList.getReplicationList()) {
                try {
                    // dispatch 分发任务
                    batchResponse.addResponse(dispatch(instanceInfo));
                } catch (Exception e) {
                    batchResponse.addResponse(new ReplicationInstanceResponse(Status.INTERNAL_SERVER_ERROR.getStatusCode(), null));
                    logger.error("{} request processing failed for batch item {}/{}",
                            instanceInfo.getAction(), instanceInfo.getAppName(), instanceInfo.getId(), e);
                }
            }
            return Response.ok(batchResponse).build();
        } catch (Throwable e) {
            logger.error("Cannot execute batch Request", e);
            return Response.status(Status.INTERNAL_SERVER_ERROR).build();
        }
    }

    private ReplicationInstanceResponse dispatch(ReplicationInstance instanceInfo) {
        ApplicationResource applicationResource = createApplicationResource(instanceInfo);
        InstanceResource resource = createInstanceResource(instanceInfo, applicationResource);

        String lastDirtyTimestamp = toString(instanceInfo.getLastDirtyTimestamp());
        String overriddenStatus = toString(instanceInfo.getOverriddenStatus());
        String instanceStatus = toString(instanceInfo.getStatus());

        Builder singleResponseBuilder = new Builder();
        // 根据不同的类型分别处理
        switch (instanceInfo.getAction()) {
            case Register:
                singleResponseBuilder = handleRegister(instanceInfo, applicationResource);
                break;
            case Heartbeat:
                singleResponseBuilder = handleHeartbeat(serverConfig, resource, lastDirtyTimestamp, overriddenStatus, instanceStatus);
                break;
            case Cancel:
                singleResponseBuilder = handleCancel(resource);
                break;
            case StatusUpdate:
                singleResponseBuilder = handleStatusUpdate(instanceInfo, resource);
                break;
            case DeleteStatusOverride:
                singleResponseBuilder = handleDeleteStatusOverride(instanceInfo, resource);
                break;
        }
        return singleResponseBuilder.build();
    }

    /* Visible for testing */ ApplicationResource createApplicationResource(ReplicationInstance instanceInfo) {
        return new ApplicationResource(instanceInfo.getAppName(), serverConfig, registry);
    }

    /* Visible for testing */ InstanceResource createInstanceResource(ReplicationInstance instanceInfo,
                                                                      ApplicationResource applicationResource) {
        return new InstanceResource(applicationResource, instanceInfo.getId(), serverConfig, registry);
    }

    private static Builder handleRegister(ReplicationInstance instanceInfo, ApplicationResource applicationResource) {
        // addInstance
        applicationResource.addInstance(instanceInfo.getInstanceInfo(), REPLICATION);
        return new Builder().setStatusCode(Status.OK.getStatusCode());
    }

    private static Builder handleCancel(InstanceResource resource) {
        // cancelLease
        Response response = resource.cancelLease(REPLICATION);
        return new Builder().setStatusCode(response.getStatus());
    }

    private static Builder handleHeartbeat(EurekaServerConfig config, InstanceResource resource, String lastDirtyTimestamp, String overriddenStatus, String instanceStatus) {
        Response response = resource.renewLease(REPLICATION, overriddenStatus, instanceStatus, lastDirtyTimestamp);
        int responseStatus = response.getStatus();
        Builder responseBuilder = new Builder().setStatusCode(responseStatus);

        if ("false".equals(config.getExperimental("bugfix.934"))) {
            if (responseStatus == Status.OK.getStatusCode() && response.getEntity() != null) {
                responseBuilder.setResponseEntity((InstanceInfo) response.getEntity());
            }
        } else {
            if ((responseStatus == Status.OK.getStatusCode() || responseStatus == Status.CONFLICT.getStatusCode())
                    && response.getEntity() != null) {
                responseBuilder.setResponseEntity((InstanceInfo) response.getEntity());
            }
        }
        return responseBuilder;
    }

    private static Builder handleStatusUpdate(ReplicationInstance instanceInfo, InstanceResource resource) {
        Response response = resource.statusUpdate(instanceInfo.getStatus(), REPLICATION, toString(instanceInfo.getLastDirtyTimestamp()));
        return new Builder().setStatusCode(response.getStatus());
    }

    private static Builder handleDeleteStatusOverride(ReplicationInstance instanceInfo, InstanceResource resource) {
        Response response = resource.deleteStatusUpdate(REPLICATION, instanceInfo.getStatus(),
                instanceInfo.getLastDirtyTimestamp().toString());
        return new Builder().setStatusCode(response.getStatus());
    }

    private static <T> String toString(T value) {
        if (value == null) {
            return null;
        }
        return value.toString();
    }
}

8、集群数据同步冲突问题

Peer to Peer 模式重点要解决的一个问题是数据复制冲突的问题，因为 peer 节点间的相互复制并不能保证所有操作都成功。eureka 主要通过 lastDirtyTimestamp 标识和心跳来进行数据的最终修复，下面就来看下 eureka 如何处理数据冲突问题的。

① 先看续约的这个方法

• 在续约 renewLease 里，如果 lastDirtyTimestamp 不为空且允许时间戳不一致时进行同步（默认开启），就调用了 validateDirtyTimestamp 方法校验 lastDirtyTimestamp。
• 接着看 validateDirtyTimestamp，如果 lastDirtyTimestamp 与本地实例的 lastDirtyTimestamp 一致，说明数据是一致的，就续约成功，返回 OK（200）。
• 如果 lastDirtyTimestamp 大于 本地实例的 lastDirtyTimestamp，说明复制的实例最新更新的，出现数据冲突，返回 NOT_FOUND（404）。
• 如果 lastDirtyTimestamp 小于 本地实例的 lastDirtyTimestamp ，说明复制的实例是旧的，出现数据冲突，返回 CONFLICT（409），并且返回了本地的实例。

@PUT
public Response renewLease(
        @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication,
        @QueryParam("overriddenstatus") String overriddenStatus,
        @QueryParam("status") String status,
        @QueryParam("lastDirtyTimestamp") String lastDirtyTimestamp) {
    boolean isFromReplicaNode = "true".equals(isReplication);
    // 调用注册表的 renew 进行服务续约
    boolean isSuccess = registry.renew(app.getName(), id, isFromReplicaNode);

    // Not found in the registry, immediately ask for a register
    if (!isSuccess) {
        logger.warn("Not Found (Renew): {} - {}", app.getName(), id);
        return Response.status(Status.NOT_FOUND).build();
    }
    // Check if we need to sync based on dirty time stamp, the client
    // instance might have changed some value
    Response response;
    // 如果是复制操作，就校验 lastDirtyTimestamp
    if (lastDirtyTimestamp != null && serverConfig.shouldSyncWhenTimestampDiffers()) {
        response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
        // Store the overridden status since the validation found out the node that replicates wins
        if (response.getStatus() == Response.Status.NOT_FOUND.getStatusCode()
                && (overriddenStatus != null)
                && !(InstanceStatus.UNKNOWN.name().equals(overriddenStatus))
                && isFromReplicaNode) {
            registry.storeOverriddenStatusIfRequired(app.getAppName(), id, InstanceStatus.valueOf(overriddenStatus));
        }
    } else {
        response = Response.ok().build();
    }
    logger.debug("Found (Renew): {} - {}; reply status={}", app.getName(), id, response.getStatus());
    return response;
}

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

private Response validateDirtyTimestamp(Long lastDirtyTimestamp, boolean isReplication) {
    InstanceInfo appInfo = registry.getInstanceByAppAndId(app.getName(), id, false);
    if (appInfo != null) {
        // 如果复制传过来的实例中 lastDirtyTimestamp 不等于本地实例的 lastDirtyTimestamp
        if ((lastDirtyTimestamp != null) && (!lastDirtyTimestamp.equals(appInfo.getLastDirtyTimestamp()))) {
            Object[] args = {id, appInfo.getLastDirtyTimestamp(), lastDirtyTimestamp, isReplication};

            if (lastDirtyTimestamp > appInfo.getLastDirtyTimestamp()) {
                logger.debug(
                        "Time to sync, since the last dirty timestamp differs -"
                                + " ReplicationInstance id : {},Registry : {} Incoming: {} Replication: {}",
                        args);
                // 如果复制实例的 lastDirtyTimestamp > 本地实例的 lastDirtyTimestamp，表示数据出现冲突，返回 404，要求应用实例重新进行 register 操作
                return Response.status(Status.NOT_FOUND).build();
            } else if (appInfo.getLastDirtyTimestamp() > lastDirtyTimestamp) {
                // In the case of replication, send the current instance info in the registry for the
                // replicating node to sync itself with this one.
                if (isReplication) {
                    logger.debug(
                            "Time to sync, since the last dirty timestamp differs -"
                                    + " ReplicationInstance id : {},Registry : {} Incoming: {} Replication: {}",
                            args);
                    // 如果本地实例的 lastDirtyTimestamp > 复制实例的 lastDirtyTimestamp，就返回 CONFLICT(409)，说明数据冲突，要求其同步自己最新的数据
                    // 注意这里将本地实例 appInfo 放入 Response entity 中了
                    return Response.status(Status.CONFLICT).entity(appInfo).build();
                } else {
                    return Response.ok().build();
                }
            }
        }

    }
    return Response.ok().build();
}

② 接着看 PeerReplicationResource 处理心跳的方法

• 首先就是调用了续约的方法 renewLease 进行续约
• 如果返回的状态是 OK 或者 CONFLICT，就在 resposeEntity 中返回本地实例

private static Builder handleHeartbeat(EurekaServerConfig config, InstanceResource resource, String lastDirtyTimestamp, String overriddenStatus, String instanceStatus) {
    // 调用 renewLease 续约
    Response response = resource.renewLease(REPLICATION, overriddenStatus, instanceStatus, lastDirtyTimestamp);
    int responseStatus = response.getStatus();
    Builder responseBuilder = new Builder().setStatusCode(responseStatus);

    if ("false".equals(config.getExperimental("bugfix.934"))) {
        if (responseStatus == Status.OK.getStatusCode() && response.getEntity() != null) {
            responseBuilder.setResponseEntity((InstanceInfo) response.getEntity());
        }
    } else {
        if ((responseStatus == Status.OK.getStatusCode() || responseStatus == Status.CONFLICT.getStatusCode())
                && response.getEntity() != null) {
            // 续约成功或 CONFLICT 冲突时，将本地实例 appInfo 返回到客户端
            responseBuilder.setResponseEntity((InstanceInfo) response.getEntity());
        }
    }
    return responseBuilder;
}

③ PeerEurekaNode 发送心跳

ReplicationTaskProcessor 收到批量任务返回结果后，会处理响应结果，对于心跳任务，可以找到，失败后就会回调 handleFailure 方法。

• 如果返回状态是 404（NOT_FOUND），就会重新注册，也是提交到队列中。通过重新注册来实现数据同步。
• 如果是其它状态（409 CONFLICT）并且开启了时间戳不一致就同步的配置，就将服务端返回的实例注册到本地，实现数据的同步。

public void heartbeat(final String appName, final String id,
                      final InstanceInfo info, final InstanceStatus overriddenStatus,
                      boolean primeConnection) throws Throwable {
    if (primeConnection) {
        // We do not care about the result for priming request.
        replicationClient.sendHeartBeat(appName, id, info, overriddenStatus);
        return;
    }
    ReplicationTask replicationTask = new InstanceReplicationTask(targetHost, Action.Heartbeat, info, overriddenStatus, false) {
        @Override
        public EurekaHttpResponse<InstanceInfo> execute() throws Throwable {
            return replicationClient.sendHeartBeat(appName, id, info, overriddenStatus);
        }

        @Override
        public void handleFailure(int statusCode, Object responseEntity) throws Throwable {
            super.handleFailure(statusCode, responseEntity);
            if (statusCode == 404) {
                logger.warn("{}: missing entry.", getTaskName());
                if (info != null) {
                    logger.warn("{}: cannot find instance id {} and hence replicating the instance with status {}",
                            getTaskName(), info.getId(), info.getStatus());
                    // 复制返回 404 时，重新注册
                    register(info);
                }
            } else if (config.shouldSyncWhenTimestampDiffers()) {
                // 409（CONFLICT）
                InstanceInfo peerInstanceInfo = (InstanceInfo) responseEntity;
                if (peerInstanceInfo != null) {
                    syncInstancesIfTimestampDiffers(appName, id, info, peerInstanceInfo);
                }
            }
        }
    };
    long expiryTime = System.currentTimeMillis() + getLeaseRenewalOf(info);
    batchingDispatcher.process(taskId("heartbeat", info), replicationTask, expiryTime);
}

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

private void syncInstancesIfTimestampDiffers(String appName, String id, InstanceInfo info, InstanceInfo infoFromPeer) {
    try {
        if (infoFromPeer != null) {
            if (infoFromPeer.getOverriddenStatus() != null && !InstanceStatus.UNKNOWN.equals(infoFromPeer.getOverriddenStatus())) {
                logger.warn("Overridden Status info -id {}, mine {}, peer's {}", id, info.getOverriddenStatus(), infoFromPeer.getOverriddenStatus());
                registry.storeOverriddenStatusIfRequired(appName, id, infoFromPeer.getOverriddenStatus());
            }
            // 将服务端的实例注册到本地，实现数据同步
            registry.register(infoFromPeer, true);
        }
    } catch (Throwable e) {
        logger.warn("Exception when trying to set information from peer :", e);
    }
}

至此，我们就可以总结出，eureka server 通过对比 lastDirtyTimestamp 和心跳操作来实现集群数据的复制和最终同步。

前面提到的实例过期就丢弃任务这样看来就没问题，它也不保证peer节点间相互复制的所有操作都成功，eureka 采用的是最终一致性，它是通过心跳的方式实现集群数据的最终修复和同步，只是集群间可能会同步延迟。

9、集群同步总结

下面总结下 eureka-server 集群节点间的同步：

• 首先 eureka-server 集群采用的是 Peer To Peer 的模式，即对等复制，各个 server 不分主从，每个 server 都可以接收写请求，然后互相之间进行数据更新同步。
• 数据同步采用了多层任务队列+批量处理的机制：
  • eureka-server 接收到客户端请求（注册、下线、续约）后都会调用集群 PeerEurekaNode 进行操作的同步
  • PeerEurekaNode  将操作封装成 InstanceReplicationTask 实例复制任务，并用批量分发器 batchingDispatcher（TaskDispatcher）来分发处理
  • batchingDispatcher 内部则将任务交给接收者执行器 AcceptorExecutor 处理，任务首先进入到 AcceptorExecutor 内的接收者队列 acceptorQueue 中
  • AcceptorExecutor 有个后台工作线程（AcceptorRunner）不断轮询，将接收者队列 acceptorQueue 和 重处理队列 reprocessQueue 中的任务转移到处理中队列中（processingOrder + pendingTasks）
  • 接着将处理中队列中的任务打包，一次最多 250 个任务，然后放到批量工作队列 batchWorkQueue。如果处理中队列中还有任务，就将任务放到单项任务队列 singleItemWorkQueue
  • 任务都打包好了，任务执行器 TaskExecutors 内分别有批量任务处理器（BatchWorkerRunnable）和单项任务处理器（SingleTaskWorkerRunnable）来处理 batchWorkQueue 和 singleItemWorkQueue 中的任务
  • 处理器会利用任务复制处理器（ReplicationTaskProcessor）来提交任务，批量任务会提交给 server 节点的批量接口（peerreplication/batch/），单项任务则提交到对应的操作接口
  • 任务提交如果阻塞或者网络失败就会被放入重处理队列 reprocessQueue，然后再次被 AcceptorRunner 轮询处理，不过过期（超过90秒）的任务会被丢弃掉
• 其它 eureka-server 同步：
  • 其它 eureka-server 接收到批量复制请求后，会轮询批量任务列表，根据不同的操作类型（Register、Heartbeat、Cancel 等）分别调用 Resource 的接口进行处理
  • 如果是续约操作，会判断复制实例的 lastDirtyTimestamp 与本地实例的 lastDirtyTimestamp，如果是一致的，就任务数据一致
  • 如果复制实例的 lastDirtyTimestamp > 本地实例的 lastDirtyTimestamp，则复制实例的数据是最新的，返回 404（NOT_FOUND） 要求客户端重新发送一个注册操作过来
  • 如果复制实例的 lastDirtyTimestamp < 本地实例的 lastDirtyTimestamp，则本地实例的数据是最新的，返回 409（CONFLICT）和本地实例，客户端用返回来的实例覆盖本地的实例

下面再用一张图总结集群同步：

十三、SpringCloud Eureka

到这里，对 Eureka 核心源码的研究就差不多了，这节来看下 Spring cloud eureka。Spring cloud eureka 提供了服务端的依赖 spring-cloud-starter-netflix-eureka-server 和客户端的依赖 spring-cloud-starter-netflix-eureka-client，这两个依赖包本身是比较简单的，只是对 netflix 的 eureka-server 和 eureka-client 的封装，它通过一些注解和配置类将 eureka 整合到 springboot 技术栈中，便于使用。

1、spring-cloud-starter-netflix-eureka-server

看 spring-cloud-starter-netflix-eureka-server 我们从 @EnableEurekaServer 这个注解来看，因为我们的注册中心是基于 springboot 的，在启动类上加上了 @EnableEurekaServer 注解就启用了 eureka-server 注册中心。

① Eureka Server 自动化配置

看这个注解的定义，从注释中可以了解到，这个注解会激活 EurekaServerAutoConfiguration 的自动化配置类。

/**
 * Annotation to activate Eureka Server related configuration.
 * {@link EurekaServerAutoConfiguration}
 *
 * @author Dave Syer
 * @author Biju Kunjummen
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(EurekaServerMarkerConfiguration.class)
public @interface EnableEurekaServer {

}

看 EurekaServerAutoConfiguration 这个类，可以发现 springcloud 几乎是将 com.netflix.eureka.EurekaBootStrap 中初始化组件的代码拷贝到了 EurekaServerAutoConfiguration，然后以 springboot 创建 bean 的方式来创建相关的组件。

@Configuration(proxyBeanMethods = false)
@Import(EurekaServerInitializerConfiguration.class)
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
@EnableConfigurationProperties({ EurekaDashboardProperties.class,
        InstanceRegistryProperties.class })
@PropertySource("classpath:/eureka/server.properties")
public class EurekaServerAutoConfiguration implements WebMvcConfigurer {

    /**
     * List of packages containing Jersey resources required by the Eureka server.
     */
    private static final String[] EUREKA_PACKAGES = new String[] {
            "com.netflix.discovery", "com.netflix.eureka" };

    @Autowired
    private ApplicationInfoManager applicationInfoManager;

    @Autowired
    private EurekaServerConfig eurekaServerConfig;

    @Autowired
    private EurekaClientConfig eurekaClientConfig;

    @Autowired
    private EurekaClient eurekaClient;

    @Autowired
    private InstanceRegistryProperties instanceRegistryProperties;

    /**
     * A {@link CloudJacksonJson} instance.
     */
    public static final CloudJacksonJson JACKSON_JSON = new CloudJacksonJson();

    @Bean
    public HasFeatures eurekaServerFeature() {
        return HasFeatures.namedFeature("Eureka Server",
                EurekaServerAutoConfiguration.class);
    }

    @Bean
    @ConditionalOnProperty(prefix = "eureka.dashboard", name = "enabled",
            matchIfMissing = true)
    public EurekaController eurekaController() {
        return new EurekaController(this.applicationInfoManager);
    }

    static {
        CodecWrappers.registerWrapper(JACKSON_JSON);
        EurekaJacksonCodec.setInstance(JACKSON_JSON.getCodec());
    }

    @Bean
    public ServerCodecs serverCodecs() {
        return new CloudServerCodecs(this.eurekaServerConfig);
    }

    private static CodecWrapper getFullJson(EurekaServerConfig serverConfig) {
        CodecWrapper codec = CodecWrappers.getCodec(serverConfig.getJsonCodecName());
        return codec == null ? CodecWrappers.getCodec(JACKSON_JSON.codecName()) : codec;
    }

    private static CodecWrapper getFullXml(EurekaServerConfig serverConfig) {
        CodecWrapper codec = CodecWrappers.getCodec(serverConfig.getXmlCodecName());
        return codec == null ? CodecWrappers.getCodec(CodecWrappers.XStreamXml.class)
                : codec;
    }

    @Bean
    @ConditionalOnMissingBean
    public ReplicationClientAdditionalFilters replicationClientAdditionalFilters() {
        return new ReplicationClientAdditionalFilters(Collections.emptySet());
    }

    @Bean
    public PeerAwareInstanceRegistry peerAwareInstanceRegistry(
            ServerCodecs serverCodecs) {
        this.eurekaClient.getApplications(); // force initialization
        return new InstanceRegistry(this.eurekaServerConfig, this.eurekaClientConfig,
                serverCodecs, this.eurekaClient,
                this.instanceRegistryProperties.getExpectedNumberOfClientsSendingRenews(),
                this.instanceRegistryProperties.getDefaultOpenForTrafficCount());
    }

    @Bean
    @ConditionalOnMissingBean
    public PeerEurekaNodes peerEurekaNodes(PeerAwareInstanceRegistry registry,
            ServerCodecs serverCodecs,
            ReplicationClientAdditionalFilters replicationClientAdditionalFilters) {
        return new RefreshablePeerEurekaNodes(registry, this.eurekaServerConfig,
                this.eurekaClientConfig, serverCodecs, this.applicationInfoManager,
                replicationClientAdditionalFilters);
    }

    @Bean
    @ConditionalOnMissingBean
    public EurekaServerContext eurekaServerContext(ServerCodecs serverCodecs,
            PeerAwareInstanceRegistry registry, PeerEurekaNodes peerEurekaNodes) {
        return new DefaultEurekaServerContext(this.eurekaServerConfig, serverCodecs,
                registry, peerEurekaNodes, this.applicationInfoManager);
    }

    @Bean
    public EurekaServerBootstrap eurekaServerBootstrap(PeerAwareInstanceRegistry registry,
            EurekaServerContext serverContext) {
        return new EurekaServerBootstrap(this.applicationInfoManager,
                this.eurekaClientConfig, this.eurekaServerConfig, registry,
                serverContext);
    }

    /**
     * Register the Jersey filter.
     * @param eurekaJerseyApp an {@link Application} for the filter to be registered
     * @return a jersey {@link FilterRegistrationBean}
     */
    @Bean
    public FilterRegistrationBean<?> jerseyFilterRegistration(
            javax.ws.rs.core.Application eurekaJerseyApp) {
        FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<Filter>();
        bean.setFilter(new ServletContainer(eurekaJerseyApp));
        bean.setOrder(Ordered.LOWEST_PRECEDENCE);
        bean.setUrlPatterns(
                Collections.singletonList(EurekaConstants.DEFAULT_PREFIX + "/*"));

        return bean;
    }

    /**
     * Construct a Jersey {@link javax.ws.rs.core.Application} with all the resources
     * required by the Eureka server.
     * @param environment an {@link Environment} instance to retrieve classpath resources
     * @param resourceLoader a {@link ResourceLoader} instance to get classloader from
     * @return created {@link Application} object
     */
    @Bean
    public javax.ws.rs.core.Application jerseyApplication(Environment environment,
            ResourceLoader resourceLoader) {

        ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(
                false, environment);

        // Filter to include only classes that have a particular annotation.
        //
        provider.addIncludeFilter(new AnnotationTypeFilter(Path.class));
        provider.addIncludeFilter(new AnnotationTypeFilter(Provider.class));

        // Find classes in Eureka packages (or subpackages)
        //
        Set<Class<?>> classes = new HashSet<>();
        for (String basePackage : EUREKA_PACKAGES) {
            Set<BeanDefinition> beans = provider.findCandidateComponents(basePackage);
            for (BeanDefinition bd : beans) {
                Class<?> cls = ClassUtils.resolveClassName(bd.getBeanClassName(),
                        resourceLoader.getClassLoader());
                classes.add(cls);
            }
        }

        // Construct the Jersey ResourceConfig
        Map<String, Object> propsAndFeatures = new HashMap<>();
        propsAndFeatures.put(
                // Skip static content used by the webapp
                ServletContainer.PROPERTY_WEB_PAGE_CONTENT_REGEX,
                EurekaConstants.DEFAULT_PREFIX + "/(fonts|images|css|js)/.*");

        DefaultResourceConfig rc = new DefaultResourceConfig(classes);
        rc.setPropertiesAndFeatures(propsAndFeatures);

        return rc;
    }

    @Bean
    @ConditionalOnBean(name = "httpTraceFilter")
    public FilterRegistrationBean<?> traceFilterRegistration(
            @Qualifier("httpTraceFilter") Filter filter) {
        FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<Filter>();
        bean.setFilter(filter);
        bean.setOrder(Ordered.LOWEST_PRECEDENCE - 10);
        return bean;
    }

    @Configuration(proxyBeanMethods = false)
    protected static class EurekaServerConfigBeanConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public EurekaServerConfig eurekaServerConfig(EurekaClientConfig clientConfig) {
            EurekaServerConfigBean server = new EurekaServerConfigBean();
            if (clientConfig.shouldRegisterWithEureka()) {
                // Set a sensible default if we are supposed to replicate
                server.setRegistrySyncRetries(5);
            }
            return server;
        }

    }

    /**
     * {@link PeerEurekaNodes} which updates peers when /refresh is invoked. Peers are
     * updated only if <code>eureka.client.use-dns-for-fetching-service-urls</code> is
     * <code>false</code> and one of following properties have changed.
     * <p>
     * </p>
     * <ul>
     * <li><code>eureka.client.availability-zones</code></li>
     * <li><code>eureka.client.region</code></li>
     * <li><code>eureka.client.service-url.&lt;zone&gt;</code></li>
     * </ul>
     */
    static class RefreshablePeerEurekaNodes extends PeerEurekaNodes
            implements ApplicationListener<EnvironmentChangeEvent> {

        private ReplicationClientAdditionalFilters replicationClientAdditionalFilters;

        RefreshablePeerEurekaNodes(final PeerAwareInstanceRegistry registry,
                final EurekaServerConfig serverConfig,
                final EurekaClientConfig clientConfig, final ServerCodecs serverCodecs,
                final ApplicationInfoManager applicationInfoManager,
                final ReplicationClientAdditionalFilters replicationClientAdditionalFilters) {
            super(registry, serverConfig, clientConfig, serverCodecs,
                    applicationInfoManager);
            this.replicationClientAdditionalFilters = replicationClientAdditionalFilters;
        }

        @Override
        protected PeerEurekaNode createPeerEurekaNode(String peerEurekaNodeUrl) {
            JerseyReplicationClient replicationClient = JerseyReplicationClient
                    .createReplicationClient(serverConfig, serverCodecs,
                            peerEurekaNodeUrl);

            this.replicationClientAdditionalFilters.getFilters()
                    .forEach(replicationClient::addReplicationClientFilter);

            String targetHost = hostFromUrl(peerEurekaNodeUrl);
            if (targetHost == null) {
                targetHost = "host";
            }
            return new PeerEurekaNode(registry, targetHost, peerEurekaNodeUrl,
                    replicationClient, serverConfig);
        }

        @Override
        public void onApplicationEvent(final EnvironmentChangeEvent event) {
            if (shouldUpdate(event.getKeys())) {
                updatePeerEurekaNodes(resolvePeerUrls());
            }
        }

        /*
         * Check whether specific properties have changed.
         */
        protected boolean shouldUpdate(final Set<String> changedKeys) {
            assert changedKeys != null;

            // if eureka.client.use-dns-for-fetching-service-urls is true, then
            // service-url will not be fetched from environment.
            if (this.clientConfig.shouldUseDnsForFetchingServiceUrls()) {
                return false;
            }

            if (changedKeys.contains("eureka.client.region")) {
                return true;
            }

            for (final String key : changedKeys) {
                // property keys are not expected to be null.
                if (key.startsWith("eureka.client.service-url.")
                        || key.startsWith("eureka.client.availability-zones.")) {
                    return true;
                }
            }
            return false;
        }

    }

    class CloudServerCodecs extends DefaultServerCodecs {

        CloudServerCodecs(EurekaServerConfig serverConfig) {
            super(getFullJson(serverConfig),
                    CodecWrappers.getCodec(CodecWrappers.JacksonJsonMini.class),
                    getFullXml(serverConfig),
                    CodecWrappers.getCodec(CodecWrappers.JacksonXmlMini.class));
        }

    }

}

但是要注意，springcloud 中，感知集群的注册表组件是 InstanceRegistry，集群 PeerEurekaNodes 组件是 RefreshablePeerEurekaNodes。

② Springboot 方式的配置

EurekaServerAutoConfiguration 中注入了 EurekaServerConfig、EurekaClientConfig，在 Netflix 中，EurekaServerConfig 默认读取的是 eureka-server.properties 配置文件，EurekaClientConfig 默认读取的是 eureka-client.properties 配置文件。而在 springcloud 中，它们的实现类为 EurekaServerConfigBean、EurekaClientConfigBean，可以看到，就是基于 springboot 的配置方式来的了，读取的是 application.yml 配置文件中 eureka 的配置了，并且每个配置也提供了默认值。

例如 EurekaServerConfigBean：

@ConfigurationProperties(EurekaServerConfigBean.PREFIX)
public class EurekaServerConfigBean implements EurekaServerConfig {

    /**
     * Eureka server configuration properties prefix.
     */
    public static final String PREFIX = "eureka.server";

    private static final int MINUTES = 60 * 1000;

    @Autowired(required = false)
    PropertyResolver propertyResolver;

    private String aWSAccessId;

    private String aWSSecretKey;

    private int eIPBindRebindRetries = 3;

    private int eIPBindingRetryIntervalMs = 5 * MINUTES;

    private int eIPBindingRetryIntervalMsWhenUnbound = 1 * MINUTES;

    private boolean enableSelfPreservation = true;

    private double renewalPercentThreshold = 0.85;

    private int renewalThresholdUpdateIntervalMs = 15 * MINUTES;

    private int peerEurekaNodesUpdateIntervalMs = 10 * MINUTES;

    private int numberOfReplicationRetries = 5;

    private int peerEurekaStatusRefreshTimeIntervalMs = 30 * 1000;

    private int waitTimeInMsWhenSyncEmpty = 5 * MINUTES;

    private int peerNodeConnectTimeoutMs = 200;

    private int peerNodeReadTimeoutMs = 200;

    private int peerNodeTotalConnections = 1000;

    private int peerNodeTotalConnectionsPerHost = 500;

    private int peerNodeConnectionIdleTimeoutSeconds = 30;

    private long retentionTimeInMSInDeltaQueue = 3 * MINUTES;

    private long deltaRetentionTimerIntervalInMs = 30 * 1000;

    private long evictionIntervalTimerInMs = 60 * 1000;

    private int aSGQueryTimeoutMs = 300;

    private long aSGUpdateIntervalMs = 5 * MINUTES;

    private long aSGCacheExpiryTimeoutMs = 10 * MINUTES; // defaults to longer than the

    // asg update interval

    private long responseCacheAutoExpirationInSeconds = 180;

    private long responseCacheUpdateIntervalMs = 30 * 1000;

    private boolean useReadOnlyResponseCache = true;

    private boolean disableDelta;

    private long maxIdleThreadInMinutesAgeForStatusReplication = 10;

    private int minThreadsForStatusReplication = 1;

    private int maxThreadsForStatusReplication = 1;

    private int maxElementsInStatusReplicationPool = 10000;

    private boolean syncWhenTimestampDiffers = true;

    private int registrySyncRetries = 0;

    private long registrySyncRetryWaitMs = 30 * 1000;

    private int maxElementsInPeerReplicationPool = 10000;

    private long maxIdleThreadAgeInMinutesForPeerReplication = 15;

    private int minThreadsForPeerReplication = 5;

    private int maxThreadsForPeerReplication = 20;

    private int maxTimeForReplication = 30000;

    private boolean primeAwsReplicaConnections = true;

    private boolean disableDeltaForRemoteRegions;

    private int remoteRegionConnectTimeoutMs = 1000;

    private int remoteRegionReadTimeoutMs = 1000;

    private int remoteRegionTotalConnections = 1000;

    private int remoteRegionTotalConnectionsPerHost = 500;

    private int remoteRegionConnectionIdleTimeoutSeconds = 30;

    private boolean gZipContentFromRemoteRegion = true;

    private Map<String, String> remoteRegionUrlsWithName = new HashMap<>();

    private String[] remoteRegionUrls;

    private Map<String, Set<String>> remoteRegionAppWhitelist = new HashMap<>();

    private int remoteRegionRegistryFetchInterval = 30;

    private int remoteRegionFetchThreadPoolSize = 20;

    private String remoteRegionTrustStore = "";

    private String remoteRegionTrustStorePassword = "changeit";

    private boolean disableTransparentFallbackToOtherRegion;

    private boolean batchReplication;

    private boolean rateLimiterEnabled = false;

    private boolean rateLimiterThrottleStandardClients = false;

    private Set<String> rateLimiterPrivilegedClients = Collections.emptySet();

    private int rateLimiterBurstSize = 10;

    private int rateLimiterRegistryFetchAverageRate = 500;

    private int rateLimiterFullFetchAverageRate = 100;

    private boolean logIdentityHeaders = true;

    private String listAutoScalingGroupsRoleName = "ListAutoScalingGroups";

    private boolean enableReplicatedRequestCompression = false;

    private String jsonCodecName;

    private String xmlCodecName;

    private int route53BindRebindRetries = 3;

    private int route53BindingRetryIntervalMs = 5 * MINUTES;

    private long route53DomainTTL = 30;

    private AwsBindingStrategy bindingStrategy = AwsBindingStrategy.EIP;

    private int minAvailableInstancesForPeerReplication = -1;

    private int initialCapacityOfResponseCache = 1000;

    private int expectedClientRenewalIntervalSeconds = 30;

    private boolean useAwsAsgApi = true;

    private String myUrl;

    @Override
    public boolean shouldEnableSelfPreservation() {
        return this.enableSelfPreservation;
    }

    @Override
    public boolean shouldDisableDelta() {
        return this.disableDelta;
    }

    @Override
    public boolean shouldSyncWhenTimestampDiffers() {
        return this.syncWhenTimestampDiffers;
    }

    @Override
    public boolean shouldPrimeAwsReplicaConnections() {
        return this.primeAwsReplicaConnections;
    }

    @Override
    public boolean shouldDisableDeltaForRemoteRegions() {
        return this.disableDeltaForRemoteRegions;
    }

    @Override
    public boolean shouldGZipContentFromRemoteRegion() {
        return this.gZipContentFromRemoteRegion;
    }

    @Override
    public Set<String> getRemoteRegionAppWhitelist(String regionName) {
        return this.remoteRegionAppWhitelist
                .get(regionName == null ? "global" : regionName.trim().toLowerCase());
    }

    @Override
    public boolean disableTransparentFallbackToOtherRegion() {
        return this.disableTransparentFallbackToOtherRegion;
    }

    @Override
    public boolean shouldBatchReplication() {
        return this.batchReplication;
    }

    @Override
    public String getMyUrl() {
        return this.myUrl;
    }

    public void setMyUrl(String myUrl) {
        this.myUrl = myUrl;
    }

    @Override
    public boolean shouldLogIdentityHeaders() {
        return this.logIdentityHeaders;
    }

    @Override
    public String getJsonCodecName() {
        return this.jsonCodecName;
    }

    @Override
    public String getXmlCodecName() {
        return this.xmlCodecName;
    }

    @Override
    public boolean shouldUseReadOnlyResponseCache() {
        return this.useReadOnlyResponseCache;
    }

    @Override
    public boolean shouldEnableReplicatedRequestCompression() {
        return this.enableReplicatedRequestCompression;
    }

    @Override
    public String getExperimental(String name) {
        if (this.propertyResolver != null) {
            return this.propertyResolver.getProperty(PREFIX + ".experimental." + name,
                    String.class, null);
        }
        return null;
    }

    @Override
    public int getInitialCapacityOfResponseCache() {
        return this.initialCapacityOfResponseCache;
    }

    public void setInitialCapacityOfResponseCache(int initialCapacityOfResponseCache) {
        this.initialCapacityOfResponseCache = initialCapacityOfResponseCache;
    }

    @Override
    public int getHealthStatusMinNumberOfAvailablePeers() {
        return this.minAvailableInstancesForPeerReplication;
    }

    public PropertyResolver getPropertyResolver() {
        return propertyResolver;
    }

    public void setPropertyResolver(PropertyResolver propertyResolver) {
        this.propertyResolver = propertyResolver;
    }

    public String getAWSAccessId() {
        return aWSAccessId;
    }

    public void setAWSAccessId(String aWSAccessId) {
        this.aWSAccessId = aWSAccessId;
    }

    public String getAWSSecretKey() {
        return aWSSecretKey;
    }

    public void setAWSSecretKey(String aWSSecretKey) {
        this.aWSSecretKey = aWSSecretKey;
    }

    public int getEIPBindRebindRetries() {
        return eIPBindRebindRetries;
    }

    public void setEIPBindRebindRetries(int eIPBindRebindRetries) {
        this.eIPBindRebindRetries = eIPBindRebindRetries;
    }

    public int getEIPBindingRetryIntervalMs() {
        return eIPBindingRetryIntervalMs;
    }

    public void setEIPBindingRetryIntervalMs(int eIPBindingRetryIntervalMs) {
        this.eIPBindingRetryIntervalMs = eIPBindingRetryIntervalMs;
    }

    public int getEIPBindingRetryIntervalMsWhenUnbound() {
        return eIPBindingRetryIntervalMsWhenUnbound;
    }

    public void setEIPBindingRetryIntervalMsWhenUnbound(
            int eIPBindingRetryIntervalMsWhenUnbound) {
        this.eIPBindingRetryIntervalMsWhenUnbound = eIPBindingRetryIntervalMsWhenUnbound;
    }

    public boolean isEnableSelfPreservation() {
        return enableSelfPreservation;
    }

    public void setEnableSelfPreservation(boolean enableSelfPreservation) {
        this.enableSelfPreservation = enableSelfPreservation;
    }

    @Override
    public double getRenewalPercentThreshold() {
        return renewalPercentThreshold;
    }

    public void setRenewalPercentThreshold(double renewalPercentThreshold) {
        this.renewalPercentThreshold = renewalPercentThreshold;
    }

    @Override
    public int getRenewalThresholdUpdateIntervalMs() {
        return renewalThresholdUpdateIntervalMs;
    }

    @Override
    public int getExpectedClientRenewalIntervalSeconds() {
        return this.expectedClientRenewalIntervalSeconds;
    }

    public void setExpectedClientRenewalIntervalSeconds(
            int expectedClientRenewalIntervalSeconds) {
        this.expectedClientRenewalIntervalSeconds = expectedClientRenewalIntervalSeconds;
    }

    public void setRenewalThresholdUpdateIntervalMs(
            int renewalThresholdUpdateIntervalMs) {
        this.renewalThresholdUpdateIntervalMs = renewalThresholdUpdateIntervalMs;
    }

    @Override
    public int getPeerEurekaNodesUpdateIntervalMs() {
        return peerEurekaNodesUpdateIntervalMs;
    }

    public void setPeerEurekaNodesUpdateIntervalMs(int peerEurekaNodesUpdateIntervalMs) {
        this.peerEurekaNodesUpdateIntervalMs = peerEurekaNodesUpdateIntervalMs;
    }

    @Override
    public int getNumberOfReplicationRetries() {
        return numberOfReplicationRetries;
    }

    public void setNumberOfReplicationRetries(int numberOfReplicationRetries) {
        this.numberOfReplicationRetries = numberOfReplicationRetries;
    }

    @Override
    public int getPeerEurekaStatusRefreshTimeIntervalMs() {
        return peerEurekaStatusRefreshTimeIntervalMs;
    }

    public void setPeerEurekaStatusRefreshTimeIntervalMs(
            int peerEurekaStatusRefreshTimeIntervalMs) {
        this.peerEurekaStatusRefreshTimeIntervalMs = peerEurekaStatusRefreshTimeIntervalMs;
    }

    @Override
    public int getWaitTimeInMsWhenSyncEmpty() {
        return waitTimeInMsWhenSyncEmpty;
    }

    public void setWaitTimeInMsWhenSyncEmpty(int waitTimeInMsWhenSyncEmpty) {
        this.waitTimeInMsWhenSyncEmpty = waitTimeInMsWhenSyncEmpty;
    }

    @Override
    public int getPeerNodeConnectTimeoutMs() {
        return peerNodeConnectTimeoutMs;
    }

    public void setPeerNodeConnectTimeoutMs(int peerNodeConnectTimeoutMs) {
        this.peerNodeConnectTimeoutMs = peerNodeConnectTimeoutMs;
    }

    @Override
    public int getPeerNodeReadTimeoutMs() {
        return peerNodeReadTimeoutMs;
    }

    public void setPeerNodeReadTimeoutMs(int peerNodeReadTimeoutMs) {
        this.peerNodeReadTimeoutMs = peerNodeReadTimeoutMs;
    }

    @Override
    public int getPeerNodeTotalConnections() {
        return peerNodeTotalConnections;
    }

    public void setPeerNodeTotalConnections(int peerNodeTotalConnections) {
        this.peerNodeTotalConnections = peerNodeTotalConnections;
    }

    @Override
    public int getPeerNodeTotalConnectionsPerHost() {
        return peerNodeTotalConnectionsPerHost;
    }

    public void setPeerNodeTotalConnectionsPerHost(int peerNodeTotalConnectionsPerHost) {
        this.peerNodeTotalConnectionsPerHost = peerNodeTotalConnectionsPerHost;
    }

    @Override
    public int getPeerNodeConnectionIdleTimeoutSeconds() {
        return peerNodeConnectionIdleTimeoutSeconds;
    }

    public void setPeerNodeConnectionIdleTimeoutSeconds(
            int peerNodeConnectionIdleTimeoutSeconds) {
        this.peerNodeConnectionIdleTimeoutSeconds = peerNodeConnectionIdleTimeoutSeconds;
    }

    @Override
    public long getRetentionTimeInMSInDeltaQueue() {
        return retentionTimeInMSInDeltaQueue;
    }

    public void setRetentionTimeInMSInDeltaQueue(long retentionTimeInMSInDeltaQueue) {
        this.retentionTimeInMSInDeltaQueue = retentionTimeInMSInDeltaQueue;
    }

    @Override
    public long getDeltaRetentionTimerIntervalInMs() {
        return deltaRetentionTimerIntervalInMs;
    }

    public void setDeltaRetentionTimerIntervalInMs(long deltaRetentionTimerIntervalInMs) {
        this.deltaRetentionTimerIntervalInMs = deltaRetentionTimerIntervalInMs;
    }

    @Override
    public long getEvictionIntervalTimerInMs() {
        return evictionIntervalTimerInMs;
    }

    @Override
    public boolean shouldUseAwsAsgApi() {
        return this.useAwsAsgApi;
    }

    public void setUseAwsAsgApi(boolean useAwsAsgApi) {
        this.useAwsAsgApi = useAwsAsgApi;
    }

    public void setEvictionIntervalTimerInMs(long evictionIntervalTimerInMs) {
        this.evictionIntervalTimerInMs = evictionIntervalTimerInMs;
    }

    public int getASGQueryTimeoutMs() {
        return aSGQueryTimeoutMs;
    }

    public void setASGQueryTimeoutMs(int aSGQueryTimeoutMs) {
        this.aSGQueryTimeoutMs = aSGQueryTimeoutMs;
    }

    public long getASGUpdateIntervalMs() {
        return aSGUpdateIntervalMs;
    }

    public void setASGUpdateIntervalMs(long aSGUpdateIntervalMs) {
        this.aSGUpdateIntervalMs = aSGUpdateIntervalMs;
    }

    public long getASGCacheExpiryTimeoutMs() {
        return aSGCacheExpiryTimeoutMs;
    }

    public void setASGCacheExpiryTimeoutMs(long aSGCacheExpiryTimeoutMs) {
        this.aSGCacheExpiryTimeoutMs = aSGCacheExpiryTimeoutMs;
    }

    @Override
    public long getResponseCacheAutoExpirationInSeconds() {
        return responseCacheAutoExpirationInSeconds;
    }

    public void setResponseCacheAutoExpirationInSeconds(
            long responseCacheAutoExpirationInSeconds) {
        this.responseCacheAutoExpirationInSeconds = responseCacheAutoExpirationInSeconds;
    }

    @Override
    public long getResponseCacheUpdateIntervalMs() {
        return responseCacheUpdateIntervalMs;
    }

    public void setResponseCacheUpdateIntervalMs(long responseCacheUpdateIntervalMs) {
        this.responseCacheUpdateIntervalMs = responseCacheUpdateIntervalMs;
    }

    public boolean isUseReadOnlyResponseCache() {
        return useReadOnlyResponseCache;
    }

    public void setUseReadOnlyResponseCache(boolean useReadOnlyResponseCache) {
        this.useReadOnlyResponseCache = useReadOnlyResponseCache;
    }

    public boolean isDisableDelta() {
        return disableDelta;
    }

    public void setDisableDelta(boolean disableDelta) {
        this.disableDelta = disableDelta;
    }

    @Override
    public long getMaxIdleThreadInMinutesAgeForStatusReplication() {
        return maxIdleThreadInMinutesAgeForStatusReplication;
    }

    public void setMaxIdleThreadInMinutesAgeForStatusReplication(
            long maxIdleThreadInMinutesAgeForStatusReplication) {
        this.maxIdleThreadInMinutesAgeForStatusReplication = maxIdleThreadInMinutesAgeForStatusReplication;
    }

    @Override
    public int getMinThreadsForStatusReplication() {
        return minThreadsForStatusReplication;
    }

    public void setMinThreadsForStatusReplication(int minThreadsForStatusReplication) {
        this.minThreadsForStatusReplication = minThreadsForStatusReplication;
    }

    @Override
    public int getMaxThreadsForStatusReplication() {
        return maxThreadsForStatusReplication;
    }

    public void setMaxThreadsForStatusReplication(int maxThreadsForStatusReplication) {
        this.maxThreadsForStatusReplication = maxThreadsForStatusReplication;
    }

    @Override
    public int getMaxElementsInStatusReplicationPool() {
        return maxElementsInStatusReplicationPool;
    }

    public void setMaxElementsInStatusReplicationPool(
            int maxElementsInStatusReplicationPool) {
        this.maxElementsInStatusReplicationPool = maxElementsInStatusReplicationPool;
    }

    public boolean isSyncWhenTimestampDiffers() {
        return syncWhenTimestampDiffers;
    }

    public void setSyncWhenTimestampDiffers(boolean syncWhenTimestampDiffers) {
        this.syncWhenTimestampDiffers = syncWhenTimestampDiffers;
    }

    @Override
    public int getRegistrySyncRetries() {
        return registrySyncRetries;
    }

    public void setRegistrySyncRetries(int registrySyncRetries) {
        this.registrySyncRetries = registrySyncRetries;
    }

    @Override
    public long getRegistrySyncRetryWaitMs() {
        return registrySyncRetryWaitMs;
    }

    public void setRegistrySyncRetryWaitMs(long registrySyncRetryWaitMs) {
        this.registrySyncRetryWaitMs = registrySyncRetryWaitMs;
    }

    @Override
    public int getMaxElementsInPeerReplicationPool() {
        return maxElementsInPeerReplicationPool;
    }

    public void setMaxElementsInPeerReplicationPool(
            int maxElementsInPeerReplicationPool) {
        this.maxElementsInPeerReplicationPool = maxElementsInPeerReplicationPool;
    }

    @Override
    public long getMaxIdleThreadAgeInMinutesForPeerReplication() {
        return maxIdleThreadAgeInMinutesForPeerReplication;
    }

    public void setMaxIdleThreadAgeInMinutesForPeerReplication(
            long maxIdleThreadAgeInMinutesForPeerReplication) {
        this.maxIdleThreadAgeInMinutesForPeerReplication = maxIdleThreadAgeInMinutesForPeerReplication;
    }

    @Override
    public int getMinThreadsForPeerReplication() {
        return minThreadsForPeerReplication;
    }

    public void setMinThreadsForPeerReplication(int minThreadsForPeerReplication) {
        this.minThreadsForPeerReplication = minThreadsForPeerReplication;
    }

    @Override
    public int getMaxThreadsForPeerReplication() {
        return maxThreadsForPeerReplication;
    }

    public void setMaxThreadsForPeerReplication(int maxThreadsForPeerReplication) {
        this.maxThreadsForPeerReplication = maxThreadsForPeerReplication;
    }

    @Override
    public int getMaxTimeForReplication() {
        return maxTimeForReplication;
    }

    public void setMaxTimeForReplication(int maxTimeForReplication) {
        this.maxTimeForReplication = maxTimeForReplication;
    }

    public boolean isPrimeAwsReplicaConnections() {
        return primeAwsReplicaConnections;
    }

    public void setPrimeAwsReplicaConnections(boolean primeAwsReplicaConnections) {
        this.primeAwsReplicaConnections = primeAwsReplicaConnections;
    }

    public boolean isDisableDeltaForRemoteRegions() {
        return disableDeltaForRemoteRegions;
    }

    public void setDisableDeltaForRemoteRegions(boolean disableDeltaForRemoteRegions) {
        this.disableDeltaForRemoteRegions = disableDeltaForRemoteRegions;
    }

    @Override
    public int getRemoteRegionConnectTimeoutMs() {
        return remoteRegionConnectTimeoutMs;
    }

    public void setRemoteRegionConnectTimeoutMs(int remoteRegionConnectTimeoutMs) {
        this.remoteRegionConnectTimeoutMs = remoteRegionConnectTimeoutMs;
    }

    @Override
    public int getRemoteRegionReadTimeoutMs() {
        return remoteRegionReadTimeoutMs;
    }

    public void setRemoteRegionReadTimeoutMs(int remoteRegionReadTimeoutMs) {
        this.remoteRegionReadTimeoutMs = remoteRegionReadTimeoutMs;
    }

    @Override
    public int getRemoteRegionTotalConnections() {
        return remoteRegionTotalConnections;
    }

    public void setRemoteRegionTotalConnections(int remoteRegionTotalConnections) {
        this.remoteRegionTotalConnections = remoteRegionTotalConnections;
    }

    @Override
    public int getRemoteRegionTotalConnectionsPerHost() {
        return remoteRegionTotalConnectionsPerHost;
    }

    public void setRemoteRegionTotalConnectionsPerHost(
            int remoteRegionTotalConnectionsPerHost) {
        this.remoteRegionTotalConnectionsPerHost = remoteRegionTotalConnectionsPerHost;
    }

    @Override
    public int getRemoteRegionConnectionIdleTimeoutSeconds() {
        return remoteRegionConnectionIdleTimeoutSeconds;
    }

    public void setRemoteRegionConnectionIdleTimeoutSeconds(
            int remoteRegionConnectionIdleTimeoutSeconds) {
        this.remoteRegionConnectionIdleTimeoutSeconds = remoteRegionConnectionIdleTimeoutSeconds;
    }

    public boolean isgZipContentFromRemoteRegion() {
        return gZipContentFromRemoteRegion;
    }

    public void setgZipContentFromRemoteRegion(boolean gZipContentFromRemoteRegion) {
        this.gZipContentFromRemoteRegion = gZipContentFromRemoteRegion;
    }

    @Override
    public Map<String, String> getRemoteRegionUrlsWithName() {
        return remoteRegionUrlsWithName;
    }

    public void setRemoteRegionUrlsWithName(
            Map<String, String> remoteRegionUrlsWithName) {
        this.remoteRegionUrlsWithName = remoteRegionUrlsWithName;
    }

    @Override
    public String[] getRemoteRegionUrls() {
        return remoteRegionUrls;
    }

    public void setRemoteRegionUrls(String[] remoteRegionUrls) {
        this.remoteRegionUrls = remoteRegionUrls;
    }

    public Map<String, Set<String>> getRemoteRegionAppWhitelist() {
        return remoteRegionAppWhitelist;
    }

    public void setRemoteRegionAppWhitelist(
            Map<String, Set<String>> remoteRegionAppWhitelist) {
        this.remoteRegionAppWhitelist = remoteRegionAppWhitelist;
    }

    @Override
    public int getRemoteRegionRegistryFetchInterval() {
        return remoteRegionRegistryFetchInterval;
    }

    public void setRemoteRegionRegistryFetchInterval(
            int remoteRegionRegistryFetchInterval) {
        this.remoteRegionRegistryFetchInterval = remoteRegionRegistryFetchInterval;
    }

    @Override
    public int getRemoteRegionFetchThreadPoolSize() {
        return remoteRegionFetchThreadPoolSize;
    }

    public void setRemoteRegionFetchThreadPoolSize(int remoteRegionFetchThreadPoolSize) {
        this.remoteRegionFetchThreadPoolSize = remoteRegionFetchThreadPoolSize;
    }

    @Override
    public String getRemoteRegionTrustStore() {
        return remoteRegionTrustStore;
    }

    public void setRemoteRegionTrustStore(String remoteRegionTrustStore) {
        this.remoteRegionTrustStore = remoteRegionTrustStore;
    }

    @Override
    public String getRemoteRegionTrustStorePassword() {
        return remoteRegionTrustStorePassword;
    }

    public void setRemoteRegionTrustStorePassword(String remoteRegionTrustStorePassword) {
        this.remoteRegionTrustStorePassword = remoteRegionTrustStorePassword;
    }

    public boolean isDisableTransparentFallbackToOtherRegion() {
        return disableTransparentFallbackToOtherRegion;
    }

    public void setDisableTransparentFallbackToOtherRegion(
            boolean disableTransparentFallbackToOtherRegion) {
        this.disableTransparentFallbackToOtherRegion = disableTransparentFallbackToOtherRegion;
    }

    public boolean isBatchReplication() {
        return batchReplication;
    }

    public void setBatchReplication(boolean batchReplication) {
        this.batchReplication = batchReplication;
    }

    @Override
    public boolean isRateLimiterEnabled() {
        return rateLimiterEnabled;
    }

    public void setRateLimiterEnabled(boolean rateLimiterEnabled) {
        this.rateLimiterEnabled = rateLimiterEnabled;
    }

    @Override
    public boolean isRateLimiterThrottleStandardClients() {
        return rateLimiterThrottleStandardClients;
    }

    public void setRateLimiterThrottleStandardClients(
            boolean rateLimiterThrottleStandardClients) {
        this.rateLimiterThrottleStandardClients = rateLimiterThrottleStandardClients;
    }

    @Override
    public Set<String> getRateLimiterPrivilegedClients() {
        return rateLimiterPrivilegedClients;
    }

    public void setRateLimiterPrivilegedClients(
            Set<String> rateLimiterPrivilegedClients) {
        this.rateLimiterPrivilegedClients = rateLimiterPrivilegedClients;
    }

    @Override
    public int getRateLimiterBurstSize() {
        return rateLimiterBurstSize;
    }

    public void setRateLimiterBurstSize(int rateLimiterBurstSize) {
        this.rateLimiterBurstSize = rateLimiterBurstSize;
    }

    @Override
    public int getRateLimiterRegistryFetchAverageRate() {
        return rateLimiterRegistryFetchAverageRate;
    }

    public void setRateLimiterRegistryFetchAverageRate(
            int rateLimiterRegistryFetchAverageRate) {
        this.rateLimiterRegistryFetchAverageRate = rateLimiterRegistryFetchAverageRate;
    }

    @Override
    public int getRateLimiterFullFetchAverageRate() {
        return rateLimiterFullFetchAverageRate;
    }

    public void setRateLimiterFullFetchAverageRate(int rateLimiterFullFetchAverageRate) {
        this.rateLimiterFullFetchAverageRate = rateLimiterFullFetchAverageRate;
    }

    public boolean isLogIdentityHeaders() {
        return logIdentityHeaders;
    }

    public void setLogIdentityHeaders(boolean logIdentityHeaders) {
        this.logIdentityHeaders = logIdentityHeaders;
    }

    @Override
    public String getListAutoScalingGroupsRoleName() {
        return listAutoScalingGroupsRoleName;
    }

    public void setListAutoScalingGroupsRoleName(String listAutoScalingGroupsRoleName) {
        this.listAutoScalingGroupsRoleName = listAutoScalingGroupsRoleName;
    }

    public boolean isEnableReplicatedRequestCompression() {
        return enableReplicatedRequestCompression;
    }

    public void setEnableReplicatedRequestCompression(
            boolean enableReplicatedRequestCompression) {
        this.enableReplicatedRequestCompression = enableReplicatedRequestCompression;
    }

    public void setJsonCodecName(String jsonCodecName) {
        this.jsonCodecName = jsonCodecName;
    }

    public void setXmlCodecName(String xmlCodecName) {
        this.xmlCodecName = xmlCodecName;
    }

    @Override
    public int getRoute53BindRebindRetries() {
        return route53BindRebindRetries;
    }

    public void setRoute53BindRebindRetries(int route53BindRebindRetries) {
        this.route53BindRebindRetries = route53BindRebindRetries;
    }

    @Override
    public int getRoute53BindingRetryIntervalMs() {
        return route53BindingRetryIntervalMs;
    }

    public void setRoute53BindingRetryIntervalMs(int route53BindingRetryIntervalMs) {
        this.route53BindingRetryIntervalMs = route53BindingRetryIntervalMs;
    }

    @Override
    public long getRoute53DomainTTL() {
        return route53DomainTTL;
    }

    public void setRoute53DomainTTL(long route53DomainTTL) {
        this.route53DomainTTL = route53DomainTTL;
    }

    @Override
    public AwsBindingStrategy getBindingStrategy() {
        return bindingStrategy;
    }

    public void setBindingStrategy(AwsBindingStrategy bindingStrategy) {
        this.bindingStrategy = bindingStrategy;
    }

    public int getMinAvailableInstancesForPeerReplication() {
        return minAvailableInstancesForPeerReplication;
    }

    public void setMinAvailableInstancesForPeerReplication(
            int minAvailableInstancesForPeerReplication) {
        this.minAvailableInstancesForPeerReplication = minAvailableInstancesForPeerReplication;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        EurekaServerConfigBean that = (EurekaServerConfigBean) o;
        return aSGCacheExpiryTimeoutMs == that.aSGCacheExpiryTimeoutMs
                && aSGQueryTimeoutMs == that.aSGQueryTimeoutMs
                && aSGUpdateIntervalMs == that.aSGUpdateIntervalMs
                && Objects.equals(aWSAccessId, that.aWSAccessId)
                && Objects.equals(aWSSecretKey, that.aWSSecretKey)
                && batchReplication == that.batchReplication
                && bindingStrategy == that.bindingStrategy
                && deltaRetentionTimerIntervalInMs == that.deltaRetentionTimerIntervalInMs
                && disableDelta == that.disableDelta
                && disableDeltaForRemoteRegions == that.disableDeltaForRemoteRegions
                && disableTransparentFallbackToOtherRegion == that.disableTransparentFallbackToOtherRegion
                && eIPBindingRetryIntervalMs == that.eIPBindingRetryIntervalMs
                && eIPBindingRetryIntervalMsWhenUnbound == that.eIPBindingRetryIntervalMsWhenUnbound
                && eIPBindRebindRetries == that.eIPBindRebindRetries
                && enableReplicatedRequestCompression == that.enableReplicatedRequestCompression
                && enableSelfPreservation == that.enableSelfPreservation
                && evictionIntervalTimerInMs == that.evictionIntervalTimerInMs
                && gZipContentFromRemoteRegion == that.gZipContentFromRemoteRegion
                && Objects.equals(jsonCodecName, that.jsonCodecName)
                && Objects.equals(listAutoScalingGroupsRoleName,
                        that.listAutoScalingGroupsRoleName)
                && logIdentityHeaders == that.logIdentityHeaders
                && maxElementsInPeerReplicationPool == that.maxElementsInPeerReplicationPool
                && maxElementsInStatusReplicationPool == that.maxElementsInStatusReplicationPool
                && maxIdleThreadAgeInMinutesForPeerReplication == that.maxIdleThreadAgeInMinutesForPeerReplication
                && maxIdleThreadInMinutesAgeForStatusReplication == that.maxIdleThreadInMinutesAgeForStatusReplication
                && maxThreadsForPeerReplication == that.maxThreadsForPeerReplication
                && maxThreadsForStatusReplication == that.maxThreadsForStatusReplication
                && maxTimeForReplication == that.maxTimeForReplication
                && minAvailableInstancesForPeerReplication == that.minAvailableInstancesForPeerReplication
                && minThreadsForPeerReplication == that.minThreadsForPeerReplication
                && minThreadsForStatusReplication == that.minThreadsForStatusReplication
                && numberOfReplicationRetries == that.numberOfReplicationRetries
                && peerEurekaNodesUpdateIntervalMs == that.peerEurekaNodesUpdateIntervalMs
                && peerEurekaStatusRefreshTimeIntervalMs == that.peerEurekaStatusRefreshTimeIntervalMs
                && peerNodeConnectionIdleTimeoutSeconds == that.peerNodeConnectionIdleTimeoutSeconds
                && peerNodeConnectTimeoutMs == that.peerNodeConnectTimeoutMs
                && peerNodeReadTimeoutMs == that.peerNodeReadTimeoutMs
                && peerNodeTotalConnections == that.peerNodeTotalConnections
                && peerNodeTotalConnectionsPerHost == that.peerNodeTotalConnectionsPerHost
                && primeAwsReplicaConnections == that.primeAwsReplicaConnections
                && Objects.equals(propertyResolver, that.propertyResolver)
                && rateLimiterBurstSize == that.rateLimiterBurstSize
                && rateLimiterEnabled == that.rateLimiterEnabled
                && rateLimiterFullFetchAverageRate == that.rateLimiterFullFetchAverageRate
                && Objects.equals(rateLimiterPrivilegedClients,
                        that.rateLimiterPrivilegedClients)
                && rateLimiterRegistryFetchAverageRate == that.rateLimiterRegistryFetchAverageRate
                && rateLimiterThrottleStandardClients == that.rateLimiterThrottleStandardClients
                && registrySyncRetries == that.registrySyncRetries
                && registrySyncRetryWaitMs == that.registrySyncRetryWaitMs
                && Objects.equals(remoteRegionAppWhitelist, that.remoteRegionAppWhitelist)
                && remoteRegionConnectionIdleTimeoutSeconds == that.remoteRegionConnectionIdleTimeoutSeconds
                && remoteRegionConnectTimeoutMs == that.remoteRegionConnectTimeoutMs
                && remoteRegionFetchThreadPoolSize == that.remoteRegionFetchThreadPoolSize
                && remoteRegionReadTimeoutMs == that.remoteRegionReadTimeoutMs
                && remoteRegionRegistryFetchInterval == that.remoteRegionRegistryFetchInterval
                && remoteRegionTotalConnections == that.remoteRegionTotalConnections
                && remoteRegionTotalConnectionsPerHost == that.remoteRegionTotalConnectionsPerHost
                && Objects.equals(remoteRegionTrustStore, that.remoteRegionTrustStore)
                && Objects.equals(remoteRegionTrustStorePassword,
                        that.remoteRegionTrustStorePassword)
                && Arrays.equals(remoteRegionUrls, that.remoteRegionUrls)
                && Objects.equals(remoteRegionUrlsWithName, that.remoteRegionUrlsWithName)
                && Double.compare(that.renewalPercentThreshold,
                        renewalPercentThreshold) == 0
                && renewalThresholdUpdateIntervalMs == that.renewalThresholdUpdateIntervalMs
                && responseCacheAutoExpirationInSeconds == that.responseCacheAutoExpirationInSeconds
                && responseCacheUpdateIntervalMs == that.responseCacheUpdateIntervalMs
                && retentionTimeInMSInDeltaQueue == that.retentionTimeInMSInDeltaQueue
                && route53BindingRetryIntervalMs == that.route53BindingRetryIntervalMs
                && route53BindRebindRetries == that.route53BindRebindRetries
                && route53DomainTTL == that.route53DomainTTL
                && syncWhenTimestampDiffers == that.syncWhenTimestampDiffers
                && useReadOnlyResponseCache == that.useReadOnlyResponseCache
                && waitTimeInMsWhenSyncEmpty == that.waitTimeInMsWhenSyncEmpty
                && Objects.equals(xmlCodecName, that.xmlCodecName)
                && initialCapacityOfResponseCache == that.initialCapacityOfResponseCache
                && expectedClientRenewalIntervalSeconds == that.expectedClientRenewalIntervalSeconds
                && useAwsAsgApi == that.useAwsAsgApi && Objects.equals(myUrl, that.myUrl);
    }

    @Override
    public int hashCode() {
        return Objects.hash(aSGCacheExpiryTimeoutMs, aSGQueryTimeoutMs,
                aSGUpdateIntervalMs, aWSAccessId, aWSSecretKey, batchReplication,
                bindingStrategy, deltaRetentionTimerIntervalInMs, disableDelta,
                disableDeltaForRemoteRegions, disableTransparentFallbackToOtherRegion,
                eIPBindRebindRetries, eIPBindingRetryIntervalMs,
                eIPBindingRetryIntervalMsWhenUnbound, enableReplicatedRequestCompression,
                enableSelfPreservation, evictionIntervalTimerInMs,
                gZipContentFromRemoteRegion, jsonCodecName, listAutoScalingGroupsRoleName,
                logIdentityHeaders, maxElementsInPeerReplicationPool,
                maxElementsInStatusReplicationPool,
                maxIdleThreadAgeInMinutesForPeerReplication,
                maxIdleThreadInMinutesAgeForStatusReplication,
                maxThreadsForPeerReplication, maxThreadsForStatusReplication,
                maxTimeForReplication, minAvailableInstancesForPeerReplication,
                minThreadsForPeerReplication, minThreadsForStatusReplication,
                numberOfReplicationRetries, peerEurekaNodesUpdateIntervalMs,
                peerEurekaStatusRefreshTimeIntervalMs, peerNodeConnectTimeoutMs,
                peerNodeConnectionIdleTimeoutSeconds, peerNodeReadTimeoutMs,
                peerNodeTotalConnections, peerNodeTotalConnectionsPerHost,
                primeAwsReplicaConnections, propertyResolver, rateLimiterBurstSize,
                rateLimiterEnabled, rateLimiterFullFetchAverageRate,
                rateLimiterPrivilegedClients, rateLimiterRegistryFetchAverageRate,
                rateLimiterThrottleStandardClients, registrySyncRetries,
                registrySyncRetryWaitMs, remoteRegionAppWhitelist,
                remoteRegionConnectTimeoutMs, remoteRegionConnectionIdleTimeoutSeconds,
                remoteRegionFetchThreadPoolSize, remoteRegionReadTimeoutMs,
                remoteRegionRegistryFetchInterval, remoteRegionTotalConnections,
                remoteRegionTotalConnectionsPerHost, remoteRegionTrustStore,
                remoteRegionTrustStorePassword, remoteRegionUrls,
                remoteRegionUrlsWithName, renewalPercentThreshold,
                renewalThresholdUpdateIntervalMs, responseCacheAutoExpirationInSeconds,
                responseCacheUpdateIntervalMs, retentionTimeInMSInDeltaQueue,
                route53BindRebindRetries, route53BindingRetryIntervalMs, route53DomainTTL,
                syncWhenTimestampDiffers, useReadOnlyResponseCache,
                waitTimeInMsWhenSyncEmpty, xmlCodecName, initialCapacityOfResponseCache,
                expectedClientRenewalIntervalSeconds, useAwsAsgApi, myUrl);
    }

    @Override
    public String toString() {
        return new ToStringCreator(this)
                .append("aSGCacheExpiryTimeoutMs", this.aSGCacheExpiryTimeoutMs)
                .append("aSGQueryTimeoutMs", this.aSGQueryTimeoutMs)
                .append("aSGUpdateIntervalMs", this.aSGUpdateIntervalMs)
                .append("aWSAccessId", this.aWSAccessId)
                .append("aWSSecretKey", this.aWSSecretKey)
                .append("batchReplication", this.batchReplication)
                .append("bindingStrategy", this.bindingStrategy)
                .append("deltaRetentionTimerIntervalInMs",
                        this.deltaRetentionTimerIntervalInMs)
                .append("disableDelta", this.disableDelta)
                .append("disableDeltaForRemoteRegions", this.disableDeltaForRemoteRegions)
                .append("disableTransparentFallbackToOtherRegion",
                        this.disableTransparentFallbackToOtherRegion)
                .append("eIPBindRebindRetries", this.eIPBindRebindRetries)
                .append("eIPBindingRetryIntervalMs", this.eIPBindingRetryIntervalMs)
                .append("eIPBindingRetryIntervalMsWhenUnbound",
                        this.eIPBindingRetryIntervalMsWhenUnbound)
                .append("enableReplicatedRequestCompression",
                        this.enableReplicatedRequestCompression)
                .append("enableSelfPreservation", this.enableSelfPreservation)
                .append("evictionIntervalTimerInMs", this.evictionIntervalTimerInMs)
                .append("gZipContentFromRemoteRegion", this.gZipContentFromRemoteRegion)
                .append("jsonCodecName", this.jsonCodecName)
                .append("listAutoScalingGroupsRoleName",
                        this.listAutoScalingGroupsRoleName)
                .append("logIdentityHeaders", this.logIdentityHeaders)
                .append("maxElementsInPeerReplicationPool",
                        this.maxElementsInPeerReplicationPool)
                .append("maxElementsInStatusReplicationPool",
                        this.maxElementsInStatusReplicationPool)
                .append("maxIdleThreadAgeInMinutesForPeerReplication",
                        this.maxIdleThreadAgeInMinutesForPeerReplication)
                .append("maxIdleThreadInMinutesAgeForStatusReplication",
                        this.maxIdleThreadInMinutesAgeForStatusReplication)
                .append("maxThreadsForPeerReplication", this.maxThreadsForPeerReplication)
                .append("maxThreadsForStatusReplication",
                        this.maxThreadsForStatusReplication)
                .append("maxTimeForReplication", this.maxTimeForReplication)
                .append("minAvailableInstancesForPeerReplication",
                        this.minAvailableInstancesForPeerReplication)
                .append("minThreadsForPeerReplication", this.minThreadsForPeerReplication)
                .append("minThreadsForStatusReplication",
                        this.minThreadsForStatusReplication)
                .append("numberOfReplicationRetries", this.numberOfReplicationRetries)
                .append("peerEurekaNodesUpdateIntervalMs",
                        this.peerEurekaNodesUpdateIntervalMs)
                .append("peerEurekaStatusRefreshTimeIntervalMs",
                        this.peerEurekaStatusRefreshTimeIntervalMs)
                .append("peerNodeConnectTimeoutMs", this.peerNodeConnectTimeoutMs)
                .append("peerNodeConnectionIdleTimeoutSeconds",
                        this.peerNodeConnectionIdleTimeoutSeconds)
                .append("peerNodeReadTimeoutMs", this.peerNodeReadTimeoutMs)
                .append("peerNodeTotalConnections", this.peerNodeTotalConnections)
                .append("peerNodeTotalConnectionsPerHost",
                        this.peerNodeTotalConnectionsPerHost)
                .append("primeAwsReplicaConnections", this.primeAwsReplicaConnections)
                .append("propertyResolver", this.propertyResolver)
                .append("rateLimiterBurstSize", this.rateLimiterBurstSize)
                .append("rateLimiterEnabled", this.rateLimiterEnabled)
                .append("rateLimiterFullFetchAverageRate",
                        this.rateLimiterFullFetchAverageRate)
                .append("rateLimiterPrivilegedClients", this.rateLimiterPrivilegedClients)
                .append("rateLimiterRegistryFetchAverageRate",
                        this.rateLimiterRegistryFetchAverageRate)
                .append("rateLimiterThrottleStandardClients",
                        this.rateLimiterThrottleStandardClients)
                .append("registrySyncRetries", this.registrySyncRetries)
                .append("registrySyncRetryWaitMs", this.registrySyncRetryWaitMs)
                .append("remoteRegionAppWhitelist", this.remoteRegionAppWhitelist)
                .append("remoteRegionConnectTimeoutMs", this.remoteRegionConnectTimeoutMs)
                .append("remoteRegionConnectionIdleTimeoutSeconds",
                        this.remoteRegionConnectionIdleTimeoutSeconds)
                .append("remoteRegionFetchThreadPoolSize",
                        this.remoteRegionFetchThreadPoolSize)
                .append("remoteRegionReadTimeoutMs", this.remoteRegionReadTimeoutMs)
                .append("remoteRegionRegistryFetchInterval",
                        this.remoteRegionRegistryFetchInterval)
                .append("remoteRegionTotalConnections", this.remoteRegionTotalConnections)
                .append("remoteRegionTotalConnectionsPerHost",
                        this.remoteRegionTotalConnectionsPerHost)
                .append("remoteRegionTrustStore", this.remoteRegionTrustStore)
                .append("remoteRegionTrustStorePassword",
                        this.remoteRegionTrustStorePassword)
                .append("remoteRegionUrls", this.remoteRegionUrls)
                .append("remoteRegionUrlsWithName", this.remoteRegionUrlsWithName)
                .append("renewalPercentThreshold", this.renewalPercentThreshold)
                .append("renewalThresholdUpdateIntervalMs",
                        this.renewalThresholdUpdateIntervalMs)
                .append("responseCacheAutoExpirationInSeconds",
                        this.responseCacheAutoExpirationInSeconds)
                .append("responseCacheUpdateIntervalMs",
                        this.responseCacheUpdateIntervalMs)
                .append("retentionTimeInMSInDeltaQueue",
                        this.retentionTimeInMSInDeltaQueue)
                .append("route53BindRebindRetries", this.route53BindRebindRetries)
                .append("route53BindingRetryIntervalMs",
                        this.route53BindingRetryIntervalMs)
                .append("route53DomainTTL", this.route53DomainTTL)
                .append("syncWhenTimestampDiffers", this.syncWhenTimestampDiffers)
                .append("useReadOnlyResponseCache", this.useReadOnlyResponseCache)
                .append("waitTimeInMsWhenSyncEmpty", this.waitTimeInMsWhenSyncEmpty)
                .append("xmlCodecName", this.xmlCodecName)
                .append("initialCapacityOfResponseCache",
                        this.initialCapacityOfResponseCache)
                .append("expectedClientRenewalIntervalSeconds",
                        this.expectedClientRenewalIntervalSeconds)
                .append("useAwsAsgApi", this.useAwsAsgApi).append("myUrl", this.myUrl)
                .toString();
    }

}

③ Eureka Server 初始化

还可以看到 EurekaServerAutoConfiguration 导入了 EurekaServerInitializerConfiguration 的初始化配置类，它启动了一个后台线程来初始化 eurekaServerBootstrap，进入可以看到跟 EurekaBootStrap 的初始化是类似的，只不过是简化了些，就不在展示了。

public void start() {
    new Thread(() -> {
        try {
            // TODO: is this class even needed now?
            eurekaServerBootstrap.contextInitialized(
                    EurekaServerInitializerConfiguration.this.servletContext);
            log.info("Started Eureka Server");

            publish(new EurekaRegistryAvailableEvent(getEurekaServerConfig()));
            EurekaServerInitializerConfiguration.this.running = true;
            publish(new EurekaServerStartedEvent(getEurekaServerConfig()));
        }
        catch (Exception ex) {
            // Help!
            log.error("Could not initialize Eureka servlet context", ex);
        }
    }).start();
}

2、spring-cloud-starter-netflix-eureka-client

① Eureka Client 自动化配置

Eureka Client 自动化配置类是 EurekaClientAutoConfiguration（@EnableEurekaClient 注解感觉没啥用），这里初始化类里主要初始化了 ApplicationInfoManager、EurekaClientConfigBean、EurekaInstanceConfigBean、EurekaClient 等。

需要注意，在 springcloud 中，EurekaClient 组件默认是 CloudEurekaClient；

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
@ConditionalOnClass(EurekaClientConfig.class)
@ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true)
@ConditionalOnDiscoveryEnabled
@AutoConfigureBefore({ NoopDiscoveryClientAutoConfiguration.class,
        CommonsClientAutoConfiguration.class, ServiceRegistryAutoConfiguration.class })
@AutoConfigureAfter(name = {
        "org.springframework.cloud.netflix.eureka.config.DiscoveryClientOptionalArgsConfiguration",
        "org.springframework.cloud.autoconfigure.RefreshAutoConfiguration",
        "org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration",
        "org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration" })
public class EurekaClientAutoConfiguration {

    private ConfigurableEnvironment env;

    public EurekaClientAutoConfiguration(ConfigurableEnvironment env) {
        this.env = env;
    }

    @Bean
    public HasFeatures eurekaFeature() {
        return HasFeatures.namedFeature("Eureka Client", EurekaClient.class);
    }

    @Bean
    @ConditionalOnMissingBean(value = EurekaClientConfig.class,
            search = SearchStrategy.CURRENT)
    public EurekaClientConfigBean eurekaClientConfigBean(ConfigurableEnvironment env) {
        return new EurekaClientConfigBean();
    }

    @Bean
    @ConditionalOnMissingBean
    public ManagementMetadataProvider serviceManagementMetadataProvider() {
        return new DefaultManagementMetadataProvider();
    }

    private String getProperty(String property) {
        return this.env.containsProperty(property) ? this.env.getProperty(property) : "";
    }

    @Bean
    @ConditionalOnMissingBean(value = EurekaInstanceConfig.class,
            search = SearchStrategy.CURRENT)
    public EurekaInstanceConfigBean eurekaInstanceConfigBean(InetUtils inetUtils,
            ManagementMetadataProvider managementMetadataProvider) {
        String hostname = getProperty("eureka.instance.hostname");
        boolean preferIpAddress = Boolean
                .parseBoolean(getProperty("eureka.instance.prefer-ip-address"));
        String ipAddress = getProperty("eureka.instance.ip-address");
        boolean isSecurePortEnabled = Boolean
                .parseBoolean(getProperty("eureka.instance.secure-port-enabled"));

        String serverContextPath = env.getProperty("server.servlet.context-path", "/");
        int serverPort = Integer.parseInt(
                env.getProperty("server.port", env.getProperty("port", "8080")));

        Integer managementPort = env.getProperty("management.server.port", Integer.class);
        String managementContextPath = env
                .getProperty("management.server.servlet.context-path");
        Integer jmxPort = env.getProperty("com.sun.management.jmxremote.port",
                Integer.class);
        EurekaInstanceConfigBean instance = new EurekaInstanceConfigBean(inetUtils);

        instance.setNonSecurePort(serverPort);
        instance.setInstanceId(getDefaultInstanceId(env));
        instance.setPreferIpAddress(preferIpAddress);
        instance.setSecurePortEnabled(isSecurePortEnabled);
        if (StringUtils.hasText(ipAddress)) {
            instance.setIpAddress(ipAddress);
        }

        if (isSecurePortEnabled) {
            instance.setSecurePort(serverPort);
        }

        if (StringUtils.hasText(hostname)) {
            instance.setHostname(hostname);
        }
        String statusPageUrlPath = getProperty("eureka.instance.status-page-url-path");
        String healthCheckUrlPath = getProperty("eureka.instance.health-check-url-path");

        if (StringUtils.hasText(statusPageUrlPath)) {
            instance.setStatusPageUrlPath(statusPageUrlPath);
        }
        if (StringUtils.hasText(healthCheckUrlPath)) {
            instance.setHealthCheckUrlPath(healthCheckUrlPath);
        }

        ManagementMetadata metadata = managementMetadataProvider.get(instance, serverPort,
                serverContextPath, managementContextPath, managementPort);

        if (metadata != null) {
            instance.setStatusPageUrl(metadata.getStatusPageUrl());
            instance.setHealthCheckUrl(metadata.getHealthCheckUrl());
            if (instance.isSecurePortEnabled()) {
                instance.setSecureHealthCheckUrl(metadata.getSecureHealthCheckUrl());
            }
            Map<String, String> metadataMap = instance.getMetadataMap();
            metadataMap.computeIfAbsent("management.port",
                    k -> String.valueOf(metadata.getManagementPort()));
        }
        else {
            // without the metadata the status and health check URLs will not be set
            // and the status page and health check url paths will not include the
            // context path so set them here
            if (StringUtils.hasText(managementContextPath)) {
                instance.setHealthCheckUrlPath(
                        managementContextPath + instance.getHealthCheckUrlPath());
                instance.setStatusPageUrlPath(
                        managementContextPath + instance.getStatusPageUrlPath());
            }
        }

        setupJmxPort(instance, jmxPort);
        return instance;
    }

    private void setupJmxPort(EurekaInstanceConfigBean instance, Integer jmxPort) {
        Map<String, String> metadataMap = instance.getMetadataMap();
        if (metadataMap.get("jmx.port") == null && jmxPort != null) {
            metadataMap.put("jmx.port", String.valueOf(jmxPort));
        }
    }

    @Bean
    public EurekaServiceRegistry eurekaServiceRegistry() {
        return new EurekaServiceRegistry();
    }

    // @Bean
    // @ConditionalOnBean(AutoServiceRegistrationProperties.class)
    // @ConditionalOnProperty(value =
    // "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true)
    // public EurekaRegistration eurekaRegistration(EurekaClient eurekaClient,
    // CloudEurekaInstanceConfig instanceConfig, ApplicationInfoManager
    // applicationInfoManager, ObjectProvider<HealthCheckHandler> healthCheckHandler) {
    // return EurekaRegistration.builder(instanceConfig)
    // .with(applicationInfoManager)
    // .with(eurekaClient)
    // .with(healthCheckHandler)
    // .build();
    // }

    @Bean
    @ConditionalOnBean(AutoServiceRegistrationProperties.class)
    @ConditionalOnProperty(
            value = "spring.cloud.service-registry.auto-registration.enabled",
            matchIfMissing = true)
    public EurekaAutoServiceRegistration eurekaAutoServiceRegistration(
            ApplicationContext context, EurekaServiceRegistry registry,
            EurekaRegistration registration) {
        return new EurekaAutoServiceRegistration(context, registry, registration);
    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnMissingRefreshScope
    protected static class EurekaClientConfiguration {

        @Autowired
        private ApplicationContext context;

        @Autowired
        private AbstractDiscoveryClientOptionalArgs<?> optionalArgs;

        @Bean(destroyMethod = "shutdown")
        @ConditionalOnMissingBean(value = EurekaClient.class,
                search = SearchStrategy.CURRENT)
        public EurekaClient eurekaClient(ApplicationInfoManager manager,
                EurekaClientConfig config) {
            return new CloudEurekaClient(manager, config, this.optionalArgs,
                    this.context);
        }

        @Bean
        @ConditionalOnMissingBean(value = ApplicationInfoManager.class,
                search = SearchStrategy.CURRENT)
        public ApplicationInfoManager eurekaApplicationInfoManager(
                EurekaInstanceConfig config) {
            InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
            return new ApplicationInfoManager(config, instanceInfo);
        }

        @Bean
        @ConditionalOnBean(AutoServiceRegistrationProperties.class)
        @ConditionalOnProperty(
                value = "spring.cloud.service-registry.auto-registration.enabled",
                matchIfMissing = true)
        public EurekaRegistration eurekaRegistration(EurekaClient eurekaClient,
                CloudEurekaInstanceConfig instanceConfig,
                ApplicationInfoManager applicationInfoManager, @Autowired(
                        required = false) ObjectProvider<HealthCheckHandler> healthCheckHandler) {
            return EurekaRegistration.builder(instanceConfig).with(applicationInfoManager)
                    .with(eurekaClient).with(healthCheckHandler).build();
        }

    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnRefreshScope
    protected static class RefreshableEurekaClientConfiguration {

        @Autowired
        private ApplicationContext context;

        @Autowired
        private AbstractDiscoveryClientOptionalArgs<?> optionalArgs;

        @Bean(destroyMethod = "shutdown")
        @ConditionalOnMissingBean(value = EurekaClient.class,
                search = SearchStrategy.CURRENT)
        @org.springframework.cloud.context.config.annotation.RefreshScope
        @Lazy
        public EurekaClient eurekaClient(ApplicationInfoManager manager,
                EurekaClientConfig config, EurekaInstanceConfig instance,
                @Autowired(required = false) HealthCheckHandler healthCheckHandler) {
            // If we use the proxy of the ApplicationInfoManager we could run into a
            // problem
            // when shutdown is called on the CloudEurekaClient where the
            // ApplicationInfoManager bean is
            // requested but wont be allowed because we are shutting down. To avoid this
            // we use the
            // object directly.
            ApplicationInfoManager appManager;
            if (AopUtils.isAopProxy(manager)) {
                appManager = ProxyUtils.getTargetObject(manager);
            }
            else {
                appManager = manager;
            }
            CloudEurekaClient cloudEurekaClient = new CloudEurekaClient(appManager,
                    config, this.optionalArgs, this.context);
            cloudEurekaClient.registerHealthCheck(healthCheckHandler);
            return cloudEurekaClient;
        }

        @Bean
        @ConditionalOnMissingBean(value = ApplicationInfoManager.class,
                search = SearchStrategy.CURRENT)
        @org.springframework.cloud.context.config.annotation.RefreshScope
        @Lazy
        public ApplicationInfoManager eurekaApplicationInfoManager(
                EurekaInstanceConfig config) {
            InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
            return new ApplicationInfoManager(config, instanceInfo);
        }

        @Bean
        @org.springframework.cloud.context.config.annotation.RefreshScope
        @ConditionalOnBean(AutoServiceRegistrationProperties.class)
        @ConditionalOnProperty(
                value = "spring.cloud.service-registry.auto-registration.enabled",
                matchIfMissing = true)
        public EurekaRegistration eurekaRegistration(EurekaClient eurekaClient,
                CloudEurekaInstanceConfig instanceConfig,
                ApplicationInfoManager applicationInfoManager, @Autowired(
                        required = false) ObjectProvider<HealthCheckHandler> healthCheckHandler) {
            return EurekaRegistration.builder(instanceConfig).with(applicationInfoManager)
                    .with(eurekaClient).with(healthCheckHandler).build();
        }

    }

    @Target({ ElementType.TYPE, ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Conditional(OnMissingRefreshScopeCondition.class)
    @interface ConditionalOnMissingRefreshScope {

    }

    @Target({ ElementType.TYPE, ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @ConditionalOnClass(RefreshScope.class)
    @ConditionalOnBean(RefreshAutoConfiguration.class)
    @ConditionalOnProperty(value = "eureka.client.refresh.enable", havingValue = "true",
            matchIfMissing = true)
    @interface ConditionalOnRefreshScope {

    }

    private static class OnMissingRefreshScopeCondition extends AnyNestedCondition {

        OnMissingRefreshScopeCondition() {
            super(ConfigurationPhase.REGISTER_BEAN);
        }

        @ConditionalOnMissingClass("org.springframework.cloud.context.scope.refresh.RefreshScope")
        static class MissingClass {

        }

        @ConditionalOnMissingBean(RefreshAutoConfiguration.class)
        static class MissingScope {

        }

        @ConditionalOnProperty(value = "eureka.client.refresh.enable",
                havingValue = "false")
        static class OnPropertyDisabled {

        }

    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(Health.class)
    protected static class EurekaHealthIndicatorConfiguration {

        @Bean
        @ConditionalOnMissingBean
        @ConditionalOnEnabledHealthIndicator("eureka")
        public EurekaHealthIndicator eurekaHealthIndicator(EurekaClient eurekaClient,
                EurekaInstanceConfig instanceConfig, EurekaClientConfig clientConfig) {
            return new EurekaHealthIndicator(eurekaClient, instanceConfig, clientConfig);
        }

    }

}

② Eureka Client 注册

Netflix 中服务注册的逻辑是在 InstanceInfoReplicator，springcloud 则封装到了 EurekaAutoServiceRegistration，InstanceInfoReplicator 启动之后要延迟40秒才会注册到注册中心，而这里的自动化配置在服务启动时就会注册到注册中心。

它这里调用了 serviceRegistry 来注册，进去可以发现它就是调用了 ApplicationInfoManager 的 setInstanceStatus 方法，进而触发了那个状态变更器 StatusChangeListener，然后向注册中心注册。

public void start() {
    // only set the port if the nonSecurePort or securePort is 0 and this.port != 0
    if (this.port.get() != 0) {
        if (this.registration.getNonSecurePort() == 0) {
            this.registration.setNonSecurePort(this.port.get());
        }

        if (this.registration.getSecurePort() == 0 && this.registration.isSecure()) {
            this.registration.setSecurePort(this.port.get());
        }
    }

    // only initialize if nonSecurePort is greater than 0 and it isn't already running
    // because of containerPortInitializer below
    if (!this.running.get() && this.registration.getNonSecurePort() > 0) {

        this.serviceRegistry.register(this.registration);

        this.context.publishEvent(new InstanceRegisteredEvent<>(this,
                this.registration.getInstanceConfig()));
        this.running.set(true);
    }
}

十四、Eureka 总结

这一节来对 eureka 的学习做个总结，注意下面的一些截图是来自《重新定义Spring Cloud实战 》，具体可以参考原著。

1、Eureka Server 提供的 API

大部分的 API 在前面的源码分析中都已经接触过了，这里看下 eureka 提供的 API列表。注意 eureka 整合到 springcloud 之后，api 前缀固定为 /eureka，在 netflix 中是 /{version} 的形式。

2、Eureka Client 核心参数

Eureka Client 的参数可以分为基本参数、定时任务参数、http参数三大类。

① 基本参数

② 定时任务参数

③ http 参数

3、Eureka Server 核心参数

Eureka Server 的参数可以分为 基本参数、多级缓存参数、集群相关参数、http参数 四大类。

① 基本参数

② 多级缓存参数

③ 集群参数

④ http 参数

4、Eureka 核心功能

① 服务注册和发现：eureka 分客户端（Eureka Client）和服务端（Eureka Server），服务端即为注册中心，提供服务注册和发现的功能。所有客户端将自己注册到注册中心上，服务端使用 Map 结构基于内存保存所有客户端信息（IP、端口、续约等信息）。客户端定时从注册中心拉取注册表到本地，就可以通过负载均衡的方式进行服务间的调用。

② 服务注册（Register）：Eureka Client 启动时向 Eureka Server 注册，并提供自身的元数据、IP地址、端口、状态等信息。

③ 服务续约（Renew）：Eureka Client 默认每隔30秒向 Eureka Server 发送一次心跳进行服务续约，通过续约告知 Eureka Server 自己是正常的。如果 Eureka Server 180 秒没有收到客户端的续约，就会认为客户端故障，并将其剔除。

④ 抓取注册表（Fetch Registry）：Eureka Client 启动时会向 Eureka Server 全量抓取一次注册表到本地，之后会每隔30秒增量抓取注册表合并到本地注册表。如果合并后的本地注册表与 Eureka Server 端的注册表不一致（hash 比对），就全量抓取注册表覆盖本地的注册表。

⑤ 服务下线（Cancel）：Eureka Client 程序正常关闭时，会向 Eureka Server 发送下线请求，之后 Eureka Server 将这个实例从注册表中剔除。

⑥ 故障剔除（Eviction）：默认情况下，Eureka Client 连续180秒没有向 Eureka Server 发送续约请求，就会被认为实例故障，然后从注册表剔除。

⑦ Eureka Server 集群：Eureka Server 采用对等复制模式（Peer to Peer）来进行副本之间的数据同步，集群中每个 Server 节点都可以接收写操作和读操作。Server 节点接收到写操作后（注册、续约、下线、状态更新）会通过后台任务打包成批量任务发送到集群其它 Server 节点进行数据同步。Eureka Server 集群副本之间的数据会有短暂的不一致性，它是满足 CAP 中的 AP，即 高可用性和分区容错性。

5、Eureka 核心类和组件

① Eureka Server 

• Eureka Server 启动初始化：com.netflix.eureka.EurekaBootStrap
• 服务端配置：com.netflix.eureka.EurekaServerConfig
• 序列化器：com.netflix.eureka.resources.ServerCodecs
• 实例注册：com.netflix.eureka.registry.InstanceRegistry
• 续约管理：com.netflix.eureka.lease.LeaseManager
• 发现服务：com.netflix.discovery.shared.LookupService
• 感知集群的注册表：com.netflix.eureka.registry.PeerAwareInstanceRegistry
• Eureka Server 集群：com.netflix.eureka.cluster.PeerEurekaNodes
• Eureka Server 集群节点：com.netflix.eureka.cluster.PeerEurekaNode
• Eureka Server 上下文：com.netflix.eureka.EurekaServerContext
• Eureka 监控统计：com.netflix.eureka.util.EurekaMonitors
• 多级缓存组件：com.netflix.eureka.registry.ResponseCache
• 资源入口：ApplicationsResource、ApplicationResource、InstancesResource、InstanceResource、PeerReplicationResource

注册表类结构：

② Eureka Client

• 应用实例配置：com.netflix.appinfo.EurekaInstanceConfig
• 客户端配置：com.netflix.discovery.EurekaClientConfig
• 网络传输配置：com.netflix.discovery.shared.transport.EurekaTransportConfig
• 实例信息：com.netflix.appinfo.providers.InstanceInfo
• 应用信息管理器：com.netflix.appinfo.ApplicationInfoManager
• Eureka 客户端：com.netflix.discovery.EurekaClient（com.netflix.discovery.DiscoveryClient）
• Eureka 客户端与服务端通信的底层组件：com.netflix.discovery.shared.transport.EurekaHttpClient
• 实例注册器：com.netflix.discovery.InstanceInfoReplicator
• 状态变更监听器：com.netflix.appinfo.ApplicationInfoManager.StatusChangeListener
• 应用管理器：com.netflix.discovery.shared.Applications
• 应用：com.netflix.discovery.shared.Application

③ 集群同步：

• 复制任务处理器：com.netflix.eureka.cluster.ReplicationTaskProcessor
• 批量分发器：com.netflix.eureka.util.batcher.TaskDispatcher
• 接收者执行器：com.netflix.eureka.util.batcher.AcceptorExecutor
• 任务处理器：com.netflix.eureka.util.batcher.TaskExecutors

6、Eureka 后台任务

Eureka 后台大量用到了定时任务来保证服务实例的注册和发现，这节看下 eureka 都有哪些地方用到了定时任务。

① Eureka Client

• DiscoveryClient：CacheRefreshThread，定时刷新注册表，30秒执行一次，定时抓取增量注册表到本地
• DiscoveryClient：HeartbeatThread，定时发送心跳，30秒执行一次，向 Eureka Server 发送续约请求
• DiscoveryClient：InstanceInfoReplicator，实例复制器，30秒执行一次，如果实例信息变更，则向 Eureka Server 重新注册

② Eureka Server

• AbstractInstanceRegistry：DeltaRetentionTask，30秒执行一次，将最近变更队列 recentlyChangedQueue 中超过 180 秒的实例从队列中移除
• ResponseCacheImpl：LoadingCacheExpire，读写缓存 readWriteCacheMap 中的数据每隔 180 秒失效，读取时重新从注册表加载新的数据
• ResponseCacheImpl：CacheUpdateTask，每隔30秒将读写缓存 readWriteCacheMap 的数据同步到只读缓存 readOnlyCacheMap 中
• PeerAwareInstanceRegistryImpl：RenewalThresholdUpdateTask，每隔15分钟更新每分钟续约阈值 numberOfRenewsPerMinThreshold
• PeerEurekaNodes：PeersUpdateTask，每隔10分钟更新集群节点信息
• AbstractInstanceRegistry：EvictionTask，每隔60秒执行一次，定时剔除故障（超过180秒未续约）的实例
• AcceptorExecutor：AcceptorRunner，后台循环运行，将 acceptorQueue 和 reprocessQueue 队列的任务转移到 processingOrder，然后每隔500毫秒将任务打包成一个批次到 batchWorkQueue
• TaskExecutors：BatchWorkerRunnable，将 batchWorkQueue 的批量任务发送到集群节点
• TaskExecutors：SingleTaskWorkerRunnable，将 singleItemWorkQueue 的单项任务发送到集群节点

7、Eureka 的一些优秀设计

① Eureka 注册中心

Eureka 作为注册中心整体的运行机制，服务注册、抓取注册表、续约、下线、定时剔除故障实例等一整套机制都是值得学习的。

② 基于接口的配置读取方式

eureka 将客户端配置、实例配置、服务端配置的读取分别定义在三个接口类中，并提供了默认实现类，在实现类中给了默认值。这种基于接口的配置读取方式也是可以借鉴的。可以看到，Springcloud 集成 eureka 时就自定义了三个配置接口的实现类，并基于 springboot 的方式从 application.yml 文件中读取配置。

③ 定时任务监管器 TimedSupervisorTask

• 首先在远程调用的时候要考虑到网络不可用、server 端 down 了等情况导致调用超时，可以使用线程池异步提交任务，实现等待超时机制。
• 超时之后，可以假想服务恢复可用状态可能需要一定的时间，如果还是按原来的时间间隔调度，可能还是会超时，因此增大延迟时间。如果调用成功，说明已经恢复了，则重置延迟时间。
• 定时任务的调度以一定的延迟时间来循环调度（schedule），延迟时间可以根据实际情况变化，而不是一开始就按一个固定的频率来调度（scheduleAtFixedRate）。

④ 最近一分钟计数器 MeasuredRate

MeasuredRate 利用两个桶来计数，一个保存上一间隔时间的计数，一个保存当前这一间隔时间的计数，然后使用定时任务每隔一定间隔时间就将当前这个桶的计数替换到上一个桶里。然后增加计数的时候增加当前桶，获取数量的时候从上一个桶里获取，就实现了获取上一个间隔时间的计数。

⑤ 定时任务补偿时间

eureka 后台用到了大量的定时任务，例如每隔30秒运行一次、每隔60秒运行一次，但是如果因为GC停顿、本地时间漂移等问题，就会导致每次任务的间隔时间不一致，因此 eureka 会判断两次任务的间隔时间与定时间隔时间，得到一个补偿时间，例如定时摘除过期实例的任务 EvictionTask。

有些任务还可能因为网络超时、阻塞等原因导致任务失败，eureka 就会认为远程服务可能暂时不可用，就会延迟一定时间再调度，避免频繁失败。例如 TimedSupervisorTask 的设计，后台发送批量任务到集群节点的任务等。

⑥ 并发队列的应用

Eureka 为了保证高性能，所有数据都是保存在内存中的，为了保证共享数据的并发安全，它大量使用了JDK并发包下的原子类（AtomicLong、AtomicReference）、并发队列（LinkedBlockingQueue、ConcurrentLinkedQueue）、并发容器（ConcurrentHashMap）、并发工具（Semaphore）等。

⑦ 三级缓存高性能读取

抓取注册表时的三级缓存结构设计，读取数据先从只读缓存读取，只读缓存没有再从读写缓存读，读写缓存没有最后再从注册表读。缓存更新的机制则是，注册、下线都会失效读写缓存，读写缓存每隔180秒过期，读写缓存每隔30秒同步到只读缓存。

⑧ 增量数据更新

定时更新注册表时，采用的是增量更新，而增量更新的数据是用一个最近变更队列保存了最近三分钟变更的实例。注册、下线等操作都会将实例放入到这个最近变更队列，然后定时任务将队列中超过180秒的实例移除。

⑨ 数据副本同步hash一致性比对

更新注册表时，合并到本地后，采用了 hash 一致性比对的方式来保证数据同步的正确性。在分布式系统中，数据同步我们也可以采用这个思路，先增量获取数据，服务端返回一个全量数据的 hash 值，客户端合并数据后，计算一个本地的 hash 值，如果 hash 值不一致，说明数据缺失，就进行一次全量更新数据，来保证数据的一致性。

⑩ 自我保护机制

如果客户端超过180秒未续约则被认为是实例故障，后台定时任务会定时清除故障的实例。但 eureka 并不是直接把所有过期实例都清除掉，它会判断最近一分钟客户端续约次数是否大于每分钟续约阈值(85%)，如果低于这个阈值，就任务是自身网络抖动导致客户端无法续约，然后进入自我保护模式，不再剔除过期实例。而且，在摘除过期实例的时候，它也不是一次性摘除所有过期实例，而是一次只摘除不超过15%的实例，分批次摘除。

eureka 认为保留可用及过期的数据总比丢失掉可用的数据好。我觉得它这里的一套自我保护机制的思想是值得我们学习的。

⑪ 监控统计

各种操作都会进行统计，比如注册、续约、下线、抓取注册表、集群同步、实例过期等，可以看下 EurekaMonitors 这个类。在开发一些系统时，我们也应该做好统计，便于分析问题。

⑫ Eureka Server 集群

Eureka 集群采用 Peer to Peer 的对等复制模式，每个节点都可以写入数据，然后通过多层任务队列+批量处理的机制进行集群间数据同步。同时后台定时更新集群节点信息，保证集群高可用。

Eureka 集群是保证CAP中的 AP，保证高可用及分区容错性，副本数据则是最终一致。集群数据同步难免可能会失败、延迟等导致数据不一致，eureka 采用最后更新时间比对以及续约的机制来进行数据的修正，保证集群数据同步的最终一致性。

8、Eureka Server 承载高并发访问压力

① Eureka Server 的访问压力有多大

首先来计算下一个大型系统会对 Eureka Server 产生多大的访问压力。例如有一个微服务系统，有 100 个服务，每个服务部署 10 个实例。

每个实例每隔30秒向Eureka Server发送一次心跳以及拉取注册表，这是 Eureka Server 的主要访问压力，那么每分钟 Eureka Server 就会接收到 4 * 100 * 10 = 4000 次请求，每秒 4000 / 60 ≈ 67 次请求。Eureka Server 还会处理集群同步、接收注册、下线、抓取全量注册表的一些额外请求，就估算每秒接收个100次请求吧。这样每天算下来就是 100 * 60 * 60 * 24 = 864万次请求，也就是每天接近千万级别的访问量。

所以各服务实例每隔30秒抓取增量注册表，以及每隔30秒发送心跳给Eureka Server，其实这个时间频率设置是有其用意的，一般我们也不用修改这两个参数。

另外 Eureka Server 每秒接收100次请求，如果一台机器每秒能扛40次请求，那 Eureka Server 集群就可以部署3个实例。我们就可以以此来估算 Eureka Server 集群部署的实例数。

② Eureka Server 如何抗住每秒百次请求的

Eureka Server 是基于纯内存的 CocurrentHashMap 结构来保存注册表的，服务注册、续约、下线、抓去注册表都是操作这个内存的注册表，这是 Eureka Server 能抗住高并发的一个核心点。

除此之外，Eureka Server 还设计了多级缓存机制来提高并发能力。因为 Eureka Server 是基于纯内存的数据结构来保存注册表的，如果所有的读和写操作都直接操作这个Map，那并发性能就非常低。所以多级缓存的设计能避免同时读写内存数据结构造成的并发冲突问题，能够进一步提升服务请求的响应速度。

9、Eureka 整体架构

最后用一张图来总结下 Eureka 的整体架构、运行流程以及核心机制。