SpringCloud学习笔记（三、SpringCloud Netflix Eureka）

时间：2019-10-04 22:45:00 阅读：105 评论：0 收藏：0 [点我收藏+]

 1 ## Eureka注册中心实例名
 2 spring.application.name=eureka-server
 3 ## Eureka注册中心端口
 4 server.port=9090
 5 
 6 ## 关闭Actuator验证开关
 7 management.security.enabled=false
 8 
 9 ## 不向注册中心获取服务列表
10 ## eureka服务端的eureka.client.fetch-registry配置必须为false让他不要去找server节点，因为它本身就是server节点
11 eureka.client.fetch-registry=false
12 ## 不注册到注册中心上
13 eureka.client.register-with-eureka=false
14 
15 ## 配置 注册中心的 地址
16 eureka.client.service-url.defaultZone=http://localhost:9090/eureka

启动后可通过http://localhost:9090/eureka查看服务端情况

2、Eureka客户端

）添加Eureka Client依赖

1 <dependency>
2     <groupId>org.springframework.cloud</groupId>
3     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
4 </dependency>

）启动类加上@EnableEurekaClient或@EnableDiscoveryClient

二者的共同点是：都是能够让注册中心能够发现，扫描到该服务。

不同点：@EnableEurekaClient只适用于Eureka作为注册中心，而@EnableDiscoveryClient可以是其他的注册中心。

）配置properties

 1 ## Eureka服务提供者实例名
 2 spring.application.name=eureka-provider
 3 ## Eureka服务提供者端口
 4 server.port=8070
 5 
 6 ## 关闭Actuator验证开关
 7 management.security.enabled=false
 8 
 9 ## 配置 注册中心的 地址
10 eureka.client.service-url.defaultZone=http://localhost:9090/eureka/

3、一些常用的配置

　　）客户端配置

技术分享图片

）服务实例配置

技术分享图片

Eureka高可用：

我们都知道Eureka分为服务端和客户端，所以搭建高可用的Eureka时二者都需要高可用。

技术分享图片

1、服务端

服务端的高可用其实就是让客户端获取服务列表时尽可能的少失败，所以我们只需要启动两个Eureka Server，让他们相互复制服务列表即可

1 server.port=9091
2 eureka.client.service-url.defaultZone=http://localhost:9092/eureka

1 server.port=9092
2 eureka.client.service-url.defaultZone=http://localhost:9091/eureka

2、客户端

客户端的高可用就是在获取服务列表时尽可能的少失败，所以我们只需要配置多个注册中心即可

1 eureka.client.service-url.defaultZone=http://localhost:9091/eureka,http://localhost:9092/eureka

Eureka Client初始化：

首先我们知道若想将一个应用程序注册为Eureka的客户端那最主要的便是在启动类上加上@EnableDiscoveryClient这个注解，这便是Eureka Client的初始化。

我们来重点分析下Eureka Client的初始化：

1、从@EnableDiscoveryClient注解字面意思来看就是启动DiscoveryClient，所以我们看看DiscoveryClient这个类

技术分享图片

根据IDEA的检索，满足条件的有两个，一个是Netflix的DiscoveryClient，一个是SpringCloud的DiscoveryClient

）com.netflix.discovery.DiscoveryClient的结构如下

技术分享图片

）org.springframework.cloud.client.discovery.DiscoveryClient是一个接口，其实现有很多，但Eureka的是org.springframework.cloud.netflix.eureka.EurekaDiscoveryClient

技术分享图片

所以两个DiscoveryClient的逻辑结构便如下图：

技术分享图片

2、我们先逐步看看这两个DiscoveryClient的实现

）首先从SpringCloud的看起，实现类org.springframework.cloud.netflix.eureka.EurekaDiscoveryClient

a、通过通读可以看出比较重要的public List<ServiceInstance> getInstances(String serviceId)、public List<String> getServices()两个方法都有使用一个eurekaClient的属性

b、而eurekaClient正是，Netflix的EurekaClient接口，所以我们可以得知SpringCloud仅是对Netflix的一个包装

c、所以我们直接看Netflix的EurekaClient接口（com.netflix.discovery.EurekaClient）的实现 >>> com.netflix.discovery.DiscoveryClient

）com.netflix.discovery.DiscoveryClient的实现

a、一般看类的实现是从构造函数入手，所以我们先找到最全的构造函数：DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args, Provider<BackupRegistry> backupRegistryProvider);

b、此构造一开始是大量的判断，这块就不看了，我们仅看最重要那部分 >>> initScheduledTasks()

c、initScheduledTasks()：初始化定时器（客户端定时获取服务列表、客户端定时发送心跳续约、客户端定时注册）

接下来，我们在细讲这三个thread

客户端定时获取服务列表源码分析：

源码示例（客户端）：

 1 if (clientConfig.shouldFetchRegistry()) {
 2     // registry cache refresh timer
 3     int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
 4     int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
 5     scheduler.schedule(
 6         new TimedSupervisorTask(
 7             "cacheRefresh",
 8             scheduler,
 9             cacheRefreshExecutor,
10             registryFetchIntervalSeconds,
11             TimeUnit.SECONDS,
12             expBackOffBound,
13             new CacheRefreshThread() // 定时获取服务列表thread
14         ),
15         registryFetchIntervalSeconds, TimeUnit.SECONDS);
16 }

1、首先我们看第1行，clientConfig.shouldFetchRegistry() == true才会执行获取服务列表的job，我们点进去看，发现其实就是我们properties配置的eureka.client.fetch-registry，而默认值为true。

2、然后执行job的周期单位为秒（11行），执行周期为registryFetchIntervalSeconds，也就是第3行；第3行和第1行同理，为properties配置的eureka.client.registry-fetchInterval-seconds，而默认值为30

3、最后我们看看其核心线程（13行），可以看到其调用的函数其实是void refreshRegistry()；函数最开始一大堆判断，最后一堆debug，这些都不用细究，我们直接看最核心的哪行代码boolean success = fetchRegistry(remoteRegionsModified)

 1 private boolean fetchRegistry(boolean forceFullRegistryFetch) {
 2     Stopwatch tracer = FETCH_REGISTRY_TIMER.start();
 3 
 4     try {
 5         // If the delta is disabled or if it is the first time, get all
 6         // applications
 7         Applications applications = getApplications();
 8 
 9         if (clientConfig.shouldDisableDelta()
10                 || (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
11                 || forceFullRegistryFetch
12                 || (applications == null)
13                 || (applications.getRegisteredApplications().size() == 0)
14                 || (applications.getVersion() == -1)) //Client application does not have latest library supporting delta
15         {
16             logger.info("Disable delta property : {}", clientConfig.shouldDisableDelta());
17             logger.info("Single vip registry refresh property : {}", clientConfig.getRegistryRefreshSingleVipAddress());
18             logger.info("Force full registry fetch : {}", forceFullRegistryFetch);
19             logger.info("Application is null : {}", (applications == null));
20             logger.info("Registered Applications size is zero : {}",
21                     (applications.getRegisteredApplications().size() == 0));
22             logger.info("Application version is -1: {}", (applications.getVersion() == -1));
23             getAndStoreFullRegistry();
24         } else {
25             getAndUpdateDelta(applications);
26         }
27         applications.setAppsHashCode(applications.getReconcileHashCode());
28         logTotalInstances();
29     } catch (Throwable e) {
30         logger.error(PREFIX + appPathIdentifier + " - was unable to refresh its cache! status = " + e.getMessage(), e);
31         return false;
32     } finally {
33         if (tracer != null) {
34             tracer.stop();
35         }
36     }
37 
38     // Notify about cache refresh before updating the instance remote status
39     onCacheRefreshed();
40 
41     // Update remote status based on refreshed data held in the cache
42     updateInstanceRemoteStatus();
43 
44     // registry was fetched successfully, so return true
45     return true;
46 }

从代码中我们可以看出要么是全量注册（23行）要么是增量注册（25行）：

）全量注册

 1 private void getAndStoreFullRegistry() throws Throwable {
 2     long currentUpdateGeneration = fetchRegistryGeneration.get();
 3 
 4     logger.info("Getting all instance registry info from the eureka server");
 5 
 6     Applications apps = null;
 7     EurekaHttpResponse<Applications> httpResponse = clientConfig.getRegistryRefreshSingleVipAddress() == null
 8             ? eurekaTransport.queryClient.getApplications(remoteRegionsRef.get())
 9             : eurekaTransport.queryClient.getVip(clientConfig.getRegistryRefreshSingleVipAddress(), remoteRegionsRef.get());
10     if (httpResponse.getStatusCode() == Response.Status.OK.getStatusCode()) {
11         apps = httpResponse.getEntity();
12     }
13     logger.info("The response status is {}", httpResponse.getStatusCode());
14 
15     if (apps == null) {
16         logger.error("The application is null for some reason. Not storing this information");
17     } else if (fetchRegistryGeneration.compareAndSet(currentUpdateGeneration, currentUpdateGeneration + 1)) {
18         localRegionApps.set(this.filterAndShuffle(apps));
19         logger.debug("Got full registry with apps hashcode {}", apps.getAppsHashCode());
20     } else {
21         logger.warn("Not updating applications as another thread is updating it already");
22     }
23 }

）从中可以看出18行set了一下，apps从httpResponse获取，故看下http调用即可；我们看下第8行，并调到其实现类com.netflix.discovery.shared.transport.jersey.AbstractJerseyEurekaHttpClient，看到其调用的http url是apps/

1 @Override
2 public EurekaHttpResponse<Applications> getApplications(String... regions) {
3     return getApplicationsInternal("apps/", regions);
4 }

再点进去看，发现其实就是调用了http://服务端ip:服务端port/eureka/apps，并且将结果放入Applications

）增量注册，增量注册与全量同理，但调用的是http://服务端ip:服务端port/eureka/apps/delta接口

全量增量注册讲完后我们来看看服务端的代码（着重将全量，增量与全量原理差不多）

源码示例（服务端）：

我们知道全量注册调用的是http://服务端ip:服务端port/eureka/apps接口，我们找下这个接口的实现，com.netflix.eureka.resources.ApplicationsResource#getContainers，并找到最重要的代码块

 1 Response response;
 2 if (acceptEncoding != null && acceptEncoding.contains(HEADER_GZIP_VALUE)) {
 3     response = Response.ok(responseCache.getGZIP(cacheKey))
 4             .header(HEADER_CONTENT_ENCODING, HEADER_GZIP_VALUE)
 5             .header(HEADER_CONTENT_TYPE, returnMediaType)
 6             .build();
 7 } else {
 8     response = Response.ok(responseCache.get(cacheKey))
 9             .build();
10 }
11 return response;

进入responseCache.getZIP(cacheKey)后，我们可以知道代码很简单，就是从缓存中获取数据给客户端

 1 @VisibleForTesting
 2 ResponseCacheImpl.Value getValue(final Key key, boolean useReadOnlyCache) {
 3     ResponseCacheImpl.Value payload = null;
 4     try {
 5         if (useReadOnlyCache) {
 6             final ResponseCacheImpl.Value currentPayload = readOnlyCacheMap.get(key);
 7             if (currentPayload != null) {
 8                 payload = currentPayload;
 9             } else {
10                 payload = readWriteCacheMap.get(key);
11                 readOnlyCacheMap.put(key, payload);
12             }
13         } else {
14             payload = readWriteCacheMap.get(key);
15         }
16     } catch (Throwable t) {
17         logger.error("Cannot get value for key :" + key, t);
18     }
19     return payload;
20 }

客户端定时发送心跳续约：

 1 scheduler.schedule(
 2         new TimedSupervisorTask(
 3                 "heartbeat",
 4                 scheduler,
 5                 heartbeatExecutor,
 6                 renewalIntervalInSecs,
 7                 TimeUnit.SECONDS,
 8                 expBackOffBound,
 9                 new DiscoveryClient.HeartbeatThread()
10         ),
11         renewalIntervalInSecs, TimeUnit.SECONDS);

进入DiscoveryClient.HeartbeatThread()线程后会发现调用了服务端的apps/appName/id这样一个接口，我们来着重看下这个接口

1、首先接口在com.netflix.eureka.resources.InstanceResource#renewLease

2、我们想其核心代码boolean isSuccess = registry.renew(app.getName(), id, isFromReplicaNode)里跟进

 1 public boolean renew(String appName, String id, boolean isReplication) {
 2     RENEW.increment(isReplication);
 3     // 还是一样的从registry中拿InstanceInfo
 4     Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
 5     Lease<InstanceInfo> leaseToRenew = null;
 6     if (gMap != null) {
 7         leaseToRenew = gMap.get(id);
 8     }
 9     // 如果拿不到InstanceInfo就表示服务挂了，心跳续约失败
10     if (leaseToRenew == null) {
11         RENEW_NOT_FOUND.increment(isReplication);
12         logger.warn("DS: Registry: lease doesn‘t exist, registering resource: {} - {}", appName, id);
13         return false;
14     } else {
15         InstanceInfo instanceInfo = leaseToRenew.getHolder();
16         if (instanceInfo != null) {
17             // touchASGCache(instanceInfo.getASGName());
18             InstanceInfo.InstanceStatus overriddenInstanceStatus = this.getOverriddenInstanceStatus(
19                     instanceInfo, leaseToRenew, isReplication);
20             if (overriddenInstanceStatus == InstanceInfo.InstanceStatus.UNKNOWN) {
21                 logger.info("Instance status UNKNOWN possibly due to deleted override for instance {}"
22                         + "; re-register required", instanceInfo.getId());
23                 RENEW_NOT_FOUND.increment(isReplication);
24                 return false;
25             }
26             if (!instanceInfo.getStatus().equals(overriddenInstanceStatus)) {
27                 Object[] args = {
28                         instanceInfo.getStatus().name(),
29                         instanceInfo.getOverriddenStatus().name(),
30                         instanceInfo.getId()
31                 };
32                 logger.info(
33                         "The instance status {} is different from overridden instance status {} for instance {}. "
34                                 + "Hence setting the status to overridden status", args);
35                 instanceInfo.setStatusWithoutDirty(overriddenInstanceStatus);
36             }
37         }
38         renewsLastMin.increment();
39         // 如果能拿到InstanceInfo就做一个续约
40         leaseToRenew.renew();
41         return true;
42     }
43 }

3、进一步看下续约leaseToRenew.renew()方法

1 public void renew() {
2     lastUpdateTimestamp = System.currentTimeMillis() + duration;
3 }

代码很简单，就是延长lastUpdateTimestamp的时间，duration则是通过构造传入的；若duration有执行则用构造指定的，若没有默认90秒

客户端定时注册：

1 instanceInfoReplicator = new InstanceInfoReplicator(
2         this,
3         instanceInfo,
4         clientConfig.getInstanceInfoReplicationIntervalSeconds(),
5         2); // burstSize

进入InstanceInfoReplicator后会发现这个类实现Runnable接口，那既然是线程就去看run方法咯

 1 public void run() {
 2     try {
 3         discoveryClient.refreshInstanceInfo();
 4 
 5         Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
 6         if (dirtyTimestamp != null) {
 7             discoveryClient.register();
 8             instanceInfo.unsetIsDirty(dirtyTimestamp);
 9         }
10     } catch (Throwable t) {
11         logger.warn("There was a problem with the instance info replicator", t);
12     } finally {
13         Future next = scheduler.schedule(this, replicationIntervalSeconds, TimeUnit.SECONDS);
14         scheduledPeriodicRef.set(next);
15     }
16 }

然后我们看第7行，一步步根进去发现其实调用了"apps/" + info.getAppName()接口

接下来我们来看看"apps/" + info.getAppName()接口的实现

1、找到com.netflix.eureka.resources.ApplicationResource的addInstance方法，找到其中的registry.register(info, "true".equals(isReplication));根进去

2、找到com.netflix.eureka.registry.AbstractInstanceRegistry的register方法

 1 public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
 2     try {
 3         read.lock();
 4         // 根据实例名registrant.getAppName()获取InstanceInfo
 5         Map<String, Lease<InstanceInfo>> gMap = registry.get(registrant.getAppName());
 6         REGISTER.increment(isReplication);
 7         if (gMap == null) {
 8             final ConcurrentHashMap<String, Lease<InstanceInfo>> gNewMap = new ConcurrentHashMap<String, Lease<InstanceInfo>>();
 9             // 若registry没有此实例时，注册一个空的示例
10             gMap = registry.putIfAbsent(registrant.getAppName(), gNewMap);
11             if (gMap == null) {
12                 gMap = gNewMap;
13             }
14         }
15         Lease<InstanceInfo> existingLease = gMap.get(registrant.getId());
16         // Retain the last dirty timestamp without overwriting it, if there is already a lease
17         if (existingLease != null && (existingLease.getHolder() != null)) {
18             Long existingLastDirtyTimestamp = existingLease.getHolder().getLastDirtyTimestamp();
19             Long registrationLastDirtyTimestamp = registrant.getLastDirtyTimestamp();
20             logger.debug("Existing lease found (existing={}, provided={}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
21 
22             // this is a > instead of a >= because if the timestamps are equal, we still take the remote transmitted
23             // InstanceInfo instead of the server local copy.
24             // 若eureka服务器存在的示例的时间戳大于传入新实例的时间戳，则用已存在的（说明eureka server使用的实例都是最新的）
25             if (existingLastDirtyTimestamp > registrationLastDirtyTimestamp) {
26                 logger.warn("There is an existing lease and the existing lease‘s dirty timestamp {} is greater" +
27                         " than the one that is being registered {}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
28                 logger.warn("Using the existing instanceInfo instead of the new instanceInfo as the registrant");
29                 registrant = existingLease.getHolder();
30             }
31         } else {
32             // The lease does not exist and hence it is a new registration
33             synchronized (lock) {
34                 if (this.expectedNumberOfRenewsPerMin > 0) {
35                     // Since the client wants to cancel it, reduce the threshold
36                     // (1
37                     // for 30 seconds, 2 for a minute)
38                     this.expectedNumberOfRenewsPerMin = this.expectedNumberOfRenewsPerMin + 2;
39                     this.numberOfRenewsPerMinThreshold =
40                             (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
41                 }
42             }
43             logger.debug("No previous lease information found; it is new registration");
44         }
45         // 根据新的示例创建新的租约
46         Lease<InstanceInfo> lease = new Lease<InstanceInfo>(registrant, leaseDuration);
47         if (existingLease != null) {
48             lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());
49         }
50         gMap.put(registrant.getId(), lease);
51         synchronized (recentRegisteredQueue) {
52             recentRegisteredQueue.add(new Pair<Long, String>(
53                     System.currentTimeMillis(),
54                     registrant.getAppName() + "(" + registrant.getId() + ")"));
55         }
56         // This is where the initial state transfer of overridden status happens
57         if (!InstanceInfo.InstanceStatus.UNKNOWN.equals(registrant.getOverriddenStatus())) {
58             logger.debug("Found overridden status {} for instance {}. Checking to see if needs to be add to the "
59                     + "overrides", registrant.getOverriddenStatus(), registrant.getId());
60             if (!overriddenInstanceStatusMap.containsKey(registrant.getId())) {
61                 logger.info("Not found overridden id {} and hence adding it", registrant.getId());
62                 overriddenInstanceStatusMap.put(registrant.getId(), registrant.getOverriddenStatus());
63             }
64         }
65         InstanceInfo.InstanceStatus overriddenStatusFromMap = overriddenInstanceStatusMap.get(registrant.getId());
66         if (overriddenStatusFromMap != null) {
67             logger.info("Storing overridden status {} from map", overriddenStatusFromMap);
68             registrant.setOverriddenStatus(overriddenStatusFromMap);
69         }
70 
71         // Set the status based on the overridden status rules
72         InstanceInfo.InstanceStatus overriddenInstanceStatus = getOverriddenInstanceStatus(registrant, existingLease, isReplication);
73         registrant.setStatusWithoutDirty(overriddenInstanceStatus);
74 
75         // If the lease is registered with UP status, set lease service up timestamp
76         if (InstanceInfo.InstanceStatus.UP.equals(registrant.getStatus())) {
77             lease.serviceUp();
78         }
79         registrant.setActionType(InstanceInfo.ActionType.ADDED);
80         recentlyChangedQueue.add(new AbstractInstanceRegistry.RecentlyChangedItem(lease));
81         registrant.setLastUpdatedTimestamp();
82         invalidateCache(registrant.getAppName(), registrant.getVIPAddress(), registrant.getSecureVipAddress());
83         logger.info("Registered instance {}/{} with status {} (replication={})",
84                 registrant.getAppName(), registrant.getId(), registrant.getStatus(), isReplication);
85     } finally {
86         read.unlock();
87     }
88 }

服务下线：

若要将此客户端下线的话，要分两步走

）启动下线接口（配置properties）

1 # 启用下线功能
2 endpoints.shutdown.enabled=true
3 # 关闭下线功能的安全校验
4 endpoints.shutdown.sensitive=false

）调用下线接口（http://当前客户端ip/当前客户端port/shutdown）

1、客户端

客户端代码很简单，主要分为两步

）cancelScheduledTasks() >>> 停止客户端初始化的三个job（客户端定时获取服务列表、客户端定时发送心跳续约、客户端定时注册）

）unregister() >>> 注销（调用apps/appName/id接口，delete方式）

2、服务端

首先我们来找到客户端调的那个接口：com.netflix.eureka.resources.InstanceResource#cancelLease

 1 @DELETE
 2 public Response cancelLease(@HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication) {
 3     boolean isSuccess = registry.cancel(app.getName(), id, "true".equals(isReplication));
 4 
 5     if (isSuccess) {
 6         logger.debug("Found (Cancel): " + app.getName() + " - " + id);
 7         return Response.ok().build();
 8     } else {
 9         logger.info("Not Found (Cancel): " + app.getName() + " - " + id);
10         return Response.status(Status.NOT_FOUND).build();
11     }
12 }

我们看核心代码（第3行），并找到方法的实现com.netflix.eureka.registry.PeerAwareInstanceRegistryImpl#cancel

 1 @Override
 2 public boolean cancel(final String appName, final String id, final boolean isReplication) {
 3     if (super.cancel(appName, id, isReplication)) {
 4         replicateToPeers(PeerAwareInstanceRegistryImpl.Action.Cancel, appName, id, null, null, isReplication);
 5         synchronized (lock) {
 6             if (this.expectedNumberOfRenewsPerMin > 0) {
 7                 // Since the client wants to cancel it, reduce the threshold (1 for 30 seconds, 2 for a minute)
 8                 this.expectedNumberOfRenewsPerMin = this.expectedNumberOfRenewsPerMin - 2;
 9                 this.numberOfRenewsPerMinThreshold =
10                         (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
11             }
12         }
13         return true;
14     }
15     return false;
16 }

看第三行，然后一步步跟进后找到其底层代码：

 1 protected boolean internalCancel(String appName, String id, boolean isReplication) {
 2     try {
 3         read.lock();
 4         CANCEL.increment(isReplication);
 5         // 还是同样的从registry中拿取数据
 6         Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
 7         Lease<InstanceInfo> leaseToCancel = null;
 8         if (gMap != null) {
 9             // 若拿到数据则移除该数据
10             leaseToCancel = gMap.remove(id);
11         }
12         synchronized (recentCanceledQueue) {
13             recentCanceledQueue.add(new Pair<Long, String>(System.currentTimeMillis(), appName + "(" + id + ")"));
14         }
15         InstanceInfo.InstanceStatus instanceStatus = overriddenInstanceStatusMap.remove(id);
16         if (instanceStatus != null) {
17             logger.debug("Removed instance id {} from the overridden map which has value {}", id, instanceStatus.name());
18         }
19         if (leaseToCancel == null) {
20             CANCEL_NOT_FOUND.increment(isReplication);
21             logger.warn("DS: Registry: cancel failed because Lease is not registered for: {}/{}", appName, id);
22             return false;
23         } else {
24             // 将此InstanceInfo移除
25             leaseToCancel.cancel();
26             InstanceInfo instanceInfo = leaseToCancel.getHolder();
27             String vip = null;
28             String svip = null;
29             if (instanceInfo != null) {
30                 instanceInfo.setActionType(InstanceInfo.ActionType.DELETED);
31                 recentlyChangedQueue.add(new AbstractInstanceRegistry.RecentlyChangedItem(leaseToCancel));
32                 instanceInfo.setLastUpdatedTimestamp();
33                 vip = instanceInfo.getVIPAddress();
34                 svip = instanceInfo.getSecureVipAddress();
35             }
36             invalidateCache(appName, vip, svip);
37             logger.info("Cancelled instance {}/{} (replication={})", appName, id, isReplication);
38             return true;
39         }
40     } finally {
41         read.unlock();
42     }
43 }

最后服务下单其实就是调用leaseToCancel.cancel()，通过更新evictionTimestamp来取消租赁

1 public void cancel() {
2     if (evictionTimestamp <= 0) {
3         evictionTimestamp = System.currentTimeMillis();
4     }
5 }

SpringCloud学习笔记（三、SpringCloud Netflix Eureka）

原文：https://www.cnblogs.com/bzfsdr/p/11614307.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)

SpringCloud学习笔记（三、SpringCloud Netflix Eureka）

目录：

服务发现简介：

SpringCloud Netflix Eureka应用：

Eureka高可用：

Eureka Client初始化：

客户端定时获取服务列表源码分析：

客户端定时发送心跳续约：

客户端定时注册：

服务下线：