Nacos心跳检测原理

工程版本

<spring-boot.version>2.2.6.RELEASE</spring-boot.version>
<spring-cloud-alibaba.version>2.2.1.RELEASE</spring-cloud-alibaba.version>
<spring-cloud.version>Hoxton.SR1</spring-cloud.version>

从上一节可以知道，Nacos客户端进行服务注册的时候首先调用NacosServiceRegistry.register(Registration registration)方法，在该方法里面最终会调用NacosNamingService.registerInstance(String serviceName, String groupName, Instance instance)进行服务注册。源码如下所示：

public class NacosNamingService implements NamingService {
     @Override
    public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
        // 判断是否为临时节点，默认情况下都是临时节点
        if (instance.isEphemeral()) {
            // 当前节点为临时节点
            // 新建一个BeatInfo对象，存储心跳检测需要的基本信息
            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);
            // 设置心跳检测的时间周期，默认是5s
            // 可以通过属性spring.cloud.nacos.discovery.heartBeatInterval配置
            beatInfo.setPeriod(instance.getInstanceHeartBeatInterval());
            // 新增一个心跳检测的基本信息，心跳检测时需要用到这些基本信息
            beatReactor.addBeatInfo(NamingUtils.getGroupedName(serviceName, groupName), beatInfo);
        }
        // 往注册中心进行注册
        serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);
    }
}

从上面可以看出，如果当前节点为临时节点则需要往beatReactor新增一个心跳检测的基本信息。NacosNamingService中的构造函数，会调用它的init()方法，然后在init方法中会创建初始化beatReactor。

public class NacosNamingService implements NamingService {
    public NacosNamingService(Properties properties) {
        init(properties);
    }
    private void init(Properties properties) {
        namespace = InitUtils.initNamespaceForNaming(properties);
        initServerAddr(properties);
        InitUtils.initWebRootContext();
        initCacheDir();
        initLogName(properties);

        eventDispatcher = new EventDispatcher();
        serverProxy = new NamingProxy(namespace, endpoint, serverList, properties);
        // 创建 BeatReactor 对象
        beatReactor = new BeatReactor(serverProxy, initClientBeatThreadCount(properties));
        
        hostReactor = new HostReactor(eventDispatcher, serverProxy, cacheDir, isLoadCacheAtStart(properties),
            initPollingThreadCount(properties));
    }
}

查看BeatReactor构造方法

public class BeatReactor {
    public BeatReactor(NamingProxy serverProxy, int threadCount) {
        this.serverProxy = serverProxy;
        // 创建一个线程池
        executorService = new ScheduledThreadPoolExecutor(threadCount, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setDaemon(true);
                thread.setName("com.alibaba.nacos.naming.beat.sender");
                return thread;
            }
        });
    }
}

再来查看BeatReactor.addBeatInfo(String serviceName, BeatInfo beatInfo)方法

public class BeatReactor {
    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);
        // 发送心跳的具体逻辑在 BeatTask 中
        // 这里会生成一个延时任务
        executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
        MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
    }
}

BeatTask是BeatReactor的一个内部类。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) {
                // 具体什么情况会出现我也没有复现出来
                // 这里应该是发送心跳检测时找不到资源，然后进行将服务注册到注册中心
                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());

        }
        // 发送一个心跳后，延迟nextTime，继续发送下一个心跳
        executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);
    }
}