@Override
public ServiceInstance choose(String serviceId) {
   return choose(serviceId, null);
}
// 通过服务名选择具体的服务实例
public ServiceInstance choose(String serviceId, Object hint) {
   Server server = getServer(getLoadBalancer(serviceId), hint);
   if (server == null) {
      return null;
   }
   return new RibbonServer(serviceId, server, isSecure(server, serviceId),
         serverIntrospector(serviceId).getMetadata(server));
}
// 通过服务名选择一个负载均衡器, 默认是 `ZoneAwareLoadBalancer`
protected ILoadBalancer getLoadBalancer(String serviceId) {
   return this.clientFactory.getLoadBalancer(serviceId);
}
// 获取服务
protected Server getServer(ILoadBalancer loadBalancer) {
   return getServer(loadBalancer, null);
}
protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
   if (loadBalancer == null) {
      return null;
   }
   // Use 'default' on a null hint, or just pass it on?
   return loadBalancer.chooseServer(hint != null ? hint : "default");
}

// LoadBalancerRequest 是通过 LoadBalancerRequestFactory.createRequest(request, body, execution) 创建
// 它实现 LoadBalancerRequest 接口是用的一个匿名内部类，泛型类型是ClientHttpResponse
// 因为最终执行的显然还是执行器：ClientHttpRequestExecution.execute()
@Override
public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
  return execute(serviceId, request, null);
}
public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint) throws IOException {
  // 拿到负载均衡器，然后拿到一个serverInstance实例
  ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
  Server server = getServer(loadBalancer, hint);
  if (server == null) { // 若没找到就直接抛出异常。这里使用的是IllegalStateException这个异常
    throw new IllegalStateException("No instances available for " + serviceId);
  }
  // 把Server适配为RibbonServer  isSecure：客户端是否安全
  // serverIntrospector内省  参考配置文件：ServerIntrospectorProperties
  RibbonServer ribbonServer = new RibbonServer(serviceId, server,
      isSecure(server, serviceId), serverIntrospector(serviceId).getMetadata(server));
  //调用本类的重载接口方法
  return execute(serviceId, ribbonServer, request);
}
// 它的参数是 ServiceInstance --> 已经确定了唯一的Server实例
@Override
public <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException {
  // 拿到 Server，RibbonServer 是 execute 时的唯一实现
  Server server = null;
  if (serviceInstance instanceof RibbonServer) {
    server = ((RibbonServer) serviceInstance).getServer();
  }
  if (server == null) {
    throw new IllegalStateException("No instances available for " + serviceId);
  }
  // 执行的上下文是和serviceId绑定的
  RibbonLoadBalancerContext context = this.clientFactory.getLoadBalancerContext(serviceId);
  ... 
  // 真正的向server发送请求，得到返回值
  // 因为有拦截器，所以这里肯定说执行的是InterceptingRequestExecution.execute()方法
  // so会调用ServiceRequestWrapper.getURI()，从而就会调用reconstructURI()方法
    T returnVal = request.apply(serviceInstance);
    return returnVal;
  ... // 异常处理
}

public class NacosServerList extends AbstractServerList<NacosServer> {
  private NacosDiscoveryProperties discoveryProperties;
  @Override
  public List<NacosServer> getUpdatedListOfServers() {
    return getServers();
  }
    private List<NacosServer> getServers() {
    try {
      String group = discoveryProperties.getGroup();
      // discoveryProperties.namingServiceInstance() 
            // 最终通过反射获取 com.alibaba.nacos.client.naming.NacosNamingService 实例
            List<Instance> instances = discoveryProperties.namingServiceInstance()
          .selectInstances(serviceId, group, true);
      return instancesToServerList(instances);
    }
    catch (Exception e) {
      throw new IllegalStateException(
          "Can not get service instances from nacos, serviceId=" + serviceId,
          e);
    }
  }
}

@Override
public List<Instance> selectInstances(String serviceName, String groupName, List<String> clusters, boolean healthy,
                                      boolean subscribe) throws NacosException {
    ServiceInfo serviceInfo;
    // subscribe 默认传的是 true
    if (subscribe) {
        serviceInfo = hostReactor.getServiceInfo(NamingUtils.getGroupedName(serviceName, groupName),
                                                 StringUtils.join(clusters, ","));
    } else {
        serviceInfo = hostReactor
            .getServiceInfoDirectlyFromServer(NamingUtils.getGroupedName(serviceName, groupName),
                                              StringUtils.join(clusters, ","));
    }
    return selectInstances(serviceInfo, healthy);
}

public ServiceInfo getServiceInfo(final String serviceName, final String clusters) {
        NAMING_LOGGER.debug("failover-mode: " + failoverReactor.isFailoverSwitch());
        String key = ServiceInfo.getKey(serviceName, clusters);
        if (failoverReactor.isFailoverSwitch()) {
            return failoverReactor.getService(key);
        }
        ServiceInfo serviceObj = getServiceInfo0(serviceName, clusters);
        if (null == serviceObj) {
            serviceObj = new ServiceInfo(serviceName, clusters);
            serviceInfoMap.put(serviceObj.getKey(), serviceObj);
            updatingMap.put(serviceName, new Object());
            updateServiceNow(serviceName, clusters);
            updatingMap.remove(serviceName);
        } else if (updatingMap.containsKey(serviceName)) {
            // UPDATE_HOLD_INTERVAL 为常量默认金辉进去
            if (UPDATE_HOLD_INTERVAL > 0) {
                // hold a moment waiting for update finish
                synchronized (serviceObj) {
                    try {
                        // 最大等待时间 5s, 在更新 serviceObj 之后, 就会执行 notifyAll()
                        // 方法入口 updateService(String serviceName, String clusters)
                        // 最大延迟 2s DEFAULT_DELAY = 1
                        serviceObj.wait(UPDATE_HOLD_INTERVAL);
                    } catch (InterruptedException e) {
                        NAMING_LOGGER
                                .error("[getServiceInfo] serviceName:" + serviceName + ", clusters:" + clusters, e);
                    }
                }
            }
        }
      // 通过 Schedule 更新 服务信息 
        scheduleUpdateIfAbsent(serviceName, clusters);
      // 获取最新的值
        return serviceInfoMap.get(serviceObj.getKey());
    }