Fork me on GitHub

framework/SpringCloud/eureka/Eureka名词

字数统计: 11.9k字   |   阅读时长≈ 55分

Eureka的名词

EurekaHttpClient

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

/*
因为eureka分布式集群是基于http来实现的

这个接口的作用就是用于eureka节点之间内部的请求发送

*/

public interface EurekaHttpClient {

    EurekaHttpResponse<Void> register(InstanceInfo info);

    EurekaHttpResponse<Void> cancel(String appName, String id);

    EurekaHttpResponse<InstanceInfo> sendHeartBeat(String appName, String id, InstanceInfo info, InstanceStatus overriddenStatus);

    EurekaHttpResponse<Void> statusUpdate(String appName, String id, InstanceStatus newStatus, InstanceInfo info);

    EurekaHttpResponse<Void> deleteStatusOverride(String appName, String id, InstanceInfo info);

    EurekaHttpResponse<Applications> getApplications(String... regions);

    EurekaHttpResponse<Applications> getDelta(String... regions);

    EurekaHttpResponse<Applications> getVip(String vipAddress, String... regions);

    EurekaHttpResponse<Applications> getSecureVip(String secureVipAddress, String... regions);

    EurekaHttpResponse<Application> getApplication(String appName);

    EurekaHttpResponse<InstanceInfo> getInstance(String appName, String id);

    EurekaHttpResponse<InstanceInfo> getInstance(String id);

    void shutdown();
}

HttpReplicationClient

1
2
3
4
5
6
7
8
//如果是eureka服务节点实例，并且eureka服务节点是集群的
//则使用实现这个接口
public interface HttpReplicationClient extends EurekaHttpClient {

    EurekaHttpResponse<Void> statusUpdate(String asgName, ASGStatus newStatus);

    EurekaHttpResponse<ReplicationListResponse> submitBatchUpdates(ReplicationList replicationList);
}
AbstractJerseyEurekaHttpClient
1
2
3
4
5
6
/*
使用Jersey作为 eurekahttpclient的实现，这是cloud默认的
AbstractJerseyEurekaHttpClient是一个骨架

*/
他的实现JerseyReplicationClient JerseyReplicationClient

EurekaHttpClientDecorator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

继承EurekaHttpClient

/*
 public enum RequestType {
        Register,
        Cancel,
        SendHeartBeat,
        StatusUpdate,
        DeleteStatusOverride,
        GetApplications,
        GetDelta,
        GetVip,
        GetSecureVip,
        GetApplication,
        GetInstance,
        GetApplicationInstance
    }
    定义了请求类型
    
    更具名字，他是一个装饰器，那个他要实现EurekaHttpClient 要依赖 别的对象
    
    做了一个骨架，定义了一个请求的执行器，包装请求的类型
  public interface RequestExecutor<R> {
        EurekaHttpResponse<R> execute(EurekaHttpClient delegate);

        RequestType getRequestType();
    }
*/
//子类扩展    
      protected abstract <R> EurekaHttpResponse<R> execute(RequestExecutor<R> requestExecutor);
MetricsCollectingEurekaHttpClient
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
继承 EurekaHttpClientDecorator
    
 private final EurekaHttpClient delegate;

    private final Map<RequestType, EurekaHttpClientRequestMetrics> metricsByRequestType;   
    
    
   protected <R> EurekaHttpResponse<R> execute(RequestExecutor<R> requestExecutor) {
        EurekaHttpClientRequestMetrics requestMetrics = metricsByRequestType.get(requestExecutor.getRequestType());
        Stopwatch stopwatch = requestMetrics.latencyTimer.start();
        try {
            EurekaHttpResponse<R> httpResponse = requestExecutor.execute(delegate);
            requestMetrics.countersByStatus.get(mappedStatus(httpResponse)).increment();
            return httpResponse;
        } catch (Exception e) {
            requestMetrics.connectionErrors.increment();
            exceptionsMetric.count(e);
            throw e;
        } finally {
            stopwatch.stop();
        }
    }
RedirectingEurekaHttpClient
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

继承EurekaHttpClientDecorator
/*
 重定向 http客户端


注册和查询的请求 应该要分开处理，就是要创建两个 此实例，一个用于注册，一个用于查询，为了线程安全
*/
    
    
       protected <R> EurekaHttpResponse<R> execute(RequestExecutor<R> requestExecutor) {
        EurekaHttpClient currentEurekaClient = delegateRef.get();
        if (currentEurekaClient == null) {
            AtomicReference<EurekaHttpClient> currentEurekaClientRef = new AtomicReference<>(factory.newClient(serviceEndpoint));
            try {
                EurekaHttpResponse<R> response = executeOnNewServer(requestExecutor, currentEurekaClientRef);
                TransportUtils.shutdown(delegateRef.getAndSet(currentEurekaClientRef.get()));
                return response;
            } catch (Exception e) {
                logger.error("Request execution error. endpoint={}", serviceEndpoint, e);
                TransportUtils.shutdown(currentEurekaClientRef.get());
                throw e;
            }
        } else {
            try {
                return requestExecutor.execute(currentEurekaClient);
            } catch (Exception e) {
                logger.error("Request execution error. endpoint={}", serviceEndpoint, e);
                delegateRef.compareAndSet(currentEurekaClient, null);
                currentEurekaClient.shutdown();
                throw e;
            }
        }
    }


 private <R> EurekaHttpResponse<R> executeOnNewServer(RequestExecutor<R> requestExecutor,
                                                         AtomicReference<EurekaHttpClient> currentHttpClientRef) {
        URI targetUrl = null;
        for (int followRedirectCount = 0; followRedirectCount < MAX_FOLLOWED_REDIRECTS; followRedirectCount++) {
            EurekaHttpResponse<R> httpResponse = requestExecutor.execute(currentHttpClientRef.get());
            if (httpResponse.getStatusCode() != 302) {
                if (followRedirectCount == 0) {
                    logger.debug("Pinning to endpoint {}", targetUrl);
                } else {
                    logger.info("Pinning to endpoint {}, after {} redirect(s)", targetUrl, followRedirectCount);
                }
                return httpResponse;
            }

            targetUrl = getRedirectBaseUri(httpResponse.getLocation());
            if (targetUrl == null) {
                throw new TransportException("Invalid redirect URL " + httpResponse.getLocation());
            }

            currentHttpClientRef.getAndSet(null).shutdown();
            currentHttpClientRef.set(factory.newClient(new DefaultEndpoint(targetUrl.toString())));
        }
        String message = "Follow redirect limit crossed for URI " + serviceEndpoint.getServiceUrl();
        logger.warn(message);
        throw new TransportException(message);
    }
RetryableEurekaHttpClient
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
继承EurekaHttpClientDecorator

/*

RetryableEurekaHttpClient重试集群中后续服务器上失败的请求。
它还维护简单的隔离列表，因此在当前无法访问的服务器上不会再次重试操作。
RetryableEurekaHttpClient retries failed requests on subsequent servers in the cluster.
 * It maintains also simple quarantine list, so operations are not retried again on servers that are not reachable at the moment.

隔离>

所有通信失败的服务器都被放在隔离列表中。第一次成功执行将清除此列表，这将使这些服务器有资格为将来的请求提供服务。一旦所有可用服务器用完，该列表也会被清除。

All the servers to which communication failed are put on the quarantine list. First successful execution clears this list, which makes those server eligible for serving future requests. The list is also cleared once all available servers are exhausted.


如果返回5xx状态代码，{@link ServerStatusEvaluator}谓词将评估是否应该在另一台服务器上重试，还是将带有此状态代码的响应返回给客户端。
If 5xx status code is returned, {@link ServerStatusEvaluator} predicate evaluates if the retries should be retried on another server, or the response with this status code returned to the client.

*/

    
 protected <R> EurekaHttpResponse<R> execute(RequestExecutor<R> requestExecutor) {
        List<EurekaEndpoint> candidateHosts = null;
        int endpointIdx = 0;
        for (int retry = 0; retry < numberOfRetries; retry++) {
            EurekaHttpClient currentHttpClient = delegate.get();
            EurekaEndpoint currentEndpoint = null;
            if (currentHttpClient == null) {
                if (candidateHosts == null) {
                   //拿到候选的所有主机
                    candidateHosts = getHostCandidates();
                    if (candidateHosts.isEmpty()) {
                        throw new TransportException("There is no known eureka server; cluster server list is empty");
                    }
                }
                //用一个指针来记录 当前访问的主机
                if (endpointIdx >= candidateHosts.size()) {
                    throw new TransportException("Cannot execute request on any known server");
                }
				//通过当前指针来获取当前访问的 终端url和端口
                currentEndpoint = candidateHosts.get(endpointIdx++);
                //更具终端创建一个eureka的http客户端
                currentHttpClient = clientFactory.newClient(currentEndpoint);
            }

            try {
                //执行
                EurekaHttpResponse<R> response = requestExecutor.execute(currentHttpClient);
                
                if (serverStatusEvaluator.accept(response.getStatusCode(), requestExecutor.getRequestType())) {
                    delegate.set(currentHttpClient);
                    if (retry > 0) {
                        logger.info("Request execution succeeded on retry #{}", retry);
                    }
                    return response;
                }
                logger.warn("Request execution failure with status code {}; retrying on another server if available", response.getStatusCode());
            } catch (Exception e) {
                logger.warn("Request execution failed with message: {}", e.getMessage());  // just log message as the underlying client should log the stacktrace
            }

            // Connection error or 5xx from the server that must be retried on another server
            delegate.compareAndSet(currentHttpClient, null);
            if (currentEndpoint != null) {
                //说明当前终端不行，添加防止重试
                quarantineSet.add(currentEndpoint);
            }
        }
        throw new TransportException("Retry limit reached; giving up on completing the request");
    }
SessionedEurekaHttpClient
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134



{@link SessionedEurekaHttpClient} enforces full reconnect at a regular interval (a session), preventing a client to sticking to a particular Eureka server instance forever. This in turn guarantees even load distribution in case of cluster topology change.
/*
{@link SessionedEurekaHttpClient} 强制定期（一个会话）进行完全重新连接，防止客户端永远坚持特定的Eureka服务器实例。这反过来保证在集群拓扑发生变化时负载分布均匀。

*/
 protected <R> EurekaHttpResponse<R> execute(RequestExecutor<R> requestExecutor) {
        long now = System.currentTimeMillis();
        long delay = now - lastReconnectTimeStamp;
        if (delay >= currentSessionDurationMs) {
            //如果超过指定时间，这把客户端给shutdown
            logger.debug("Ending a session and starting anew");
            lastReconnectTimeStamp = now;
            currentSessionDurationMs = randomizeSessionDuration(sessionDurationMs);
            TransportUtils.shutdown(eurekaHttpClientRef.getAndSet(null));
        }

        EurekaHttpClient eurekaHttpClient = eurekaHttpClientRef.get();
        if (eurekaHttpClient == null) {
            //获取另一个 eureka服务的远程主机 的http客户端
            eurekaHttpClient = TransportUtils.getOrSetAnotherClient(eurekaHttpClientRef, clientFactory.newClient());
        }
    
        return requestExecutor.execute(eurekaHttpClient);
    }














  @Override
    public TransportClientFactory newTransportClientFactory(EurekaClientConfig clientConfig,
            Collection<ClientFilter> additionalFilters, InstanceInfo myInstanceInfo, Optional<SSLContext> sslContext,
            Optional<HostnameVerifier> hostnameVerifier) {
        final TransportClientFactory jerseyFactory = JerseyEurekaHttpClientFactory.create(
                clientConfig,
                additionalFilters,
                myInstanceInfo,
                new EurekaClientIdentity(myInstanceInfo.getIPAddr()),
                sslContext,
                hostnameVerifier
        );
        
        final TransportClientFactory metricsFactory = MetricsCollectingEurekaHttpClient.createFactory(jerseyFactory);

        return new TransportClientFactory() {
            @Override
            public EurekaHttpClient newClient(EurekaEndpoint serviceUrl) {
                return metricsFactory.newClient(serviceUrl);
            }

            @Override
            public void shutdown() {
                metricsFactory.shutdown();
                jerseyFactory.shutdown();
            }
        };
    }





eurekaTransport.transportClientFactory = providedJerseyClient == null
                ? transportClientFactories.newTransportClientFactory(clientConfig, additionalFilters, applicationInfoManager.getInfo(), sslContext, hostnameVerifier)
                : transportClientFactories.newTransportClientFactory(additionalFilters, providedJerseyClient); 
    


 new EurekaHttpClientFactory() {
            @Override
            public EurekaHttpClient newClient() {
                return new SessionedEurekaHttpClient(
                        name,
                        RetryableEurekaHttpClient.createFactory(
                                name,
                                transportConfig,
                                clusterResolver,
                                RedirectingEurekaHttpClient.createFactory(transportClientFactory),
                                ServerStatusEvaluators.legacyEvaluator()),
                        transportConfig.getSessionedClientReconnectIntervalSeconds() * 1000
                );
            }

            @Override
            public void shutdown() {
                wrapClosable(clusterResolver).shutdown();
            }
        };


new EurekaHttpClientFactory() {
            @Override
            public EurekaHttpClient newClient() {
                return new RetryableEurekaHttpClient(name, transportConfig, clusterResolver, delegateFactory,
                        serverStatusEvaluator, DEFAULT_NUMBER_OF_RETRIES);
            }

            @Override
            public void shutdown() {
                delegateFactory.shutdown();
            }
        };



new TransportClientFactory() {
            @Override
            public EurekaHttpClient newClient(EurekaEndpoint endpoint) {
                return new RedirectingEurekaHttpClient(endpoint.getServiceUrl(), delegateFactory, dnsService);
            }

            @Override
            public void shutdown() {
                delegateFactory.shutdown();
            }
        };

jersey 的hettp客户端
所以excute的执行是 session --> retryable-->Redirect-->MetricsCollecting--->具体的调用
    其他的两个少了MetricsCollecting这一层
    
    装饰器的强大在于对一个一个 对象无限的扩展，在扩展，包装再包装，人都搞晕

RestTemplateEurekaHttpClient

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

/*
他是使用RestTemplate进行http发送

*/
register：注册
	String urlPath = serviceUrl + "apps/" + info.getAppName();
cancel：注销
String urlPath = serviceUrl + "apps/" + appName + '/' + id;

sendHeartBeat：续约
String urlPath = serviceUrl + "apps/" + appName + '/' + id + "?status="
				+ info.getStatus().toString() + "&lastDirtyTimestamp="
				+ info.getLastDirtyTimestamp().toString() + (overriddenStatus != null
						? "&overriddenstatus=" + overriddenStatus.name() : "");

statusUpdate：更新状态
String urlPath = serviceUrl + "apps/" + appName + '/' + id + "/status?value="
				+ newStatus.name() + "&lastDirtyTimestamp="
				+ info.getLastDirtyTimestamp().toString();

getApplications：拉取注册表
public EurekaHttpResponse<Applications> getApplications(String... regions) {
		return getApplicationsInternal("apps/", regions);
	}

getDelta：
	@Override
	public EurekaHttpResponse<Applications> getDelta(String... regions) {
		return getApplicationsInternal("apps/delta", regions);
	}

getVip：
	public EurekaHttpResponse<Applications> getVip(String vipAddress, String... regions) {
		return getApplicationsInternal("vips/" + vipAddress, regions);
	}

getSecureVip：
	@Override
	public EurekaHttpResponse<Applications> getSecureVip(String secureVipAddress,
			String... regions) {
		return getApplicationsInternal("svips/" + secureVipAddress, regions);
	}


getApplication： 获取指定服务的注册信息
	String urlPath = serviceUrl + "apps/" + appName;

getInstance：
	@Override
	public EurekaHttpResponse<InstanceInfo> getInstance(String appName, String id) {
		return getInstanceInternal("apps/" + appName + '/' + id);
	}
public EurekaHttpResponse<InstanceInfo> getInstance(String id) {
		return getInstanceInternal("instances/" + id);
	}

EurekaHttpClientFactory

1
2
3
4
5
6
7
8
9

准确点是创建 真正传输EurekaHttpClient的包装类
public interface EurekaHttpClientFactory {

    EurekaHttpClient newClient();

    void shutdown();

}

TransportClientFactory

1
2
3
4
5
6
7
8
准确点是创建 真正传输EurekaHttpClient
public interface TransportClientFactory {

    EurekaHttpClient newClient(EurekaEndpoint serviceUrl);

    void shutdown();

}

EurekaTransportConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

/*
Config类，用于管理与传输层相关的配置

*/


/**@返回用于会话客户端的reconnect inverval,重新连接的间隔
     * @return the reconnect inverval to use for sessioned clients
     */
    int getSessionedClientReconnectIntervalSeconds();

    /**
    @返回在[0，1.0]范围内清除 隔离集合 的完整endpoint集合  的百分比
     * @return the percentage of the full endpoints set above which the quarantine set is cleared in the range [0, 1.0]
     */
    double getRetryableClientQuarantineRefreshPercentage();

    /**返回应用程序解析程序 允许的最大过期阈值
     * @return the max staleness threshold tolerated by the applications resolver
     */
    int getApplicationsResolverDataStalenessThresholdSeconds();

    /**默认情况下，应用程序解析程序从内部instanceinfo中提取公共主机名以进行解析。
     * By default, the applications resolver extracts the public hostname from internal InstanceInfos for resolutions.
     将此设置为true可将此行为更改为使用ip地址（如果可以确定ip类型，则使用私有ip）。
     * Set this to true to change this behaviour to use ip addresses instead (private ip if ip type can be determined).
     *
     * @return false by default
     */
    boolean applicationsResolverUseIp();

    /**返回异步解析程序的轮询间隔。
     * @return the interval to poll for the async resolver.
     */
    int getAsyncResolverRefreshIntervalMs();

    /**返回异步刷新超时阈值（毫秒）。
     * @return the async refresh timeout threshold in ms.
     */
    int getAsyncResolverWarmUpTimeoutMs();

    /**返回异步解析程序的执行器的最大线程池大小
     * @return the max threadpool size for the async resolver's executor
     */
    int getAsyncExecutorThreadPoolSize();

    /**要注册的主eureka群集的远程vipAddress。
     * The remote vipAddress of the primary eureka cluster to register with.
     *
     * @return the vipAddress for the write cluster to register with
     */
    String getWriteClusterVip();

    /**要从中获取注册表数据的eureka集群（主服务器或只读副本）的远程vipAddress。
     * The remote vipAddress of the eureka cluster (either the primaries or a readonly replica) to fetch registry data from.
     *如果适用，返回要重定向到的只读集群的vipAddress（可以与引导相同）
     * @return the vipAddress for the readonly cluster to redirect to, if applicable (can be the same as the bootstrap)
     */
    String getReadClusterVip();

    /**
     * 可用于指定不同的引导解析策略。目前支持的策略有：
         - 默认（如果不匹配）：从dns txt记录或静态配置主机名引导
     *  - composite: 从本地注册表引导，如果数据可用且温暖（请参见{@link#getApplicationsResolvedDataStaleNessThresholdSeconds（）}，否则将返回到支持默认值
     *
     * @return null for the default strategy, by default
     */
    String getBootstrapResolverStrategy();

    /**默认情况下，transport查询时 使用相同的（引导）解析器。
     * By default, the transport uses the same (bootstrap) resolver for queries.
     *将此属性设置为false以使用间接解析器通过{@link\#getReadClusterVip（）}解析查询目标。根据服务器的设置方式，此间接解析程序可能返回或不返回与引导服务器相同的目标。
     * Set this property to false to use an indirect resolver to resolve query targets via {@link #getReadClusterVip()}. This indirect resolver may or may not return the same targets as the bootstrap servers depending on how servers are setup.
     *
     * @return true by default.
     */
    boolean useBootstrapResolverForQuery();

InstanceRegistry

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

实现:
	LookupService<T>:主要提供查找可用的application（服务节点）
    LeaseManager<T> ：此类负责为特定实例提供 创建/续订和收回<em>租约的功能。  租约决定哪些实例接收流量。当没有来自客户端的续订请求时，租约将过期，实例将从{@link abstractinstanceregistry}中移出。这是实例是否接收流量（客户端请求）的关键。

/*


*/
 void openForTraffic(ApplicationInfoManager applicationInfoManager, int count);

    void shutdown();

    @Deprecated
    void storeOverriddenStatusIfRequired(String id, InstanceStatus overriddenStatus);

    void storeOverriddenStatusIfRequired(String appName, String id, InstanceStatus overriddenStatus);

    boolean statusUpdate(String appName, String id, InstanceStatus newStatus,
                         String lastDirtyTimestamp, boolean isReplication);

    boolean deleteStatusOverride(String appName, String id, InstanceStatus newStatus,
                                 String lastDirtyTimestamp, boolean isReplication);

    Map<String, InstanceStatus> overriddenInstanceStatusesSnapshot();

    Applications getApplicationsFromLocalRegionOnly();

    List<Application> getSortedApplications();

    /**
     * Get application information.
     *
     * @param appName The name of the application
     * @param includeRemoteRegion true, if we need to include applications from remote regions
     *                            as indicated by the region {@link java.net.URL} by this property
     *                            {@link com.netflix.eureka.EurekaServerConfig#getRemoteRegionUrls()}, false otherwise
     * @return the application
     */
    Application getApplication(String appName, boolean includeRemoteRegion);

    /**
     * Gets the {@link InstanceInfo} information.
     *
     * @param appName the application name for which the information is requested.
     * @param id the unique identifier of the instance.
     * @return the information about the instance.
     */
    InstanceInfo getInstanceByAppAndId(String appName, String id);

    /**
     * Gets the {@link InstanceInfo} information.
     *
     * @param appName the application name for which the information is requested.
     * @param id the unique identifier of the instance.
     * @param includeRemoteRegions true, if we need to include applications from remote regions
     *                             as indicated by the region {@link java.net.URL} by this property
     *                             {@link com.netflix.eureka.EurekaServerConfig#getRemoteRegionUrls()}, false otherwise
     * @return the information about the instance.
     */
    InstanceInfo getInstanceByAppAndId(String appName, String id, boolean includeRemoteRegions);

    void clearRegistry();

    void initializedResponseCache();

    ResponseCache getResponseCache();

    long getNumOfRenewsInLastMin();

    int getNumOfRenewsPerMinThreshold();

    int isBelowRenewThresold();

    List<Pair<Long, String>> getLastNRegisteredInstances();

    List<Pair<Long, String>> getLastNCanceledInstances();

    /**
     * Checks whether lease expiration is enabled.
     * @return true if enabled
     */
    boolean isLeaseExpirationEnabled();

    boolean isSelfPreservationModeEnabled();

LookupService

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/**
    * 返回相应的{@link Application}对象，该对象基本上是所有已注册的<code>appName</code>{@link InstanceInfo}s的容器。
    *
    * @param appName
    * @return a {@link Application} or null if we couldn't locate any app of
    *         the requested appName
    */
   Application getApplication(String appName);

   /**
    * 返回{@link Applications}对象，它基本上是所有当前注册的{@link Application}的容器。
    *
    * @return {@link Applications}
    */
   Applications getApplications();

   /**
    * 返回与传入的id匹配的{@link InstanceInfo}的{@link List}。单个{@link InstanceInfo}可以与多个{@link Application}一起注册
    *
    * @param id
    * @return {@link List} of {@link InstanceInfo}s or
    *         {@link java.util.Collections#emptyList()}
    */
   List<InstanceInfo> getInstancesById(String id);

   /**
    * Gets the next possible server to process the requests from the registry information received from eureka.
    *获取下一个可能的服务器来处理来自eureka的注册表信息的请求。
    * <p>
    下一个服务器是以循环方式选择的。默认情况下，此方法只返回当前状态为InstanceStatusUP的服务器。可以通过重写shouldFilterOnlyUpInstances（）来控制此配置。请注意，在某些情况下（Eureka紧急模式情况下），返回的实例可能不是无法访问的，此时只能由客户端快速超时并重试下一个服务器。
    * </p>
    *
    * @param virtualHostname
    *            the virtual host name that is associated to the servers.
    * @param secure
    *            indicates whether this is a HTTP or a HTTPS request - secure
    *            means HTTPS.
    * @return the {@link InstanceInfo} information which contains the public
    *         host name of the next server in line to process the request based
    *         on the round-robin algorithm.
    * @throws java.lang.RuntimeException if the virtualHostname does not exist
    */
   InstanceInfo getNextServerFromEureka(String virtualHostname, boolean secure);

LeaseManager

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

/**
    * Assign a new {@link Lease} to the passed in {@link T}.
    * 将新的{@link Lease}分配给传入的{@link T}。
    * @param r
    *            - T to register
    * @param leaseDuration
    * @param isReplication
    *            - whether this is a replicated entry from another eureka node.
    */
   void register(T r, int leaseDuration, boolean isReplication);

   /**
    * 注销与传入的<code>appName</code>和<code>id</code>关联的{@link Lease}。
    *
    * @param appName
    *            - unique id of the application.
    * @param id
    *            - unique id within appName.
    * @param isReplication
    *            - whether this is a replicated entry from another eureka node.
    * @return true, if the operation was successful, false otherwise.
    */
   boolean cancel(String appName, String id, boolean isReplication);

   /**
    * 更新与传入的<code>appName</code>和<code>id</code>关联的{@link Lease}。
    *
    * @param id
    *            - unique id within appName
    * @param isReplication
    *            - whether this is a replicated entry from another ds node
    * @return whether the operation of successful
    */
   boolean renew(String appName, String id, boolean isReplication);

   /**
    * 使用过期的{@link Lease}逐出{@link T}。
    */
   void evict();

PeerAwareInstanceRegistry

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
继承InstanceRegistry
    
/*


*/    
     void init(PeerEurekaNodes peerEurekaNodes) throws Exception;
    

    //从对等eureka节点填充注册表信息。如果通信失败，此操作将故障转移到其他节点，直到列表用尽为止。
     int syncUp();//同步启动


/**
     *检查是否允许访问注册表，或者服务器处于无法全部获取注册表信息的情况。如果在启动时无法从对等eureka节点获取注册表信息，则服务器在 {@link com.netflix.eureka.EurekaServerConfig#getWaitTimeInMsWhenSyncEmpty()}中指定的时间段内不会返回注册表信息。
     * @return false - if the instances count from a replica transfer returned
     *         zero and if the wait time has not elapsed, otherwise returns true
     */
     boolean shouldAllowAccess(boolean remoteRegionRequired);

   void register(InstanceInfo info, boolean isReplication);

     void statusUpdate(final String asgName, final ASGResource.ASGStatus newStatus, final boolean isReplication);
AbstractInstanceRegistry
1
2
3
4
5
6
7
继承 InstanceRegistry

/*
处理来自eureka客户端的所有注册表请求。

执行的主要操作是<em>注册</em>、<em>续订</em>、<in>取消</em>、<in>过期</em>和<in>状态更改</em>。注册表也只存储增量操作（delta operations）
*/

EurekaClientConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388

/*
eureka客户端向<em>eureka</em>服务器上 注册实例时所需的配置信息。
大多数必需的信息是由默认配置{@link DefaultEurekaClientConfig}提供的。用户只需提供eureka服务器服务url即可。Eureka服务器服务URL可以通过2种机制进行配置

1)By registering the information in the DNS. 通过在DNS中注册信息。
2) By specifying it in the configuration. 通过在配置中指定它。


一旦注册了客户机，用户就可以根据<em>虚拟主机名</em>从{@link  EurekaClient}中查找信息（也称为VIPAddress），这是最常见的方法，也可以通过其他方式获取与注册到<em>Eureka</em>的其他实例通信所需的信息。

请注意，除非另有规定，否则所有配置在运行时都无效。



*/

/**
     * 指示从eureka服务器获取注册表信息的频率（秒）。
     *
     * @return the fetch interval in seconds.
     */
    int getRegistryFetchIntervalSeconds();

 /**
     * Indicates how often(in seconds) to replicate instance changes to be replicated to the eureka server.指示将集群实例更改 发送到eureka服务器同步的频率（以秒为单位）。
     *
     * @return the instance replication interval in seconds.
     */
    int getInstanceInfoReplicationIntervalSeconds();


  /**
     * Indicates how long initially (in seconds) to replicate instance info to the eureka server
     指示最初将实例信息复制到eureka服务器的时间（以秒为单位）
     */
    int getInitialInstanceInfoReplicationIntervalSeconds();



 /**
     * 指示轮询eureka服务器信息更改的频率（秒）
     *可以添加或删除Eureka服务器，此设置控制Eureka客户端应该知道它的时间。
     *
     * @return the interval to poll for eureka service url changes.
     */
    int getEurekaServiceUrlPollIntervalSeconds();

  /**
     *获取eureka服务器的代理主机（如果有）。
     *
     * @return the proxy host.
     */
    String getProxyHost();

 /**
     *获取指向eureka服务器的代理端口（如果有）。
     *
     * @return the proxy port.
     */
    String getProxyPort();

/**
     * 获取代理用户名（如果有）。
     * @return the proxy user name.
     */
    String getProxyUserName();

    /**
     *获取代理密码（如果有）。
     * @return the proxy password.
     */
    String getProxyPassword();


   /**指示无论何时只要eureka服务器支持从eureka服务器获取的内容都必须进行压缩。
   //来自eureka服务器的注册表信息被压缩以获得最佳的网络流量。
     *
     * @return true, 如果内容需要压缩true，否则为false。
     * @deprecated gzip内容编码将始终在下一个Eureka次要版本中强制执行。（意思就是 现在正在使用这个压缩 (see com.netflix.eureka.GzipEncodingEnforcingFilter).
     */
    boolean shouldGZipContent();


 /**
     *指示从eureka服务器读取需要等待多长时间（以秒为单位）。
     * @return time in seconds before the read should timeout.
     */
    int getEurekaServerReadTimeoutSeconds();

/**指示连接到eureka服务器需要超时的等待时间（秒）。
     *
     * <p>
     * Note that the connections in the client are pooled by {@link org.apache.http.client.HttpClient} and this setting affects the actual connection creation and also the wait time to get the connection from the pool.
     请注意，客户机中的连接由{@link org.apache.http.client.HttpClient}共用，此设置会影响实际的连接创建以及从池中获取连接的等待时间。
     * </p>
     *
     * @return time in seconds before the connections should timeout.
     */
    int getEurekaServerConnectTimeoutSeconds();

 /**
    
     获取实现{@link BackupRegistry}的实现的名称，该实现仅在eureka客户机启动时第一次获取作为  回退选项的注册表信息。
     * 对于需要额外恢复注册表信息的应用程序来说，这可能是必需的，否则无法运行。
     *
     * @return the class name which implements {@link BackupRegistry}.
     */
    String getBackupRegistryImpl();


/**
     *获取允许从eureka客户端到所有eureka服务器的连接总数。
     * @return total number of allowed connections from eureka client to all
     *         eureka servers.
     */
    int getEurekaServerTotalConnections();


 /**
     * 获取允许从eureka客户端到eureka服务器主机的连接总数。
     *
     * @return total number of allowed connections from eureka client to a eureka server.
     */
    int getEurekaServerTotalConnectionsPerHost();


 /**URL context用于构造<em>service URL</em>加到eureka服务器中 当eureka服务器列表来自DNS时
 如果契约通过实现{@link#getEurekaServerServiceUrls（String）}返回服务URL，则不需要此信息。
     *
     当{@link shouldUseDnsForFetchingServiceUrls（）}设置为<em>true</em>时，使用DNS机制，并且eureka客户端希望DNS以某种方式配置，以便可以动态获取不断变化的eureka服务器。

     * <em>更改在运行时有效。</em>
     * @return the string indicating the context {@link java.net.URI} of the eureka
     *         server.
     */
    String getEurekaServerURLContext();


 /**
     * 获取用于 当eureka服务器列表来自DNS时  构造<em>服务url</em>以联系eureka服务器的端口。
     如果契约通过实现{@link#getEurekaServerServiceUrls（String）}返回服务URL，则不需要此信息。
     *当{@linkŠshouldUseDnsForFetchingServiceUrls（）}设置为<em>true</em>时，使用DNS机制，并且eureka客户端希望DNS以某种方式配置，以便可以动态获取不断变化的eureka服务器。
     * <em>The changes are effective at runtime.
     *
     * @return the string indicating the port where the eureka server is
     *         listening.
     */
    String getEurekaServerPort();

 /**
     * 获取要查询以获取eureka服务器列表的DNS名称。
     如果契约通过实现{@link#getEurekaServerServiceUrls（String）}返回服务URL，则不需要此信息。
     * 当{@link shouldUseDnsForFetchingServiceUrls（）}设置为<em>true</em>时，使用DNS机制，并且eureka客户端希望DNS以某种方式配置，以便可以动态获取不断变化的eureka服务器。
     * <em>The changes are effective at runtime.
     * @return the string indicating the DNS name to be queried for eureka
     *         servers.
     */
    String getEurekaServerDNSName();

   /**指示eureka客户端是否应使用DNS机制来获取要与之通信的eureka服务器列表。当DNS名称被更新为具有额外的服务器时，在eureka客户端轮询{@link #getEurekaServiceUrlPollIntervalSeconds()}中指定的信息后，将立即使用该信息。
     *或者，服务url可以返回{@link#getEurekaServerServiceUrls（String）}，但是用户应该实现自己的机制，以便在发生更改时返回更新的列表。
     * <em>The changes are effective at runtime。
     * @return true if the DNS mechanism should be used for fetching urls, false otherwise.
     */
    boolean shouldUseDnsForFetchingServiceUrls();

/**
     * 指示此实例是否应将其信息注册到eureka服务器以供其他人发现。
     * 在某些情况下，您不希望发现您的实例，而只希望发现其他实例。
     * @return true if this instance should register with eureka, false
     *         otherwise
     */
    boolean shouldRegisterWithEureka();


/**指示客户端是否应在客户端关闭时从远程服务器显式注销自己。
     * 
     * @return true if this instance should unregister with eureka on client shutdown, false otherwise
     */
    default boolean shouldUnregisterOnShutdown() {
        return true;
    }


 /**指示此实例是否应出于延迟 和/或 其他原因尝试使用同一区域中的eureka服务器。
     * Indicates whether or not this instance should try to use the eureka server in the same zone for latency and/or other reason.
     * <p>
     * 理想情况下，eureka客户机配置为与同一区域中的服务器通信
     * </p>
     * <em>更改在运行时在{@link#getRegistryFetchIntervalSeconds（）指定的下一个注册表获取周期生效</em>
     * @return true if the eureka client should prefer the server in the same zone, false otherwise.
     */
    boolean shouldPreferSameZoneEureka();

/**
     * 指示服务器是否可以将客户端请求重定向到备份 服务器/群集。
     *如果设置为false，则服务器将直接处理请求，如果设置为true，则可能向客户端发送HTTP重定向，并提供新的服务器位置。
     * @return true if HTTP redirects are allowed
     */
    boolean allowRedirects();



  /**指示是否记录eureka服务器和eureka客户端在注册表信息方面的差异。
     *Eureka客户端尝试只从Eureka服务器检索 增量更改，以最小化网络流量。
     在接收到delta之后，eureka客户端会核对来自服务器的信息，以验证它没有漏掉一些信息。当客户端与服务器的通信出现网络问题时，可能会发生协调失败。
     如果对账失败，eureka客户端将获得完整的注册表信息。
     * <p>在获取完整的注册表信息时，eureka客户端可以记录客户机和服务器之间的差异，此设置控制这一点。
     * </p>
     更改在运行时在{@link#getRegistryFetchIntervalSeconds（）指定的下一个注册表获取周期生效
     *
     * @return true if the eureka client should log delta differences in the case of reconciliation failure.
     */
    boolean shouldLogDeltaDiff();


/**
     * 指示eureka客户端是否应禁用delta的获取，而应求助于获取完整的注册表信息。
     * <p>
     * 请注意，delta获取可以极大地减少流量，因为eureka服务器的更改率通常远低于获取率。
     * <em>The changes are effective at runtime at the next registry fetch cycle as specified by {@link #getRegistryFetchIntervalSeconds()}</em>
     * @return true to enable fetching delta information for registry, false to get the full registry.
     */
    boolean shouldDisableDelta();


 /**
     *将获取eureka注册表信息的区域的逗号分隔列表。必须按照{@link#getAvailabilityZones（String）}返回的每个区域定义可用性区域。否则，将导致发现客户端启动失败。
     * @return Comma separated list of regions for which the eureka registry information will be fetched. <code>null</code> if no remote region has to be fetched.
     */
    @Nullable
    String fetchRegistryForRemoteRegions();

/**
     * 获取此实例所在的区域（在AWS数据中心中使用）。
     * @return AWS region where this instance resides.
     */
    String getRegion();

/**
     * 获取此实例所在区域的可用区域列表（在AWS数据中心中使用）。
     * <em>The changes are effective at runtime at the next registry fetch cycle as specified by {@link #getRegistryFetchIntervalSeconds()}</em>
     * </p>
     * @param region the region where this instance is deployed.
     *
     * @return the list of available zones accessible by this instance.
     */
    String[] getAvailabilityZones(String region);


 /**
     * 获取完全限定的{@link的列表java.net.URL}与eureka服务器通信。获取与eureka服务器通信的完全限定{@link java.net.URL}s的列表。
     *{@link java.net.URL}s
     * <p>
     * 通常，eureka服务器{@link java.net.URL}s携带协议、主机、端口、上下文和版本信息（如果有的话）。
     * <code>
     Example: http://ec2-256-156-243-129.compute-1.amazonaws.com:7001/eureka/v2/
     </code>
     * <em>更改在运行时在{@link#getEurekaServiceUrlPollIntervalSeconds（）指定的下一个服务url刷新周期时生效</em>
     * </p>
     * @param myZone部署实例的区域。
     * @return the list of eureka server service urls for eureka clients to talk to.
     */
    List<String> getEurekaServerServiceUrls(String myZone);


  /**指示在筛选仅具有InstanceStatus启动状态的实例的应用程序后，是否获取<em>applications</em>
     * <em>The changes are effective at runtime at the next registry fetch cycle as specified by
     * {@link #getRegistryFetchIntervalSeconds()}</em>
     * </p>
     *
     * @return true to filter, false otherwise.
     */
    boolean shouldFilterOnlyUpInstances();

  /**
     * 指示与eureka服务器的HTTP连接在关闭之前可以保持空闲的时间（以秒为单位）。
     * <p>
     * 在AWS环境中，建议将该值设置为30秒或更短，因为防火墙会在几分钟后清理连接信息，使连接悬而未决
     * @return time in seconds the connections to eureka can stay idle before it  can be closed.
     */
    int getEurekaConnectionIdleTimeoutSeconds();


/**
     *指示此客户端是否应从eureka服务器获取eureka注册表信息。
     *
     * @return {@code true} if registry information has to be fetched, {@code false} otherwise.
     */
    boolean shouldFetchRegistry();

/**
     * Indicates whether the client is only interested in the registry information for a single VIP.指示客户端是否只对单个VIP(虚拟ip)的注册表信息感兴趣。
     *
     * @return the address of the VIP (name:port).
     * <code>null</code> if single VIP interest is not present.
     */
    @Nullable
    String getRegistryRefreshSingleVipAddress();

    /**
     * 用于初始化heartbeatExecutor的线程池大小
     *
     * @return the heartbeatExecutor thread pool size
     */
    int getHeartbeatExecutorThreadPoolSize();

    /**
     * 心跳执行器指数相关后备属性。
     * 它是重试延迟的最大乘数值，以防发生一系列超时。
     * @return maximum multiplier value for retry delay
     */
    int getHeartbeatExecutorExponentialBackOffBound();

    /**
     *用于初始化cacheRefreshExecutor的线程池大小
     * @return the cacheRefreshExecutor thread pool size
     */
    int getCacheRefreshExecutorThreadPoolSize();

    /**
     * 缓存刷新执行器指数相关后备属性。
     * 它是重试延迟的最大乘数值，以防发生一系列超时。
     *
     * @return maximum multiplier value for retry delay
     */
    int getCacheRefreshExecutorExponentialBackOffBound();

    /**
     * 在eureka服务器中 序列化/反序列化信息时，获取美元符号的替换字符串。
     * @return Replacement string for Dollar sign <code>$</code>.
     */
    String getDollarReplacement();

    /**
     * eureka服务器中 序列化/反序列化 信息时，获取下划线符号的替换字符串。
     *
     * @return Replacement string for underscore sign <code>_</code>.
     */
    String getEscapeCharReplacement();

    /**如果设置为true，则通过{@link com.netflix.appinfo.ApplicationInfoManager#setInstanceStatus(com.netflix.appinfo.InstanceInfo.InstanceStatus)}进行的本地状态更新将触发对远程eureka服务器的按需（但速率有限）注册/更新
     * @return true or false for whether local status updates should be updated to remote servers on-demand
     */
    boolean shouldOnDemandUpdateStatusChange();

    /**
     *如果设置为true，{@link EurekaClient}初始化应该在构造函数时抛出异常，如果对远程服务器的初始注册失败。
     *
     * 请注意，如果{@link#shouldRegisterWithEureka（）}设置为false，则此配置为无操作
     * @return true or false for whether the client initialization should enforce an initial registration
     */
    default boolean shouldEnforceRegistrationAtInit() {
        return false;
    }

    /**
     * 这是一个临时配置，一旦最新的编解码器稳定，就可以删除（因为只有一个）
     * @return the class name of the encoding codec to use for the client. If none set a default codec will be used
     */
    String getEncoderName();

    /**
     * 这是一个临时配置，一旦最新的编解码器稳定，就可以删除（因为只有一个）
     *
     * @return the class name of the decoding codec to use for the client. If none set a default codec will be used
     */ 解码
    String getDecoderName();

    /**
     * @return {@link com.netflix.appinfo.EurekaAccept#name()} for client data accept
     */
    String getClientDataAccept();

    /**
     * 为了避免在尝试 新的/实验性的 或 特性时 或迁移过程中配置API污染，可以将相应的配置放入实验配置部分。配置格式为：
     * eureka.experimental.freeFormConfigString
     *
     * @return a property of experimental feature
     */
    String getExperimental(String name);

    /**
     * 为了兼容性，返回传输层配置类
     * @return an instance of {@link EurekaTransportConfig}
     */
    EurekaTransportConfig getTransportConfig();

EurekaClientConfigBean

1
2
3
4
5
6
7


继承EurekaClientConfig
    
    
    @NestedConfigurationProperty
	private EurekaTransportConfig transport = new CloudEurekaTransportConfig();

EurekaInstanceConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222

/*
 实例向Eureka服务器注册所需的配置信息。
 注册后，用户可以根据虚拟主机名（也称为VIPAddress）从{@link com.netflix.discovery.EurekaClient}查找信息，这是最常见的方法，也可以通过其他方式获取与注册到<em>Eureka</em>的其他实例通信所需的信息。
  作为注册的要求，必须提供id和appname。在appname的范围内，id应该是唯一的。
  
  请注意，除非另有规定，否则所有配置在运行时都无效。
*/

 /**
     * 获取要向eureka注册的此实例的唯一Id（在appName的范围内）。
     * @return the (appname scoped) unique id for this instance
     */
    String getInstanceId();

    /**
     * 获取要向eureka注册的应用程序的名称。
     * @return string denoting the name.
     */
    String getAppname();

    /**
     * 获取要向eureka注册的应用程序组的名称。
     * @return string denoting the name.
     */
    String getAppGroupName();

    /**
     * 指示是否应启用实例以便在向eureka注册后立即获取流量。有时，应用程序可能需要在准备接收流量之前进行一些预处理。
     *
     * :( 公共API错误是最糟糕的。我想这应该是“OnInit”。
     *
     * @return true to immediately start taking traffic, false otherwise.
     */
    boolean isInstanceEnabledOnit();

    /**
     * 获取实例应在其上接收流量的<code>非安全</code>端口。
     * @return the non-secure port on which the instance should receive traffic.
     */
    int getNonSecurePort();

    /**
     * 获取实例应在其上接收流量的<code>安全端口</code>。
     * @return the secure port on which the instance should receive traffic.
     */
    int getSecurePort();

    /**
     * 指示是否应为通信启用<code>非安全</code>端口
     *
     * @return true if the <code>non-secure</code> port is enabled, false otherwise.
     */
    boolean isNonSecurePortEnabled();

    /**
     * 指示是否应为通信启用<code>安全</code>端口。
     *
     * @return true if the <code>secure</code> port is enabled, false otherwise.
     */
    boolean getSecurePortEnabled();

    /**
     * 指示eureka客户端需要多长时间（以秒为单位）向eureka服务器发送心跳以指示它仍然处于活动状态。
     如果在{@link\getLeaseExpirationDurationInSeconds（）}中指定的时间段内没有接收到心跳信号，则eureka服务器将从其视图中删除该实例，方法是禁止对此实例进行通信。
     *
     * 请注意，如果实例实现了{@link healthcheckcallback}，然后决定使自己不可用，那么它仍然无法获取流量。
     * </p>
     *
     * @return time in seconds
     */
    int getLeaseRenewalIntervalInSeconds();

    /**
     * 指示eureka服务器自收到最后一次检测信号后等待的时间（以秒为单位），然后它才能通过禁止对此实例的流量将此实例从其视图中删除。
     * 将此值设置得太长可能意味着即使实例不存在，通信量也可能被路由到该实例。可能是因为这个网络的临时流量太小了小故障。这个要设置为至少高于{@link\#GetLeasereRenewalIntervalInSeconds（）}中指定的值的值
     *
     * @return value indicating time in seconds.
     */
    int getLeaseExpirationDurationInSeconds();

    /**
     * 获取为此实例定义的虚拟主机名。
     * <p>
     * 这通常是其他实例通过使用虚拟主机名来查找此实例的方式。
    可以将其视为类似于完全限定的域名，即您的服务的用户将需要找到此实例。
     * </p>
     *
     * @return the string indicating the virtual host name which the clients use
     *         to call this service.
     */
    String getVirtualHostName();

    /**
     * 获取为此实例定义的安全虚拟主机名。
     * 这通常是其他实例通过使用安全虚拟主机名来查找此实例的方式。
    可以将其视为类似于完全限定的域名，即您的服务的用户将需要找到此实例。
     * </p>
     *
     * @return the string indicating the secure virtual host name which the
     *         clients use to call this service.
     */
    String getSecureVirtualHostName();

    /**
     * 获取与此实例关联的<code>AWS autoscaling group name</code>。此信息专门用于AWS环境中，以在实例启动后自动停止服务，并且该实例已因流量而被禁用。。
     *
     * @return the autoscaling group name associated with this instance.
     */
    String getASGName();

    /**
     * 获取与此实例关联的主机名。这是其他实例用来进行调用的确切名称。
     * @param refresh
     *            true if the information needs to be refetched, false otherwise.
     * @return hostname of this instance which is identifiable by other
     *         instances for making remote calls.
     */
    String getHostName(boolean refresh);

    /**
     * 获取与此实例关联的 元数据名称/值对。此信息被发送到eureka服务器，并可供其他实例使用。
     *
     * @return Map containing application-specific metadata.
     */
    Map<String, String> getMetadataMap();

    /**
     * 返回部署此实例的数据中心。如果实例部署在AWS中，则此信息用于获取特定于AWS的实例信息
     *
     * @return information that indicates which data center this instance is
     *         deployed in.
     */
    DataCenterInfo getDataCenterInfo();

    /**
     * 获取实例的ipaddress。此信息仅用于学术目的，因为来自其他实例的通信主要使用{@link#getHostName（boolean）}中提供的信息进行。
     *
     * @return the ip address of this instance.
     */
    String getIpAddress();

    /**获取相对状态页{@linkjava.net.URL}<em>此实例的路径</em>。然后，根据{@link#getHostName（boolean）}和{@link}getSecurePort（）}和{@link}getnonsecurereport（）}中指定的通信类型（安全或不安全）构造状态页URL。
     *
     * <p>
     * 它通常用于提供信息，以便其他服务查找有关此实例的状态。用户可以提供一个简单的<code>HTML</code>来指示实例的当前状态. </p>
     *
     * @return - 指定状态页的相对<code>URL</code>。
     */
    String getStatusPageUrlPath();

    /**
     * 获取绝对状态页{@linkjava.net.URL}对于这个例子。如果状态页位于与eureka对话的同一个实例中，则用户可以提供{@link#getStatusPageUrlPath（）}，否则在实例是其他服务器的代理的情况下，用户可以提供完整的{@linkjava.net.URL}. 如果完整{@链接java.net.URL}前提是它优先。
  * 它通常用于提供信息，以便其他服务查找有关此实例的状态。用户可以提供一个简单的<code>HTML</code>来指示实例的当前状态。
. 完整的{@链接java.net.URL}应遵循http://${尤里卡主机名}：7001/其中${尤里卡主机名}在运行时被替换。
     * </p>
     *
     * @return absolute status page URL of this instance.
     */
    String getStatusPageUrl();

    /**
     * 获取相对主页{@linkjava.net.URL}<em>此实例的路径</em>。然后，主页URL由{@link#getHostName（boolean）}和{@link}getSecurePort（）}和{@link}getnonsecurereport（）}中指定的通信类型（安全或不安全）构成。
     * 它通常用于提供信息，以便其他服务将其用作登录页。
     * </p>
     *
     * @return relative <code>URL</code> that specifies the home page.
     */
    String getHomePageUrlPath();

    /**
     * 获取绝对主页{@linkjava.net.URL}对于这个例子。如果主页位于与eureka对话的同一个实例中，则用户可以提供{@link#getHomePageUrlPath（）}，否则，如果该实例是其他服务器的代理，则用户可以提供完整的{@linkjava.net.URL}. 如果完整{@链接java.net.URL}前提是它优先。
     *
     * <p>
     * 它通常用于提供信息，以便其他服务将其用作登录页。完整的{@链接java.net.URL}应遵循http://${尤里卡主机名}：7001/其中${尤里卡主机名}在运行时被替换。
     * </p>
     *
     * @return absolute home page URL of this instance.
     */
    String getHomePageUrl();

    /**
     * 获取相对运行状况检查{@linkjava.net.URL}<em>此实例的路径</em>。然后，健康检查页URL由{@link#getHostName（boolean）}和{@link}getSecurePort（）}和{@link}getnonsecurereport（）}中指定的通信类型构造而成。
     *
     * 它通常用于根据实例的运行状况做出有根据的决策—例如，它可以用于确定是继续部署到整个服务器场还是停止部署而不会造成进一步的损害。
     * @return - relative <code>URL</code> that specifies the health check page.
     */
    String getHealthCheckUrlPath();

    /**
     * 获取绝对运行状况检查页{@linkjava.net.URL}对于这个例子。如果健康检查页位于与eureka对话的同一实例中，则用户可以提供{@link#getHealthCheckUrlPath（）}，否则，在实例是其他服务器的代理的情况下，用户可以提供完整的{@linkjava.net.URL}. 如果完整{@链接java.net.URL}前提是它优先。
     *
     * <p>
     * 它通常用于根据实例的运行状况做出有根据的决策—例如，它可以用于确定是继续部署到整个服务器场还是停止部署而不会造成进一步的损害。完整的{@链接java.net.URL}应遵循http://${尤里卡主机名}：7001/其中${尤里卡主机名}在运行时被替换。
     * </p>
     *
     * @return absolute health check page URL of this instance.
     */
    String getHealthCheckUrl();

    /**
     * 获取绝对安全的运行状况检查页{@linkjava.net.URL}对于这个例子。如果健康检查页面位于与eureka对话的同一实例中，则用户可以提供{@link#getSecureHealthCheckUrl（）}，否则，在实例是其他服务器的代理的情况下，用户可以提供完整的{@linkjava.net.URL}. 如果完整{@链接java.net.URL}前提是它优先。
     * 它通常用于根据实例的运行状况做出有根据的决策—例如，它可以用于确定是继续部署到整个服务器场还是停止部署而不会造成进一步的损害。完整的{@链接java.net.URL}应遵循http://${尤里卡主机名}：7001/其中${尤里卡主机名}在运行时被替换。
     * </p>
     *
     * @return absolute health check page URL of this instance.
     */
    String getSecureHealthCheckUrl();

    /**
  
    实例的网络地址应该完全用{@linkdatacenterinfo}表示。例如，对于AWS中的实例，这将包括publicHostname、publicIp、privateHostname和privateIp（如果可用）。{@link com.netflix.appinfo.InstanceInfo}将进一步表示一个“默认地址”，这是一个可以由注册实例配置以公布其默认地址的字段。可用于解析该默认配置的地址列表的字段。确切的字段值将取决于相应的实现DataCenterInfo类型的实现细节。
     * @return an ordered list of fields that should be used to preferentially
     *         resolve this instance's default address, empty String[] for default.
     */
    String[] getDefaultAddressResolutionOrder();

    /**
     * 获取用于查找属性的命名空间。
     * @return the namespace used to find properties.
     */
    String getNamespace();

ServiceRegistry

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*

使用服务注册表注册和注销实例的合约。


*/
/**
	 *登记注册。注册通常包含有关实例的信息，例如其主机名和端口。
	 * @param registration registration meta data
	 */
	void register(R registration);

	/**
	 * 注销注册。
	 * @param registration registration meta data
	 */
	void deregister(R registration);

	/**
	 * 关闭ServiceRegistry。这是一种生命周期方法。
	 */
	void close();

	/**
	 * 设置注册的状态。状态值由各个实现确定。
	 * @param registration The registration to update.
	 * @param status The status to set.
	 * @see org.springframework.cloud.client.serviceregistry.endpoint.ServiceRegistryEndpoint
	 */
	void setStatus(R registration, String status);

	/**
	 * 获取特定注册的状态。
	 * @param registration The registration to query.
	 * @param <T> The type of the status.
	 * @return The status of the registration.
	 * @see org.springframework.cloud.client.serviceregistry.endpoint.ServiceRegistryEndpoint
	 */
	<T> T getStatus(R registration);

子类实现只有EurekaServiceRegistry

registration

1
2

{@linkserviceregistry}使用的标记接口。

ServiceInstance

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


/*
表示发现系统中服务的实例。

*/
/**
	 * @返回注册的唯一实例ID.
	 */
	default String getInstanceId() {
		return null;
	}

	/**
	 * @返回已注册的服务ID。
	 */
	String getServiceId();

	/**
	 * @返回已注册服务实例的主机名。
	 */
	String getHost();

	/**
	 * @返回已注册服务实例的端口。
	 */
	int getPort();

	/**
	 * @返回注册服务实例的端口是否使用HTTPS。
	 */
	boolean isSecure();

	/**
	 * @返回服务URI地址。
	 */
	URI getUri();

	/**
	 * @返回与实例关联的元数据/服务值。
	 */
	Map<String, String> getMetadata();

	/**
	 * @返回服务实例的方案。
	 */
	default String getScheme() {
		return null;
	}

AzToRegionMapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/*
一个接口，包含将可用区映射到区域映射的约定。一个实现总是事先知道将从映射器查询哪个区域到区域的映射，这将有助于提前缓存这些信息。



*/
/**
     * 返回传递的可用性区域的区域。
     * @param availabilityZone Availability zone for which the region is to be retrieved.
     *
     * @return The region for the passed zone.
     */
    String getRegionForAvailabilityZone(String availabilityZone);

    /**
     * 更新此映射器知道的区域。
     * @param regionsToFetch Regions to fetch. This should be the super set of all regions that this mapper should know.
     */
    void setRegionsToFetch(String[] regionsToFetch);

    /**
     * 如果映射依赖于外部源，则更新映射。
     */
    void refreshMapping();

Timer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
com.netflix.servo.monitor
    
   是一个秒表
/**
 * Monitor type for tracking how much time something is taking.用于跟踪某事物所用时间的监视器类型。
 */
public interface Timer extends NumericMonitor<Long> {

  /**
   * Returns a stopwatch that has been started and will automatically record its result to this timer when stopped.返回已启动的秒表，停止时将自动将其结果记录到此计时器。
   */
  Stopwatch start();

  /**
   * 这个计时器报告的时间单位。
   */
  TimeUnit getTimeUnit();

  /**
   * 为此计时器记录一个新值。
   *
   * @deprecated Use record(duration, timeUnit). By always providing a timeUnit to record()
   * you can have a base time unit of seconds, but
   * use recordings with timeunit of milliseconds for example.
   */
  @Deprecated
  void record(long duration);

  /**
   * 记录使用给定时间单位收集的新值。
   */
  void record(long duration, TimeUnit timeUnit);
}

PeerEurekaNodes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
一个用于管理所有PeerEurekaNode的生命周期的工具类
    protected final PeerAwareInstanceRegistry registry;
    protected final EurekaServerConfig serverConfig;
    protected final EurekaClientConfig clientConfig;
    protected final ServerCodecs serverCodecs;
    private final ApplicationInfoManager applicationInfoManager;

    private volatile List<PeerEurekaNode> peerEurekaNodes = Collections.emptyList();
    private volatile Set<String> peerEurekaNodeUrls = Collections.emptySet();

    private ScheduledExecutorService taskExecutor;



 public void start() {
        taskExecutor = Executors.newSingleThreadScheduledExecutor(
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r, "Eureka-PeerNodesUpdater");
                        thread.setDaemon(true);
                        return thread;
                    }
                }
        );
        try {
            updatePeerEurekaNodes(resolvePeerUrls());
            Runnable peersUpdateTask = new Runnable() {
                @Override
                public void run() {
                    try {
                        updatePeerEurekaNodes(resolvePeerUrls());
                    } catch (Throwable e) {
                        logger.error("Cannot update the replica Nodes", e);
                    }

                }
            };
            taskExecutor.scheduleWithFixedDelay(
                    peersUpdateTask,
                    serverConfig.getPeerEurekaNodesUpdateIntervalMs(),
                    serverConfig.getPeerEurekaNodesUpdateIntervalMs(),
                    TimeUnit.MILLISECONDS
            );
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
        for (PeerEurekaNode node : peerEurekaNodes) {
            logger.info("Replica node URL:  {}", node.getServiceUrl());
        }
    }

    public void shutdown() {
        taskExecutor.shutdown();
        List<PeerEurekaNode> toRemove = this.peerEurekaNodes;

        this.peerEurekaNodes = Collections.emptyList();
        this.peerEurekaNodeUrls = Collections.emptySet();

        for (PeerEurekaNode node : toRemove) {
            node.shutDown();
        }
    }

PeerEurekaNode

eureka服务器的节点也是分布式的，这个类就代表 eureka服务器集群的某一台

1
2
3
4
5
6
7

/*
PeerEurekaNode</code>表示一个对等节点，该节点应该向其共享信息。

此类处理将所有更新操作（如<em>注册、续订、取消、过期和状态更改等）复制到它表示的eureka节点。

*/

TaskDispatcher

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/*
一个任务分发器

TaskDispatcher从客户端接收任务，并将它们的执行委托给可配置数量的worker（线程）。

任务可以一次处理一个，也可以成批处理。只执行未过期的任务，如果计划执行具有相同id的新任务，则会删除旧任务。延迟地向work分派工作（仅按需），确保数据始终是最新的，并且不会发生过时的任务处理。


--任务处理---

此组件的客户端必须提供{@link TaskProcessor}接口的实现，该接口将执行任务处理的实际工作。此实现必须是线程安全的，因为它由多个线程并发调用。


----执行模式---
批处理，和 非批处理
通过TaskDispatchers工具类来创建


*/

    void process(ID id, T task, long expiryTime);

    void shutdown();

ReplicationTask

1
2
3
4
5
6
7
8
/*
所有复制任务的基类。


*/
所以一个集群的复制任务 一定需要 对等节点名，和任务动作类型
    protected final String peerNodeName;
    protected final Action action;

EurekaServerContext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
eureka服务端的上下文
public interface EurekaServerContext {

    void initialize() throws Exception;

    void shutdown() throws Exception;

    EurekaServerConfig getServerConfig();

    PeerEurekaNodes getPeerEurekaNodes();

    ServerCodecs getServerCodecs();

    PeerAwareInstanceRegistry getRegistry();

    ApplicationInfoManager getApplicationInfoManager();

}

UriRule

1
2
3
4
/*
可以接受URI路径的URI规则。

*/

RequestDispatcher

1
2
3
/*资源方法调度程序。*/

调度到资源类实例的resource方法。

注解

@Produces

1
2
3
4
5
6
7
8
9
10
11
/*
定义资源类或MessageBodyWriter的方法可以生成的媒体类型。如果未指定，则容器将假定可以生成任何类型。方法级注释覆盖类级注释。容器负责确保调用的方法能够生成HTTP请求中请求的一种媒体类型。如果没有可用的此类方法，则容器必须使用RFC 2616指定的HTTP“406不可接受”进行响应。

不需要使用单值<code>Produces</code>的方法来设置它生成的表示形式的媒体类型：发送响应时，容器将使用<code>Produces</code>的值。

*/

/**
媒体类型列表。每个条目可以指定一种类型，也可以由逗号分隔的类型列表组成。例如：{“图像/jpeg，图像/gif”，“图像/png”}。使用逗号分隔形式可以定义用于多个目标的通用字符串常量。
     */
    String[] value() default "*/*";

@Path

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

/*
标识资源类或类方法将为请求提供服务的URI路径。

路径是相对的。对于带注释的类，基本URI是应用程序路径，请参阅应用程序路径。对于带注释的方法，基本URI是包含类的有效URI。为了绝对针对基本URI的路径，路径中的前导'/'被忽略，基本URI被视为以'/'结尾。例如。：

* <pre>@Path("widgets")
 *public class WidgetsResource {
 *  @GET
 *  String getList() {...}
 * 
 *  @GET 
 *  @Path("{id}")
 *  String getWidget(@PathParam("id") String id)     {...}
 *}</pre>
 * <p>In the above, if the application path is
 * <code>catalogue</code> and the application is deployed at <code>http://example.com/</code>, then <code>GET</code> requests for
 * <code>http://example.com/catalogue/widgets</code> will be handled by the
 * <code>getList</code> method while requests for
 * <code>http://example.com/catalogue/widgets/<i>nnn</i></code> (where 
 * <code><i>nnn</i></code> is some value) will be handled by the
 * <code>getWidget</code> method. The same would apply if the value of either
 * <code>&#64;Path</code> annotation started with '/'.


类和方法也可以用{@link Consumes}和{@link Produces}注释，以过滤他们将收到的请求。


*/

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Path {
    
    /**
     * Defines a URI template for the resource class or method, must not 
     * include matrix parameters.
     * 
     * <p>Embedded template parameters are allowed and are of the form:</p>
     * 
     * <pre> param = "{" *WSP name *WSP [ ":" *WSP regex *WSP ] "}"
     * name = (ALPHA / DIGIT / "_")*(ALPHA / DIGIT / "." / "_" / "-" ) ; \w[\w\.-]*
     * regex = *( nonbrace / "{" *nonbrace "}" ) ; where nonbrace is any char other than "{" and "}"</pre>
     * 
     * <p>See {@link <a href="http://tools.ietf.org/html/rfc5234">RFC 5234</a>} 
     * for a description of the syntax used above and the expansions of 
     * {@code WSP}, {@code ALPHA} and {@code DIGIT}. In the above {@code name}
     * is the template parameter name and the optional {@code regex} specifies 
     * the contents of the capturing group for the parameter. If {@code regex}
     * is not supplied then a default value of {@code [^/]+} which terminates at
     * a path segment boundary, is used. Matching of request URIs to URI 
     * templates is performed against encoded path values and implementations
     * will not escape literal characters in regex automatically, therefore any
     * literals in {@code regex} should be escaped by the author according to
     * the rules of
     * {@link <a href="http://tools.ietf.org/html/rfc3986#section-3.3">RFC 3986 section 3.3</a>}.
     * Caution is recommended in the use of {@code regex}, incorrect use can
     * lead to a template parameter matching unexpected URI paths. See 
     * {@link <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Pattern.html">Pattern</a>}
     * for further information on the syntax of regular expressions.
     * Values of template parameters may be extracted using {@link PathParam}.
     *
     * <p>The literal part of the supplied value (those characters
     * that are not part of a template parameter) is automatically percent 
     * encoded to conform to the {@code path} production of 
     * {@link <a href="http://tools.ietf.org/html/rfc3986#section-3.3">RFC 3986 section 3.3</a>}.
     * Note that percent encoded values are allowed in the literal part of the
     * value, an implementation will recognize such values and will not double
     * encode the '%' character.</p>
     */
    String value();
}
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发
开源爱好者、Linux

联系QQ:2960571342

很惭愧

只做了一点微小的工作
谢谢大家