SpringCloud Eureka Client源码解析（初始化）

小鱼儿 2022-09-09 09:14 181阅读 0赞

> 原创不易，转载请注明出处

# 系列文章目录 #

1.  《[SpringCloud Eureka Server源码解析（启动流程）][SpringCloud Eureka Server]》
2.  《[Eureka Server源码解析（服务注册流程）][Eureka Server]》
3.  《[Eureka Server源码解析（服务续约流程）][Eureka Server 1]》
4.  《[Eureka Server源码解析（服务主动下线流程）][Eureka Server 2]》
5.  《[Eureka Server源码解析（服务故障下线剔除流程）][Eureka Server 3]》
6.  《[Eureka Server源码解析（全量拉取注册表流程）][Eureka Server 4]》
7.  《[Eureka Server源码解析（增量拉取注册表）][Eureka Server 5]》
8.  《[深度解析Eureka的自我保护机制][Eureka]》

### 文章目录 ###

*  系列文章目录
 *  前言
 *  1. Spring Cloud整合Eureka Client
 *  2. Eureka Client 初始化
 *   *  2.1 拉取全量注册表信息
     *  2.2 定时任务
     *   *  2.2.1 增量拉取定时任务
         *  2.2.2 服务续约定时任务
         *  2.2.3服务注册
 *  总结

--------------------

# 前言 #

本文主要是解析下Spring Cloud整合Eureka Client的源码，这块代码比较多，而且都是些胶水代码，我们稍微看下就行，这就是介绍下Eureka Client初始化过程，不管你Spring Cloud 怎样封装，底层还是Eureka Client的内容，初始化过程大致上有这么几块重点的：1.去Eureka Server 拉取全量注册表， 2.创建定时任务，包括定时去Eureka Server 上增量拉取注册表信息，定时renew （服务续约）。3.服务注册

# 1. Spring Cloud整合Eureka Client #

要看Spring Cloud 怎样整合 Eureka Client ，就需要找到它们的自动装配配置类  
在spring-cloud-starter-netflix-eureka-client 依赖的jar里面能够找到spring.factories 文件，这个文件是spring spi文件。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAJOeggeWHuuacquadpQ_size_20_color_FFFFFF_t_70_g_se_x_16]  
核心就是EurekaClientAutoConfiguration 这个自动装配类。  
我们这里不一一看了，只看下几个核心组件的装配。

@Bean
    @ConditionalOnMissingBean(value = ApplicationInfoManager.class, search = SearchStrategy.CURRENT)
    public ApplicationInfoManager eurekaApplicationInfoManager(
    		EurekaInstanceConfig config) { 
    	InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
    	return new ApplicationInfoManager(config, instanceInfo);
    }

创建ApplicationInfoManager 对象，这个对象主要就是管着当前实例信息，也就是instanceInfo ， 可以看到，在这个方法中先是创建的instanceInfo，然后将instanceInfo 作为构造参数传入了ApplicationInfoManager 中。  
这个实例信息instanceInfo 里面维护了你当前实例的ip ，端口，appName等信息，注册的时候就是拿这些信息到Eureka Server 上注册。

@Bean(destroyMethod = "shutdown")
    @ConditionalOnMissingBean(value = EurekaClient.class, search = SearchStrategy.CURRENT)
    public EurekaClient eurekaClient(ApplicationInfoManager manager, EurekaClientConfig config) { 
    	return new CloudEurekaClient(manager, config, this.optionalArgs,
    			this.context);
    }

创建Eureka Client 对象，这个CloudEurekaClient 类是Spring Cloud 搞得，然后继承Eureka 原生的DiscoveryClient 类。

public class CloudEurekaClient extends DiscoveryClient

我们可以看看它的构造  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAJOeggeWHuuacquadpQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
最重要的是，它调用了父类的DiscoveryClient 的构造，第2小节我们一起看下。

# 2. Eureka Client 初始化 #

接下来我们看下DiscoveryClient 是怎样初始化的（构造方法中）。  
这里我们还是调最主要的核心流程介绍。

## 2.1 拉取全量注册表信息 ##

// 如果开启拉取注册表的话
    if (clientConfig.shouldFetchRegistry()) { 
          // 拉取注册表信息
          boolean primaryFetchRegistryResult = fetchRegistry(false);
    }

如果开启拉取注册信息，就会调用fetchRegistry 方法去Eureka Server上面拉取注册表信息。

// If the delta is disabled or if it is the first time, get all
    // applications
     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
    { 
        // 全量拉取注册表信息
        getAndStoreFullRegistry();
    } else { 
        // 增量更新
        getAndUpdateDelta(applications);
    }
    // 设置hashCode
    applications.setAppsHashCode(applications.getReconcileHashCode());
    logTotalInstances();

可以看下最上面的注释，不启用增量 或者是第一次，就拉取全量注册表信息。  
不启用增量|| 强制全量|| 本地注册表是空的， 这个时候就会调用getAndStoreFullRegistry 方法去Eureka Server 拉取全量注册表。  
否则的话调用 getAndUpdateDelta 方法获取增量注册表信息。  
接下来我们看下getAndStoreFullRegistry 方法，看看是怎样拉取全量注册表的。

// 获取所有注册表信息
        private void getAndStoreFullRegistry() throws Throwable { 
            long currentUpdateGeneration = fetchRegistryGeneration.get();
            Applications apps = null;
            //交给网络传输组件，发起网络请求，获得响应
            EurekaHttpResponse<Applications> httpResponse = clientConfig.getRegistryRefreshSingleVipAddress() == null
                    ? eurekaTransport.queryClient.getApplications(remoteRegionsRef.get())
                    : eurekaTransport.queryClient.getVip(clientConfig.getRegistryRefreshSingleVipAddress(), remoteRegionsRef.get());
            if (httpResponse.getStatusCode() == Status.OK.getStatusCode()) { 
                apps = httpResponse.getEntity();
            }
            localRegionApps.set(this.filterAndShuffle(apps));
        }

这里其实就是调用网络组件来发起请求，得到响应了，然后拿到所有得实例信息后，将实例信息设置到本地注册表中。  
我们这里再深入一点，看看`eurekaTransport.queryClient.getApplications(remoteRegionsRef.get())` 是请求得哪个url

getApplicationsInternal("apps/", regions);

请求uri就是 /apps

## 2.2 定时任务 ##

// 如果进行服务注册的话 
    if (clientConfig.shouldRegisterWithEureka() && clientConfig.shouldEnforceRegistrationAtInit()) { 
        try { 
            // 进行服务注册
            if (!register() ) { 
                throw new IllegalStateException("Registration error at startup. Invalid server response.");
            }
        } catch (Throwable th) { 
            logger.error("Registration error at startup: {}", th.getMessage());
            throw new IllegalStateException(th);
        }
    }

拉取完注册表后， 有这么一段代码，不深入看的话，还以为是服务注册的代码。实际上shouldEnforceRegistrationAtInit 默认返回的值 false，也就不会走里面服务注册的代码  
接着往下

initScheduledTasks();

初始化定时任务们。

### 2.2.1 增量拉取定时任务 ###

// 拉取注册表
    if (clientConfig.shouldFetchRegistry()) { 
        // registry cache refresh timer
        // 拉取间隔，默认是30s
        int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
        int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        cacheRefreshTask = new TimedSupervisorTask(
                "cacheRefresh",
                scheduler,
                cacheRefreshExecutor,
                registryFetchIntervalSeconds,
                TimeUnit.SECONDS,
                expBackOffBound,
                new CacheRefreshThread()
        );
        //放入定时任务 默认30s执行一次
        scheduler.schedule(
                cacheRefreshTask,
                registryFetchIntervalSeconds, TimeUnit.SECONDS);
    }

默认每隔30s 增量拉取注册表信息。拉取注册表信息，最终还是走我们上面介绍的fetchRegistry 方法。

### 2.2.2 服务续约定时任务 ###

// 续约间隔30s
    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);

每30s 执行一次服务续约  
直接看下HeartbeatThread 类。

private class HeartbeatThread implements Runnable { 
        public void run() { 
            if (renew()) { 
                lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
            }
        }
    }

走的是renew 方法请求服务续约，成功后会更新lastSuccessfulHeartbeatTimestamp 字段。

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;
            }
        }

很简单，就是调用 eurekaTransport.registrationClient.sendHeartBeat 方法发送服务续约的请求，如果你实例信息在Eureka Server中不存在的话，就进行服务注册，我们再稍微看下sendHeartBeat 方法，里面请求uri就是 String urlPath = “apps/” + appName + ‘/’ + id;  
apps/\{appName\}/\{instanceId\}

### 2.2.3服务注册 ###

// InstanceInfo replicator
                instanceInfoReplicator = new InstanceInfoReplicator(
                        this,
                        instanceInfo,
                        clientConfig.getInstanceInfoReplicationIntervalSeconds(),
                        2); // burstSize
    
     instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());

我们看下这个start启动 方法

public void start(int initialDelayMs) { 
         if (started.compareAndSet(false, true)) { 
             instanceInfo.setIsDirty();  // for initial register
             Future next = scheduler.schedule(this, initialDelayMs, TimeUnit.SECONDS);
             scheduledPeriodicRef.set(next);
         }
     }

这里有个非常重要的点，调用了实例信息的setIsDirty 方法，后面的注释说是为了初始化服务注册。  
创建一个延时任务，默认是40s。  
看看40s执行啥东西。

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);
         }
     }

如果这个时间戳不是null的话，调用register 方法进行服务注册，这个时间戳肯定不是null的， `instanceInfo.setIsDirty(); // for initial register` 我们上面这个方法就是设置了这个时间戳。最后又将这个任务放入延时调度中。  
其实这个定时任务是为了检测服务信息有没有变动，如果有变动重新注册到Eureka Server上去。  
最后我们看下register 服务注册方法实现。

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();
     }

服务注册请求的uri 就是`String urlPath = "apps/" + info.getAppName();`

# 总结 #

Eureka Client 实例化的时候有几个重要步骤，1是全量拉取注册表信息，放入自己本地注册表中。  
2.创建定时任务，服务续约，默认是30s，增量拉取注册表 默认是30s， 实例信息变更 重新服务注册，默认是40s。

[SpringCloud Eureka Server]: https://blog.csdn.net/yuanshangshenghuo/article/details/119920341
[Eureka Server]: https://blog.csdn.net/yuanshangshenghuo/article/details/119931667
[Eureka Server 1]: https://blog.csdn.net/yuanshangshenghuo/article/details/119951880
[Eureka Server 2]: https://blog.csdn.net/yuanshangshenghuo/article/details/119960880
[Eureka Server 3]: https://blog.csdn.net/yuanshangshenghuo/article/details/119961592
[Eureka Server 4]: https://blog.csdn.net/yuanshangshenghuo/article/details/119972511
[Eureka Server 5]: https://inetyoung.blog.csdn.net/article/details/119979197
[Eureka]: https://inetyoung.blog.csdn.net/article/details/110131223
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAJOeggeWHuuacquadpQ_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/271f7506e8724129868745f596b56b0d.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAJOeggeWHuuacquadpQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/4b76f19dbedd4879a74926d23725cee9.png