Eureka 服务注册源码探秘——图解、源码级解析

- 日理万妓 2024-05-24 21:37 14阅读 0赞

> ? Java学习：[社区快速通道][Link 1]  
>   
> 
> 
> ? 深入浅出RocketMQ设计思想：[深入浅出RocketMQ设计思想][RocketMQ]  
>   
> 
> 
> ? 绝对不一样的职场干货：[大厂最佳实践经验指南][Link 2]  
>   
>   
> ? 最近更新：2023年5月2日  
>   
> 
> 
>   
> 
> 
> ? 点赞 ? 收藏 ⭐留言 ? 都是我最大的动力！

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

#### 文章目录 ####

*  引言
 *  Eureka 服务注册源码
 *   *  寻找配置类
     *  寻找服务注册的元数据
     *  register方法
     *  下一个流程
     *  继续execute

## 引言 ##

服务注册是为了解决各个微服务的“你是谁”这个问题，即获取所有服务节点的身份信息和服务名称，站在注册中心的角度来看，有以下两种比较直观的解决方案：

1.  由注册中心主动访问网络节点中所有机器
2.  注册中心等待服务节点主动进行注册

![在这里插入图片描述][025ce76bc0d04c8d899af21e888de178.png]

目前主流的注册中心（Nacos、Eureka）都选择了第二种方案，主要原因是第一种方案有很多弊端：

*  **模型复杂：** 网络结点构成了一张复杂的网，结点与结点之间的关系错综复杂，轮询每个节点的做法通常是注册中心发局域网广播，客户端响应的方式。现实中对于跨局域网的分布式系统来说，响应模型会更加复杂。
 *  **网络开销大：** 整个网络环境里会掺杂大量非服务节点，这些节点无需对送达的广播请求做出响应，这种广播的模式无疑增加了网络通信成本。
 *  **服务端压力增加：** 不仅要求注册中心向网络中所有节点主动发送广播请求，还需要对客户端的应答做出响应。考虑到注册中心的节点数远远少于服务节点，所以要尽可能地减轻服务中心承载的业务。

一一对照着看，第二种实现方案就有如下优点：

1.  **注册中心压力小：** 网络中其它非服务节点不会产生任何无效请求，也就不用做额外的判断
2.  **效率高：** 省去了广播环节的时间，使注册效率大大提高
3.  **节省成本：** 节省了大量网络请求的开销

下面就来探索一下经典注册中心微服务 `Eureka` 服务注册源码。

## Eureka 服务注册源码 ##

### 寻找配置类 ###

要使用Eureka，就需要在SpringBoot的启动类上添加 `@EnableDiscoveryClient` 注解，所以我们的源码解析，从启动类上的 `@EnableDiscoveryClient` 注解开始：  
![请添加图片描述][6f72ccf0ddfc42deaf4ea9ac6b0a2892.png_pic_center]

在Eureka已经启动的状态下，以debug模式启动`EurekaClientApplication`，会来到这里面的断点：

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]  
其中`metadata`是`main`函数里挂的注解：

![请添加图片描述][781edb6af2fd44609ad2ba5d4140f621.png_pic_center]  
`attributes`是会获得`@EnableDiscoveryClient`的`EnableDiscoveryClient`注解，接下来读取注解里面的`autoRegister`属性，如果是true的话，会发现之后导入了一个配置类：

![请添加图片描述][41e9b7a520764bfd8c1f18a0d6d5a7bb.png_pic_center]

### 寻找服务注册的元数据 ###

进入到该配置类：

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_17_color_FFFFFF_t_70_g_se_x_16]  
继续进入到`AutoServiceRegistrationProperties`类里：  
![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_18_color_FFFFFF_t_70_g_se_x_16_pic_center]  
这些个属性一定会在某些配置项加载的流程中应用到，大家尝试找一下哪些类会引用它。

其中你会找到`AbstractAutoServiceRegistration`，发现其在初始化的流程里使用到：

protected AbstractAutoServiceRegistration(ServiceRegistry<R> serviceRegistry, AutoServiceRegistrationProperties properties) {
        
        this.serviceRegistry = serviceRegistry;
        this.properties = properties;
    }

同时还发现了一个服务注册属性`serviceRegistry`：

private final ServiceRegistry<R> serviceRegistry;

进入到`ServiceRegistry`的实现类`EurekaServiceRegistry`里

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]  
进入到第一行的方法`maybeInitializeClient`里：

private void maybeInitializeClient(EurekaRegistration reg) {
        
        reg.getApplicationInfoManager().getInfo();
        reg.getEurekaClient().getApplications();
    }

继续进入到`getInfo`里

![请添加图片描述][ccdca3b455bd40b6afc3c69901de5649.png_pic_center]  
![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_14_color_FFFFFF_t_70_g_se_x_16_pic_center]

发现这里面的信息其实就是我们要向服务中心注册的东西。

### register方法 ###

接下来继续执行`EurekaServiceRegistry`的`register`方法：

reg.getApplicationInfoManager().setInstanceStatus(reg.getInstanceConfig().getInitialStatus());

首先设置了`instance`的状态，这里`reg.getInstanceConfig().getInitialStatus()`是UP

这里的`register`并没有发起服务调用请求，所以还要通过调用栈来继续寻找。来到上一层`EurekaAutoServiceRegistration`的`start`方法里：

![请添加图片描述][229a8dfb65cd4236b42e5e9c6d1054f4.png_pic_center]  
停留在的这一行往上下文中发布了一个事件`InstanceRegisteredEvent`，但此时我们会发现服务其实并没有注册  
![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_13_color_FFFFFF_t_70_g_se_x_16_pic_center]  
说明在`event`发布前后肯定发生了什么事，让`eureka`服务提供者向注册中心发送了请求，既然`event`发布之后`running`的状态变为了`true`，那确实是运行起来了。

### 下一个流程 ###

下一个流程在`DiscoveryClient`里，它封装了我们服务的`client`和注册中心之间的各种交互，里面有一个`register`方法

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_Center]  
跟着断点继续往下走：  
![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]  
发现这里用的是`SessionedEurekaHttpClient`，接下来去找它的源码：

![请添加图片描述][bfbf51564d544e549af124beec78b8e3.png_pic_center]  
`register`方法在其父类`EurekaHttpClientDecorator`中

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]  
通过一个子类实现的`execute`方法，参数是由父类传入的一个代理`delegate`，`execute`是由`SessionedEurekaHttpClient`子类实现的

protected <R> EurekaHttpResponse<R> execute(RequestExecutor<R> requestExecutor) {
        
        long now = System.currentTimeMillis();
        long delay = now - this.lastReconnectTimeStamp;
        if (delay >= this.currentSessionDurationMs) {
        
            logger.debug("Ending a session and starting anew");
            this.lastReconnectTimeStamp = now;
            this.currentSessionDurationMs = this.randomizeSessionDuration(this.sessionDurationMs);
            TransportUtils.shutdown((EurekaHttpClient)this.eurekaHttpClientRef.getAndSet((Object)null));
        }
    
        EurekaHttpClient eurekaHttpClient = (EurekaHttpClient)this.eurekaHttpClientRef.get();
        if (eurekaHttpClient == null) {
        
            eurekaHttpClient = TransportUtils.getOrSetAnotherClient(this.eurekaHttpClientRef, this.clientFactory.newClient());
        }
    
        return requestExecutor.execute(eurekaHttpClient);
    }

这一段代码尝试从`HttpClient`里拿实例，如果实例为空则会调用一个工具类的方法`getOrSetAnotherClient`去获取一个新的实例，但这里我们会发现其实并不为空：

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_16_color_FFFFFF_t_70_g_se_x_16_pic_center]  
这里调用了另一个`httpclient`。其中`SessionedEurekaHttpClient`用到了装饰器模式，主要装饰的功能是`delay`时间过长时重新启动一个`session`

进入到下一层`RetryableEurekaHttpClient`，这一层装饰的功能是可以重试，默认最大重试次数为3：

protected <R> EurekaHttpResponse<R> execute(RequestExecutor<R> requestExecutor) {
        
        List<EurekaEndpoint> candidateHosts = null;
        int endpointIdx = 0;
    
        for(int retry = 0; retry < this.numberOfRetries; ++retry) {
        
            EurekaHttpClient currentHttpClient = (EurekaHttpClient)this.delegate.get();
            EurekaEndpoint currentEndpoint = null;
            if (currentHttpClient == null) {
        
                if (candidateHosts == null) {
        
                    candidateHosts = this.getHostCandidates();
                    if (candidateHosts.isEmpty()) {
        
                        throw new TransportException("There is no known eureka server; cluster server list is empty");
                    }
                }
    
                if (endpointIdx >= candidateHosts.size()) {
        
                    throw new TransportException("Cannot execute request on any known server");
                }
    
                currentEndpoint = (EurekaEndpoint)candidateHosts.get(endpointIdx++);
                currentHttpClient = this.clientFactory.newClient(currentEndpoint);
            }
    
            try {
        
                EurekaHttpResponse<R> response = requestExecutor.execute(currentHttpClient);
                if (this.serverStatusEvaluator.accept(response.getStatusCode(), requestExecutor.getRequestType())) {
        
                    this.delegate.set(currentHttpClient);
                    if (retry > 0) {
        
                        logger.info("Request execution succeeded on retry #{}", retry);
                    }
    
                    return response;
                }
    
                logger.warn("Request execution failure with status code {}; retrying on another server if available", response.getStatusCode());
            } catch (Exception var8) {
        
                logger.warn("Request execution failed with message: {}", var8.getMessage());
            }
    
            this.delegate.compareAndSet(currentHttpClient, (Object)null);
            if (currentEndpoint != null) {
        
                this.quarantineSet.add(currentEndpoint);
            }
        }
    
        throw new TransportException("Retry limit reached; giving up on completing the request");
    }

其中`this.getHostCandidates();`获取的是注册中心：

private List<EurekaEndpoint> getHostCandidates() {
        
        List<EurekaEndpoint> candidateHosts = this.clusterResolver.getClusterEndpoints();
        this.quarantineSet.retainAll((Collection)candidateHosts);
        int threshold = (int)((double)((List)candidateHosts).size() * this.transportConfig.getRetryableClientQuarantineRefreshPercentage());
        if (threshold > ((List)candidateHosts).size()) {
        
            threshold = ((List)candidateHosts).size();
        }
    
        if (!this.quarantineSet.isEmpty()) {
        
            if (this.quarantineSet.size() >= threshold) {
        
                logger.debug("Clearing quarantined list of size {}", this.quarantineSet.size());
                this.quarantineSet.clear();
            } else {
        
                List<EurekaEndpoint> remainingHosts = new ArrayList(((List)candidateHosts).size());
                Iterator var4 = ((List)candidateHosts).iterator();
    
                while(var4.hasNext()) {
        
                    EurekaEndpoint endpoint = (EurekaEndpoint)var4.next();
                    if (!this.quarantineSet.contains(endpoint)) {
        
                        remainingHosts.add(endpoint);
                    }
                }
    
                candidateHosts = remainingHosts;
            }
        }
    
        return (List)candidateHosts;
    }

如果坏注册中心节点的数量超过了阈值（66%），则要重启。`quarantineSet`存储的是失败的注册中心，`remainingHosts`存储的是成功的注册中心。

### 继续execute ###

回到上面的`execute`方法里，如果重试的索引大于候选注册中心的size时，就表示已知的所有注册中心都不能处理注册请求，此时会抛一个异常出来：

if (endpointIdx >= candidateHosts.size()) {
        
        throw new TransportException("Cannot execute request on any known server");
    }
    
    currentEndpoint = (EurekaEndpoint)candidateHosts.get(endpointIdx++);
    currentHttpClient = this.clientFactory.newClient(currentEndpoint);

如果在某一层`execute`成功了，则会将`deligate`设置为当前的`client`，如果不成功则会通过CAS操作将`currentHttpClient`设置为空，然后放置到失效的`EurekaEndpoint`加入到`quarantineSet`，下次不用了  
![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]  
此时还有好多层装饰器，这里直接快进跳到最后一层`AbstractJerseyEurekaHttpClient`中的`register`方法：

public EurekaHttpResponse<Void> register(InstanceInfo info) {
        
        String urlPath = "apps/" + info.getAppName();
        ClientResponse response = null;
    
        EurekaHttpResponse var5;
        try {
        
            Builder resourceBuilder = this.jerseyClient.resource(this.serviceUrl).path(urlPath).getRequestBuilder();
            this.addExtraHeaders(resourceBuilder);
            response = (ClientResponse)((Builder)((Builder)((Builder)resourceBuilder.header("Accept-Encoding", "gzip")).type(MediaType.APPLICATION_JSON_TYPE)).accept(new String[]{
        "application/json"})).post(ClientResponse.class, info);
            var5 = EurekaHttpResponse.anEurekaHttpResponse(response.getStatus()).headers(headersOf(response)).build();
        } finally {
        
            if (logger.isDebugEnabled()) {
        
                logger.debug("Jersey HTTP POST {}/{} with instance {}; statusCode={}", new Object[]{
        this.serviceUrl, urlPath, info.getId(), response == null ? "N/A" : response.getStatus()});
            }
    
            if (response != null) {
        
                response.close();
            }
        }
        return var5;
    }

在这里发送了http请求，info里面存的是当前服务的所有信息

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_13_color_FFFFFF_t_70_g_se_x_16_pic_center 1]  
这一步结束之后就注册成功了

![请添加图片描述][b6cbd9be48f645299ecba59f7c31550c.png_pic_center]

[Link 1]: https://bbs.csdn.net/forums/TOBEJAVAGOD
[RocketMQ]: https://blog.csdn.net/hnu_csee_wjw/category_11789299.html
[Link 2]: https://blog.csdn.net/hnu_csee_wjw/category_11693862.html
[025ce76bc0d04c8d899af21e888de178.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/49c4662d061c4fa0803e73b5f65f35bf.png
[6f72ccf0ddfc42deaf4ea9ac6b0a2892.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/084f4cdb908e46d7a48ba0202a7bb202.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/cef2b4c793094fbd8ea0713b10b9f9d7.png
[781edb6af2fd44609ad2ba5d4140f621.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/83f460220de34f25bac89a013e1cf3e3.png
[41e9b7a520764bfd8c1f18a0d6d5a7bb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/9347b498b6ee4b5396db731725797755.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_17_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/e2ae2a36d0404ed1aaa3358b58f8fc6d.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_18_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/64781c141c8c4006ba4a3ead36dce50b.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/e6f8396aab194023957bdfd8b2a14051.png
[ccdca3b455bd40b6afc3c69901de5649.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/2e5bd6decb654a02a15bb7d7438b3347.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_14_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/6ff4d82756ba485cb8fcb1642af52cd6.png
[229a8dfb65cd4236b42e5e9c6d1054f4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/22a9e1398333434386ff9492739ec3e4.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_13_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/b4f7b7a00f1941beb70b28375ce68324.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_Center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/44252cfe5c144ef7853cafc1056af97a.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/a85e0ff2e8a543cb88349f1d978a38f0.png
[bfbf51564d544e549af124beec78b8e3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/69cf7f122c604563a63928a212131492.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/d45b5379f9de4c3ebf987c0a9b673f20.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_16_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/e1a99784fdea4d55b9ef98114b7b930c.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/ed71e385ee17422bb88c24084488ee57.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP546L5pu-5piv5bCR5bm0_size_13_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/32c7fb4feb214229b0bac9c3d7268671.png
[b6cbd9be48f645299ecba59f7c31550c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/7ec4d88f93c34a97bc369112e2520c89.png