Nacos 注册中心

Nacos 注册中心

目录

1. 健康检查介绍

2. 客户端健康检查

2.1 临时实例的健康检查

2.2 永久实例的健康检查

3. 服务端健康检查

3.1 临时实例的健康检查

3.2 永久实例服务端健康检查

---

1. 健康检查介绍

当一个服务实例注册到 Nacos 中后，其他服务就可以从 Nacos 中查询出该服务实例信息，就可以调用使用了。

然而服务提供者如果此时挂掉了，此时其他服务拿到信息后就会调用不通，所以Nacos中的服务信息应该有一个更新机制（即删除掉挂掉的服务）

那么服务注册信息应该如何维护呢，那就是判断某个服务实例是否有问题，如果检测到服务实例出现问题了就将他剔除掉。

那么如何判断 服务实例 是否有问题呢？这就是健康检查要做的事情，即检查服务实例的健康状态。不健康则剔除下线。

下面看看客户端和服务端为了实现健康检查功能都各自做了哪些事情。

2. 客户端健康检查

2.1 临时实例的健康检查

从 Nacos 2.x 开始，临时实例的服务注册由原来的 HTTP 更换为了 GRPC 长连接方式。Nacos Client 和 Nacos Server 之间建立的 RPC 长连接，服务注册、服务取消注册等接口都是通过 GRPC 消息与服务端通信的。

GRPC 长连接是一直存在的，只要连接一直存在就代表Nacos Client 和 Nacos Server 之间的连接是通的，Nacos Client 则一直在线。如果Nacos Client 由于网络问题等其他问题挂掉了，那么这条长连接也会断开连接。

那么服务实例如何算健康呢，就是长连接一直存在没有断那就算健康的。

如果连接断掉了，那么该客户端上注册的全部服务实例都是不健康的了。

GRPC 长连接如果想一直保证连接状态，就需要定时发送心跳包，以确保连接处于活动的状态。否则一段时间不操作的话就会自动断开连接。

接下来看看 NacosClient 如何开启 RPC 长连接的

NacosClient 操作注册中心的 API 是通过 NamingService 进行的

在 NacosNamingService 的构造器中调用了 init 初始化方法：init 方法最后

进入最后一行代码：

再看最后 new NamingGrpcClientProxy 的源码：

public class NamingGrpcClientProxy {public NamingGrpcClientProxy(String namespaceId, SecurityProxy securityProxy, ServerListFactory serverListFactory,NacosClientProperties properties, ServiceInfoHolder serviceInfoHolder) {// 省略部分代码// 创建 RPC Clientthis.rpcClient = ateClient(uuid, ConnectionType.GRPC, labels);// 启动 RPC Clientstart(serverListFactory, serviceInfoHolder);}private void start(ServerListFactory serverListFactory, ServiceInfoHolder serviceInfoHolder) throws NacosException {rpcClient.serverListFactory(serverListFactory);isterConnectionListener(redoService);isterServerRequestHandler(new NamingPushRequestHandler(serviceInfoHolder));// 启动rpcClient.start();}

看看 RpcClient.start 做了什么

public abstract class RpcClient {protected BlockingQueue<ConnectionEvent> eventLinkedBlockingQueue = new LinkedBlockingQueue<>();public final void start() {// 省略部分代码// connection event consumer.clientEventExecutor.submit(() -> {while (!clientEventExecutor.isTerminated() && !clientEventExecutor.isShutdown()) {ConnectionEvent take = eventLinkedBlockingQueue.take();if (take.isConnected()) {notifyConnected();} else if (take.isDisConnected()) {notifyDisConnected();}}});Connection connectToServer = null;// 状态设置为启动中rpcClientStatus.set(RpcClientStatus.STARTING);int startUpRetryTimes = Times();while (startUpRetryTimes > 0 && connectToServer == null) {startUpRetryTimes--;ServerInfo serverInfo = nextRpcServer();// 建立连接connectToServer = connectToServer(serverInfo);}this.currentConnection = connectToServer;// 状态设置为 运行中rpcClientStatus.set(RpcClientStatus.RUNNING);eventLinkedBlockingQueue.offer(new ConnectionEvent(ConnectionEvent.CONNECTED));// 省略部分代码}}

省略了一些代码，这次只关注核心的两个点

1. 找到下一个 RPC Server 建立连接

因为 Nacos 支持集群部署，此时的 RPC Server List 其实就是这些集群节点。也就是找到集群下一个节点建议连接，如果连接失败就走到下一轮循环再获取到下一个节点继续连接（再重试次数内循环）

2. eventLinkedBlockingQueue 队列中加入一项

eventLinkedBlockingQueue 队列里存的是 ConnectionEvent，ConnectionEvent 代表一个连接事件，事件有 已连接事件、断开连接事件。

public class ConnectionEvent {public static final int CONNECTED = 1;public static final int DISCONNECTED = 0;int eventType;public ConnectionEvent(int eventType) {this.eventType = eventType;}public boolean isConnected() {return eventType == CONNECTED;}public boolean isDisConnected() {return eventType == DISCONNECTED;}
}

可见上面的源码，连接建立成功后，就会往队列压入一个 已连接事件 CONNECTED

队列事件的消费者在哪里呢？

便是在 start 方法的最开头定义的，while 循环不断从队列中获取到数据然后根据事件类型，进行各自的通知。

    public final void start() {// 省略部分代码// connection event consumer.clientEventExecutor.submit(() -> {while (!clientEventExecutor.isTerminated() && !clientEventExecutor.isShutdown()) {ConnectionEvent take = eventLinkedBlockingQueue.take();if (take.isConnected()) {// 通知连接notifyConnected();} else if (take.isDisConnected()) {// 通知断开连接notifyDisConnected();}}});}

notifyConnected 和 notifyDisConnected 实现差不多，所以这里只看一个的实现源码。

protected List<ConnectionEventListener> connectionEventListeners = new ArrayList<>();
​
protected void notifyConnected() {// 省略部分源码if (connectionEventListeners.isEmpty()) {return;}// 循环全部监听器 一个个回调for (ConnectionEventListener connectionEventListener : connectionEventListeners) {                      Connected();    }
}

connectionEventListeners 里的数据是什么时候加入的呢？

那就是在 NamingGrpcClientProxy.start 方法

public class NamingGrpcRedoService implements ConnectionEventListener {private volatile boolean connected = false;@Overridepublic void onConnected() {// 建立连接，改变连接状态connected = true;}@Overridepublic void onDisConnect() {connected = false;// 将 redoService 上的全部缓存数据一改synchronized (registeredInstances) {registeredInstances.values().forEach(instanceRedoData -> instanceRedoData.setRegistered(false));}synchronized (subscribes) {subscribes.values().forEach(subscriberRedoData -> subscriberRedoData.setRegistered(false));}}

当GRPC 长连接断开后就会进入 onDisConnect 事件回调中，这里改变了setRegistered 状态

上篇说过，redoService的作用 Nacos 注册中心 - 服务注册源码

此时会走入服务卸载流程。

2.2 永久实例的健康检查

永久实例客户端只负责提交一个请求即完成了全部操作。

健康检查工作由 服务端做。

3. 服务端健康检查

在收到客户端建立连接事件回调后，会调用 init 方法

public class IpPortBasedClient extends AbstractClient {public void init() {if (ephemeral) {beatCheckTask = new ClientBeatCheckTaskV2(this);HealthCheckReactor.scheduleCheck(beatCheckTask);} else {healthCheckTaskV2 = new HealthCheckTaskV2(this);HealthCheckReactor.scheduleCheck(healthCheckTaskV2);}}   
}

如果当前是临时实例：使用 ClientBeatCheckTaskV2 处理健康检查

如果当前是永久实例：使用 HealthCheckTaskV2处理健康检查

然后将任务放到线程池中执行定时执行

3.1 临时实例的健康检查

看看 ClientBeatCheckTaskV2 如何实现：

public class ClientBeatCheckTaskV2 extends AbstractExecuteTask implements BeatCheckTask, NacosHealthCheckTask {// 省略部分代码private final IpPortBasedClient client;private final InstanceBeatCheckTaskInterceptorChain interceptorChain;// 执行健康检查@Overridepublic void doHealthCheck() {// 拿到当前客户端上注册的全部服务Collection<Service> services = AllPublishedService();for (Service each : services) {HealthCheckInstancePublishInfo instance = (HealthCheckInstancePublishInfo) InstancePublishInfo(each);// 将全部服务用拦截器链一个个执行interceptorChain.doInterceptor(new InstanceBeatCheckTask(client, each, instance));} }@Overridepublic void run() {doHealthCheck();}
}

看看拦截器链如何实现

这里的拦截器链是一个典型的责任链模式

public abstract class AbstractNamingInterceptorChain<T extends Interceptable>implements NacosNamingInterceptorChain<T> {@Overridepublic void doInterceptor(T object) {for (NacosNamingInterceptor<T> each : interceptors) {if (!each.Class())) {continue;}// 当前是责任节点，直接由该责任节点处理if (each.intercept(object)) {object.afterIntercept();// 不往后执行了return;}}// 如果没有责任节点执行，就调用 passInterceptobject.passIntercept();}
}

首先第一个问题：拦截器都是些什么呢？

可见具体的有三个实现类

这三个类代表者三个地方的判断，判断是否开启了 健康心跳检查功能？ 如果没开，那就被拦截了呀，就走不到后面的心跳检查代码了

ServiceEnableBeatCheckInterceptor

从 Service 的元数据上判断

public class ServiceEnableBeatCheckInterceptor extends AbstractBeatCheckInterceptor {@Overridepublic boolean intercept(InstanceBeatCheckTask object) {NamingMetadataManager metadataManager = Bean(NamingMetadataManager.class);// 获取当前 Service 的元数据Optional<ServiceMetadata> metadata = Service());// 如果元数据存在，并且其数据 enableClientBeat 配置了if (metadata.isPresent() && ().getExtendData().containsKey(UtilsAndCommons.ENABLE_CLIENT_BEAT)) {// 直接取 enableClientBeat 值return Boolean.().getExtendData().get(UtilsAndCommons.ENABLE_CLIENT_BEAT));}return false;}}

InstanceBeatCheckResponsibleInterceptor

并不是一个客户端要负责集群中全部节点的心跳处理的，而是只负责自己注册的。

public class InstanceBeatCheckResponsibleInterceptor extends AbstractBeatCheckInterceptor {@Overridepublic boolean intercept(InstanceBeatCheckTask object) {// 是否是当前责任节点return !Bean(DistroMapper.class).Client().getResponsibleId());}}

InstanceEnableBeatCheckInterceptor

这个就是实例级别的健康检查判断

public class InstanceEnableBeatCheckInterceptor extends AbstractBeatCheckInterceptor {@Overridepublic boolean intercept(InstanceBeatCheckTask object) {NamingMetadataManager metadataManager = Bean(NamingMetadataManager.class);HealthCheckInstancePublishInfo instance = InstancePublishInfo();// 获取到实例上的元数据Optional<InstanceMetadata> metadata = Service(), MetadataId());// 从元数据上取if (metadata.isPresent() && ().getExtendData().containsKey(UtilsAndCommons.ENABLE_CLIENT_BEAT)) {// 元数据存在取该值().getExtendData().get(UtilsAndCommons.ENABLE_CLIENT_BEAT).toString());}// 从 extendDatum 中取数据if (ExtendDatum().containsKey(UtilsAndCommons.ENABLE_CLIENT_BEAT)) {ExtendDatum().get(UtilsAndCommons.ENABLE_CLIENT_BEAT).toString());}return false;}}

如果都没被上面三个拦截器拦截掉，那就代表 当前实例是 开启了 健康检查，所以后面就要开始进行 检查操作 了

检查操作由 object.passIntercept(); 做

object.passIntercept(); 是什么呢？

就是刚才的 开始拦截方法最后一行

@Override
public void doInterceptor(T object) {for (NacosNamingInterceptor<T> each : interceptors) {if (!each.Class())) {continue;}// 拦截器是否拦截？if (each.intercept(object)) {object.afterIntercept();// 拦截了，直接返回return;}}// 未被拦截到object.passIntercept();
}

object 是什么？

就是之前传过来的 InstanceBeatCheckTask

接下来看看 InstanceBeatCheckTask

public class InstanceBeatCheckTask implements Interceptable {// 全部检查项目private static final List<InstanceBeatChecker> CHECKERS = new LinkedList<>();private final IpPortBasedClient client;private final Service service;private final HealthCheckInstancePublishInfo instancePublishInfo;static {// 添加检查项目CHECKERS.add(new UnhealthyInstanceChecker());CHECKERS.add(new ExpiredInstanceChecker());// SPI 机制添加CHECKERS.addAll(NacosServiceLoader.load(InstanceBeatChecker.class));}@Overridepublic void passIntercept() {// 遍历全部检查项目for (InstanceBeatChecker each : CHECKERS) {// 开始检查each.doCheck(client, service, instancePublishInfo);}}
}

全部检查项目 都是什么呢？

下面分别介绍

UnhealthyInstanceChecker

不健康实例检查器

public class UnhealthyInstanceChecker implements InstanceBeatChecker {// 开始做检查@Overridepublic void doCheck(Client client, Service service, HealthCheckInstancePublishInfo instance) {if (instance.isHealthy() && isUnhealthy(service, instance)) {// 当前实例不健康了 -> 改变健康状态为 不健康changeHealthyStatus(client, service, instance);}}// 判断实例是否健康private boolean isUnhealthy(Service service, HealthCheckInstancePublishInfo instance) {// 获取超时时间 默认 15 秒；可通过配置更改。long beatTimeout = getTimeout(service, instance);// 当前时间距离上一次发送心跳包时间  超过了 规定的超时时间  则返回 true,代表节点不健康了return System.currentTimeMillis() - LastHeartBeatTime() > beatTimeout;}​// 改变健康状态private void changeHealthyStatus(Client client, Service service, HealthCheckInstancePublishInfo instance) {instance.setHealthy(false);// 省略部分代码}}

ExpiredInstanceChecker

过期实例检查器

public class ExpiredInstanceChecker implements InstanceBeatChecker {@Overridepublic void doCheck(Client client, Service service, HealthCheckInstancePublishInfo instance) {boolean expireInstance = Bean(GlobalConfig.class).isExpireInstance();if (expireInstance && isExpireInstance(service, instance)) {// 如果实例过期了，则直接剔除实例deleteIp(client, service, instance);}}private boolean isExpireInstance(Service service, HealthCheckInstancePublishInfo instance) {// 获取超时时间 默认 30 秒；可通过配置更改。long deleteTimeout = getTimeout(service, instance);// 当前时间距离上一次发送心跳包时间  超过了 规定的超时时间  则返回 true,代表节点过期了，需要进行节点剔除操作return System.currentTimeMillis() - LastHeartBeatTime() > deleteTimeout;}/*** 服务直接剔除掉*/private void deleteIp(Client client, Service service, InstancePublishInfo instance) {veServiceInstance(service);// 客户端下线NotifyCenter.publishEvent(new ClientOperationEvent.ClientDeregisterServiceEvent(service, ClientId()));// 元数据改变NotifyCenter.publishEvent(new MetadataEvent.InstanceMetadataEvent(service, MetadataId(), true));// 注销实例NotifyCenter.publishEvent(new DeregisterInstanceTraceEvent(System.currentTimeMillis(), "",false, DeregisterInstanceReason.HEARTBEAT_EXPIRE, Namespace(), Group(),Name(), Ip(), Port()));}

3.2 永久实例服务端健康检查

永久实例的健康检查是服务端主动探测方式，服务端定时外部请求客户端来看是否健康。

public class IpPortBasedClient extends AbstractClient {public void init() {if (ephemeral) {beatCheckTask = new ClientBeatCheckTaskV2(this);HealthCheckReactor.scheduleCheck(beatCheckTask);} else {healthCheckTaskV2 = new HealthCheckTaskV2(this);HealthCheckReactor.scheduleCheck(healthCheckTaskV2);}}   
}

入口类是 HealthCheckTaskV2

public class HealthCheckTaskV2 extends AbstractExecuteTask implements NacosHealthCheckTask {// 省略部分代码private final IpPortBasedClient client;@Overridepublic void doHealthCheck() {// 获取到当前客户端上注册的全部节点for (Service each : AllPublishedService()) {// 如果开启了健康检查if (switchDomain.GroupedServiceName())) {// 拿到实例注册信息InstancePublishInfo instancePublishInfo = InstancePublishInfo(each);// 拿到集群元数据ClusterMetadata metadata = getClusterMetadata(each, instancePublishInfo);// 调用 HealthCheckProcessorV2Delegate.process()Bean(HealthCheckProcessorV2Delegate.class).process(this, each, metadata);
​}}}
​@Overridepublic void run() {doHealthCheck();}}

最终调用了 HealthCheckProcessorV2Delegate.process 方法

看看如何实现

HealthCheckProcessorV2Delegate 这个类就是一个委托类

public class HealthCheckProcessorV2Delegate implements HealthCheckProcessorV2 {// 类型,健康检查实现类private final Map<String, HealthCheckProcessorV2> healthCheckProcessorMap = new HashMap<>();
​@Autowiredpublic void addProcessor(Collection<HealthCheckProcessorV2> processors) {healthCheckProcessorMap.putAll(processors.stream().filter(processor -> Type() != null).Map(HealthCheckProcessorV2::getType, processor -> processor)));}@Overridepublic void process(HealthCheckTaskV2 task, Service service, ClusterMetadata metadata) {// 从元数据中获取到当前的健康检查类型 （HTTP、MySQL、TCP、None）String type = HealthyCheckType();// 根据类型找到具体的 健康检查类HealthCheckProcessorV2 processor = (type);if (processor == null) {// 找不到 就使用 None 健康检查processor = (NoneHealthCheckProcessor.TYPE);}// 开始进行健康检查processor.process(task, service, metadata);}
}

健康检查有如下几类，还可通过 SPI 方式扩展

下面一个一个介绍

NoneHealthCheckProcessor

None 代表不做健康检查，所以这个类的Process 为空实现

public class NoneHealthCheckProcessor implements HealthCheckProcessorV2 {public static final String TYPE = HealthCheckType.NONE.name();@Overridepublic void process(HealthCheckTaskV2 task, Service service, ClusterMetadata metadata) {}@Overridepublic String getType() {return TYPE;}
}

TcpHealthCheckProcessor

TCP 健康检查，用于通过 TCP 方式检查是否健康，本质上是通过建立 Socket 连接，发送 Socket 信息实现

public class TcpHealthCheckProcessor implements HealthCheckProcessorV2, Runnable {@Overridepublic void process(HealthCheckTaskV2 task, Service service, ClusterMetadata metadata) {// 省略}// 省略部分代码private class TaskProcessor implements Callable<Void> {
​@Overridepublic Void call() {// 发送 Socket 请求SocketChannel channel = null;HealthCheckInstancePublishInfo instance = Instance();BeatKey beatKey = (String());if (beatKey != null && beatKey.key.isValid()) {if (System.currentTimeMillis() - beatKey.birthTime < TCP_KEEP_ALIVE_MILLIS) {instance.finishCheck();return null;}beatKey.key.cancel();beatKey.key.channel().close();}channel = SocketChannel.open();figureBlocking(false);// only by setting this can we make the socket close event asynchronouschannel.socket().setSoLinger(false, -1);channel.socket().setReuseAddress(true);channel.socket().setKeepAlive(true);channel.socket().setTcpNoDelay(true);ClusterMetadata cluster = Metadata();int port = cluster.isUseInstancePortForCheck() ? Port() : HealthyCheckPort();t(new Ip(), port));SelectionKey key = ister(selector, SelectionKey.OP_CONNECT | SelectionKey.OP_READ);key.attach(beat);keyMap.String(), new BeatKey(key));beat.setStartTime(System.currentTimeMillis());GlobalExecutor.scheduleTcpSuperSenseTask(new TimeOutTask(key), CONNECT_TIMEOUT_MS, TimeUnit.MILLISECONDS);return null;}}
}

MysqlHealthCheckProcessor

本质是 发送一个 sql。（sql从配置中获取），整个过程没报异常就算健康

public class MysqlHealthCheckProcessor implements HealthCheckProcessorV2 {public static final String TYPE = HealthCheckType.MYSQL.name();private final HealthCheckCommonV2 healthCheckCommon;private final SwitchDomain switchDomain;public static final int CONNECT_TIMEOUT_MS = 500;private static final String CHECK_MYSQL_MASTER_SQL = "show global variables where variable_name='read_only'";private static final String MYSQL_SLAVE_READONLY = "ON";private static final ConcurrentMap<String, Connection> CONNECTION_POOL = new ConcurrentHashMap<String, Connection>();public MysqlHealthCheckProcessor(HealthCheckCommonV2 healthCheckCommon, SwitchDomain switchDomain) {this.healthCheckCommon = healthCheckCommon;this.switchDomain = switchDomain;}@Overridepublic String getType() {return TYPE;}@Overridepublic void process(HealthCheckTaskV2 task, Service service, ClusterMetadata metadata) {// 省略}private class MysqlCheckTask implements Runnable {@Overridepublic void run() {Statement statement = null;ResultSet resultSet = null;String clusterName = Cluster();String key &#GroupedServiceName() + ":" + clusterName + ":" + Ip() + ":" + Port();Connection connection = (key);Mysql config = (Mysql) HealthChecker();if (connection == null || connection.isClosed()) {String url = "jdbc:mysql://" + Ip() + ":" + Port() + "?connectTimeout="+ CONNECT_TIMEOUT_MS + "&socketTimeout=" + CONNECT_TIMEOUT_MS + "&loginTimeout=" + 1;connection = Connection(url, User(), Pwd());CONNECTION_POOL.put(key, connection);}statement = ateStatement();statement.setQueryTimeout(1);resultSet = Cmd());int resultColumnIndex = 2;if (CHECK_MYSQL_MASTER_SQL.Cmd())) {();if (MYSQL_SLAVE_READONLY.String(resultColumnIndex))) {throw new IllegalStateException("current node is slave!");}}healthCheckCommon.checkOk(task, service, "mysql:+ok");EvaluateCheckRT(System.currentTimeMillis() - startTime, MysqlHealthParams());
​}
}

HttpHealthCheckProcessor

本质是发送一个 HTTP 请求，返回状态码 200 就算健康

public class HttpHealthCheckProcessor implements HealthCheckProcessorV2 {public static final String TYPE = HealthCheckType.HTTP.name();private static final NacosAsyncRestTemplate ASYNC_REST_TEMPLATE = ProcessorNacosAsyncRestTemplate();private final HealthCheckCommonV2 healthCheckCommon;
​@Overridepublic void process(HealthCheckTaskV2 task, Service service, ClusterMetadata metadata) {HealthCheckInstancePublishInfo instance = (HealthCheckInstancePublishInfo) Client().getInstancePublishInfo(service);if (null == instance) {return;}try {if (!StartCheck()) {SRV_LOG.warn("http check started before last one finished, service: {} : {} : {}:{}",GroupedServiceName(), Cluster(), Ip(), Port());CheckRtNormalized() * 2, task, HttpHealthParams());return;}Http healthChecker = (Http) HealthChecker();int ckPort = metadata.isUseInstancePortForCheck() ? Port() : HealthyCheckPort();URL host = new URL(HTTP_PREFIX + Ip() + ":" + ckPort);URL target = new URL(host, Path());Map<String, String> customHeaders = CustomHeaders();Header header = wInstance();header.addAll(customHeaders);// 发送 HTTP 请求ASYNC_(String(), header, Query.EMPTY, String.class,new HttpHealthCheckCallback(instance, task, service));HttpHealthCheckMonitor().incrementAndGet();} catch (Throwable e) {instance.HttpHealthParams().getMax());healthCheckCommon.checkFail(task, service, "http:error:" + e.getMessage());HttpHealthParams().getMax(), HttpHealthParams());}}@Overridepublic String getType() {return TYPE;}private class HttpHealthCheckCallback implements Callback<String> {private final HealthCheckTaskV2 task;private final Service service;private final HealthCheckInstancePublishInfo instance;private long startTime = System.currentTimeMillis();public HttpHealthCheckCallback(HealthCheckInstancePublishInfo instance, HealthCheckTaskV2 task,Service service) {this.instance = instance;this.task = task;this.service = service;}@Overridepublic void onReceive(RestResult<String> result) {instance.setCheckRt(System.currentTimeMillis() - startTime);int httpCode = Code();if (HttpURLConnection.HTTP_OK == httpCode) {healthCheckCommon.checkOk(task, service, "http:" + httpCode);EvaluateCheckRT(System.currentTimeMillis() - startTime, HttpHealthParams());} else if (HttpURLConnection.HTTP_UNAVAILABLE == httpCode|| HttpURLConnection.HTTP_MOVED_TEMP == httpCode) {// server is busy, need verification laterhealthCheckCommon.checkFail(task, service, "http:" + httpCode);CheckRtNormalized() * 2, task, HttpHealthParams());} else {//probably means the state files has been removed by administratorhealthCheckCommon.checkFailNow(task, service, "http:" + httpCode);HttpHealthParams().getMax(), HttpHealthParams());}}@Overridepublic void onError(Throwable throwable) {Throwable cause = throwable;instance.setCheckRt(System.currentTimeMillis() - startTime);int maxStackDepth = 50;for (int deepth = 0; deepth < maxStackDepth && cause != null; deepth++) {if (HttpUtils.isTimeoutException(cause)) {healthCheckCommon.checkFail(task, service, "http:" + Message());CheckRtNormalized() * 2, HttpHealthParams());return;}cause = Cause();}if (throwable instanceof ConnectException) {healthCheckCommon.checkFailNow(task, service, "http:unable2connect:" + Message());} else {healthCheckCommon.checkFail(task, service, "http:error:" + Message());}HttpHealthParams().getMax(), HttpHealthParams());}@Overridepublic void onCancel() {}}
}
​

可见，不同方式的健康检查差异还是挺大的，那么如果将检查结果告知 Nacos 呢，那就是调用

// 健康检查结果：健康
healthCheckCommon.checkOk(task, service, "");// 健康检查结果：不健康
healthCheckCommon.checkFail(task, service, "");

健康检查成功

检查成功主要做的事情就是 重置失败次数、结束检查

public void checkOk(HealthCheckTaskV2 task, Service service, String msg) {try {HealthCheckInstancePublishInfo instance = (HealthCheckInstancePublishInfo) Client().getInstancePublishInfo(service);if (instance == null) {// 实例不存在，不做处理return;}if (!instance.isHealthy()) {// 如果实例不健康的，将状态改为 健康// 代码省略}} finally {// 重置失败次数setFailCount();// 结束检查instance.finishCheck();}
}

健康检查失

public void checkFail(HealthCheckTaskV2 task, Service service, String msg) {
​HealthCheckInstancePublishInfo instance = (HealthCheckInstancePublishInfo) Client().getInstancePublishInfo(service);if (instance == null) {return;}try {if (instance.isHealthy()) {// 如果实例是健康的，将状态改为 不健康// 代码省略}} finally {// 重置健康次数setOkCount();// 结束检查instance.finishCheck();}
}