1
@Override
2
public void removeInstance(String namespaceId, String serviceName, Instance instance) {
3
    boolean ephemeral = instance.isEphemeral();
4
    String clientId = IpPortBasedClient.getClientId(instance.toInetAddr(), ephemeral);
5
    // 这里进入 if 分支后直接 return 了
6
    if (!clientManager.contains(clientId)) {
7
        Loggers.SRV_LOG.warn("remove instance from non-exist client: {}", clientId);
8
        return;
9
    }
10
    Service service = getService(namespaceId, serviceName, ephemeral);
11
    clientOperationService.deregisterInstance(service, instance, clientId);
12
}

1
public class ClientManagerDelegate implements ClientManager {
2

3
    private final ConnectionBasedClientManager connectionBasedClientManager;
4

5
    // 临时节点的客户端管理器
6
    private final EphemeralIpPortClientManager ephemeralIpPortClientManager;
7

8
    // 持久化节点的客户端管理器
9
    private final PersistentIpPortClientManager persistentIpPortClientManager;
10

11
    // ...
12

13
    @Override
14
    public boolean contains(String clientId) {
15
        return connectionBasedClientManager.contains(clientId) || ephemeralIpPortClientManager.contains(clientId)
16
                || persistentIpPortClientManager.contains(clientId);
17
    }
18

19
    // 根据clientId的格式选择不通的ClientManager
20
    private ClientManager getClientManagerById(String clientId) {
21
        if (isConnectionBasedClient(clientId)) {
22
            return connectionBasedClientManager;
23
        }
24
        // clientId以false结尾的是ephemeralIpPortClientManager
25
        // 否则是 persistentIpPortClientManager
26
        return clientId.endsWith(ClientConstants.PERSISTENT_SUFFIX) ?
27
            persistentIpPortClientManager : ephemeralIpPortClientManager;
28
    }
29

30
    // clientId不包含#服务的客户端
31
    private boolean isConnectionBasedClient(String clientId) {
32
        return !clientId.contains(IpPortBasedClient.ID_DELIMITER);
33
    }
34

35
    // ...
36
}

1
public class ExpiredInstanceChecker implements InstanceBeatChecker {
2

3
    @Override
4
    public void doCheck(Client client, Service service, HealthCheckInstancePublishInfo instance) {
5
        // 从配置信息  nacos.naming.expireInstance 中获取是否开启过期实例探测, 默认为 true
6
         boolean expireInstance = ApplicationUtils.getBean(GlobalConfig.class).isExpireInstance();
7
        if (expireInstance && isExpireInstance(service, instance)) {
8
            deleteIp(client, service, instance);
9
        }
10
    }
11

12
    private boolean isExpireInstance(Service service, HealthCheckInstancePublishInfo instance) {
13
        long deleteTimeout = getTimeout(service, instance);
14
        return System.currentTimeMillis() - instance.getLastHeartBeatTime() > deleteTimeout;
15
    }
16

17
    private long getTimeout(Service service, InstancePublishInfo instance) {
18
        Optional<Object> timeout = getTimeoutFromMetadata(service, instance);
19
        if (!timeout.isPresent()) {
20
            // IP_DELETE_TIMEOUT = preserved.ip.delete.timeout
21
            timeout = Optional.ofNullable(instance.getExtendDatum().get(PreservedMetadataKeys.IP_DELETE_TIMEOUT));
22
        }
23
        // DEFAULT_IP_DELETE_TIMEOUT = 30 秒
24
        return timeout.map(ConvertUtils::toLong).orElse(Constants.DEFAULT_IP_DELETE_TIMEOUT);
25
    }
26

27
    private Optional<Object> getTimeoutFromMetadata(Service service, InstancePublishInfo instance) {
28
        Optional<InstanceMetadata> instanceMetadata = ApplicationUtils.getBean(NamingMetadataManager.class)
29
                .getInstanceMetadata(service, instance.getMetadataId());
30
        return instanceMetadata.map(metadata -> metadata.getExtendData().get(PreservedMetadataKeys.IP_DELETE_TIMEOUT));
31
    }
32

33
    // 这里会自动移除过期的服务实例
34
    private void deleteIp(Client client, Service service, InstancePublishInfo instance) {
35
        Loggers.SRV_LOG.info("[AUTO-DELETE-IP] service: {}, ip: {}", service.toString(), JacksonUtils.toJson(instance));
36
        client.removeServiceInstance(service);
37
        NotifyCenter.publishEvent(new ClientOperationEvent.ClientDeregisterServiceEvent(service, client.getClientId()));
38
        NotifyCenter.publishEvent(new MetadataEvent.InstanceMetadataEvent(service, instance.getMetadataId(), true));
39
        NotifyCenter.publishEvent(new DeregisterInstanceTraceEvent(System.currentTimeMillis(), "",
40
                false, DeregisterInstanceReason.HEARTBEAT_EXPIRE, service.getNamespace(), service.getGroup(),
41
                service.getName(), instance.getIp(), instance.getPort()));
42
    }
43
}

1
 public class InstanceBeatCheckTask implements Interceptable {
2
    static {
3
        CHECKERS.add(new UnhealthyInstanceChecker());
4
        CHECKERS.add(new ExpiredInstanceChecker());
5
        CHECKERS.addAll(NacosServiceLoader.load(InstanceBeatChecker.class));
6
    }
7
 }

1
public class IpPortBasedClient extends AbstractClient {
2

3
    public void init() {
4
        if (ephemeral) {
5
            // client 初始化时, 如果是临时性节点, 会初始化自动探测任务
6
            beatCheckTask = new ClientBeatCheckTaskV2(this);
7
            HealthCheckReactor.scheduleCheck(beatCheckTask);
8
        } else {
9
            healthCheckTaskV2 = new HealthCheckTaskV2(this);
10
            HealthCheckReactor.scheduleCheck(healthCheckTaskV2);
11
        }
12
    }
13
}