启动Eureka客户端主要做了两件事:
- 在应用主类中配置了@EnableDiscoveryClient注解。
- 在 application.properties 中用 eureka .client.serviceUrl.defaultZone参数指定了服务注册中心的位置。
@EnableDiscoveryClient注解
@EnableDiscoveryClient注解如下:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface EnableEurekaClient {
}
该注解用于开启DiscoveryClient实例,依赖关系图如下:

EurekaClient的核心接口如下:
@ImplementedBy(DiscoveryClient.class)
public interface EurekaClient extends LookupService {
Applications getApplicationsForARegion(@Nullable String var1);
Applications getApplications(String var1);
List<InstanceInfo> getInstancesByVipAddress(String var1, boolean var2);
List<InstanceInfo> getInstancesByVipAddress(String var1, boolean var2, @Nullable String var3);
List<InstanceInfo> getInstancesByVipAddressAndAppName(String var1, String var2, boolean var3);
Set<String> getAllKnownRegions();
InstanceStatus getInstanceRemoteStatus();
void registerHealthCheck(HealthCheckHandler var1);
void registerEventListener(EurekaEventListener var1);
boolean unregisterEventListener(EurekaEventListener var1);
HealthCheckHandler getHealthCheckHandler();
void shutdown();
EurekaClientConfig getEurekaClientConfig();
ApplicationInfoManager getApplicationInfoManager();
}
从接口定义我们看到Eureka Client的核心功能如下:
- 向Eureka Server注册服务实例
- 向Eureka Server服务续约
- 当服务关闭时取消租约
- 查询Eureka Server中服务实例列表
DiscoveryClient(位于 com.netflix.discovery 包中),该类包含了服务提供者和服务消费者的核心处理逻辑,同时提供了我们在介绍 Eureka 服务器端基本原理时所介绍的 register、renew 等方法。
服务注册源码分析
boolean register() throws Throwable {
logger.info(PREFIX + "{}: registering service...", appPathIdentifier);
EurekaHttpResponse<Void> httpResponse;
try {
httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
} catch (Exception e) {
logger.warn(PREFIX + "{} - registration failed {}", appPathIdentifier, e.getMessage(), e);
throw e;
}
if (logger.isInfoEnabled()) {
logger.info(PREFIX + "{} - registration status: {}", appPathIdentifier, httpResponse.getStatusCode());
}
return httpResponse.getStatusCode() == Status.NO_CONTENT.getStatusCode();
}
上述register方法会在InstanceInfoReplicator 类的run方法中进行执行,run方法如下:
public void run() {
try {
discoveryClient.refreshInstanceInfo();
Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
if (dirtyTimestamp != null) {
discoveryClient.register();
instanceInfo.unsetIsDirty(dirtyTimestamp);
}
} catch (Throwable t) {
logger.warn("There was a problem with the instance info replicator", t);
} finally {
Future next = scheduler.schedule(this, replicationIntervalSeconds, TimeUnit.SECONDS);
scheduledPeriodicRef.set(next);
}
}
从操作流程上讲,上述代码的逻辑非常简单,即服务提供者先将自己注册到 Eureka 服务器中,然后根据返回的结果确定操作是否成功。
而register方法的核心是
httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
DiscoveryClient 通过这行代码发起了远程请求。registrationClient 的类型是 EurekaHttpClient 接口,该接口的定义如下:
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();
}
可以看到这个 EurekaHttpClient 接口定义了 Eureka 服务器的一些底层 REST API,包括register、cancel、sendHeartBeat、statusUpdate、getApplications 等。在Eureka中,Eureka客户端通过该RESTful风格的HTTP接口与Eureka服务端进行通讯。
EurekaHttpClient的构建使用工厂模式,通过 EurekaHttpClientFactory 接口的实现类来构建具体的 EurekaHttpClient
ublic interface EurekaHttpClientFactory {
EurekaHttpClient newClient();
void shutdown();
}
服务获取与服务续约
服务消费者将获取到的服务列表进行缓存并通过定时任务完成缓存刷新操作,DiscoveryClient中的initScheduledTasks函数中有两个定时任务分别用于服务获取和服务租约
- 服务获取
initScheduledTasks函数中的服务获取功能
//是否从eureka 服务端获取注册的服务列表
if (clientConfig.shouldFetchRegistry()) {
// registry cache refresh timer
//获取定时拉取更新的间隔
int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
//缓存刷新重试 延迟时间的最大乘数值
int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
//创建定时任务
cacheRefreshTask = new TimedSupervisorTask(
"cacheRefresh",
scheduler,
cacheRefreshExecutor,
registryFetchIntervalSeconds,
TimeUnit.SECONDS,
expBackOffBound,
new CacheRefreshThread()
);
scheduler.schedule(
cacheRefreshTask,
registryFetchIntervalSeconds, TimeUnit.SECONDS);
}
clientConfig.shouldFetchRegistry()通过获取配置项eureka.client.fetch-registry
registryFetchIntervalSeconds通过获取配置项eureka.client.registry-fetch-interval-seconds,默认30s
eureka相关配置项详细说明可参考:Eureka常用配置项说明_skh2015java的博客-优快云博客
通过ScheduleExecutorService 定时调度new CacheRefreshThread()任务。
CacheRefreshThread是线程执行的任务
class CacheRefreshThread implements Runnable {
public void run() {
refreshRegistry();
}
}
refreshRegistry函数用于从eureka服务端获取注册的服务列表并更新本地服务列表的缓存,refreshRegistry函数最终调用 fetchRegistry函数获取服务列表
2. 服务租约
initScheduledTasks函数中的服务租约功能
if (clientConfig.shouldRegisterWithEureka()) {
int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
logger.info("Starting heartbeat executor: " + "renew interval is: {}", renewalIntervalInSecs);
// Heartbeat timer
heartbeatTask = new TimedSupervisorTask(
"heartbeat",
scheduler,
heartbeatExecutor,
renewalIntervalInSecs,
TimeUnit.SECONDS,
expBackOffBound,
new HeartbeatThread()
);
scheduler.schedule(
heartbeatTask,
renewalIntervalInSecs, TimeUnit.SECONDS);
// InstanceInfo replicator
instanceInfoReplicator = new InstanceInfoReplicator(
this,
instanceInfo,
clientConfig.getInstanceInfoReplicationIntervalSeconds(),
2); // burstSize
statusChangeListener = new ApplicationInfoManager.StatusChangeListener() {
@Override
public String getId() {
return "statusChangeListener";
}
@Override
public void notify(StatusChangeEvent statusChangeEvent) {
logger.info("Saw local status change event {}", statusChangeEvent);
instanceInfoReplicator.onDemandUpdate();
}
};
if (clientConfig.shouldOnDemandUpdateStatusChange()) {
applicationInfoManager.registerStatusChangeListener(statusChangeListener);
}
instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
} else {
logger.info("Not registering with Eureka server per configuration");
}
clientConfig.shouldRegisterWithEureka()通过配置项eureka.client.register-with-eureka是否注册服务到eureka服务端
renewalIntervalInSecs通过配置项eureka.instance.lease-renewal-interval-in-seconds定时向eureka 服务端发送心跳
定时发送心跳任务
private class HeartbeatThread implements Runnable {
public void run() {
if (renew()) {
lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
}
}
}
通过renew函数中的sendHeartBeat向eureka 服务端发送心跳,并返回是否发送成功。
boolean renew() {
EurekaHttpResponse<InstanceInfo> httpResponse;
try {
httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);
logger.debug(PREFIX + "{} - Heartbeat status: {}", appPathIdentifier, httpResponse.getStatusCode());
if (httpResponse.getStatusCode() == Status.NOT_FOUND.getStatusCode()) {
REREGISTER_COUNTER.increment();
logger.info(PREFIX + "{} - Re-registering apps/{}", appPathIdentifier, instanceInfo.getAppName());
long timestamp = instanceInfo.setIsDirtyWithTime();
boolean success = register();
if (success) {
instanceInfo.unsetIsDirty(timestamp);
}
return success;
}
return httpResponse.getStatusCode() == Status.OK.getStatusCode();
} catch (Throwable e) {
logger.error(PREFIX + "{} - was unable to send heartbeat!", appPathIdentifier, e);
return false;
}
}
3878



被折叠的 条评论
为什么被折叠?



