Nacos 服务注册源码解析

最新推荐文章于 2024-08-16 08:30:00 发布
最新推荐文章于 2024-08-16 08:30:00 发布
阅读量1.5k 收藏 4
点赞数 1
分类专栏： springcloud springcloudalbaba
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu1390910/article/details/107741401
版权

nacos官方提供额架构图：

  • Provider App：服务提供者
  • Consumer App：服务消费者
  • Name Server：通过VIP（Vritual IP）或者DNS的方式实现Nacos高可用集群的服务路由
  • Nacos Server：Nacos服务提供者，包含OpenApi访问入口，Config Service 和 Naming Service是Nacos的配置服务，名字服务模块。Consistency Protocol是一致性协议，用来实现Nacos集群接节点的数据同步，使用的是 Raft算法。
  • Nacos Console：控制台

详细信息可以进入官方文档查看Nacos官方架构

Nacos服务注册源码解析

主要三部分：

  • 服务注册
  • 服务地址的获取
  • 服务地址变化的感知

 

Spring-Cloud-common包中有一个类ServiceRegistry，它是提供服务注册的标准。集成Spring Cloud实现服务注册的组件都会实现该接口。

package org.springframework.cloud.client.serviceregistry;

public interface ServiceRegistry<R extends Registration> {
    void register(R registration);

    void deregister(R registration);

    void close();

    void setStatus(R registration, String status);

    <T> T getStatus(R registration);
}

Nacos正是实现了这个接口：

 

Nacos触发服务注册的时机：

首先在Spring-cloud-common包中有一个配置文件spring.factories

AutoServiceRegistrationAutoConfiguration 是服务注册相关的配置类

 

AutoServiceRegistration

这块有个小插曲 ，官方 nacos-example中使用的是2.0.0版本的spring-cloud-commons，发现只 实现了3个接口。

  ApplicationEvent是通过注解实现的

 

而2.1.1版本的 spring-cloud-commons中实现了4个接口，区别 就是 ApplicationListener

这里看达到监听了WebServerInitializedEvent事件，当Webserver初始化完成后，调用 bind方法 。

  1. bind中 调用了 start方法。
  2. start中调用了register方法。
  3. register方法，就是ServiceRegistry接口中的方法。
  4. NacosServiceRegistry  实现了ServiceRegistry接口，通过register方法进行注册

最终再回来看这个：

创建心跳信息实现 健康检查 

 通过定时线程池实现，Nacos服务端会根据客户端的心跳包 不断更新服务的状态 

 

 

这里针对目前最新版1.3.1版本的Nacos的源码进行分析：

由于Nacos底层 是 基于HTTP协议完成的请求，所以直接分析Open API即可。

1.服务注册

 @CanDistro
    @PostMapping
    @Secured(parser = NamingResourceParser.class, action = ActionTypes.WRITE)
    public String register(HttpServletRequest request) throws Exception {
        
        final String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
        final String namespaceId = WebUtils
                .optional(request, CommonParams.NAMESPACE_ID, Constants.DEFAULT_NAMESPACE_ID);
        
        final Instance instance = parseInstance(request);
        
        serviceManager.registerInstance(namespaceId, serviceName, instance);
        return "ok";
    }

servicename 就是注册的服务名：

namespaceId：值为public

public void registerInstance(String namespaceId, String serviceName, Instance instance) throws NacosException {
        //创建1个空服务
        createEmptyService(namespaceId, serviceName, instance.isEphemeral());
        //从serviceMap中获取服务对象
        Service service = getService(namespaceId, serviceName);
        
        if (service == null) {
            throw new NacosException(NacosException.INVALID_PARAM,
                    "service not found, namespace: " + namespaceId + ", service: " + serviceName);
        }
        //添加服务实例
        addInstance(namespaceId, serviceName, instance.isEphemeral(), instance);
    }

 创建服务代码 ：

public void createServiceIfAbsent(String namespaceId, String serviceName, boolean local, Cluster cluster)
            throws NacosException {
        //从缓存中获取service
        Service service = getService(namespaceId, serviceName);
        if (service == null) { //如果为空保存到缓存中
            
            Loggers.SRV_LOG.info("creating empty service {}:{}", namespaceId, serviceName);
            service = new Service();
            service.setName(serviceName);
            service.setNamespaceId(namespaceId);
            service.setGroupName(NamingUtils.getGroupName(serviceName));
            // now validate the service. if failed, exception will be thrown
            service.setLastModifiedMillis(System.currentTimeMillis());
            service.recalculateChecksum();
            if (cluster != null) {
                cluster.setService(service);
                service.getClusterMap().put(cluster.getName(), cluster);
            }
            service.validate();
            
            putServiceAndInit(service);
            if (!local) {
                addOrReplaceService(service);
            }
        }
    }

 主要是putServiceAndInit代码

private void putServiceAndInit(Service service) throws NacosException {
        //将缓存中的service put到内存
        putService(service);
        //建立心跳检测机制
        service.init();
        //实现数据一致性的监听
        consistencyService
                .listen(KeyBuilder.buildInstanceListKey(service.getNamespaceId(), service.getName(), true), service);
        consistencyService
                .listen(KeyBuilder.buildInstanceListKey(service.getNamespaceId(), service.getName(), false), service);
        Loggers.SRV_LOG.info("[NEW-SERVICE] {}", service.toJson());
    }
  • 1.将缓存放入内存
 public void putService(Service service) {
        if (!serviceMap.containsKey(service.getNamespaceId())) {
            synchronized (putServiceLock) {
                if (!serviceMap.containsKey(service.getNamespaceId())) {
                    serviceMap.put(service.getNamespaceId(), new ConcurrentHashMap<>(16));
                }
            }
        }
        serviceMap.get(service.getNamespaceId()).put(service.getName(), service);
    }

 最终Nacos内存中的 service组装 Map

 

  • 2.建立心跳机制
public void init() {
        HealthCheckReactor.scheduleCheck(clientBeatCheckTask);
        for (Map.Entry<String, Cluster> entry : clusterMap.entrySet()) {
            entry.getValue().setService(this);
            entry.getValue().init();
        }
    }

 可以看到这里的默认心跳机制是5秒

public static void scheduleCheck(ClientBeatCheckTask task) {
        futureMap.putIfAbsent(task.taskKey(), GlobalExecutor.scheduleNamingHealth(task, 5000, 5000, TimeUnit.MILLISECONDS));
    }
  • 3.数据一致性监听 

这里调用了 ConsistencyService.java接口中的 listen方法

void listen(String key, RecordListener listener) throws NacosException;

可以发现这里有3个实现类 

 

可以发现只有 DelegateConsistencyServiceImpl.java 才是真正 的 实现者，这里采用了委派 机制 ，同时执行了Distro和Raft两个实现类。由此可以说明Nacos同时使用Raft协议和 Distro协议维护数据一致性的。

2.服务查询

@GetMapping("/list")
    @Secured(parser = NamingResourceParser.class, action = ActionTypes.READ)
    public ObjectNode list(HttpServletRequest request) throws Exception {
        
        String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID, Constants.DEFAULT_NAMESPACE_ID);
        
        String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
        String agent = WebUtils.getUserAgent(request);
        String clusters = WebUtils.optional(request, "clusters", StringUtils.EMPTY);
        String clientIP = WebUtils.optional(request, "clientIP", StringUtils.EMPTY);
        int udpPort = Integer.parseInt(WebUtils.optional(request, "udpPort", "0"));
        String env = WebUtils.optional(request, "env", StringUtils.EMPTY);
        boolean isCheck = Boolean.parseBoolean(WebUtils.optional(request, "isCheck", "false"));
        
        String app = WebUtils.optional(request, "app", StringUtils.EMPTY);
        
        String tenant = WebUtils.optional(request, "tid", StringUtils.EMPTY);
        
        boolean healthyOnly = Boolean.parseBoolean(WebUtils.optional(request, "healthyOnly", "false"));
        
        return doSrvIpxt(namespaceId, serviceName, agent, clusters, clientIP, udpPort, env, isCheck, app, tenant,
                healthyOnly);
    }

核心逻辑 ：

  • 根据namespaceId，serviceName获取service实例
  • 从service事例中基于srvIps得到 所有 服务提供者 信息。
  • 遍历组装JSON字符串 返回
    public ObjectNode doSrvIpxt(String namespaceId, String serviceName, String agent, String clusters, String clientIP,
            int udpPort, String env, boolean isCheck, String app, String tid, boolean healthyOnly) throws Exception {
        
        ClientInfo clientInfo = new ClientInfo(agent);
        ObjectNode result = JacksonUtils.createEmptyJsonNode();
        Service service = serviceManager.getService(namespaceId, serviceName);
        
        if (service == null) {
            if (Loggers.SRV_LOG.isDebugEnabled()) {
                Loggers.SRV_LOG.debug("no instance to serve for service: {}", serviceName);
            }
            result.put("name", serviceName);
            result.put("clusters", clusters);
            result.replace("hosts", JacksonUtils.createEmptyArrayNode());
            return result;
        }
        
        checkIfDisabled(service);
        
        long cacheMillis = switchDomain.getDefaultCacheMillis();
        
        // now try to enable the push
        try {
            if (udpPort > 0 && pushService.canEnablePush(agent)) {
                
                pushService
                        .addClient(namespaceId, serviceName, clusters, agent, new InetSocketAddress(clientIP, udpPort),
                                pushDataSource, tid, app);
                cacheMillis = switchDomain.getPushCacheMillis(serviceName);
            }
        } catch (Exception e) {
            Loggers.SRV_LOG
                    .error("[NACOS-API] failed to added push client {}, {}:{}", clientInfo, clientIP, udpPort, e);
            cacheMillis = switchDomain.getDefaultCacheMillis();
        }
        
        List<Instance> srvedIPs;
        
        srvedIPs = service.srvIPs(Arrays.asList(StringUtils.split(clusters, ",")));
        
        // filter ips using selector:
        if (service.getSelector() != null && StringUtils.isNotBlank(clientIP)) {
            srvedIPs = service.getSelector().select(clientIP, srvedIPs);
        }
        
        if (CollectionUtils.isEmpty(srvedIPs)) {
            
            if (Loggers.SRV_LOG.isDebugEnabled()) {
                Loggers.SRV_LOG.debug("no instance to serve for service: {}", serviceName);
            }
            
            if (clientInfo.type == ClientInfo.ClientType.JAVA
                    && clientInfo.version.compareTo(VersionUtil.parseVersion("1.0.0")) >= 0) {
                result.put("dom", serviceName);
            } else {
                result.put("dom", NamingUtils.getServiceName(serviceName));
            }
            
            result.put("hosts", JacksonUtils.createEmptyArrayNode());
            result.put("name", serviceName);
            result.put("cacheMillis", cacheMillis);
            result.put("lastRefTime", System.currentTimeMillis());
            result.put("checksum", service.getChecksum());
            result.put("useSpecifiedURL", false);
            result.put("clusters", clusters);
            result.put("env", env);
            result.put("metadata", JacksonUtils.transferToJsonNode(service.getMetadata()));
            return result;
        }
        
        Map<Boolean, List<Instance>> ipMap = new HashMap<>(2);
        ipMap.put(Boolean.TRUE, new ArrayList<>());
        ipMap.put(Boolean.FALSE, new ArrayList<>());
        
        for (Instance ip : srvedIPs) {
            ipMap.get(ip.isHealthy()).add(ip);
        }
        
        if (isCheck) {
            result.put("reachProtectThreshold", false);
        }
        
        double threshold = service.getProtectThreshold();
        
        if ((float) ipMap.get(Boolean.TRUE).size() / srvedIPs.size() <= threshold) {
            
            Loggers.SRV_LOG.warn("protect threshold reached, return all ips, service: {}", serviceName);
            if (isCheck) {
                result.put("reachProtectThreshold", true);
            }
            
            ipMap.get(Boolean.TRUE).addAll(ipMap.get(Boolean.FALSE));
            ipMap.get(Boolean.FALSE).clear();
        }
        
        if (isCheck) {
            result.put("protectThreshold", service.getProtectThreshold());
            result.put("reachLocalSiteCallThreshold", false);
            
            return JacksonUtils.createEmptyJsonNode();
        }
        
        ArrayNode hosts = JacksonUtils.createEmptyArrayNode();
        
        for (Map.Entry<Boolean, List<Instance>> entry : ipMap.entrySet()) {
            List<Instance> ips = entry.getValue();
            
            if (healthyOnly && !entry.getKey()) {
                continue;
            }
            
            for (Instance instance : ips) {
                
                // remove disabled instance:
                if (!instance.isEnabled()) {
                    continue;
                }
                
                ObjectNode ipObj = JacksonUtils.createEmptyJsonNode();
                
                ipObj.put("ip", instance.getIp());
                ipObj.put("port", instance.getPort());
                // deprecated since nacos 1.0.0:
                ipObj.put("valid", entry.getKey());
                ipObj.put("healthy", entry.getKey());
                ipObj.put("marked", instance.isMarked());
                ipObj.put("instanceId", instance.getInstanceId());
                ipObj.put("metadata", JacksonUtils.transferToJsonNode(instance.getMetadata()));
                ipObj.put("enabled", instance.isEnabled());
                ipObj.put("weight", instance.getWeight());
                ipObj.put("clusterName", instance.getClusterName());
                if (clientInfo.type == ClientInfo.ClientType.JAVA
                        && clientInfo.version.compareTo(VersionUtil.parseVersion("1.0.0")) >= 0) {
                    ipObj.put("serviceName", instance.getServiceName());
                } else {
                    ipObj.put("serviceName", NamingUtils.getServiceName(instance.getServiceName()));
                }
                
                ipObj.put("ephemeral", instance.isEphemeral());
                hosts.add(ipObj);
                
            }
        }
        
        result.replace("hosts", hosts);
        if (clientInfo.type == ClientInfo.ClientType.JAVA
                && clientInfo.version.compareTo(VersionUtil.parseVersion("1.0.0")) >= 0) {
            result.put("dom", serviceName);
        } else {
            result.put("dom", NamingUtils.getServiceName(serviceName));
        }
        result.put("name", serviceName);
        result.put("cacheMillis", cacheMillis);
        result.put("lastRefTime", System.currentTimeMillis());
        result.put("checksum", service.getChecksum());
        result.put("useSpecifiedURL", false);
        result.put("clusters", clusters);
        result.put("env", env);
        result.replace("metadata", JacksonUtils.transferToJsonNode(service.getMetadata()));
        return result;
    }
}

 

 3.服务地址动态感知原理

NamingService.java  中的 subscribe方法

核心代码：

@Override
    public void subscribe(String serviceName, EventListener listener) throws NacosException {
        subscribe(serviceName, new ArrayList<String>(), listener);
    }
    
    @Override
    public void subscribe(String serviceName, String groupName, EventListener listener) throws NacosException {
        subscribe(serviceName, groupName, new ArrayList<String>(), listener);
    }
    
    @Override
    public void subscribe(String serviceName, List<String> clusters, EventListener listener) throws NacosException {
        subscribe(serviceName, Constants.DEFAULT_GROUP, clusters, listener);
    }
    
    @Override
    public void subscribe(String serviceName, String groupName, List<String> clusters, EventListener listener)
            throws NacosException {
        eventDispatcher.addListener(hostReactor
                        .getServiceInfo(NamingUtils.getGroupedName(serviceName, groupName), StringUtils.join(clusters, ",")),
                StringUtils.join(clusters, ","), listener);
    }

这里有一个HostReactor类  ，它的功能是实现服务的 动态 更新，基本原理是：

  • 客户端 发起事件的订阅 后，在HostReactor中有一个 UpdateTask线程 ，每1秒法发送一次请求，获得服务端最新的地址列表。

  • 对于服务端，它和服务提供者的实例之间维持了心跳检测，一旦 服务提供者出现 异常，则会发送一个Push消息给Nacos客户端，也就是服务消费者。
  • 服务消费者收到请求后 ，使用HostReactor中提供的processServiceJSON解析消息，并更新本地服务地址列表

 

 

 

 

 

 

星月的雨
关注
专栏目录
Nacos 1.4.1注册中心源码深度解析-服务发现
MaoTongBin的专栏
03-11 277
服务发现 在scheduleUpdateIfAbsent方法中，添加了一个UpdateTask的定时任务。这里的核心还是调用上面的updateService方法，从服务端获取最新的列表更新到缓存。在getServiceInfo的底部，有一个定时任务的方法，会定时从服务端拉取最新的服务列表，更新到缓存。首次进入可能是获取不到的，所以这里就会调用updateServiceNow方法进行更新服务列表。客户端的实现比较简单，我们在来看下服务端。这里就是服务注册的时候注册的实例列表了。OK，服务端的服务发现更简单，
Nacos源码之服务注册源码解析
从入门到脱发
11-27 1982
文章目录前言主要类图客户端逻辑服务端逻辑 前言 本篇就开始探索Nacos的服务注册逻辑，建议大家准备两个项目，一个是Nacos的源码项目，一个是整合Nacos注册中心的业务项目。探索过程也是分为客户端和服务端的代码解析，我觉得这样应该更利于代码跟进和理解，篇幅过长，还请耐心观看。 主要类图 客户端逻辑 首先来看客户端，也就是我们的项目在启动时，Nacos依赖偷偷干了哪些见不得人的事情。打开项目依赖，找到引入的注册中心依赖，我们知道SpringBoot项目启动时会读取spring.factories文件进行
nacos源码解析——服务注册
ZXMSH的博客
06-12 1326
我们下载下来的的源码中，在他提供的测试类中有一个叫做，其中有服务注册的，我们就从这个例子来剖析服务注册的流程。 1.2 、NacosNamingService构造方法 1.2.1 、NacosNamingService#init 1.3 NacosNamingService#registerInstance 1.3.1、NamingClientProxyDelegate#registerService 1.3.2、NamingHttpClientProxy#registerService
【Nacos源码篇二】Nacos客户端自动注册源码实现-发起自动注册请求
最新发布
qq_38226564的博客
08-16 1730
Nacos客户端springboot项目启动的时候发生了什么，你知道吗？你想要知道吗？作为一个程序员你好奇它是怎么完成自动注册的吗？那么请花费5~10分钟，你就可以揭开它的神秘面纱，一睹他的面容，来吧...
【Nacos】源码之服务端服务注册
morris
12-05 1万+
Nacos客户端在启动时以及定时任务会发送Http请求，调用Nacos服务端接口/nacos/v1/ns/instance进行服务注册。我们根据url找到Nacos服务端服务注册的源码入口： InstanceController#register 将请求封装为Instance，注意serviceName使用@@分隔组名和服务名，如DEFAULT_GROUP@@user，存入注册表中的serviceName也是包含组名的。com.alibaba.nacos.naming.controllers.Instanc
深度解析nacos源码之注册中心（服务发现上篇）
猿上生活
12-18 1320
原创不易，转载请注明出处 本文基于nacos1.4.0 深度解析nacos源码系列文章目录 《深度解析nacos源码之注册中心（服务注册）》 《深度解析nacos源码之注册中心（服务注册流程图补充）》 《深度解析nacos源码之注册中心（服务主动下线）》 《深度解析nacos源码之注册中心（服务续约与故障下线）》 文章目录深度解析nacos源码系列文章目录前言1. 客户端服务订阅源码分析2. 服务端处理服务订阅源码分析总结 前言 1. 客户端服务订阅源码分析 2. 服务端处理服务订阅源码分析 总结.
Nacos客户端实例注册源码分析
qq_41683000的博客
01-02 297
Nacos客户端实例注册源码分析
nacos 源码解析
11-17
nacos 源码解析，解读和理解nacos 源码解析，可大大提升对分布式应用及微服务理解的能力。 Nacos 支持基于 DNS 和基于 RPC 的服务发现（可以作为springcloud的注册中心）、动态配置服务（可以做配置中心）、动态 ...
Nacos源码流程——服务注册与发现.png
04-02
Nacos服务注册与发现源码流程图， 通过流程图展示了服务注册到Nacos服务注册中心的整个源码过程，同时对Nacos代码中一些优秀的思想进行总结
【微服务】Nacos服务发现源码分析_nacos 服务发现源码
2401_84182073的博客
04-30 867
这篇文章就介绍下，服务发现的入口是什么？本地缓存数据结构、缓存时机、如果缓存中没有如何处理？使用了定时任务，那定时任务的底层基于什么的、它是干什么的、定时间隔？监听服务端UDP通知、发送ACK？发送http请求到服务端，谁发的、如何接收？服务端如何推送服务实例的、采用什么方式？带着这些问题，下面我们来探究探究。注意：Nacos源码版本为1.x。
nacos源码阅读--服务注册
热门推荐
旭旭1998的博客
02-07 6万+
一、springboot启动日志报NacosServiceRegistry springboot+nacos启动时，log会有一条nacos注册信息如下： **很显然，启动注册服务的操作便在NacosServiceRegistry当中。 NacosServiceRegistry可以通过查找所有类直接寻找，也可以从以下springboot自动装配的角度去寻找 通过查看spring.factories文件也可以看到，nacos自动装配的类如下，nacos按照了springboot的约定进行了自动装配：**
nacos注册发现中心和配置管理中心快速入门代码示例
qq_44871403的博客
06-20 120
nacos快速入门demo
Nacos安装和服务注册
Leon_Jinhai_Sun的博客
08-09 191
Nacos下载和安装 （1）下载地址和版本 下载地址：https://github.com/alibaba/nacos/releases 下载版本：nacos-server-1.1.4.tar.gz或nacos-server-1.1.4.zip，解压任意目录即可 （2）启动nacos服务 - Linux/Unix/Mac 启动命令(standalone代表着单机模式运行，非集群模式) 启动命令：sh startup.sh -m standalone - Windows 启动命令：cm.
SpringCloud----Nacos服务注册实践
weixin_58668484的博客
10-15 367
转载的nacos实践
Nacos 注册中心 - 服务注册源码
深度
03-12 1072
订阅服务的意思是：订阅服务的变更，如果数据变更了，NacosServer 端会推送事件过来，这样 Client 的数据就会是最新的了。好了，这里已经完成了可靠性的保证，定时任务 RedoScheduledTask 会定时扫描 缓存 map 里的数据并做处理。在微服务架构中，服务之间的调用非常频繁，而且调用链路很长，因此需要对服务之间的调用进行跟踪和监控，以便及时发现和解决问题。这里也就是说，RPC 请求发送完成后，将缓存中的数据做了一个改动，意思就是代表 缓存的这条数据 是正常的（不需要重试了）
Nacos注册中心11-Server端（处理服务发现请求）
BASK2311的博客
11-09 859
总结一下，其实不订阅的服务发现非常简单，就是客户端发起请求直接去服务端拉取订阅的服务实例列表就可以了，如果是订阅的话，客户端先去服务端拉取订阅服务列表，并且客户端带上自己本地的udp端口给服务端，服务端会根据udp与客户端版本判断能不能订阅，能的话服务端根据订阅信息生成一个PushClient放到一个clientMap中，到时候服务实例信息改变的时候，就会从这个clientMap 取到这个PushClient信息，然后进行推送。
nacos 服务发现获取列表源码分析
nandao158的博客
01-30 2759
nacos 服务发现获取列表源码分析
微服务版 ruoyi 整合jimureport 问题记录
山巅
04-29 2996
maven 命令增加-e -X cd ${workspace}/${service} && mvn -gs ${workspace}/configuration/settings.xml -DskipTests=true clean package -Ptest jib:build -Djib.httpTimeout=200000 -DsendCredentialsOverHttp=true -f pom.xml -e -X" 查看日志，发现如下信息 [WARNING] The POM
Nacos注册中心源码解析-服务端
qq_38038507的博客
11-09 236
与instance有关的请求都是这个来处理。该类为一个服务实例处理器API，用于处理的心跳、注册、下线等请求。
nacos服务注册发现源码分析
09-13
nacos服务注册与发现的源码可以分为两个部分：注册中心（服务注册）和服务发现。在注册中心方面，nacos提供了以下几篇深度解析的文章，分别介绍了服务注册的整个流程，包括服务注册、服务主动下线、服务续约与故障下线等内容。这些文章详细解析了nacos注册中心的源码实现。 在服务发现方面，nacos支持两种方式：直接拉取服务实例列表和订阅服务实例列表。直接拉取方式通过创建NamingService对象，并设置相应的属性来实现。例如，通过设置serverAddr和namespace属性，可以创建一个NamingService对象，然后使用该对象进行服务注册、获取实例列表等操作。另外一种方式是通过订阅服务实例列表的变化来获取最新的实例列表。这部分的源码实现涉及到两个定时任务：一个是定时从服务端查询可用服务实例的任务，另一个是定时从已变服务队列中取出服务并通知EventListener持有者的任务。 综上所述，nacos服务注册与发现的源码涉及到注册中心和服务发现两个方面。在注册中心方面，可以参考深度解析的文章来了解具体的实现细节。在服务发现方面，可以通过直接拉取方式或订阅方式来获取服务实例列表，并根据具体需求选择合适的方式进行实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值