dubbo消费端如何找到服务端对象，进行方法调用的

关于该问题，要从以下几点点出发

• 消费端如何生成代理对象的
  dubbo的ReferenceBean实现了InitializingBean，这是Spring中Bean的生命周期的方法，所以生成代理对象的逻辑放在了afterPropertiesSet()里面，创建代理对象的逻辑最终追溯到ReferenceConfig#createProxy方法里面。

  private T createProxy(Map<String, String> map) {
      if (shouldJvmRefer(map)) {
          URL url = new URL(LOCAL_PROTOCOL, LOCALHOST_VALUE, 0, interfaceClass.getName()).addParameters(map);
          invoker = REF_PROTOCOL.refer(interfaceClass, url);
          if (logger.isInfoEnabled()) {
              logger.info("Using injvm service " + interfaceClass.getName());
          }
      } else {
          urls.clear(); // reference retry init will add url to urls, lead to OOM
          if (url != null && url.length() > 0) { // user specified URL, could be peer-to-peer address, or register center's address.
              String[] us = SEMICOLON_SPLIT_PATTERN.split(url);
              if (us != null && us.length > 0) {
                  for (String u : us) {
                      URL url = URL.valueOf(u);
                      if (StringUtils.isEmpty(url.getPath())) {
                          url = url.setPath(interfaceName);
                      }
                      if (REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                          urls.add(url.addParameterAndEncoded(REFER_KEY, StringUtils.toQueryString(map)));
                      } else {
                          urls.add(ClusterUtils.mergeUrl(url, map));
                      }
                  }
              }
          } else { // assemble URL from register center's configuration
              // if protocols not injvm checkRegistry
              if (!LOCAL_PROTOCOL.equalsIgnoreCase(getProtocol())){
                  checkRegistry();
                  List<URL> us = loadRegistries(false);
                  if (CollectionUtils.isNotEmpty(us)) {
                      for (URL u : us) {
                          URL monitorUrl = loadMonitor(u);
                          if (monitorUrl != null) {
                              map.put(MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
                          }
                          urls.add(u.addParameterAndEncoded(REFER_KEY, StringUtils.toQueryString(map)));
                      }
                  }
                  if (urls.isEmpty()) {
                      throw new IllegalStateException("No such any registry to reference " + interfaceName + " on the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", please config <dubbo:registry address=\"...\" /> to your spring config.");
                  }
              }
          }
  
          if (urls.size() == 1) {
              invoker = REF_PROTOCOL.refer(interfaceClass, urls.get(0));
          } else {
              List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
              URL registryURL = null;
              for (URL url : urls) {
              	//关键入口
                  invokers.add(REF_PROTOCOL.refer(interfaceClass, url));
                  if (REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                      registryURL = url; // use last registry url
                  }
              }
              if (registryURL != null) { // registry url is available
                  // use RegistryAwareCluster only when register's CLUSTER is available
                  URL u = registryURL.addParameter(CLUSTER_KEY, RegistryAwareCluster.NAME);
                  // The invoker wrap relation would be: RegistryAwareClusterInvoker(StaticDirectory) -> FailoverClusterInvoker(RegistryDirectory, will execute route) -> Invoker
                  invoker = CLUSTER.join(new StaticDirectory(u, invokers));
              } else { // not a registry url, must be direct invoke.
                  invoker = CLUSTER.join(new StaticDirectory(invokers));
              }
          }
      }
  

  通过refer方法，来到RegistryProtocol#doRefer方法，生成代理对象的关键方法，该方法主要做了几件事情

  private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
      RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
      directory.setRegistry(registry);
      directory.setProtocol(protocol);
      // all attributes of REFER_KEY
      Map<String, String> parameters = new HashMap<String, String>(directory.getUrl().getParameters());
      URL subscribeUrl = new URL(CONSUMER_PROTOCOL, parameters.remove(REGISTER_IP_KEY), 0, type.getName(), parameters);
      if (!ANY_VALUE.equals(url.getServiceInterface()) && url.getParameter(REGISTER_KEY, true)) {
          directory.setRegisteredConsumerUrl(getRegisteredConsumerUrl(subscribeUrl, url));
          registry.register(directory.getRegisteredConsumerUrl());
      }
      directory.buildRouterChain(subscribeUrl);
      //订阅
      directory.subscribe(subscribeUrl.addParameter(CATEGORY_KEY,
              PROVIDERS_CATEGORY + "," + CONFIGURATORS_CATEGORY + "," + ROUTERS_CATEGORY));
  
      Invoker invoker = cluster.join(directory);
      ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
      return invoker;
  }
  

  1. 创建了RegistryDirectory对象，这里的RegistryDirectory是一个关键点，仔细查看的话，该类是实现了NotifyListener接口，说白了它自己是一个listener，doRefer里面directory进行了订阅，具体代码如下，比如我们用zk作为注册中心，实际应该是执行的ZookeeperRegistry#subscribe，但是它没有，所以去找其父类FailbackRegistry

  public void subscribe(URL url, NotifyListener listener) {
      super.subscribe(url, listener);
      removeFailedSubscribed(url, listener);
      try {
          // Sending a subscription request to the server side
          doSubscribe(url, listener);
      } catch (Exception e) {
          Throwable t = e;
  
          List<URL> urls = getCacheUrls(url);
          if (CollectionUtils.isNotEmpty(urls)) {
              notify(url, listener, urls);
              logger.error("Failed to subscribe " + url + ", Using cached list: " + urls + " from cache file: " + getUrl().getParameter(FILE_KEY, System.getProperty("user.home") + "/dubbo-registry-" + url.getHost() + ".cache") + ", cause: " + t.getMessage(), t);
          } else {
              // If the startup detection is opened, the Exception is thrown directly.
              boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
                      && url.getParameter(Constants.CHECK_KEY, true);
              boolean skipFailback = t instanceof SkipFailbackWrapperException;
              if (check || skipFailback) {
                  if (skipFailback) {
                      t = t.getCause();
                  }
                  throw new IllegalStateException("Failed to subscribe " + url + ", cause: " + t.getMessage(), t);
              } else {
                  logger.error("Failed to subscribe " + url + ", waiting for retry, cause: " + t.getMessage(), t);
              }
          }
  
          // Record a failed registration request to a failed list, retry regularly
          addFailedSubscribed(url, listener);
      }
  }
  

  最终是super.subscribe将我们的URL和listener关联(其实也就是directory对象本身)，放入成员变量subscribed里。

  2. 将客户端的信息注册到注册中心上去

  registry.register(directory.getRegisteredConsumerUrl());
  

  3. 对directory进行包装，生成一个invoker对象，生成invoker对象的逻辑基本到此结束了，需要关注的点是生成的invoker其实是MockClusterInvoker(FailoverClusterInvoker(directory))
  4. 回到createProxy方法里，在得到invoker之后，通过getProxy创建代理对象

     return (T) PROXY_FACTORY.getProxy(invoker);
     

     最终生成InvokerInvocationHandler(MockClusterInvoker(FailoverCusterInvoker(directory)))

• 消费端调用
  在上边的逻辑中我们分析了客户端生成代理对象，那么发起调用也是通过上边的代理对象进行的。通过InvokerInvocationHandler#invoke方法，先到MockClusterInvoker，再到FailOverClusterInvoer，而FailoverClusterInvoker并没有invoke方法。所以去其父类AbstractClusterInvoker里面的invoker查看。

  public Result invoke(final Invocation invocation) throws RpcException {
      checkWhetherDestroyed();
  
      // binding attachments into invocation.
      Map<String, String> contextAttachments = RpcContext.getContext().getAttachments();
      if (contextAttachments != null && contextAttachments.size() != 0) {
          ((RpcInvocation) invocation).addAttachments(contextAttachments);
      }
  	//获取服务端Invokers
      List<Invoker<T>> invokers = list(invocation);
      LoadBalance loadbalance = initLoadBalance(invokers, invocation);
      RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
      return doInvoke(invocation, invokers, loadbalance);
  }
  

  那么重点终于来了，list方法就是根据invocation获取我们服务端的invokers

  List<Invoker<T>> invokers = list(invocation);
  

  但是深入下去发现invokers是RegistryDirectory的一个成员变量，那么他是怎么来的呢？前面看过directory进行订阅的源码，我们知道，订阅会发生notify，从ZookeeperRegistry#doSubcribe的notify可知，通知是通知Listener，而RegistryDirectory本身就是Listener，所以会执行RegistryDirectory的notify，并且可以知道，只要服务发生变化都会通知。

  public synchronized void notify(List<URL> urls) {
      Map<String, List<URL>> categoryUrls = urls.stream()
              .filter(Objects::nonNull)
              .filter(this::isValidCategory)
              .filter(this::isNotCompatibleFor26x)
              .collect(Collectors.groupingBy(url -> {
                  if (UrlUtils.isConfigurator(url)) {
                      return CONFIGURATORS_CATEGORY;
                  } else if (UrlUtils.isRoute(url)) {
                      return ROUTERS_CATEGORY;
                  } else if (UrlUtils.isProvider(url)) {
                      return PROVIDERS_CATEGORY;
                  }
                  return "";
              }));
  
      List<URL> configuratorURLs = categoryUrls.getOrDefault(CONFIGURATORS_CATEGORY, Collections.emptyList());
      this.configurators = Configurator.toConfigurators(configuratorURLs).orElse(this.configurators);
  
      List<URL> routerURLs = categoryUrls.getOrDefault(ROUTERS_CATEGORY, Collections.emptyList());
      toRouters(routerURLs).ifPresent(this::addRouters);
  
      // providers
      List<URL> providerURLs = categoryUrls.getOrDefault(PROVIDERS_CATEGORY, Collections.emptyList());
      refreshOverrideAndInvoker(providerURLs);
  }
  

  最后的refreshOverrideAndInvoker–>refreshInvoker正是拿到是远程服务invoker，通过路由筛选，拿到符合消费端的invoker。

  private void refreshInvoker(List<URL> invokerUrls) {
      Assert.notNull(invokerUrls, "invokerUrls should not be null");
  
      if (invokerUrls.size() == 1
              && invokerUrls.get(0) != null
              && EMPTY_PROTOCOL.equals(invokerUrls.get(0).getProtocol())) {
          this.forbidden = true; // Forbid to access
          this.invokers = Collections.emptyList();
          routerChain.setInvokers(this.invokers);
          destroyAllInvokers(); // Close all invokers
      } else {
          this.forbidden = false; // Allow to access
          Map<String, Invoker<T>> oldUrlInvokerMap = this.urlInvokerMap; // local reference
          if (invokerUrls == Collections.<URL>emptyList()) {
              invokerUrls = new ArrayList<>();
          }
          if (invokerUrls.isEmpty() && this.cachedInvokerUrls != null) {
              invokerUrls.addAll(this.cachedInvokerUrls);
          } else {
              this.cachedInvokerUrls = new HashSet<>();
              this.cachedInvokerUrls.addAll(invokerUrls);//Cached invoker urls, convenient for comparison
          }
          if (invokerUrls.isEmpty()) {
              return;
          }
          Map<String, Invoker<T>> newUrlInvokerMap = toInvokers(invokerUrls);// Translate url list to Invoker map
  
          /**
           * If the calculation is wrong, it is not processed.
           *
           * 1. The protocol configured by the client is inconsistent with the protocol of the server.
           *    eg: consumer protocol = dubbo, provider only has other protocol services(rest).
           * 2. The registration center is not robust and pushes illegal specification data.
           *
           */
          if (CollectionUtils.isEmptyMap(newUrlInvokerMap)) {
              logger.error(new IllegalStateException("urls to invokers error .invokerUrls.size :" + invokerUrls.size() + ", invoker.size :0. urls :" + invokerUrls
                      .toString()));
              return;
          }
  
          List<Invoker<T>> newInvokers = Collections.unmodifiableList(new ArrayList<>(newUrlInvokerMap.values()));
          // pre-route and build cache, notice that route cache should build on original Invoker list.
          // toMergeMethodInvokerMap() will wrap some invokers having different groups, those wrapped invokers not should be routed.
          routerChain.setInvokers(newInvokers);
          this.invokers = multiGroup ? toMergeInvokerList(newInvokers) : newInvokers;
          this.urlInvokerMap = newUrlInvokerMap;
  
          try {
              destroyUnusedInvokers(oldUrlInvokerMap, newUrlInvokerMap); // Close the unused Invoker
          } catch (Exception e) {
              logger.warn("destroyUnusedInvokers error. ", e);
          }
      }
  }
  

  通知中除了更新invokers，在AbstractRegistry#notify方法中对服务地址进行了缓存，也就是说即使注册中心挂了之后，我们的消费端仍然能通过缓存获取服务地址，进行调用。

缓存存储

protected void notify(URL url, NotifyListener listener, List<URL> urls) {
 		...
            saveProperties(url);
        ...
}

private void saveProperties(URL url) {
        if (file == null) {
            return;
        }

        try {
            StringBuilder buf = new StringBuilder();
            Map<String, List<URL>> categoryNotified = notified.get(url);
            if (categoryNotified != null) {
                for (List<URL> us : categoryNotified.values()) {
                    for (URL u : us) {
                        if (buf.length() > 0) {
                            buf.append(URL_SEPARATOR);
                        }
                        buf.append(u.toFullString());
                    }
                }
            }
            properties.setProperty(url.getServiceKey(), buf.toString());
            long version = lastCacheChanged.incrementAndGet();
            if (syncSaveFile) {
                doSaveProperties(version);
            } else {
                registryCacheExecutor.execute(new SaveProperties(version));
            }
        } catch (Throwable t) {
            logger.warn(t.getMessage(), t);
        }
    }

值得注意的是在doSaveProperties方法中,使用的是文件锁实现占用的问题，缓存文件具体格式为文件名是服务名称，里面的内容是消费端列表，多个相同的服务实例，修改缓存文件会引起冲突，需要我们自定义配置

缓存使用

public void subscribe(URL url, NotifyListener listener) {
        super.subscribe(url, listener);
        removeFailedSubscribed(url, listener);
        try {
            // Sending a subscription request to the server side
            doSubscribe(url, listener);
        } catch (Exception e) {
            Throwable t = e;

            List<URL> urls = getCacheUrls(url);
            if (CollectionUtils.isNotEmpty(urls)) {
                notify(url, listener, urls);
                logger.error("Failed to subscribe " + url + ", Using cached list: " + urls + " from cache file: " + getUrl().getParameter(FILE_KEY, System.getProperty("user.home") + "/dubbo-registry-" + url.getHost() + ".cache") + ", cause: " + t.getMessage(), t);
            } else {
                // If the startup detection is opened, the Exception is thrown directly.
                boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
                        && url.getParameter(Constants.CHECK_KEY, true);
                boolean skipFailback = t instanceof SkipFailbackWrapperException;
                if (check || skipFailback) {
                    if (skipFailback) {
                        t = t.getCause();
                    }
                    throw new IllegalStateException("Failed to subscribe " + url + ", cause: " + t.getMessage(), t);
                } else {
                    logger.error("Failed to subscribe " + url + ", waiting for retry, cause: " + t.getMessage(), t);
                }
            }

            // Record a failed registration request to a failed list, retry regularly
            addFailedSubscribed(url, listener);
        }
    }

在FailbackRegistry中执行订阅的时候，如果能正常从注册中心订阅，也就是调用模板方法doSubscribe，默认是ZoookeeperRegistry#doSubscribe方法，如果失败，则会从缓存获取地址，然后notify生成相应的invokers。