Nacos源码分析之服务列表查询

Nacos源码分析之服务列表查询（三）

客户端

nacos官网推荐的获取所有实例的方法， 我们就从这里往下分析。

https://nacos.io/zh-cn/docs/sdk.html

注意：subscribe默认是true，但是从代码上看，好像是去客户端的缓存列表去拿取缓存的数据。变量名是否调整一下会比较合适。

如果从缓存拿的话，进入到serviceInfoHolder.getServiceInfo

• NacosNamingService.getAllInstances

  这里有2个分支，一个是subscribe=true，另外一个是直接去查询服务器端的地址。

public List<Instance> getAllInstances(String serviceName, String groupName, List<String> clusters,
                                      boolean subscribe) throws NacosException {
    ServiceInfo serviceInfo;
    String clusterString = StringUtils.join(clusters, ",");
    if (subscribe) {
        serviceInfo = serviceInfoHolder.getServiceInfo(serviceName, groupName, clusterString);
        if (null == serviceInfo || !clientProxy.isSubscribed(serviceName, groupName, clusterString)) {
            serviceInfo = clientProxy.subscribe(serviceName, groupName, clusterString);
        }
    } else {
        serviceInfo = clientProxy.queryInstancesOfService(serviceName, groupName, clusterString, 0, false);
    }
    List<Instance> list;
    if (serviceInfo == null || CollectionUtils.isEmpty(list = serviceInfo.getHosts())) {
        return new ArrayList<Instance>();
    }
    return list;
}

• ServiceInfoHolder.getServiceInfo

可以看到这里的serviceInfoMap是一个集合，这个就是本地的缓存了。毕竟如果并发量大的话，不可能每次都去请求server端的数据。

private final ConcurrentMap<String, ServiceInfo> serviceInfoMap;
public ServiceInfo getServiceInfo(final String serviceName, final String groupName, final String clusters) {
    NAMING_LOGGER.debug("failover-mode: {}", failoverReactor.isFailoverSwitch());
    String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
    String key = ServiceInfo.getKey(groupedServiceName, clusters);
    if (failoverReactor.isFailoverSwitch()) {
        return failoverReactor.getService(key);
    }
    return serviceInfoMap.get(key);
}

• NamingGrpcClientProxy.queryInstancesOfService

NamingClientProxy这个类是个接口，他的类图如下。可以很明显的看到有个委派类，而实现有grpc和http的形式。我们直接来看grpc的形式。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C7SCzG6D-1676452414768)(E:\books\img\image-
.png)]

@Override
public ServiceInfo queryInstancesOfService(String serviceName, String groupName, String clusters, int udpPort,
                                           boolean healthyOnly) throws NacosException {
    ServiceQueryRequest request = new ServiceQueryRequest(namespaceId, serviceName, groupName);
    request.setCluster(clusters);
    request.setHealthyOnly(healthyOnly);
    request.setUdpPort(udpPort);
    QueryServiceResponse response = requestToServer(request, QueryServiceResponse.class);
    return response.getServiceInfo();
}

再往下就是grpc交互的源码，这里就不继续跟了。下边我们来看server端。

服务端

客户端组了一个ServiceQueryRequest，那么一定是进入到ServiceQueryRequestHandler中。

• ServiceQueryRequestHandler.handle

可以看到这里的serviceStorage.getData(service)，这里很关键，再进入到这个里边。

private final ServiceStorage serviceStorage;

private final NamingMetadataManager metadataManager;

public ServiceQueryRequestHandler(ServiceStorage serviceStorage, NamingMetadataManager metadataManager) {
    this.serviceStorage = serviceStorage;
    this.metadataManager = metadataManager;
}
@Override
@Secured(action = ActionTypes.READ)
public QueryServiceResponse handle(ServiceQueryRequest request, RequestMeta meta) throws NacosException {
	// 获取3个要素
    String namespaceId = request.getNamespace();
    String groupName = request.getGroupName();
    String serviceName = request.getServiceName();
    // 构建一个service
    Service service = Service.newService(namespaceId, groupName, serviceName);
    String cluster = null == request.getCluster() ? "" : request.getCluster();
    boolean healthyOnly = request.isHealthyOnly();
    ServiceInfo result = serviceStorage.getData(service);
    ServiceMetadata serviceMetadata = metadataManager.getServiceMetadata(service).orElse(null);
    result = ServiceUtil.selectInstancesWithHealthyProtection(result, serviceMetadata, cluster, healthyOnly, true,
                                                              meta.getClientIp());
    return QueryServiceResponse.buildSuccessResponse(result);
}

• ServiceStorage.getData

这里有2个Map，一个是根据传入的查询条件去查询服务实例的serviceDataIndexes。

private final ConcurrentMap<Service, ServiceInfo> serviceDataIndexes;
    
private final ConcurrentMap<Service, Set<String>> serviceClusterIndex;

public ServiceInfo getData(Service service) {
    return serviceDataIndexes.containsKey(service) ? serviceDataIndexes.get(service) : getPushData(service);
}

这里的逻辑是先去map中查询，如果有的话，就直接get数据返回。而如果没有的话，会getPushData(service).

这里有个读写分离的设计，用serviceDataIndexes来作为存储的map，而写入的是另外一个集合，如果在这个集合中可以查到，那么直接就可以返回了。如果查不到的话，就会去写入的集合把数据同步过来。

public ServiceInfo getPushData(Service service) {
    // 构建一个空的service作为result
    ServiceInfo result = emptyServiceInfo(service);
    if (!ServiceManager.getInstance().containSingleton(service)) {
        return result;
    }
    // 创建一个singletong的单例实例
    Service singleton = ServiceManager.getInstance().getSingleton(service);
    // 获取这个实例的所有host列表。
    result.setHosts(getAllInstancesFromIndex(singleton));
    // 存入到读取的map中。
    serviceDataIndexes.put(singleton, result);
    return result;
}

getAllInstancesFromIndex从索引中获取所有的实例列表。

private List<Instance> getAllInstancesFromIndex(Service service) {
    Set<Instance> result = new HashSet<>();
    Set<String> clusters = new HashSet<>();
    // 这里根据service获取到所有的已经注册的clientId
    for (String each : serviceIndexesManager.getAllClientsRegisteredService(service)) {
        // 再根据clientId获取到注册的client，获取client中的服务注册的信息
        Optional<InstancePublishInfo> instancePublishInfo = getInstanceInfo(each, service);
        if (instancePublishInfo.isPresent()) {
            InstancePublishInfo publishInfo = instancePublishInfo.get();
            //If it is a BatchInstancePublishInfo type, it will be processed manually and added to the instance list
            if (publishInfo instanceof BatchInstancePublishInfo) {
                BatchInstancePublishInfo batchInstancePublishInfo = (BatchInstancePublishInfo) publishInfo;
                List<Instance> batchInstance = parseBatchInstance(service, batchInstancePublishInfo, clusters);
                result.addAll(batchInstance);
            } else {
                Instance instance = parseInstance(service, instancePublishInfo.get());
                result.add(instance);
                clusters.add(instance.getClusterName());
            }
        }
    }
    // cache clusters of this service
    serviceClusterIndex.put(service, clusters);
    return new LinkedList<>(result);
}

private Optional<InstancePublishInfo> getInstanceInfo(String clientId, Service service) {
    Client client = clientManager.getClient(clientId);
    if (null == client) {
        return Optional.empty();
    }
    return Optional.ofNullable(client.getInstancePublishInfo(service));
}

• serviceIndexesManager.getAllClientsRegisteredService(service)

这里的publisherIndexes是服务注册已经放进去的数据。而在查询的时候直接进行查询。

// 应用Service和clientId的映射，一个应用Service有多个服务，所以会建立多个长连接，用Set来保存clientId
private final ConcurrentMap<Service, Set<String>> publisherIndexes = new ConcurrentHashMap<>();
// 应用Service和订阅者clientId的关系
private final ConcurrentMap<Service, Set<String>> subscriberIndexes = new ConcurrentHashMap<>();

public Collection<String> getAllClientsRegisteredService(Service service) {
    return publisherIndexes.containsKey(service) ? publisherIndexes.get(service) : new ConcurrentHashSet<>();
}

到这里就可以获取到所有的已经注册的服务列表了。