DiscoverClient
com.netflix.discovery.DiscoveryClient ,使用的@Inject //google guice 注入遵循 JSR-330規范
@Inject
DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
Provider<BackupRegistry> backupRegistryProvider) {
// 省略N多代碼
// 初始化定時器信息
initScheduledTasks();
}
private void initScheduledTasks() {
// 省略N多代碼。。。
if (clientConfig.shouldRegisterWithEureka()) {
int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
logger.info("Starting heartbeat executor: " + "renew interval is: " + renewalIntervalInSecs);
// 在這里，初始化一個定時器任務
scheduler.schedule(
new TimedSupervisorTask(
"heartbeat",
scheduler,
heartbeatExecutor,
renewalIntervalInSecs,
TimeUnit.SECONDS,
expBackOffBound,
new HeartbeatThread()
),
renewalIntervalInSecs, TimeUnit.SECONDS);
// 省略N多代碼。。。
} else {
logger.info("Not registering with Eureka server per configuration");
}
}
由上可以看出，在DiscoverClient這個類初始化的時候，會初始化定期任務，每30秒執行一次，用來發送心跳
HeartbeatThread
這個是用來續約的線程，主要看其run方法，
private class HeartbeatThread implements Runnable {
public void run() {
if (renew()) {
// 更新最后一次心跳的時間
lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
}
}
}
// 續約的主方法
boolean renew() {
EurekaHttpResponse<InstanceInfo> httpResponse;
try {
httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);
logger.debug("{} - Heartbeat status: {}", PREFIX + appPathIdentifier, httpResponse.getStatusCode());
if (httpResponse.getStatusCode() == 404) {
REREGISTER_COUNTER.increment();
logger.info("{} - Re-registering apps/{}", PREFIX + appPathIdentifier, instanceInfo.getAppName());
return register();
}
return httpResponse.getStatusCode() == 200;
} catch (Throwable e) {
logger.error("{} - was unable to send heartbeat!", PREFIX + appPathIdentifier, e);
return false;
}
}
上面的代碼很簡單，主要就是啟動一個線程，然后線程執行renew()方法， 最終發送心跳給Eureka-Server
接口地址： apps/ + appName + /' + id ，
如果接口返回值為404，就是說不存在，從來沒有注冊過，那么重新走注冊流程
lastDirtyTimestamp
即該instance在client端最后被修改的時間戳
Eureka-Server接收心跳
InstanceResource
@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);
// 續約
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 = null;
// 比較lastDirtyTimestamp
if (lastDirtyTimestamp != null && serverConfig.shouldSyncWhenTimestampDiffers()) {
// 比較lastDirtyTimestamp的大小，這個還是比較重要的
response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
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) {
// 獲取本機的instance實例信息
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};
// lastDirtyTimestamp>本地的時間，則認為當前實例是無效的，返回404錯誤，客戶端重新發起注冊
if (lastDirtyTimestamp > appInfo.getLastDirtyTimestamp()) {
logger.debug(
"Time to sync, since the last dirty timestamp differs -"
+ " ReplicationInstance id : {},Registry : {} Incoming: {} Replication: {}",
args);
return Response.status(Status.NOT_FOUND).build();
} else if (appInfo.getLastDirtyTimestamp() > lastDirtyTimestamp) {
// 如果是集群同步請求，本地的時間，大于客戶端傳過來的時間，則返回 “沖突” 這個狀態回去，以本地的時間大的為準
if (isReplication) {
logger.debug(
"Time to sync, since the last dirty timestamp differs -"
+ " ReplicationInstance id : {},Registry : {} Incoming: {} Replication: {}",
args);
return Response.status(Status.CONFLICT).entity(appInfo).build();
} else {
return Response.ok().build();
}
}
}
}
return Response.ok().build();
}
代碼說明：
1.lastDirtyTimestamp 是客戶端向服務端發請求的版本號 ， 一切請求都以版本號大的為準。， 如： 注冊
2.在調用續約的方法之后，Eureka Server 會對請求過來的lastDirtyTimestamp和本地的做對比， 如果
請求lastDirtyTimestamp>本地的時間，則認為當前實例是無效的，返回404錯誤，客戶端重新發起注冊。
3.如果是集群同步請求，本地的時間，大于其他Eureka Server傳過來的時間，則返回 “沖突” 這個狀態回去，
以本地的時間大的為準，注意是集群同步請求，如果是客戶端傳過的，是不會有這個規則的。
應用續約
//PeerAwareInstanceRegistryImpl.java
public boolean renew(final String appName, final String id, final boolean isReplication) {
// 執行續約操作
if (super.renew(appName, id, isReplication)) {
// 同步Eureka-Server集群
replicateToPeers(Action.Heartbeat, appName, id, null, null, isReplication);
return true;
}
return false;
}
//AbstractInstanceRegistry.java
public boolean renew(String appName, String id, boolean isReplication) {
// 增加續約次數到統計枚舉
RENEW.increment(isReplication);
// 從Eureka-Server端本地的CurrentHashMap中，通過appName獲取Lease信息
Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
Lease<InstanceInfo> leaseToRenew = null;
if (gMap != null) {
leaseToRenew = gMap.get(id);
}
// lease為空，lease在第一次注冊的時候會創建，為空，則表示從來沒有注冊過，租約不存在
if (leaseToRenew == null) {
RENEW_NOT_FOUND.increment(isReplication);
logger.warn("DS: Registry: lease doesn't exist, registering resource: {} - {}", appName, id);
return false;
} else {
// 獲取lease里面的instance信息
InstanceInfo instanceInfo = leaseToRenew.getHolder();
if (instanceInfo != null) {
// touchASGCache(instanceInfo.getASGName());
// 一系列狀態判斷，目前還不是很清楚，但是不影響主流程
InstanceStatus overriddenInstanceStatus = this.getOverriddenInstanceStatus(
instanceInfo, leaseToRenew, isReplication);
if (overriddenInstanceStatus == InstanceStatus.UNKNOWN) {
logger.info("Instance status UNKNOWN possibly due to deleted override for instance {}"
+ "; re-register required", instanceInfo.getId());
RENEW_NOT_FOUND.increment(isReplication);
return false;
}
if (!instanceInfo.getStatus().equals(overriddenInstanceStatus)) {
Object[] args = {
instanceInfo.getStatus().name(),
instanceInfo.getOverriddenStatus().name(),
instanceInfo.getId()
};
logger.info(
"The instance status {} is different from overridden instance status {} for instance {}. "
+ "Hence setting the status to overridden status", args);
instanceInfo.setStatus(overriddenInstanceStatus);
}
}
// 設置每分鐘的續約次數
renewsLastMin.increment();
// 續約
leaseToRenew.renew();
return true;
}
}
從上面可以看到整個續約過程，主要就是從本地的CurrentHashMap中獲取租約信息， 獲取到了之后，設置每分鐘的續約次數以及續約時間。
renewsLastMin.increment()， 這個里面。主要是更新一個currentBucket的變量，類型為AtomicLong ， 同時有個定時器一分鐘去更新一次。一分鐘之后，這個值會重新設置為0 。
leaseToRenew.renew() , 更新lastUpdateTimestamp, duration默認為90秒
//Lease.java
public void renew() {
lastUpdateTimestamp = System.currentTimeMillis() + duration;
}
總結：
在一下三種情況，續約是返回404 ， 需要客戶端重新發起注冊的。
1.當客戶端的lastDirtyTimestamp> 大于服務端的instance的lastDirtyTimestamp時候，會認為服務端
的信息是無效的，因此無法續約，需要重新發起注冊請求。
2.服務端的注冊信息不存在
3.服務端的instance的status = UNKONW， 為什么會出現UNKONW這個狀態呢，因為在deleteStatusOverride
的時候存在傳入UNKONW的可能性。
