3、Nacos服务注册-客户端流程

最新推荐文章于 2024-09-07 17:39:29 发布
最新推荐文章于 2024-09-07 17:39:29 发布
阅读量2.2k 收藏 5
点赞数 5
分类专栏： 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jb84006/article/details/117456880
版权

  如果您对Nacos工作流程和原理还不是很清楚的话，建议从前面的文章开始看：
  1、nacos功能简介
  2、Nacos服务注册-客户端自动注册流程
  

一、主流程
  上篇讲到了com.alibaba.cloud.nacos.registry.NacosServiceRegistry#register方法，现在就以这个方法开始，看下这个方法代码：

@Override
public void register(Registration registration) {

   if (StringUtils.isEmpty(registration.getServiceId())) {
      log.warn("No service to register for nacos client...");
      return;
   }
    //构造NamingService
   NamingService namingService = namingService();
   String serviceId = registration.getServiceId();
   String group = nacosDiscoveryProperties.getGroup();
   
    //获取将要注册的客户端实例信息
   Instance instance = getNacosInstanceFromRegistration(registration);

   try {
       //服务注册
      namingService.registerInstance(serviceId, group, instance);
      log.info("nacos registry, {} {} {}:{} register finished", group, serviceId,
            instance.getIp(), instance.getPort());
   }
   catch (Exception e) {
      log.error("nacos registry, {} register failed...{},", serviceId,
            registration.toString(), e);
      // rethrow a RuntimeException if the registration is failed.
      // issue : https://github.com/alibaba/spring-cloud-alibaba/issues/1132
      rethrowRuntimeException(e);
   }
}

  其实这个方法就干了一件事：调用Nacos提供的客户端API进行服务注册。Nacos提供了一个非常核心的接口：NamingService，该接口提供了实例注册、实例注销、服务发现、服务订阅和取消订阅等等一系列的API供客户端调用。接着会根据registration对象构造实例信息，如图：
在这里插入图片描述

  接着就是调用NacosNamingService.registerInstance方法，这是在nacos-client包中，代码：

@Override
public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
    NamingUtils.checkInstanceIsLegal(instance);
    String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
    //如果是临时实例，发送心跳
    if (instance.isEphemeral()) {
        BeatInfo beatInfo = beatReactor.buildBeatInfo(groupedServiceName, instance);
        beatReactor.addBeatInfo(groupedServiceName, beatInfo);
    }
    //HTTP调用nacos-server端服务注册接口
    serverProxy.registerService(groupedServiceName, groupName, instance);
}

  可以看到这里有两个关键点：发送心跳和服务注册，我们先来看下serverProxy.registerService方法，这个方法往下一直跟会发现最终其实是通过NamingProxy.callServer方法发起了一个对地址/nacos/v1/ns/instance的HTTP调用，/nacos/v1/ns/instance就是nacos-server端提供的服务注册的接口地址，nacos-server端逻辑会在下一篇讲。这里有一个地方需要讲一下，就是如果nacos-server是集群部署的话，其实客户端仍然只会发送请求到其中一个集群节点上进行注册，并不会每个集群节点都去注册一遍（可以先想一下为什么这样做，会在后面讲到），具体实现是在NamingProxy.reqApi方法：

public String reqApi(String api, Map<String, String> params, Map<String, String> body, List<String> servers,
        String method) throws NacosException {
            
    //非关键代码略
    
    if (StringUtils.isNotBlank(nacosDomain)) {
        for (int i = 0; i < maxRetry; i++) {
            try {
                return callServer(api, params, body, nacosDomain, method);
            } catch (NacosException e) {
                exception = e;
                if (NAMING_LOGGER.isDebugEnabled()) {
                    NAMING_LOGGER.debug("request {} failed.", nacosDomain, e);
                }
            }
        }
    } else {
        Random random = new Random(System.currentTimeMillis());
        int index = random.nextInt(servers.size());
        
        for (int i = 0; i < servers.size(); i++) {
            String server = servers.get(index);
            try {
                return callServer(api, params, body, server, method);
            } catch (NacosException e) {
                exception = e;
                if (NAMING_LOGGER.isDebugEnabled()) {
                    NAMING_LOGGER.debug("request {} failed.", server, e);
                }
            }
            index = (index + 1) % servers.size();
        }
    }
    
    //非关键代码略
}

以上代码的意思其实很简单，通过nacosDomain进行判断，nacosDomain是在构造方法中赋值的：
在这里插入图片描述
  serverList表示的就是服务端节点列表，对应于配置文件中所配置的server地址，用逗号隔开，需要注意的是，如果server-addr配置的是nacos-server集群的vip，比如nginx地址，那么在这里也是走的“单机”部署（其实并不一定是单机部署，我这里为了更容易与集群部署的代码分支区分，所以下文都称为单机部署）的流程，只不过负载由nginx负责了。在这里插入图片描述
  如果serverList中只有一个值，说明就是nacos-server是单机部署，那么就把serverList赋值给nacosDoman属性，所以如果nacosDoman不为空，那就说明是单机部署，单机部署时，如果客户端通过HTTP远程调用服务端注册接口失败时，会进行maxRetry次重试（默认3次），重试成功即返回；如果nacosDomain不为空即集群部署时，则通过index = (index + 1) % servers.size()算法选出一个权威节点来进行调用，如果调用失败，就重新再随机选出一个下标再进行上述运算，一直到所有节点都尝试了一遍为止。所以说nacos-server以集群方式部署时，每个客户端每次注册也只是往其中一个节点发送服务注册请求。

需要注意的一点就是，AP模式下所有集群节点都是平等的，即没有主从节点的概念，所有节点
都有可能接受客户端的注册请求，然后会将注册的实例数据同步到其它集群节点。

二、心跳机制
  现在再回到前面说到的发送心跳的地方：

if (instance.isEphemeral()) {
    BeatInfo beatInfo = beatReactor.buildBeatInfo(groupedServiceName, instance);
    beatReactor.addBeatInfo(groupedServiceName, beatInfo);
}

//构造心跳信息
public BeatInfo buildBeatInfo(String groupedServiceName, Instance instance) {
    BeatInfo beatInfo = new BeatInfo();
    beatInfo.setServiceName(groupedServiceName);
    beatInfo.setIp(instance.getIp());
    beatInfo.setPort(instance.getPort());
    beatInfo.setCluster(instance.getClusterName());
    beatInfo.setWeight(instance.getWeight());
    beatInfo.setMetadata(instance.getMetadata());
    beatInfo.setScheduled(false);
    //心跳周期，默认5秒一次
    beatInfo.setPeriod(instance.getInstanceHeartBeatInterval());
    return beatInfo;
}

//发送心跳
public void addBeatInfo(String serviceName, BeatInfo beatInfo) {
    NAMING_LOGGER.info("[BEAT] adding beat: {} to beat map.", beatInfo);
    String key = buildKey(serviceName, beatInfo.getIp(), beatInfo.getPort());
    BeatInfo existBeat = null;
    //fix #1733
    if ((existBeat = dom2Beat.remove(key)) != null) {
        existBeat.setStopped(true);
    }
    dom2Beat.put(key, beatInfo);
    //延迟任务，客户端启动后，延迟5秒发送心跳，之后每5秒发送一次心跳
    executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
    MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
}

以上代码很简单，就不作详细解释了，主要看下心跳任务的核心实现BeatTask：

class BeatTask implements Runnable {

    BeatInfo beatInfo;

    public BeatTask(BeatInfo beatInfo) {
        this.beatInfo = beatInfo;
    }

    @Override
    public void run() {
        if (beatInfo.isStopped()) {
            return;
        }
        long nextTime = beatInfo.getPeriod();
        try {
            //发送心跳
            JsonNode result = serverProxy.sendBeat(beatInfo, BeatReactor.this.lightBeatEnabled);
            long interval = result.get("clientBeatInterval").asLong();
            boolean lightBeatEnabled = false;
            if (result.has(CommonParams.LIGHT_BEAT_ENABLED)) {
                lightBeatEnabled = result.get(CommonParams.LIGHT_BEAT_ENABLED).asBoolean();
            }
            BeatReactor.this.lightBeatEnabled = lightBeatEnabled;
            if (interval > 0) {
                nextTime = interval;
            }
            int code = NamingResponseCode.OK;
            if (result.has(CommonParams.CODE)) {
                code = result.get(CommonParams.CODE).asInt();
            }
            //如果服务端响应码是20404（服务端不存在该实例并且心跳信息为空），
            //则重新发起注册请求
            if (code == NamingResponseCode.RESOURCE_NOT_FOUND) {
                Instance instance = new Instance();
                instance.setPort(beatInfo.getPort());
                instance.setIp(beatInfo.getIp());
                instance.setWeight(beatInfo.getWeight());
                instance.setMetadata(beatInfo.getMetadata());
                instance.setClusterName(beatInfo.getCluster());
                instance.setServiceName(beatInfo.getServiceName());
                instance.setInstanceId(instance.getInstanceId());
                instance.setEphemeral(true);
                try {
                    serverProxy.registerService(beatInfo.getServiceName(),
                            NamingUtils.getGroupName(beatInfo.getServiceName()), instance);
                } catch (Exception ignore) {
                }
            }
        } catch (NacosException ex) {
            NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, code: {}, msg: {}",
                    JacksonUtils.toJson(beatInfo), ex.getErrCode(), ex.getErrMsg());

        }
        executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);
    }
}

  BeatTask是一个线程，先整体看一下run()方法的主体结构：前面部分是心跳的处理逻辑；最后一句代码又是开启了一个延迟任务：executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS)，我觉得这是对定时任务的一个比较灵活的使用方式，它并没有按照传统的定时任务（如Spring的scheduler）的方式指定一个时间间隔，固定以该时间间隔进行循环调用，而是手动以类似递归的方式开启一个延迟任务，这样做的好处是不需要受固定的时间间隔的约束，因为该任务中包含了HTTP远程调用，所以无法准确预估任务的执行时间，这个时间间隔也就不是那么容易确定，也就是说万一由于网络问题或者其它未知因素导致HTTP调用耗时超过了5秒，也没关系，那就等本次心跳任务执行完成后再启动下一次的心跳任务。nacos中存在大量这种用法，后面还会讲到。

发送心跳的关键代码：serverProxy.sendBeat(beatInfo,BeatReactor.this.lightBeatEnabled)：

public JsonNode sendBeat(BeatInfo beatInfo, boolean lightBeatEnabled) throws NacosException {
    
    if (NAMING_LOGGER.isDebugEnabled()) {
        NAMING_LOGGER.debug("[BEAT] {} sending beat to server: {}", namespaceId, beatInfo.toString());
    }
    Map<String, String> params = new HashMap<String, String>(8);
    Map<String, String> bodyMap = new HashMap<String, String>(2);
    if (!lightBeatEnabled) {
        bodyMap.put("beat", JacksonUtils.toJson(beatInfo));
    }
    params.put(CommonParams.NAMESPACE_ID, namespaceId);
    params.put(CommonParams.SERVICE_NAME, beatInfo.getServiceName());
    params.put(CommonParams.CLUSTER_NAME, beatInfo.getCluster());
    params.put("ip", beatInfo.getIp());
    params.put("port", String.valueOf(beatInfo.getPort()));
    String result = reqApi(UtilAndComs.nacosUrlBase + "/instance/beat", params, bodyMap, HttpMethod.PUT);
    return JacksonUtils.toObj(result);
}

  所以实际上也是通过HTTP调用nacos-server端的接口：nacos/v1/ns/instance/beat。
其中一个很重要的一点就是，如果收到的服务端的响应码为20404时（服务端不存在该实例并且心跳信息为空），则重新发起注册请求，这个需要结合服务端一起来看才能完整的理解这个心跳机制，服务端还有个健康检查任务，与客户端心跳密切相关，因此心跳逻辑将会在服务端流程讲完之后我会另开一篇单独来讲。

  本文主要介绍了客户端发送服务注册请求到服务端以及心跳相关流程，下篇开始讲服务端处理客户端注册请求的流程。

毛龙蛋
关注
专栏目录
Nacos注册中心——源码解析客户端自动注册
qq_42866927的博客
04-06 379
Nacos 阿里巴巴开发的一款产品为了服务微服务而诞生 支持服务注册 心跳检测 配置中心 支持AP+CP切换 一般情况下满足AP 采用SpringCloudAlibaba构建的服务可以知道在项目启动的时候会自动将当前服务注册到Nacos服务端中。 SpringCloudAlibaba–Nacos自动注册实现流程图： 图片链接：https://www.processon.com/view/link/6068719df346fb0aa98425c2 1.Nacos客户端如何在项目启动的时候完成自动注册？
nacos服务注册流程
cqlaopan的博客
04-26 8686
nacos客户端注册流程 nacos的客户端已经搭建好了，那么客户端是怎么将服务注册到注册中心去的呢。 1、 如果对springboot自动配置原理有一定了解的话，那么第三方框架一般都会通过spi的方式来初始化自己包中的bean。比如mybatis与spring结合都会在/META-INFO/spring.factories下进行自动装配 2、 那么nacos是不是一样的也是基于这种方式来处理的...
【Nacos】Nacos快速上手使用(注册中心)【详解】
最新发布
2301_77431942的博客
09-07 892
Nacos(Dynamic Naming and Configuration Service)是服务中心的另外一种实现。从注册中心的功能实现角度，与Eureka等价，只是实现方式有所差异。与Eureka不同的是，Nacos注册中心类似于Tomcat，是独立启动的服务器。因此在我们的代码中，无需在专门创建一个工程用于启动注册中心。一句话：Nacos就是代理已经过时的注册中心Eureka + 配置中心config首先，下载好Nacos安装包(.zip压缩包)，解压后，如下图。
Nacos服务注册流程（一）
weixin_39575794的博客
03-14 4175
Nacos客户端注册与服务端发现流程 目录 一、准备事项 1.1 Nacos源码下载 1.2 启动Nacos服务端项目 1.3 启动Nacos客户端项目 二、Nacos客户端注册流程 2.1 注册方法的调用 2.2时序图 2.3注册代码 2.4数据结构 三、Nacos服务端服务注册流程 3.1 注册流程 1. 时序图 2. 具体代码 3.2数据结构 四、总结 一、准备事项 1.1 Nacos源码下载 Nacos官网 Nacos项目地址 将项目clone...
Nacos服务注册流程
weixin_44610169的博客
10-12 514
二、在要注册的服务的配置文件中，添加注册Nacos服务的配置信息。-- 服务注册 -->一、pom文件中引入对应依赖。三、在启动类中添加注解。
Nacos服务注册简要流程
小桶的博客
08-25 2105
以下内容基于Nacos 2.1.0-SNAPSHOT 1. 服务实例注册示例 当nacos服务已经启动后，可以使用以下示例代码向nacos注册服务实例 @Test public void testRegisterInstance() throw Exception { // nacos地址，用户和密码 Properties properties = new Properties(); properties.put(PropertyKeyConst.SERVER_ADDR, "...
nacos-server-2.1.1.
08-12
Nacos作为服务注册与发现的平台，允许应用在启动时向Nacos注册自身服务，同时其他应用可以通过Nacos查找并消费这些服务。服务发现机制降低了服务间的耦合性，提高了系统的可扩展性和容错性。 2. **配置管理**： ...
nacos-server-1.4.1.zip
08-07
1. **服务发现**：Nacos作为服务注册与发现的中心，允许应用在启动时向Nacos注册自身服务，同时其他应用可以通过Nacos查找并消费这些服务。服务发现机制降低了服务间的耦合性，使得服务能够动态地添加、删除或更新，...
nacos-server-1.4.2.tar.gz
10-22
6. **丰富的API与SDK**：Nacos提供了全面的RESTful API和客户端SDK，开发者可以轻松地进行服务的注册、发现和配置操作，同时也方便集成到现有的开发流程中。 7. **监控与日志**：Nacos集成了监控功能，可以实时查看...
nacos-server-1.4.0
01-03
Nacos支持服务注册与发现，允许服务提供者将自身服务信息发布到Nacos，同时服务消费者可以通过Nacos查询到可用的服务实例，实现动态的服务发现。这种机制极大地提高了服务的可扩展性和弹性。 2. **配置管理**： ...
Nacos源码流程——服务注册与发现.png
04-02
Nacos服务注册与发现源码流程图， 通过流程图展示了服务注册到Nacos服务注册中心的整个源码过程，同时对Nacos代码中一些优秀的思想进行总结
nacos-server-2.3.2.7z
06-25
Nacos 与流行的微服务框架Spring Cloud和Dubbo有良好的集成，可以直接在这些框架中使用Nacos 的服务发现和配置管理功能，简化了开发流程。 通过上述特性，Nacos 2.3.2版本为微服务架构带来了更强大的服务治理能力，...
二、Nacos源码系列：Nacos服务注册流程(一)
weixiaohuai的博客
01-17 2369
本篇文章中，我们从Nacos客户端自动注册在何时触发开始，然后分析了客户端向Nacos服务端提交服务注册请求，最后到Nacos服务端处理这个注册请求，整个流程大概梳理了一下，下一篇文章，我们将会详细分析NotifyCenter这个事件-发布机制的原理，然后继续分析服务端处理注册请求过程中涉及到的后续流程处理。
nacos服务注册
qq_41860765的博客
02-20 1664
流程如下：1、微服务启动，将自己注册到Nacos，Nacos记录了各微服务实例的地址。2、网关从Nacos读取服务列表，包括服务名称、服务地址等。3、请求到达网关，网关将请求路由到具体的微服务。要使用网关首先搭建Nacos，Nacos有两个作用：1、服务发现中心。微服务将自身注册至Nacos，网关从Nacos获取微服务列表。2、配置中心。微服务众多，它们的配置信息也非常复杂，为了提供系统的可维护性，微服务的配置信息统一在Nacos配置。
Nacos 注册流程分析（一）
pangxiaoliang14的博客
11-12 515
nacos注册流程分析
【微服务】Nacos客户端微服务注册原理流程
qq_57756904的博客
11-04 2431
Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式) 的服务基础设施。其特性有：服务发现和服务健康监测、动态配置服务、动态 DNS 服务、服务及其元数据管理。
nacos注册流程
程序猿
06-06 161
NacosDiscoveryAutoConfiguration 为注册流程入口类定义了3个beanNacosServiceRegistry声明向注册中心注册服务的beanNacosRegistration声明存储nacos服务信息的beanNacosAutoServiceRegistration声明用于nacos服务自动注册的bean。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值