EurekaClient源码分析

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量251 收藏
点赞数 1
分类专栏： SpringCloud java 文章标签： java SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38121659/article/details/107145660
版权

EurekaClient 源码分析

eureka 源码地址: https://github.com/Netflix/eureka
eureka 项目整合地址: https://github.com/TongBlackLittle/springCloud
以下内容 参照 SpringCloud 微服务实战,进行学习记录的,我在这里根据个人理解进行了记录,欢迎大家一起交流

EurekaClient 的实现关系

  1. 通过注解 @EnableDiscoveryClient 进入到类内部

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({EnableDiscoveryClientImportSelector.class})
public @interface EnableDiscoveryClient {
    boolean autoRegister() default true;
}



// 同级目录可以看到 discoveryClient

package org.springframework.cloud.client.discovery;

import java.util.List;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.core.Ordered;

public interface DiscoveryClient extends Ordered {
    int DEFAULT_ORDER = 0;

    String description();

    List<ServiceInstance> getInstances(String serviceId);

    List<String> getServices();

    default int getOrder() {
        return 0;
    }
}

discoverClient 该接口为 springCloud 提供的接口 定义发现服务的抽象方法.通过搜索可以发现,EurekaDiscouveryClient 是对该接口的实现

import com.netflix.discovery.EurekaClient;

public class EurekaDiscoveryClient implements DiscoveryClient {
    public static final String DESCRIPTION = "Spring Cloud Eureka Discovery Client";
    private final EurekaClient eurekaClient;
    private final EurekaClientConfig clientConfig;

}

实现类依赖了 netflix.discovery.EurekaClient 而 EurekaClient 继承了 LookupService 类,而真正的实现类是 erureka 包下的 DiscveryClient

EurekaClient 负责的任务

  • 向 Eureka Server 注册服务示例
  • 向 Eureka Servier 服务租约
  • 当服务关闭期间, 向Eureka Server 取消租约
  • 查询Eureka Server 中的服务示例列表

Eureka Client 还需要配置一个Eureka Server 的 URL 列表

EurekaClient 配置的服务列表如何配置的

  • 配置的名称 : eureka.client.serviceUrl.defaultZone

通过 serviceUrl 我们可以在 EurekaDiiscoveryClient 中发现 getServiceUrlsFromConfig 方法 但是 该方法是被 @Deprecated 声明的 说明该方法已经被弃用了(如果对源码好奇,可以在 github 上边下载 eureka 的源码进行查看了解具体细节)
看源码 发现 该方法被连接 @link 到 EndpointUriles ,所以我们到 EndpointUrils中去查看

 public static List<String> getServiceUrlsFromConfig(EurekaClientConfig clientConfig, String instanceZone, boolean preferSameZone) {
        List<String> orderedUrls = new ArrayList<String>();
        String region = getRegion(clientConfig);
        String[] availZones = clientConfig.getAvailabilityZones(clientConfig.getRegion());
        if (availZones == null || availZones.length == 0) {
            availZones = new String[1];
            availZones[0] = DEFAULT_ZONE;
        }
        logger.debug("The availability zone for the given region {} are {}", region, availZones);
        int myZoneOffset = getZoneOffset(instanceZone, preferSameZone, availZones);

        List<String> serviceUrls = clientConfig.getEurekaServerServiceUrls(availZones[myZoneOffset]);
        if (serviceUrls != null) {
            orderedUrls.addAll(serviceUrls);
        }
        int currentOffset = myZoneOffset == (availZones.length - 1) ? 0 : (myZoneOffset + 1);
        while (currentOffset != myZoneOffset) {
            serviceUrls = clientConfig.getEurekaServerServiceUrls(availZones[currentOffset]);
            if (serviceUrls != null) {
                orderedUrls.addAll(serviceUrls);
            }
            if (currentOffset == (availZones.length - 1)) {
                currentOffset = 0;
            } else {
                currentOffset++;
            }
        }

        if (orderedUrls.size() < 1) {
            throw new IllegalArgumentException("DiscoveryClient: invalid serviceUrl specified!");
        }
        return orderedUrls;
    }


    public static String getRegion(EurekaClientConfig clientConfig) {
        String region = clientConfig.getRegion();
        if (region == null) {
            region = DEFAULT_REGION;
        }
        region = region.trim().toLowerCase();
        return region;
    }
	
	
	public String[] getAvailabilityZones(String region) {
        String value = (String)this.availabilityZones.get(region);
        if (value == null) {
            value = "defaultZone";
        }

        return value.split(",");
    }

可以看到 该方法一次加载了 getRegion() 和 getAvailabilityZones() 来获取配置,也就是 说明 一个微服务只对应了一个 Region 和 多个 Zones 他们之间是 一对多的关系 (这个配置是在区分物理机位置时来进行配置,当发生服务宕机时可以根据 region 来快速进行定位)
eurekaClient 默认加载 defaultZone 获取 AvaliableilityZones() 时 可以看到 他是 ‘,’ 进行区分的,defaultZone 可以加载多个
加载了 Region 和 Zone 之后 开始真正的加载 EurekaServer 的地址

int myZoneOffset = getZoneOffset(instanceZone, preferSameZone, availZones);

List<String> serviceUrls = clientConfig.getEurekaServerServiceUrls(availZones[myZoneOffset]);
if (serviceUrls != null) {
	orderedUrls.addAll(serviceUrls);
}

通过上边的 getEurekaServerServiceUrls () 可以看一下具体的实现

public List<String> getEurekaServerServiceUrls(String myZone) {
        String serviceUrls = (String)this.serviceUrl.get(myZone);
        if (serviceUrls == null || serviceUrls.isEmpty()) {
            serviceUrls = (String)this.serviceUrl.get("defaultZone");
        }

        if (!StringUtils.isEmpty(serviceUrls)) {
            String[] serviceUrlsSplit = StringUtils.commaDelimitedListToStringArray(serviceUrls);
            List<String> eurekaServiceUrls = new ArrayList(serviceUrlsSplit.length);
            String[] var5 = serviceUrlsSplit;
            int var6 = serviceUrlsSplit.length;

            for(int var7 = 0; var7 < var6; ++var7) {
                String eurekaServiceUrl = var5[var7];
                if (!this.endsWithSlash(eurekaServiceUrl)) {
                    eurekaServiceUrl = eurekaServiceUrl + "/";
                }

                eurekaServiceUrls.add(eurekaServiceUrl.trim());
            }

            return eurekaServiceUrls;
        } else {
            return new ArrayList();
        }
    }

通过 Ribbon 来获取服务调用时 先访问 一个 Zone 中的服务端实例, 当这个实例为 null 时 在去访问其他的Zone 中的实例 Eureka 在进行高可用时 进行的多节点配置,就是这个时候用的

服务注册

  1. 通过 DiscoverClient 的构造方法 可以找到该方法 initScheduledTasks();
private void initScheduledTasks() {
        int renewalIntervalInSecs;
        int expBackOffBound;
        if (this.clientConfig.shouldFetchRegistry()) {
            renewalIntervalInSecs = this.clientConfig.getRegistryFetchIntervalSeconds();
            expBackOffBound = this.clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
            this.cacheRefreshTask = new TimedSupervisorTask("cacheRefresh", this.scheduler, this.cacheRefreshExecutor, renewalIntervalInSecs, TimeUnit.SECONDS, expBackOffBound, new DiscoveryClient.CacheRefreshThread());
            this.scheduler.schedule(this.cacheRefreshTask, (long)renewalIntervalInSecs, TimeUnit.SECONDS);
        }

        if (this.clientConfig.shouldRegisterWithEureka()) {
            renewalIntervalInSecs = this.instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
            expBackOffBound = this.clientConfig.getHeartbeatExecutorExponentialBackOffBound();
            logger.info("Starting heartbeat executor: renew interval is: {}", renewalIntervalInSecs);
            this.heartbeatTask = new TimedSupervisorTask("heartbeat", this.scheduler, this.heartbeatExecutor, renewalIntervalInSecs, TimeUnit.SECONDS, expBackOffBound, new DiscoveryClient.HeartbeatThread());
            this.scheduler.schedule(this.heartbeatTask, (long)renewalIntervalInSecs, TimeUnit.SECONDS);
            this.instanceInfoReplicator = new InstanceInfoReplicator(this, this.instanceInfo, this.clientConfig.getInstanceInfoReplicationIntervalSeconds(), 2);
            this.statusChangeListener = new StatusChangeListener() {
                public String getId() {
                    return "statusChangeListener";
                }

                public void notify(StatusChangeEvent statusChangeEvent) {
                    if (InstanceStatus.DOWN != statusChangeEvent.getStatus() && InstanceStatus.DOWN != statusChangeEvent.getPreviousStatus()) {
                        DiscoveryClient.logger.info("Saw local status change event {}", statusChangeEvent);
                    } else {
                        DiscoveryClient.logger.warn("Saw local status change event {}", statusChangeEvent);
                    }

                    DiscoveryClient.this.instanceInfoReplicator.onDemandUpdate();
                }
            };
            if (this.clientConfig.shouldOnDemandUpdateStatusChange()) {
                this.applicationInfoManager.registerStatusChangeListener(this.statusChangeListener);
            }

            this.instanceInfoReplicator.start(this.clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
        } else {
            logger.info("Not registering with Eureka server per configuration");
        }

    }

该方法中提供了 服务注册 服务续约 服务获取 的具体内容
this.heartbeatTask = new TimedSupervisorTask(“heartbeat”, this.scheduler, this.heartbeatExecutor, renewalIntervalInSecs, TimeUnit.SECONDS, expBackOffBound, new DiscoveryClient.HeartbeatThread());
this.instanceInfoReplicator = new InstanceInfoReplicator(this, this.instanceInfo, this.clientConfig.getInstanceInfoReplicationIntervalSeconds(), 2);

heartbeatTask 开启了心跳进行服务续约 instanceInfoReplicator 进行服务注册

new InstanceInfoReplicator() 方法我们可以看到 该类实现了 Runable 接口 通过该类启动了一个定时任务,在 该 run 方法中 .register() 方法来真正的执行服务注册的

public void run() {
        boolean var6 = false;

        ScheduledFuture next;
        label53: {
            try {
                var6 = true;
                this.discoveryClient.refreshInstanceInfo();
                Long dirtyTimestamp = this.instanceInfo.isDirtyWithTime();
                if (dirtyTimestamp != null) {
                    this.discoveryClient.register();
                    this.instanceInfo.unsetIsDirty(dirtyTimestamp);
                    var6 = false;
                } else {
                    var6 = false;
                }
                break label53;
            } catch (Throwable var7) {
                logger.warn("There was a problem with the instance info replicator", var7);
                var6 = false;
            } finally {
                if (var6) {
                    ScheduledFuture next = this.scheduler.schedule(this, (long)this.replicationIntervalSeconds, TimeUnit.SECONDS);
                    this.scheduledPeriodicRef.set(next);
                }
            }

            next = this.scheduler.schedule(this, (long)this.replicationIntervalSeconds, TimeUnit.SECONDS);
            this.scheduledPeriodicRef.set(next);
            return;
        }

        next = this.scheduler.schedule(this, (long)this.replicationIntervalSeconds, TimeUnit.SECONDS);
        this.scheduledPeriodicRef.set(next);
    }


boolean renew() {
        try {
            EurekaHttpResponse<InstanceInfo> httpResponse = this.eurekaTransport.registrationClient.sendHeartBeat(this.instanceInfo.getAppName(), this.instanceInfo.getId(), this.instanceInfo, (InstanceStatus)null);
            logger.debug("DiscoveryClient_{} - Heartbeat status: {}", this.appPathIdentifier, httpResponse.getStatusCode());
            if (httpResponse.getStatusCode() == Status.NOT_FOUND.getStatusCode()) {
                this.REREGISTER_COUNTER.increment();
                logger.info("DiscoveryClient_{} - Re-registering apps/{}", this.appPathIdentifier, this.instanceInfo.getAppName());
                long timestamp = this.instanceInfo.setIsDirtyWithTime();
                boolean success = this.register();
                if (success) {
                    this.instanceInfo.unsetIsDirty(timestamp);
                }

                return success;
            } else {
                return httpResponse.getStatusCode() == Status.OK.getStatusCode();
            }
        } catch (Throwable var5) {
            logger.error("DiscoveryClient_{} - was unable to send heartbeat!", this.appPathIdentifier, var5);
            return false;
        }
    }

boolean renew() {
        try {
            EurekaHttpResponse<InstanceInfo> httpResponse = this.eurekaTransport.registrationClient.sendHeartBeat(this.instanceInfo.getAppName(), this.instanceInfo.getId(), this.instanceInfo, (InstanceStatus)null);
            logger.debug("DiscoveryClient_{} - Heartbeat status: {}", this.appPathIdentifier, httpResponse.getStatusCode());
            if (httpResponse.getStatusCode() == Status.NOT_FOUND.getStatusCode()) {
                this.REREGISTER_COUNTER.increment();
                logger.info("DiscoveryClient_{} - Re-registering apps/{}", this.appPathIdentifier, this.instanceInfo.getAppName());
                long timestamp = this.instanceInfo.setIsDirtyWithTime();
                boolean success = this.register();
                if (success) {
                    this.instanceInfo.unsetIsDirty(timestamp);
                }

                return success;
            } else {
                return httpResponse.getStatusCode() == Status.OK.getStatusCode();
            }
        } catch (Throwable var5) {
            logger.error("DiscoveryClient_{} - was unable to send heartbeat!", this.appPathIdentifier, var5);
            return false;
        }
    }

进入到 register 方法中 我们可以看到 该方法 通过发送 http 请求来进行服务注册 其中 注册信息为 InstanceInfo (保存服务实例的相关信息)
同理 进入到 renew 方法中 this.instanceInfo.getAppName(), this.instanceInfo.getId(), this.instanceInfo, (InstanceStatus)null 将这些数据定时发送给 server 端进行 服务续约

服务获取

在上边的源码中 我们可以看到 this.cacheRefreshTask = new TimedSupervisorTask(“cacheRefresh”, this.scheduler, this.cacheRefreshExecutor, renewalIntervalInSecs, TimeUnit.SECONDS, expBackOffBound, new DiscoveryClient.CacheRefreshThread());

服务获取和服务续约 服务注册是分开放在不同的 if 判断中的 (可以理解 注册之后 需要对服务进行续约)

服务获取和服务续约查看逻辑类似,当时比较复杂

TO-DO
LittleBlackTong
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Eureka源码学习(一)——Eureka-Client
km56558的博客
07-15 414
关于Eureka的学习，先了解client，client会做些什么呢？通过源码简单的了解一下，client是如何向发起注册、续约、抓取注册列表刷新本地缓存、变动通知、下线这些操作的。 我们建个工程，maven导入spring-cloud-starter-netflix-eureka-client包2.2.3，找到其中spring.factories,EurekaClientAutoConfiguration自动配置类会生效,并且会注入一个EurekaClient @Bean(destroyMethod
Eureka Client源码分析
wolfcode_cn的博客
10-31 1273
作者：陈刚，叩丁狼高级讲师。本文为原创文章，转载请注明出处。     对于一个优秀的程序员而言，一个技术不仅要会用，还要知道他的实现原理和思想，即不仅要知其然还要知其所以然，这样我们写代码才会特别自信，出现bug才能很快定位到问题所在。接下来我们就来简单探讨一下SpringCloud的实现原理，即：源码分析 一.服务注册 服务注册与发现是SpringCloud最基础的部分，我们就从这部分开始...
Eureka-Client（Golang实现）
weixin_30412167的博客
04-10 472
Eureka-Client Golang实现eureka-client 原理 根据Java版本的源码，可以看出client主要是通过REST请求来与server进行通信。 Java版本的核心实现：com.netflix.discovery.DiscoveryClient。 其中主要逻辑如下： client启动时注册信息到server 定时心跳、刷新服务列表，主要是两个线程池：heartbea...
SpringCloud Eureka Client 源码解析
码上代码的博客
12-21 2684
Eureka Client 源码解析 读取应用自身配置信息 服务发现客户端 拉取注册表信息 服务注册 初始化定时任务 服务下线 看本篇之前请先看 五分钟学会 Spring Cloud Eureka：服务注册与发现（小白必看，一看就会教程） Eureka Client 为了简化开发人员的开发工作，将很多与Eureka Server 交互的工作隐藏起来，自主完成 为了跟踪Eureka 的运行机制，读者可以通过打开Spring Boot 的Debug 模式来查看更多的输出日志， 如下所示： loggi
Eureka Client 源码解析
寒山道杳
11-16 1033
一、Client 端基本信息 在老版本的 Spring Cloud 的使用中，当构建客户端的时候，会在启动类上标注 @EnableDiscoveryClient 注解，但是在新版本的时候，便不需再标注了，这是因为 Spring Boot 中的自动配置机制不同的原因，这里暂不做论述。那客户端是如何做自动装配的呢？Spring Boot 自身的注解 @SpringBootApplication 本身就是一个组合注解，其中之一的 @EnableAutoConfiguration。 注：本系列文章 spri
下载eureka执行 从 github 获取 Eureka 源码 报错 缺少依赖
weixin_42210195的博客
10-15 424
解决：git的版本太低 更新git版本 Git版本1.7.11.3或更高版本
Eureka源码解析
qq_43623447的博客
07-06 212
文章目录 本篇文章以源码的角度来深入理解Eureka. Eureka的一些概念 - Register：服务注册 当Eureka客户端向Eureka Server注册时，它提供自身的元数据，比如IP地址、端口，运行状况指示符URL，主页等。 Renew：服务续约 Eureka客户会每隔30秒发送一次心跳来续约。 通过续约来告知Eureka Server该Eureka客户仍然存在，没有出现问题。 正常情况下，如果Eureka Server在90秒没有收到Eureka客户的续约，它会将实例从其注册表中删除。
eureka实践源码.zip
04-29
此外，还会配置EurekaClient，使服务器自身也作为一个客户端注册到自己，形成自我保护机制。 接下来，producer-demo工程代表了服务提供者。服务提供者需要在启动时向Eureka服务器注册自身的信息，包括服务ID、服务...
Eureka核心源码分析，包含注册，剔除，服务发现，续约的分析
12-30
下面我们将深入分析 Eureka 的核心源码，探讨服务注册、剔除、服务发现和续约的实现原理。 ### 服务注册 服务注册是 Eureka 工作的起点。客户端（Eureka Client）在启动时，会向 Eureka Server 注册自身的信息。这...
SpringCloud+SpringBoot+Eureka源码
02-28
源码分析方面，Eureka Server主要由两个核心组件构成：`EurekaClient`和`EurekaServer`. `EurekaClient`是每个服务实例的客户端，负责服务注册和心跳维持；`EurekaServer`则负责存储和处理这些注册信息，提供服务...
spring cloud eureka 服务搭建
04-24
Eureka Client 的关键类有 `EurekaClient` 和 `DiscoveryClient`，它们实现了客户端与服务器的交互。 **工具使用** 在实际开发中，可以利用 Spring Boot Admin、Prometheus、Grafana 等工具监控 Eureka Server 的...
spring cloud eureka集群模拟源码实现
11-01
你可以在这个项目的基础上，按照上述步骤和源码分析，扩展到多节点的Eureka集群。 总的来说，构建Spring Cloud Eureka集群是一项关键任务，它涉及到服务注册、发现、健康检查和治理等多个方面。通过源码实现，不仅...
服务注册与发现框架discovery源码解析
azhuwc0914的博客
07-30 567
B站开源注册中心discovery源码解析
源码分析之Eureka客户端源码解析
evasnowind的专栏
09-22 303
文章目录说明预备知识一些注解的说明@ConfigurationProperties("eureka.instance")@ConditionalOnBean/@ConditionalOnClass@ImplementedBy@Singletoneureka架构eureka客户端源码eureka客户端工作流程DiscoverClientDiscoveryClient构造方法小结拉取注册表过程全量拉取 getAndStoreFullRegistry()增量拉取getAndUpdateDelta(applicat
Eureka服务注册源码分析
wh柒八九的博客
08-23 579
本文来说下Eureka服务注册源码 文章目录Eureka-Client注册服务啥时候会注册 Eureka-Client注册服务 啥时候会注册 在两种情况下客户端会主动向服务端发送自己的注册信息 当客户端的instance信息发生改变时，Eureka-Client和Server端信息不一致时 当客户端刚刚启动的时候。 ...
Eureka(四) Eureka 源码分析之EurekaClient源码分析
ForestCat的专栏
10-11 770
一.EurekaClient EurekaClient 为了简化开发人员的工作量，将很多与EurekaServer交互的工作隐藏起来，自主完成。具体完成的工作分为三个阶段， 应用启动阶段,执行阶段, 销毁阶段. 各阶段的工作如下: 应用启动阶段 读取与 Eureka Server交互的配置信息,封装成 EurekaClientConfig 读取自身服务实例配置信息,封装成EurekalnstanceConfig 从Eureka server拉取注册表信息并缓存到本地 服务注册 ...
Eureka详解系列(四)--Eureka Client部分的源码和配置
子月生的博客
02-06 301
<img src="https://images.cnblogs.com/cnblogs_com/ZhangZiSheng001/1920994/o_210122134252eureka-logo-2624.png" class="desc_img">按照原定的计划，我将分三个部分来分析 Eureka 的源码： 1. Eureka 的配置体系； 2. Eureka Client 的交互行为； 3. Eureka Server 的交互行为。 今天，我们来研究第二部分的源码。
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1120
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
eurekaclient.
05-16
Eureka Client 是 Netflix 开源的一个服务发现组件。它是基于 RESTful API 的，可以实现服务注册与发现的功能。在微服务架构中，服务的数量通常很多，每个服务都需要知道其他服务的地址。Eureka Client 可以自动地将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值