SpringCloud Nacos服务注册和心跳发送(源码)

最新推荐文章于 2023-06-17 09:35:06 发布
最新推荐文章于 2023-06-17 09:35:06 发布
阅读量499 收藏
点赞数
分类专栏： nacos 文章标签： spring cloud java nacos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guandongsheng110/article/details/121165704
版权

Nacos入口

jar包目录下META-INF目录下spring.factories文件中

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.alibaba.cloud.nacos.discovery.NacosDiscoveryAutoConfiguration,\
  com.alibaba.cloud.nacos.ribbon.RibbonNacosAutoConfiguration,\
  com.alibaba.cloud.nacos.endpoint.NacosDiscoveryEndpointAutoConfiguration,\
  com.alibaba.cloud.nacos.registry.NacosServiceRegistryAutoConfiguration,\
  com.alibaba.cloud.nacos.discovery.NacosDiscoveryClientConfiguration,\
  com.alibaba.cloud.nacos.discovery.reactive.NacosReactiveDiscoveryClientConfiguration,\
  com.alibaba.cloud.nacos.discovery.configclient.NacosConfigServerAutoConfiguration
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
  com.alibaba.cloud.nacos.discovery.configclient.NacosDiscoveryClientConfigServiceBootstrapConfiguration

NacosServiceRegistryAutoConfiguration

自动装配com.alibaba.cloud.nacos.registry.NacosServiceRegistryAutoConfiguration

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
// 默认注解开启服务发现 @ConditionalOnProperty(value = "spring.cloud.nacos.discovery.enabled", matchIfMissing = true)
@ConditionalOnNacosDiscoveryEnabled
@ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true)
// 在各个类加载后加载当前类
@AutoConfigureAfter({ AutoServiceRegistrationConfiguration.class,
		AutoServiceRegistrationAutoConfiguration.class,
		NacosDiscoveryAutoConfiguration.class })
public class NacosServiceRegistryAutoConfiguration {

	...

	@Bean
	@ConditionalOnBean(AutoServiceRegistrationProperties.class)
	public NacosAutoServiceRegistration nacosAutoServiceRegistration(
			NacosServiceRegistry registry,
			AutoServiceRegistrationProperties autoServiceRegistrationProperties,
			NacosRegistration registration) {
		return new NacosAutoServiceRegistration(registry,
				autoServiceRegistrationProperties, registration);
	}

}

NacosAutoServiceRegistration

继承了抽象类 AbstractAutoServiceRegistration, 而抽象类又实现了ApplicationListener接口, 当spring refresh完成时会调用对应的onApplicationEvent方法, 开始注册
在这里插入图片描述

@Override
@SuppressWarnings("deprecation")
public void onApplicationEvent(WebServerInitializedEvent event) {
	// 服务注册入口
	bind(event);
}

@Deprecated
public void bind(WebServerInitializedEvent event) {
	...
	// 开始注册
	this.start();
}

public void start() {
	...

	if (!this.running.get()) {
		// 注册之前事件发布
		this.context.publishEvent(
				new InstancePreRegisteredEvent(this, getRegistration()));
		// 注册
		register();
		if (shouldRegisterManagement()) {
			registerManagement();
		}
		// 注册之后事件发布
		this.context.publishEvent(
				new InstanceRegisteredEvent<>(this, getConfiguration()));
		// 标记状态
		this.running.compareAndSet(false, true);
	}

}

protected void register() {
	this.serviceRegistry.register(getRegistration());
}

NacosServiceRegistry

调用NacosServiceRegistry的register方法开始执行注册, 实现了服务注册的接口, 包含服务注册/下线/关闭/状态变更及获取等方法

@Override
public void register(Registration registration) {
	...

	// 设置一系列参数
	String serviceId = registration.getServiceId();
	String group = nacosDiscoveryProperties.getGroup();
	// ephemeral 默认为true 下一个方法会校验
	Instance instance = getNacosInstanceFromRegistration(registration);
	namingService.registerInstance(serviceId, group, instance);
	...
}

NacosNamingService
先注册心跳定时任务, 默认5s后执行, 紧接着去注册服务. 虽然程序上是先发心跳再注册, 实际是先注册再发送心跳.

@Override
public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
	// 判断服务是否为临时 默认为true
    if (instance.isEphemeral()) {
    	// 包含心跳定时为5s
        BeatInfo beatInfo = new BeatInfo();
        beatInfo.setServiceName(NamingUtils.getGroupedName(serviceName, groupName));
        beatInfo.setIp(instance.getIp());
        beatInfo.setPort(instance.getPort());
        beatInfo.setCluster(instance.getClusterName());
        beatInfo.setWeight(instance.getWeight());
        beatInfo.setMetadata(instance.getMetadata());
        beatInfo.setScheduled(false);
        beatInfo.setPeriod(instance.getInstanceHeartBeatInterval());
        // 发起心跳
        beatReactor.addBeatInfo(NamingUtils.getGroupedName(serviceName, groupName), beatInfo);
    }
    // 注册服务
    serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);
}

BeatReactor 发送心跳

使用一个带定时的执行器来定时发送心跳, 循环发送并创建定时任务

public void addBeatInfo(String serviceName, BeatInfo beatInfo) {
    ...
    // 添加一个定时任务 默认间隔是5s
    executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
    ...
}

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 {
        	// 发送心跳
            JSONObject result = serverProxy.sendBeat(beatInfo, BeatReactor.this.lightBeatEnabled);
            // 根据结果做相应处理
            long interval = result.getIntValue("clientBeatInterval");
            boolean lightBeatEnabled = false;
            if (result.containsKey(CommonParams.LIGHT_BEAT_ENABLED)) {
                lightBeatEnabled = result.getBooleanValue(CommonParams.LIGHT_BEAT_ENABLED);
            }
            BeatReactor.this.lightBeatEnabled = lightBeatEnabled;
            if (interval > 0) {
                nextTime = interval;
            }
            int code = NamingResponseCode.OK;
            if (result.containsKey(CommonParams.CODE)) {
                code = result.getIntValue(CommonParams.CODE);
            }
            if (code == NamingResponseCode.RESOURCE_NOT_FOUND) {
            	// 如果返回状态码为20404 表示服务已经下线
                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 ne) {
            NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, code: {}, msg: {}",
                JSON.toJSONString(beatInfo), ne.getErrCode(), ne.getErrMsg());

        }
        // 注册下一个心跳任务, 循环发送
        executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);
    }
}

发送心跳

public JSONObject 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);
    String body = StringUtils.EMPTY;
    if (!lightBeatEnabled) {
        try {
            body = "beat=" + URLEncoder.encode(JSON.toJSONString(beatInfo), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new NacosException(NacosException.SERVER_ERROR, "encode beatInfo error", e);
        }
    }
    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()));
    // reqAPI 是通用方法 服务注册也是调用此方法 后面提供源码
    String result = reqAPI(UtilAndComs.NACOS_URL_BASE + "/instance/beat", params, body, HttpMethod.PUT);
    return JSON.parseObject(result);
}

服务注册

public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
	// 构造请求
    final Map<String, String> params = new HashMap<String, String>(9);
    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", JSON.toJSONString(instance.getMetadata()));
    // 发送请求
    reqAPI(UtilAndComs.NACOS_URL_INSTANCE, params, HttpMethod.POST);
}

发送请求

通用reqAPI方法, 提供http请求, 其中参数servers为nacos服务地址列表

public String reqAPI(String api, Map<String, String> params, String body, List<String> servers, String method) throws NacosException {
    params.put(CommonParams.NAMESPACE_ID, getNamespaceId());
    if (CollectionUtils.isEmpty(servers) && StringUtils.isEmpty(nacosDomain)) {
        throw new NacosException(NacosException.INVALID_PARAM, "no server available");
    }

    NacosException exception = new NacosException();
    if (servers != null && !servers.isEmpty()) {

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

public String callServer(String api, Map<String, String> params, String body, String curServer, String method)
    throws NacosException {
    // 计时
    long start = System.currentTimeMillis();
    long end = 0;
    // 安全方面 加密
    injectSecurityInfo(params);
    // 请求头
    List<String> headers = builderHeaders();

    // 拼装url 根据配置参数生成完成的url
    String url;
    if (curServer.startsWith(UtilAndComs.HTTPS) || curServer.startsWith(UtilAndComs.HTTP)) {
        url = curServer + api;
    } else {
        if (!curServer.contains(UtilAndComs.SERVER_ADDR_IP_SPLITER)) {
            curServer = curServer + UtilAndComs.SERVER_ADDR_IP_SPLITER + serverPort;
        }
        url = HttpClient.getPrefix() + curServer + api;
    }

    // 请求server
    HttpClient.HttpResult result = HttpClient.request(url, headers, params, body, UtilAndComs.ENCODING, method);
    end = System.currentTimeMillis();

    MetricsMonitor.getNamingRequestMonitor(method, url, String.valueOf(result.code))
        .observe(end - start);

    if (HttpURLConnection.HTTP_OK == result.code) {
        return result.content;
    }

    if (HttpURLConnection.HTTP_NOT_MODIFIED == result.code) {
        return StringUtils.EMPTY;
    }

    throw new NacosException(result.code, result.content);
}

至此, 服务已经完成注册, 并循环发起心跳

跟心爱的人浪迹天涯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【微服务】Day03（Nacos心跳机制、cart，stock项目业务、Dubbo概述）
shortcutsuccess的博客
10-01 661
RPC是Remote Procedure Call的缩写 翻译为:远程过程调用目标是为了实现两台(多台)计算机\服务器,相互调用方法\通信的解决方案RPC只是实现远程调用的一套标准该标准主要规定了两部分内容1.通信协议2.序列化协议为了方便大家理解RPC,下面的图片帮助理解[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-csOHcs00-1664554865779)(image-20220505143449423.png)]
springcloud-learning-master.zip
03-14
SpringCloud是中国Java开发者广泛...在实践中，你可以学习如何配置服务注册与发现、实现客户端负载均衡、使用Nacos进行服务管理和配置、利用Feign进行声明式服务调用等技术，从而在实际项目中有效地运用SpringCloud。
SpringCloudAlibaba 之 nacos 心跳功能源码分析
nandao158的博客
01-30 377
SpringCloudAlibaba 之 nacos 心跳功能源码分析
2021-12-03 DataNode注册与心跳
cn987654的博客
12-03 3334
本文基于hadoop-3.3.0 目录 1 概述 2 注册过程 2.1 注册前置过程 2.2 注册过程 2.3 心跳发送 1 概述 dn在完成启动（源码阅读）之后，需要向nn进行注册，才能提供后续的数据存储服务，注册完成后定时进行心跳检测，确保dn的存活。 而注册的流程是在DataNode的构造函数中的startDataNode方法中调用refreshNamenode方法完成： blockPoolManager.refreshNamenodes(getConf()); 2 注册过程
Spring Cloud Alibaba Nacos（心跳与选举）
文刀的博客天地
07-08 5057
本文继续带你阅读NACOS源代码，讨论NACOS的两个至关重要的的细节：心跳和选举机制。
springCloudAlibaba组件-Nacos-服务注册与心跳机制（二）
任亚兵
06-17 872
（微服务开启时自动会获取将所处的ip地址、端口号、服务名称，先开启心跳机制，并将这些信息注册到nacos的服务中服务列表中，通过服务中心来管理这些微服务）2)流程：服务启动后每隔5秒会向Nacos发送一个“心跳包”，这个心跳包中包含了当前服务的基本信息，Nacos接收到这个心跳包，首先检查当前服务在不在注册列表中，如果不在按新服务的业务·进行注册，如果在，表示当前这个服务是健康的。重要性较高的服务：如果服务对于业务运行的重要性较高，需要持久地注册和心跳发送，可以选择永久实例。注册后同时会发布服务变更事件。
nacos.rar源码
08-11
Nacos 是一个由 Alibaba 开发并维护的分布式服务治理平台，它主要关注服务发现、配置管理和元数据管理等核心功能。...对于想要深入学习分布式系统和服务治理的开发者来说，Nacos 源码无疑是一份宝贵的资料。
Springboot + Dubbo + Nacos 整合源码
最新发布
11-10
Nacos作为服务注册与发现的中心，可以替代传统的Zookeeper或Eureka，其特点是易用性好，功能强大，且与Alibaba Cloud其他产品有良好的集成。 整合SpringBoot、Dubbo和Nacos的过程主要包括以下几个步骤： 1. **添加...
cloud2020.zip--周阳老师源码
03-18
此外，Spring Cloud Alibaba的Nacos在该项目中可能作为配置中心和服务中心，提供服务的注册、发现以及动态配置等功能。Sentinel可能被用来实现服务的流量控制和降级策略，以保证系统的稳定性和可用性。 通过对...
nacos1.2.1.zip
05-09
作为一个新的coder，源码方面也是必不可少的一部分，最近在刚读完...个人很看好nacos，里边的一些源码精髓值得我们去学习，只做了服务注册，心跳日任务，健康检查的中午注释，后期会慢慢的更新饿的，这里是1.2.1版本的
【Spring Cloud Alibaba Nacos】Nacos心跳机制实现快速上下线
DreamSun的博客
03-23 1188
我们都知道是通过客户端和服务端的心跳机制，来实现服务的注册和下线的，Nacos的心跳机制默认是存在BeatInfo的period属性里面的，默认的心跳周期是5s，心跳的超时时间是15s，就意味着如果超过15秒不发送心跳，Nacos就认为这个服务不健康了，超过30秒该实例就将被Nacos删除下线。在某种情况下，显然不太满足公司项目的要求，默认的心跳时间30秒太长了，服务的上线和下线的感知还是有点慢的，为了能让服务上下线进行快速感知，我调整了Nacos的心跳配置时间。
Cloud Eureka概念、原理、心跳机制
学渣的博客
07-13 2321
Eureka是什么？ Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。 Eureka包含两个组件：Eureka Server和Eureka Client。 Eureka Server提供服务注册服务，各个节点启动后，会在Eu...
Nacos心跳机制
Jak的博客
11-14 8048
一、nacos心跳机制 当nacos进行服务注册的时候，NacosServiceRegistry.class会调用register()方法进行服务注册，该方法中调用了namingService.registerInstance()方法进行服务注册的逻辑。 NacosNamingService实现了NamingService的接口；然后在namingService.registerInstance()方法中，会做两件事情，第一件事就是组装心跳包BeatInfo，并且发送心跳： Nacos
SpringCloudAlibaba——Nacos实现原理详解
weixin_37627646的博客
08-29 418
在Spring-Cloud-Common包中有一个类org.springframework.cloud. client.serviceregistry .ServiceRegistry ,它是Spring Cloud提供的服务注册的标准。集成到Spring Cloud中实现服务注册的组件,都会实现该接口。从上述代码看,所谓心跳机制就是客户端通过schedule定时向服务端发送一个数据包 ,然后启动-个线程不断检测服务端的回应,如果在设定时间内没有收到服务端的回应,则认为服务器出现了故障。...
spring cloud alibaba - nacos原理
weixin_38612401的博客
07-20 1024
nacos原理，包含nacos集群的数据同步distro协议，nacos配置中心的进阶使用，配置中心原理，注册/发现中心原理
Nacos学习笔记（四）：心跳机制
仔哥学编程
12-16 2489
Nacos源码学习：心跳
微服务如何向Nacos进行注册及心跳检测?James带你从源码一步步深入分析
Jack博客
02-02 4142
大家好, 我是James, 最近整理了一下客户端微服务向Nacos注册及心跳的源码分析, 希望对大家学习有帮助, 源码可以找我的助理要一下哈v: lzc1314592 首先下载好Nacos的源码 关于源码怎么导入到maven, 在预习资料有个文档,写的很清楚 Nacos源码分析 访问nacos 启动业务服务 然后再停掉一个服务 发现变成1了 如果客户端访问刚关闭的那台服务, 是不是会报错呢? 有可能还会调到已停的服务, 怎么处理?其实就是做了一个服务降级的处理 互联网线上一般对非核心非关键的
Nacos健康检查
Jak的博客
11-14 8799
一、健康检查流程图 二、客户端 nacos是如何定时通过心跳机制判断实例是否存活的呢，这就是健康检查机制。 NamingService.registerInstance()方法中，会做两件事情 组装心跳包BeatInfo，并且发送心跳 注册nacos实例，通过http调用的方式，将请求发送到InstanceController.register()方法中 三、服务端 客户端请求，发送到服务端InstanceController.register()方法中 该方法中调用了serv
springcloud微服务：nacos的配置说明与服务注册
FeiChangWuRao的博客
03-07 4356
这部分我要知道两点就是nacos如何去注册服务和发现服务的。 注册服务
springcloud nacos服务注册
10-31
Nacos作为服务注册中心，可以让微服务在启动时将自己注册到Nacos上，以便其他微服务可以发现和调用它。同时，Nacos还提供了配置中心的功能，可以让微服务在启动时从Nacos上获取配置信息。在Spring Cloud Nacos中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值