Nacos源码-客户端服务注册

最新推荐文章于 2023-06-29 17:22:39 发布
最新推荐文章于 2023-06-29 17:22:39 发布
阅读量154 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yx_yancy1992/article/details/131185609
版权

Nacos源码-客户端服务注册

  1. 通过Nacos工厂创建NamingService,比如NacosNamingService实例；
  2. NacosNamingService 执行init 方法初始化；
  3. 执行registerInstance判断(Ephemeral)是否为临时节点；
  4. Ephemeral = true 临时节点 注册心跳，默认间隔5s向nacos服务端发送心跳数据包；
  5. serverProxy向nacos服务端发送注册服务请求；

首先让我们看一下来自官网的简单注册代码：
在这里插入图片描述

public class NacosFactory {
    
    public static NamingService createNamingService(String serverAddr) throws NacosException {
        return NamingFactory.createNamingService(serverAddr);
    }
    
    public static NamingService createNamingService(Properties properties) throws NacosException {
        return NamingFactory.createNamingService(properties);
    }
 
    public static NamingMaintainService createMaintainService(String serverAddr) throws NacosException {
        return NamingMaintainFactory.createMaintainService(serverAddr);
    }
    
    public static NamingMaintainService createMaintainService(Properties properties) throws NacosException {
        return NamingMaintainFactory.createMaintainService(properties);
    }
}


public class NamingFactory {
    
    public static NamingService createNamingService(String serverList) throws NacosException {
        try {
            Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.naming.NacosNamingService");
            Constructor constructor = driverImplClass.getConstructor(String.class);
            NamingService vendorImpl = (NamingService) constructor.newInstance(serverList);
            return vendorImpl;
        } catch (Throwable e) {
            throw new NacosException(NacosException.CLIENT_INVALID_PARAM, e);
        }
    }
    
    public static NamingService createNamingService(Properties properties) throws NacosException {
        try {
            Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.naming.NacosNamingService");
            Constructor constructor = driverImplClass.getConstructor(Properties.class);
            NamingService vendorImpl = (NamingService) constructor.newInstance(properties);
            return vendorImpl;
        } catch (Throwable e) {
            throw new NacosException(NacosException.CLIENT_INVALID_PARAM, e);
        }
    }
}

NamingService 实现类NacosNamingService 代码逻辑

public class NacosNamingService implements NamingService {
    
    /**
     * Each Naming service should have different namespace.
     */
    private String namespace;
    
    private String endpoint;
    
    private String serverList;
    
    private String cacheDir;
    
    private String logName;
    
    private HostReactor hostReactor;
    
    private BeatReactor beatReactor;
    
    private NamingProxy serverProxy;
    
    public NacosNamingService(String serverList) throws NacosException {
        Properties properties = new Properties();
        properties.setProperty(PropertyKeyConst.SERVER_ADDR, serverList);
        init(properties);
    }
    
    public NacosNamingService(Properties properties) throws NacosException {
        init(properties);
    }
    
    private void init(Properties properties) throws NacosException {
        ValidatorUtils.checkInitParam(properties);
        this.namespace = InitUtils.initNamespaceForNaming(properties);
        InitUtils.initSerialization();
        initServerAddr(properties);
        InitUtils.initWebRootContext(properties);
        
        initCacheDir();
     
        initLogName(properties);
        
        this.serverProxy = new NamingProxy(this.namespace, this.endpoint, this.serverList, properties);
        this.beatReactor = new BeatReactor(this.serverProxy, initClientBeatThreadCount(properties));
        this.hostReactor = new HostReactor(this.serverProxy, beatReactor, this.cacheDir, isLoadCacheAtStart(properties),
                isPushEmptyProtect(properties), initPollingThreadCount(properties));
    }
    
    @Override
    public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
        NamingUtils.checkInstanceIsLegal(instance);
        String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
        //如果是临时节点 ap 模式，添加beat
        if (instance.isEphemeral()) {
            BeatInfo beatInfo = beatReactor.buildBeatInfo(groupedServiceName, instance);
            beatReactor.addBeatInfo(groupedServiceName, beatInfo);
        }
        //注册服务
        serverProxy.registerService(groupedServiceName, groupName, instance);
    }
    
}

BeatReactor 主要用于向nacos服务端发送心跳数据包

public class BeatReactor implements Closeable {
    
    private final ScheduledExecutorService executorService;
    
    private final NamingProxy serverProxy;
    
    private boolean lightBeatEnabled = false;
    
    public final Map<String, BeatInfo> dom2Beat = new ConcurrentHashMap<String, BeatInfo>();
    
    public BeatReactor(NamingProxy serverProxy) {
        this(serverProxy, UtilAndComs.DEFAULT_CLIENT_BEAT_THREAD_COUNT);
    }
  
    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);
        //添加执行任务
        executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
        //指标监控统计
        MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
    }
    
    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);
        //默认值为5s
        beatInfo.setPeriod(instance.getInstanceHeartBeatInterval());
        return beatInfo;
    }
    
   /**
   * 间隔5s 向服务端发送心跳包
    */  
    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();
                }
                //如果code为RESOURCE_NOT_FOUND 发起注册服务逻辑
                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);
        }
    }
}

NamingProxy将请求发送到服务端注册服务实例


public class NamingProxy implements Closeable {

public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
        
        NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance: {}", namespaceId, serviceName,
                instance);
        
        final Map<String, String> params = new HashMap<String, String>(16);
        params.put(CommonParams.NAMESPACE_ID, namespaceId);
        params.put(CommonParams.SERVICE_NAME, serviceName);
        params.put(CommonParams.GROUP_NAME, groupName);
        params.put(CommonParams.CLUSTER_NAME, instance.getClusterName());
        params.put("ip", instance.getIp());
        params.put("port", String.valueOf(instance.getPort()));
        params.put("weight", String.valueOf(instance.getWeight()));
        params.put("enable", String.valueOf(instance.isEnabled()));
        params.put("healthy", String.valueOf(instance.isHealthy()));
        params.put("ephemeral", String.valueOf(instance.isEphemeral()));
        params.put("metadata", JacksonUtils.toJson(instance.getMetadata()));
        
        reqApi(UtilAndComs.nacosUrlInstance, params, HttpMethod.POST);
        
    }

 public String reqApi(String api, Map<String, String> params, Map<String, String> body, List<String> servers,
            String method) throws NacosException {
        
        params.put(CommonParams.NAMESPACE_ID, getNamespaceId());
        
        if (CollectionUtils.isEmpty(servers) && StringUtils.isBlank(nacosDomain)) {
            throw new NacosException(NacosException.INVALID_PARAM, "no server available");
        }
        
        NacosException exception = new 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();
            }
        }
        
        NAMING_LOGGER.error("request: {} failed, servers: {}, code: {}, msg: {}", api, servers, exception.getErrCode(),
                exception.getErrMsg());
        
        throw new NacosException(exception.getErrCode(),
                "failed to req API:" + api + " after all servers(" + servers + ") tried: " + exception.getMessage());
        
    }

public String callServer(String api, Map<String, String> params, Map<String, String> body, String curServer,
            String method) throws NacosException {
        long start = System.currentTimeMillis();
        long end = 0;
        injectSecurityInfo(params);
        Header header = builderHeader();
        
        String url;
        if (curServer.startsWith(UtilAndComs.HTTPS) || curServer.startsWith(UtilAndComs.HTTP)) {
            url = curServer + api;
        } else {
            if (!IPUtil.containsPort(curServer)) {
                curServer = curServer + IPUtil.IP_PORT_SPLITER + serverPort;
            }
            url = NamingHttpClientManager.getInstance().getPrefix() + curServer + api;
        }
        
        try {
        // 发送请求
            HttpRestResult<String> restResult = nacosRestTemplate
                    .exchangeForm(url, header, Query.newInstance().initParams(params), body, method, String.class);
            end = System.currentTimeMillis();
            
            MetricsMonitor.getNamingRequestMonitor(method, url, String.valueOf(restResult.getCode()))
                    .observe(end - start);
            
            if (restResult.ok()) {
                return restResult.getData();
            }
            if (HttpStatus.SC_NOT_MODIFIED == restResult.getCode()) {
                return StringUtils.EMPTY;
            }
            throw new NacosException(restResult.getCode(), restResult.getMessage());
        } catch (Exception e) {
            NAMING_LOGGER.error("[NA] failed to request", e);
            throw new NacosException(NacosException.SERVER_ERROR, e);
        }
    }
    }

提示：nacos 服务端会开启客户端心跳检索，默认5秒执行一次，判断服务最后心跳更新时间，如果大于15s默认值 就将服务健康状态设置为instance.setHealthy(false)，如果最后心跳时间大于30s默认值，则将服务剔除deleteIp(instance)；

yx_yancy1992
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
最新nacos-server-2.2.0下载
12-29
1. **服务注册与发现**：Nacos作为一个服务注册中心，允许微服务实例向中心注册，其他服务可以通过Nacos发现并调用这些服务，实现了服务间的动态路由。 2. **配置管理**：Nacos提供集中式配置管理，服务实例可以从...
Nacos的服务注册之客户端
qq_40708942的博客
12-10 1671
服务注册到Nacos以后,会保存在一个本地注册表中,这个注册表是一个map.key是namespace,用来隔离环境value又是一个mapkey是groupvalue又是一个serviceservice中又维护了一个mapkey是服务的某个集群的名称value是Cluster类型Cluster内部又维护了一个set< Instance >集合,该集合就是集群下的实例的集合Instance:包含石榴的IP、Port、健康状态、权重等信息。
Nacos 注册中心 - 服务注册源码
深度
03-12 917
订阅服务的意思是：订阅服务的变更，如果数据变更了，NacosServer 端会推送事件过来，这样 Client 的数据就会是最新的了。好了，这里已经完成了可靠性的保证，定时任务 RedoScheduledTask 会定时扫描 缓存 map 里的数据并做处理。在微服务架构中，服务之间的调用非常频繁，而且调用链路很长，因此需要对服务之间的调用进行跟踪和监控，以便及时发现和解决问题。这里也就是说，RPC 请求发送完成后，将缓存中的数据做了一个改动，意思就是代表 缓存的这条数据 是正常的（不需要重试了）
nacos源码服务注册
Jelly
04-10 935
这次版本是一次重大升级优化，由原来（临时服务）服务注册tcp改成grpc方式，减少资源消耗，服务推送由udp也改为grpc。springboot自动装载，是不是引入nacos依赖，就可以实现服务注册功能。这时，你需要clean 再install 最后reimport，就不会问题。首先让我去实现一个服务注册，我们如何去做？按照上面的思路去分析注册大概过程就很清晰了。启动时nacos没有以单例模式启动也会报错。本文章是分析的是nacos版本2.2。是不是项目启动的时候进行服务注册。idea 运行源码找不到类。
Nacos 客户端源码分析——服务注册
weixin_45270863的博客
05-29 858
【代码】Nacos 客户端源码分析——服务注册。
【云原生】Nacos源码以及客户端服务注册源码分析
欢迎来到三十七度的博客
10-24 2317
Nacos服务注册流程总结注册步骤小结：读取Spring Boot装载配置文件，找到启动类；继承，它实现接口；实现ApplicationListener接口的方法，该方法调用bind()，然后调用start()方法；start()方法中调用register()，该方法调用的register方法；NacosServiceRegistry的register方法内部调用的方法；根据实例的瞬时状态选择不同的proxy执行注册，默认是gRPC协议的执行注册；完成实例注册（POST请求）。
nacos-2.1.0源码包
06-21
- **服务注册与发现**：如何优雅地将服务注册到Nacos，以及消费者如何从Nacos获取服务实例。 - **配置管理**：如何实现动态配置，如何配置数据源，以及如何处理配置变更的监听和推送。 - **故障转移与恢复**：在...
Nacos源码nacos-1.4.1.zip
05-26
2. **服务注册与发现**：服务提供者启动时向Nacos注册，Nacos通过心跳机制监控服务状态。服务消费者通过Nacos查询服务列表并实现负载均衡。 3. **配置变更推送**：Nacos如何实现配置变更的实时推送，以及客户端如何...
nacos-2.0.3 Source code
12-19
- 源码中涉及的服务发现模块主要位于`server-cluster`子模块，包括服务注册、心跳检测、健康检查等机制。 2. **配置管理**： - Nacos提供集中式的动态配置管理，允许开发者在不重启应用的情况下更新配置，提高...
nacos-2.2.3资源下载
最新发布
07-10
Nacos作为服务注册与发现的平台，允许微服务实例在启动时向Nacos注册，其他服务通过Nacos查询服务实例，实现服务间的相互发现。这种模式简化了服务间的通信，并提高了系统的可扩展性。 2. **动态配置**： 在Nacos...
Nacos配置中心源码浅析
Java_dragon95的博客
05-24 590
nacos配置中心源码浅析
Nacos临时实例和永久实例的区别以及健康检查机制
xzh_blog
07-08 7393
临时实例只是临时存在于注册中心中，会在服务下线或不可用时被注册中心剔除，临时实例会与注册中心保持心跳，注册中心会在⼀段时间没有收到来自客户端的心跳后会将实例设置为不健康，然后在⼀段时间后进行剔除。 永久实例在被删除之前会永久的存在于注册中心，且有可能并不知道注册中心存在，不会主动向注册中心上报心跳，那么这个时候就需要注册中心主动进行探活。...
Nacos 注册流程分析（二）
pangxiaoliang14的博客
11-19 765
nacos服务端注册流程分析
python-注册nacos服务
AP1005834的博客
06-29 2438
Nacos（Naming and Configuration Service）是一个用于实现服务注册和发现的开源项目。Nacos注册服务的主要作用是帮助微服务架构中的各个服务实例进行注册和发现，以便于服务之间的通信和协作，另外，也可以在nacos上简历一些配置，服务可以获取配置，便于配置的修改管理。本篇主要是python 登陆nacos平台，对grpc服务（也可以是http服务）注册的示例。
nacos源码解析——服务注册
ZXMSH的博客
06-12 1264
我们下载下来的的源码中，在他提供的测试类中有一个叫做，其中有服务注册的，我们就从这个例子来剖析服务注册的流程。 1.2 、NacosNamingService构造方法 1.2.1 、NacosNamingService#init 1.3 NacosNamingService#registerInstance 1.3.1、NamingClientProxyDelegate#registerService 1.3.2、NamingHttpClientProxy#registerService
【源码系列】Nacos服务注册原理源码
苏雨丶
04-06 787
Nacos服务注册原理源码客户端服务注册测试单元Nacos自动装配服务注册服务端服务注册集群同步 Nacos服务注册原理源码 客户端 服务注册测试单元 我们先看一下Nacos客户端给出的服务注册的测试单元代码 测试单元中主要做的事情： 构建服务Instance对象 通过工厂创建NamingService对象 Instance向NamingService（注册中心）注册 通过serviceName向注册中心（NamingService）获取实例列表信息 测试单元中我们知道客户端根据服务的ip、
Nacos服务注册与发现中心之服务注册(服务端代码)
zmjmvp的专栏
07-02 468
从上篇文章我们可以知道使用SpringCloud集成的Nacos，客户端是通过发送HTTP请求的方式进行服务注册的，那么服务端的代码入口就是一个HTTP的请求地址了，从客户端代码可以得出请求的URI为：，方法为。我们研读的源码的Nacos分支为，Nacos2.0开始发生了比较大的重构，但是我们目前使用较多的版本依然为Nacos1的版本及其分支。我们先来看到URI: 的处理类及其对应的方法 从此处可以看到，主要的逻辑为：从请求参数中获取服务名称和服务所在的命名空间的ID的值，然后通过方法创建一个Instant
nacos客户端注册至服务端时，设置服务详情中的元数据。
yuan6068132的博客
06-04 9881
import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.autoconfigure.AutoConfigureBefore; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure...
Nacos服务注册源码
Jak的博客
11-15 804
todo
Nacos源码执行流程
05-22
6. 客户端 SDK 模块：提供客户端 SDK，方便开发者在应用中使用 Nacos 的服务发现和配置管理功能。 7. 监控和报警模块：对 Nacos 运行状态进行监控和报警，保证 Nacos 服务的稳定性和可靠性。 总的来说，Nacos 的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值