eureka源码系列 - 续租流程

最新推荐文章于 2020-12-22 06:49:20 发布
最新推荐文章于 2020-12-22 06:49:20 发布
阅读量282 收藏
点赞数
分类专栏： 学习 微服务 文章标签： java eureka 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/V_zxw/article/details/108104872
版权

eureka源码系列 - 续租流程

@Author：zxw
@email：502513206@qq.com
@Jishou University

1.前言

在eureka中有3个定时任务，分别为心跳检测heartbeatExecutor，注册表拉取cacheRefreshExecutor，实例信息更新instanceInfoReplicator。

2.拉取注册中心服务

起点是由CacheRefreshThread线程进行调用DiscoveryClient.refreshRegistry()该方法的主要作用就是在拉取注册表前后进行一些操作。

void refreshRegistry() {
        try {
            boolean isFetchingRemoteRegionRegistries = isFetchingRemoteRegionRegistries();

            boolean remoteRegionsModified = false;
            // 确保对远程区域进行动态更改以获取数据。
            String latestRemoteRegions = clientConfig.fetchRegistryForRemoteRegions();
            if (null != latestRemoteRegions) {
                String currentRemoteRegions = remoteRegionsToFetch.get();
                if (!latestRemoteRegions.equals(currentRemoteRegions)) {
                    // Both remoteRegionsToFetch and AzToRegionMapper.regionsToFetch need to be in sync
                    synchronized (instanceRegionChecker.getAzToRegionMapper()) {
                        if (remoteRegionsToFetch.compareAndSet(currentRemoteRegions, latestRemoteRegions)) {
                            String[] remoteRegions = latestRemoteRegions.split(",");
                            remoteRegionsRef.set(remoteRegions);
                            instanceRegionChecker.getAzToRegionMapper().setRegionsToFetch(remoteRegions);
                            remoteRegionsModified = true;
                        } else {
                            logger.info("Remote regions to fetch modified concurrently," +
                                    " ignoring change from {} to {}", currentRemoteRegions, latestRemoteRegions);
                        }
                    }
                } else {
                    // Just refresh mapping to reflect any DNS/Property change
                    instanceRegionChecker.getAzToRegionMapper().refreshMapping();
                }
            }
			// 拉取注册信息表
            boolean success = fetchRegistry(remoteRegionsModified);
            // 成功，更新当前时间
            if (success) {
                registrySize = localRegionApps.get().size();
                lastSuccessfulRegistryFetchTimestamp = System.currentTimeMillis();
            }

            if (logger.isDebugEnabled()) {
               // --- 记录log
            }
        } catch (Throwable e) {
            logger.error("Cannot fetch registry from server", e);
        }
    }

DiscoverClient.fetchRegistry()如果是一次从注册中心拉取注册表或者设置了全量注册或者关闭了增量注册，则会进行一次全量拉取。默认情况进行增量拉取

private boolean fetchRegistry(boolean forceFullRegistryFetch) {
  		// 启动计时器
        Stopwatch tracer = FETCH_REGISTRY_TIMER.start();

        try {
             // 如果禁止增量获取或者第一次获取，则进行全量获取
            Applications applications = getApplications();
			// 根据参数判断是否进行一次全量拉取，一般第一次启动时会进行一次全量获取。
            if (clientConfig.shouldDisableDelta()
                    || (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
                    || forceFullRegistryFetch
                    || (applications == null)
                    || (applications.getRegisteredApplications().size() == 0)
                    || (applications.getVersion() == -1)) //Client application does not have latest library supporting delta
            {
                // 是否关闭了增量
                logger.info("Disable delta property : {}", clientConfig.shouldDisableDelta());
                // 
                logger.info("Single vip registry refresh property : {}", clientConfig.getRegistryRefreshSingleVipAddress());
                // 是否强制全量更新
                logger.info("Force full registry fetch : {}", forceFullRegistryFetch);
                // 应用是为null
                logger.info("Application is null : {}", (applications == null));
                logger.info("Registered Applications size is zero : {}",
                        (applications.getRegisteredApplications().size() == 0));
                logger.info("Application version is -1: {}", (applications.getVersion() == -1));
                // 进行全量更新
                getAndStoreFullRegistry();
            } else {
                // 获取增量注册表信息更新到本地
                getAndUpdateDelta(applications);
            }
            applications.setAppsHashCode(applications.getReconcileHashCode());
            logTotalInstances();
        } catch (Throwable e) {
            logger.error(PREFIX + "{} - was unable to refresh its cache! status = {}", appPathIdentifier, e.getMessage(), e);
            return false;
        } finally {
            if (tracer != null) {
                tracer.stop();
            }
        }

        // 每次刷新本地注册表缓存时（无论是否检测到更改）都调用此方法。
    	// 调用缓存事件CacheRefreshedEvent
        onCacheRefreshed();

        // 根据缓存中的数据更新远程状态
    	// 调用更新事件StatusChangeEvent
        updateInstanceRemoteStatus();

        // registry was fetched successfully, so return true
        return true;
    }

DiscoveryClient.getAndUpdateDelta()从eureka注册中心获取增量注册表并且更新到本地

 private void getAndUpdateDelta(Applications applications) throws Throwable {
     	// 获取应用id
        long currentUpdateGeneration = fetchRegistryGeneration.get();

        Applications delta = null;
     	// 远程调用
        EurekaHttpResponse<Applications> httpResponse = eurekaTransport.queryClient.getDelta(remoteRegionsRef.get());
     	// 判断是否调用成功
        if (httpResponse.getStatusCode() == Status.OK.getStatusCode()) {
            delta = httpResponse.getEntity();
        }
		// 如果获取增量注册为空，则进行一次全量更新
        if (delta == null) {
            logger.warn("The server does not allow the delta revision to be applied because it is not safe. "
                    + "Hence got the full registry.");
            getAndStoreFullRegistry();
            
        } else if (fetchRegistryGeneration.compareAndSet(currentUpdateGeneration, currentUpdateGeneration + 1)) {
            logger.debug("Got delta update with apps hashcode {}", delta.getAppsHashCode());
            String reconcileHashCode = "";
            if (fetchRegistryUpdateLock.tryLock()) {
                try {
                    // 更新从eureka server拉取的信息到本地
                    updateDelta(delta);
                    reconcileHashCode = getReconcileHashCode(applications);
                } finally {
                    fetchRegistryUpdateLock.unlock();
                }
            } else {
                logger.warn("Cannot acquire update lock, aborting getAndUpdateDelta");
            }
            // There is a diff in number of instances for some reason
            if (!reconcileHashCode.equals(delta.getAppsHashCode()) || clientConfig.shouldLogDeltaDiff()) {
                reconcileAndLogDifference(delta, reconcileHashCode);  // this makes a remoteCall
            }
        } else {
            logger.warn("Not updating application delta as another thread is updating it already");
            logger.debug("Ignoring delta update with apps hashcode {}, as another thread is updating it already", delta.getAppsHashCode());
        }
    }

updateDelta(Applications delta)在该方法中会循环

 private void updateDelta(Applications delta) {
     	// 记录增量更新服务个数
        int deltaCount = 0;
     	// 循环所有eureka实例
        for (Application app : delta.getRegisteredApplications()) {
            // 循环当前实例的实例信息
            for (InstanceInfo instance : app.getInstances()) {
                // 获取本地region中的Applications
                Applications applications = getApplications();
                // 获取实例所处region
                String instanceRegion = instanceRegionChecker.getInstanceRegion(instance);
                // 判断实例区域是否非本地区域
                if (!instanceRegionChecker.isLocalRegion(instanceRegion)) {
                    Applications remoteApps = remoteRegionVsApps.get(instanceRegion);
                    if (null == remoteApps) {
                        remoteApps = new Applications();
                        remoteRegionVsApps.put(instanceRegion, remoteApps);
                    }
                    applications = remoteApps;
                }

                ++deltaCount;
                // 判断当前类型为ADDED/MODIFY/DELETED
                if (ActionType.ADDED.equals(instance.getActionType())) {
                    // 从appNameApplicationMap缓存中获取实例信息
                    Application existingApp = applications.getRegisteredApplications(instance.getAppName());
                    // 如果当前实例不存在，则添加进appNameApplicationMap缓存中
                    if (existingApp == null) {
                        applications.addApplication(app);
                    }
                    logger.debug("Added instance {} to the existing apps in region {}", instance.getId(), instanceRegion);
                    applications.getRegisteredApplications(instance.getAppName()).addInstance(instance);
                } else if (ActionType.MODIFIED.equals(instance.getActionType())) {
                    Application existingApp = applications.getRegisteredApplications(instance.getAppName());
                    if (existingApp == null) {
                        applications.addApplication(app);
                    }
                    logger.debug("Modified instance {} to the existing apps ", instance.getId());

                    applications.getRegisteredApplications(instance.getAppName()).addInstance(instance);

                }
                // 当实例信息剔除时，会将ActionType改为DELETED
                else if (ActionType.DELETED.equals(instance.getActionType())) {
                    Application existingApp = applications.getRegisteredApplications(instance.getAppName());
                    // 如果为空
                    if (existingApp != null) {
                        logger.debug("Deleted instance {} to the existing apps ", instance.getId());
                        // 剔除实例信息
                        existingApp.removeInstance(instance);
                        /*
                         * We find all instance list from application(The status of instance status is not only the status is UP but also other status)
                         * if instance list is empty, we remove the application.
                         */
                        if (existingApp.getInstancesAsIsFromEureka().isEmpty()) {
                            applications.removeApplication(existingApp);
                        }
                    }
                }
            }
        }
        logger.debug("The total number of instances fetched by the delta processor : {}", deltaCount);

        getApplications().setVersion(delta.getVersion());
        getApplications().shuffleInstances(clientConfig.shouldFilterOnlyUpInstances());

        for (Applications applications : remoteRegionVsApps.values()) {
            applications.setVersion(delta.getVersion());
            // 在缓存中进行一些更新
            applications.shuffleInstances(clientConfig.shouldFilterOnlyUpInstances());
        }
    }

自此服务拉取的方法已经完成。该方法的主要核心流程(主讲增量获取getAndUpdateDelta())

  1. 判断是增量还是全量拉取注册表
  2. 远程调用获取applications
  3. 如果获取为空，则进行一次全量获取，否则进行一次增量更新
  4. 循环区域的Applications列表以及instanceInfo表(集群)
  5. 根据当前实例的状态判断进行ADDED、MODIFY、DELETED操作
  6. 更新缓存
  7. 调用回调缓存时间和实例更新事件

3.续约

不管是eureka client还是server，都会定期发送续租命令。跟之前的拉取注册中心服务一样，续约也是通过定时任务进行执行的。

private class HeartbeatThread implements Runnable {

        public void run() {
            if (renew()) {
                lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
            }
        }
    }

renew()

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());
                // 获取当前时间戳lastDirtyTimestamp
                long timestamp = instanceInfo.setIsDirtyWithTime();
                // 再次发起注册
                boolean success = register();
                if (success) {
                    // 将unsetDirty时间戳与lastDirty时间戳匹配的unflag重置为unset。
                    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;
        }
    }

续租的流程相当比较简单

  1. 发送请求获取实例信息，会从ResponseCache中获取缓存实例并返回响应信息
  2. 根据响应信息判断缓存是否已失效，如果失效则重新注册该实例

4.更新注册信息

eureka会定期向注册中心更新自己的实例以及续租信息

InstanceInfoReplicator.run()

public void run() {
        try {
            // 如果实力信息有更改，则标记为脏数据
            discoveryClient.refreshInstanceInfo();
			 
            Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
            // 重新注册自身实力信息
            if (dirtyTimestamp != null) {
                discoveryClient.register();
                // 重置dirty flag
                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);
        }
    }

DiscoverClient.refreshInstanceInfo()

void refreshInstanceInfo() {
    	// 判断host地址是否更改
        applicationInfoManager.refreshDataCenterInfoIfRequired();
    	// 判断租赁信息是否更改
        applicationInfoManager.refreshLeaseInfoIfRequired();

        InstanceStatus status;
        try {
            // 判断当前状态
            status = getHealthCheckHandler().getStatus(instanceInfo.getStatus());
        } catch (Exception e) {
            logger.warn("Exception from healthcheckHandler.getStatus, setting status to DOWN", e);
            status = InstanceStatus.DOWN;
        }
		// 更新状态
        if (null != status) {
            applicationInfoManager.setInstanceStatus(status);
        }
    }

``ApplicationInfoManager.refreshDataCenterInfoIfRequired`重新获取client的host地址，以判断其host是否发生迁移，如果迁移则将host和ip清空，并且进行脏数据标记，在下个心跳检查中传递到eureka注册中心中。

 public void refreshDataCenterInfoIfRequired() {
     	// 获取client的host地址
        String existingAddress = instanceInfo.getHostName();

        String existingSpotInstanceAction = null;
        if (instanceInfo.getDataCenterInfo() instanceof AmazonInfo) {
            existingSpotInstanceAction = ((AmazonInfo) instanceInfo.getDataCenterInfo()).get(AmazonInfo.MetaDataKey.spotInstanceAction);
        }

        String newAddress;
     	// 从config中获取ipaddress
        if (config instanceof RefreshableInstanceConfig) {
            // Refresh data center info, and return up to date address
            newAddress = ((RefreshableInstanceConfig) config).resolveDefaultAddress(true);
        } else {
            newAddress = config.getHostName(true);
        }
        String newIp = config.getIpAddress();
		// 判断是否发生改变
        if (newAddress != null && !newAddress.equals(existingAddress)) {
            logger.warn("The address changed from : {} => {}", existingAddress, newAddress);
            updateInstanceInfo(newAddress, newIp);
        }

        if (config.getDataCenterInfo() instanceof AmazonInfo) {
            String newSpotInstanceAction = ((AmazonInfo) config.getDataCenterInfo()).get(AmazonInfo.MetaDataKey.spotInstanceAction);
            if (newSpotInstanceAction != null && !newSpotInstanceAction.equals(existingSpotInstanceAction)) {
                logger.info(String.format("The spot instance termination action changed from: %s => %s",
                        existingSpotInstanceAction,
                        newSpotInstanceAction));
                updateInstanceInfo(null , null );
            }
        }        
    }

ApplicationInfoManager.refreshLeaseInfoIfRequired()该方法主要判断eureka的租赁信息是否发生更改

 public void refreshLeaseInfoIfRequired() {
     	// 获取租约信息
        LeaseInfo leaseInfo = instanceInfo.getLeaseInfo();
        if (leaseInfo == null) {
            return;
        }
     	// 判断当前租约配置信息是否更改
        int currentLeaseDuration = config.getLeaseExpirationDurationInSeconds();
        int currentLeaseRenewal = config.getLeaseRenewalIntervalInSeconds();
        if (leaseInfo.getDurationInSecs() != currentLeaseDuration || leaseInfo.getRenewalIntervalInSecs() != currentLeaseRenewal) {
            LeaseInfo newLeaseInfo = LeaseInfo.Builder.newBuilder()
                    .setRenewalIntervalInSecs(currentLeaseRenewal)
                    .setDurationInSecs(currentLeaseDuration)
                    .build();
            instanceInfo.setLeaseInfo(newLeaseInfo);
            instanceInfo.setIsDirty();
        }
    }

以上就是eureka续租、拉取注册表等功能实现的分析。

（七）EurekaServer-处理客户端心跳续租请求
qq_42467713的博客
06-07 236
0. 前言 springboot版本：2.1.9.RELEASE springcloud版本：Greenwich.SR4 1. InstanceResource 服务端处理客户端心跳续租请求，在 InstanceResource 类的 renewLease() 方法 // InstanceResource.class public Response renewLease( @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isR
Eureka源码之服务获取与服务续约
实践求真知
07-16 850
首先看一下DiscoveryClient的initScheduledTasks函数，可以看到其中有两个定时任务，分别是“服务获取”和“服务续约”。 private void initScheduledTasks() {         if (clientConfig.shouldFetchRegistry()) {             // registry cache refres...
Eureka 源码解析 —— 应用实例注册发现（二）之续租
weixin_42073629的博客
06-09 410
1. 概述 本文主要分享Eureka-Client 向 Eureka-Server 续租应用实例的过程。 FROM《深度剖析服务发现组件Netflix Eureka》二次编辑 蓝框部分，为本文重点。 非蓝框部分，Eureka-Server 集群间复制注册的应用实例信息，不在本文内容范畴。 推荐 Spring Cloud 书籍： 请支持正版。下载盗版，等于主动编写低级 BUG。 程序猿DD ——《Spring Cloud微服务实战》 周立 ——《Spring Cloud与Dock...
was unable to refresh its cache! status = Cannot execute request on any known server
热门推荐
mbshqqb的博客
03-15 3万+
出现这种错误是因为:Eureka服务注册中心也会将自己作为客户端来尝试注册它自己，所以我们需要禁用它的客户端注册行为。 禁止方式如下:在 yml中设置eureka.client.register-with-eureka=false eureka.client.fetch-registry=false
但在服务端是要这是为false的，在客户端需要设置为true的，当在客户端设置为true之后若还是...
Eureka 常见故障
大漠知秋的加油站
10-24 5060
文章目录Eureka Server 全部不可用Eureka Client 启动前 Eureka Server 全部不可用Eureka Client 运行时 Eureka Server 不可用Eureka Server 部分不可用Client 端Server 端 Eureka Server 全部不可用 Eureka Client 启动前 Eureka Server 全部不可用   如果 Eureka...
注册中心 Eureka 源码解析 —— Eureka-Server 集群同步
芋道源码
08-09 788
点击上方“芋道源码”，选择“置顶公众号”技术文章第一时间送达！源码精品专栏 精尽 Dubbo 原理与源码专栏( 已经完成 69+ 篇，预计总共 75+ 篇 )中文详细注释...
源码分析之Eureka服务端源码解析
evasnowind的专栏
09-29 576
文章目录说明eureka server基本功能启动eureka-server注册相关bean开启eureka server开启注册注册表管理核心类 InstanceRegistrycom.netflix.eureka.registry.InstanceRegistry是euraka server中注册表管理的核心接口。职责是在内存中管理注册到Eureka Server中的服务实例信息。实现类有PeerAwareInstanceRegistryImpl。服务注册接收服务心跳请求服务剔除剔除的限制剔除服务的定时
1-4Eureka 服务端源码解析
brusion的博客
04-16 258
服务端 Eureka Server同时也是Eureka Client，在不禁止Server的客户端行为时，他会向Server拉取注册表，服务注册，发送心跳等功能 一、相关类介绍 1.1、类结构 instanceRegistry(1)：是Eureka Server注册表的最核心接口，主要是在内存中管理注册到Server中的服务实例信息 instanceRegistry(2)：对PeerAwa...
Eureka 学习 源码分析05 应用实例续租
郭传志的博客
10-26 145
2. Eureka-Client 发起续租 Eureka-Client 向 Eureka-Server 发起注册应用实例成功后获得租约 ( Lease )。 Eureka-Client固定间隔向 Eureka-Server 发起续租( renew )，避免租约过期。 默认情况下，租约有效期为 90 秒，续租频率为 30 秒。两者比例为 1 : 3 ，保证在网络异常等情况下，有三次重试的机...
Eureka源码解析(二) renew源码分析
augsm的专栏
10-25 529
承接上篇，本章节主要讲服务续租以及心跳过实现过程。
避坑指南（一）：Spring Security Oauth2中refresh_token刷新access_token异常
w36680130的博客
10-02 468
避坑指南（一）：Spring Security Oauth2中refresh_token刷新access_token异常
instance “error” 了怎么办？- 每天5分钟玩转 OpenStack（159）
weixin_33759269的博客
03-06 179
  这是 OpenStack 实施经验分享系列的第 9 篇。 OpenStack 用多了，经常会遇到这种情况：对 instance 执行某个操作如果失败了就会处于 “error” 状态： 而且这时我们除了删除 instance 外，几乎做不了其他操作。 本节就教大家如何恢...
两个月学习springcloud(5):eureka详细配置介绍
DazedMen的博客
11-09 432
通过前四篇文章，大家已经可以成功搭建eureka服务模块了。众所周知，spring cloud eureka基于netflix eureka做了二次封装，主要负责实现微服务架构中的服务治理功能。dubbo也是一款不错的服务治理框架，服务治理必须要有一个注册中心，注册中心选型有很多种:redis,zookeeper,consul,etcd等。 当前使用最多的是zookeeper，那么为什么eur...
python eureka服务发现_Eureka - 服务发现
weixin_39626409的博客
12-22 546
在Eureka - Client服务启动我们看到，注册表获取的地方有两个，一个是EurekaClient构造函数，一个是定时器每隔30秒去获取。我们先看看定时器TimedSupervisorTask的run方法定时器这个方法有三个比较重要的参数，timeoutMillis、delay、maxDelay。比如频率是30s，那这个maxDelay就是30*10=300s(这个10的来源参考上一篇)，d...
eureka 缓存更新剖析
dweizhao的专栏
11-03 460
影响服务注册信息生效主要有三个配置： 注册中心刷新响应缓存的频率，单位ms 客户端从注册中心拉取实例信息的频率，单位为s ribbon刷新本地缓存的频率，单位ms 如果在配合服务的上下线就可以实现平滑发布。 客户端从注册中心拉取实例信息的频率，单位为s key：eureka.client.registryFetchIntervalSeconds 默认值：30s 初始化源码 新客户端缓存的任务在DiscoveryClient的构造函数中进行初始化 @Inject DiscoveryClie
[享学Eureka] 二十五、DiscoveryClient透彻解析(二)：初始化逻辑详解
架构师：通透，才能写出好代码！
04-08 2467
主要介绍了`DiscoveryClient`的成员属性，达30+个之多。我们发现其成员属性中，绝大多数否是final修饰，也就是说他们大多均得在`DiscoveryClient`初始化阶段完成赋值，由此你也能感受到它初始化的“压力”。 确实，`DiscoveryClient`的初始化阶段是它，**甚至是整个Eureka Client**最为重要的逻辑片段之一，属于掌握Eureka一定、必须精通的知识点。在上文已经了解了它的成员属性以及含义后，本文在其基础上继续深入，深入讲解`DiscoveryClient
Eureka缓存机制及Eureka常用配置
liu_ares的博客
11-21 1128
Eureka Server 内部有二层缓存机制，那这些机制是如何工作的，以及 Eureka Server 是如何存储服务的注册信息，本节会给大家揭晓。 Eureka 在使用过程中有一些非常重要的配置项，本节也会整理出来，方便大家以后在生产环境根据项目场景来调整。 Eureka Server 数据存储 我们知道 Eureka Server 在运行期间就是一个普通的 Java 项目，并没有使用数据库之类的存储软件，那么在运行期间是如何存储数据的呢？ Eureka Server 的数据存储分了两层：数据存
eureka跨服务_Eureka的服务治理优化实践
weixin_39934302的博客
11-21 185
将Eureka作为服务注册中心的小伙伴在使用过程中一定会烦恼于以下两个问题： 1. 服务A某实例已经启动完成，要过很久服务B.C.D...才发现这个新的服务实例。 2. 服务A某实例异常下线了，要过很久服务B.C.D...才停止调用这个实例的接口。 问题1在系统滚动升级场景容易引起问题。如果服务A的实例在很短时间内全部依次滚动升级完成，服务A第一个升级实例重启到被其它服务感知这段时间内出现服务中...
Eureka服务注册、续约、注销原理
weixin_40969698的博客
03-14 3402
这篇文章，我们将深入学习Eureka底层中服务注册、续约、注销的基本原理。 1.服务注册 在微服务架构中，一个服务提供者本质上也是一个Eureka客户端。启动时，会调用Eureka所提供的服务注册相关方法，向Eureka服务器注册自己的信息。同时，在Eureka服务器会维护一个已注册的服务列表。注册服务列表使用一个嵌套HashMap保存信息，数据结构如下： ·HashMap的第一层为应用名称和对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值