// 1. 创建ServiceConfig实例
ServiceConfig<IGreetingService> serviceConfig = new ServiceConfig<>();
// 2. 设置应用程序配置
serviceConfig.setApplication(new ApplicationConfig("deep-in-dubbo-first-provider"));
// 3. 设置注册中心
RegistryConfig registryConfig = new RegistryConfig("zookeeper://127.0.0.1:2181/");
serviceConfig.setRegistry(registryConfig);
// 4. 设置接口和实现类
// 5. 设置服务分组和版本
// dubbo中，服务接口+服务分组+服务版本 唯一的确定一个服务，同一个接口可以有不同版本，方便维护升级
serviceConfig.setInterface(IGreetingService.class);
serviceConfig.setRef(new GreetingServiceImpl());
serviceConfig.setVersion("1.0.0");
serviceConfig.setGroup("dubbo-sxzhongf-group");
RpcContext.getContext().setAttachment("age","18");

// 7. 导出服务，启动Netty监听链接请求，并将服务注册到注册中心
serviceConfig.export();

// 8. 挂起线程，避免服务停止
System.out.println("api provider service is started...");
System.in.read();

public synchronized void export() {
//1. 是否导出
  if (!shouldExport()) {
      return;
  }
  ...
      //2.延迟导出
  if (shouldDelay()) {
      DELAY_EXPORT_EXECUTOR.schedule(this::doExport, getDelay(), TimeUnit.MILLISECONDS);
  } else {
      //3.立刻导出
      doExport();
  }
}

private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
    String key = getCacheKey(originInvoker);
    return (ExporterChangeableWrapper<T>) bounds.computeIfAbsent(key, s -> {
        Invoker<?> invokerDelegate = new InvokerDelegate<>(originInvoker, providerUrl);
        return new ExporterChangeableWrapper<>((Exporter<T>) protocol.export(invokerDelegate), originInvoker);
    });
}

@Override
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        URL url = invoker.getUrl();
        // export service.
        String key = serviceKey(url);
        // invoker->exporter
        DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
        exporterMap.put(key, exporter);

        //export an stub service for dispatching event
        Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT);
        Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false);
        if (isStubSupportEvent && !isCallbackservice) {
            String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY);
            if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
                if (logger.isWarnEnabled()) {
                    logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY) +
                            "], has set stubproxy support event ,but no stub methods founded."));
                }

            } else {
                stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
            }
        }
        //创建server
        openServer(url);
        //序列化提示
        optimizeSerialization(url);
        return exporter;
    }

private void openServer(URL url) {
    // find server.
    String key = url.getAddress();
    //client can export a service which's only for server to invoke
    boolean isServer = url.getParameter(IS_SERVER_KEY, true);
    if (isServer) {
        ProtocolServer server = serverMap.get(key);
        if (server == null) {
            synchronized (this) {
                server = serverMap.get(key);
                if (server == null) {
                    serverMap.put(key, createServer(url));
                }
            }
        } else {
            // server supports reset, use together with override
            server.reset(url);
        }
    }
}

final Registry registry = getRegistry(originInvoker);
...
protected Registry getRegistry(final Invoker<?> originInvoker) {
    URL registryUrl = getRegistryUrl(originInvoker);
    return registryFactory.getRegistry(registryUrl);
}

@Override
public void doRegister(URL url) {
    try {
        zkClient.create(toUrlPath(url), url.getParameter(DYNAMIC_KEY, true));
    } catch (Throwable e) {
        throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
    }
}

public class ApiConsumerApplication {
    public static void main(String[] args) {
        // 1. 创建服务引用对象实例
        ReferenceConfig<IGreetingService> referenceConfig = new ReferenceConfig<IGreetingService>();
        // 2. 设置应用程序信息
        referenceConfig.setApplication(new ApplicationConfig("deep-in-dubbo-first-consumer"));
        // 3. 设置注册中心
        referenceConfig.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181/"));
        // 4. 设置服务接口和超时时间
        referenceConfig.setInterface(IGreetingService.class);
        // 默认重试3次
        referenceConfig.setTimeout(5000);
        // 5 设置服务分组和版本
        referenceConfig.setGroup("dubbo-sxzhongf-group");
        referenceConfig.setVersion("1.0.0");
        // 6. 引用服务
        IGreetingService greetingService = referenceConfig.get();
        // 7. 设置隐式参数
        RpcContext.getContext().setAttachment("company", "sxzhongf");
        // 获取provider端传递的隐式参数(FIXME: 需要后续追踪)
//        System.out.println("年龄是：" + RpcContext.getContext().getAttachment("age"));
        //8. 调用服务
        System.out.println(greetingService.sayHello("pan"));
    }
}

private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
    // 1.可以查寻RegistryDirectory & StaticDirectory 区别
    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());
    //2. 封装订阅所用URL
    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());
    }
    //3.build路由规则链
    directory.buildRouterChain(subscribeUrl);
    //4.订阅服务提供者地址
    directory.subscribe(subscribeUrl.addParameter(CATEGORY_KEY,
            PROVIDERS_CATEGORY + "," + CONFIGURATORS_CATEGORY + "," + ROUTERS_CATEGORY));
    //5.封装集群策略到虚拟invoker
    Invoker invoker = cluster.join(directory);
    return invoker;
}

@Override
public <T> Invoker<T> protocolBindingRefer(Class<T> serviceType, URL url) throws RpcException {
    optimizeSerialization(url);

    // create rpc invoker.
    DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);
    invokers.add(invoker);

    return invoker;
}

private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
    Invoker<T> last = invoker;
    // 获取所有在MATA-INF文件中配置的激活的责任链接口
    List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);

    if (!filters.isEmpty()) {
        for (int i = filters.size() - 1; i >= 0; i--) {
            final Filter filter = filters.get(i);
            final Invoker<T> next = last;
            last = new Invoker<T>() {

                @Override
                public Class<T> getInterface() {
                    return invoker.getInterface();
                }

                @Override
                public URL getUrl() {
                    return invoker.getUrl();
                }

                @Override
                public boolean isAvailable() {
                    return invoker.isAvailable();
                }

                @Override
                public Result invoke(Invocation invocation) throws RpcException {
                    Result asyncResult;
                    try {
                        asyncResult = filter.invoke(next, invocation);
                    } catch (Exception e) {
                        if (filter instanceof ListenableFilter) {// Deprecated!
                            Filter.Listener listener = ((ListenableFilter) filter).listener();
                            if (listener != null) {
                                listener.onError(e, invoker, invocation);
                            }
                        } else if (filter instanceof Filter.Listener) {
                            Filter.Listener listener = (Filter.Listener) filter;
                            listener.onError(e, invoker, invocation);
                        }
                        throw e;
                    } finally {

                    }
                    return asyncResult.whenCompleteWithContext((r, t) -> {
                        if (filter instanceof ListenableFilter) {// Deprecated!
                            Filter.Listener listener = ((ListenableFilter) filter).listener();
                            if (listener != null) {
                                if (t == null) {
                                    listener.onMessage(r, invoker, invocation);
                                } else {
                                    listener.onError(t, invoker, invocation);
                                }
                            }
                        } else if (filter instanceof Filter.Listener) {
                            Filter.Listener listener = (Filter.Listener) filter;
                            if (t == null) {
                                listener.onMessage(r, invoker, invocation);
                            } else {
                                listener.onError(t, invoker, invocation);
                            }
                        } else {// Deprecated!
                            filter.onResponse(r, invoker, invocation);
                        }
                    });
                }

                @Override
                public void destroy() {
                    invoker.destroy();
                }

                @Override
                public String toString() {
                    return invoker.toString();
                }
            };
        }
    }

    return last;
}

public class JavassistProxyFactory extends AbstractProxyFactory {

    @Override
    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }
    ...
}

private volatile List<Invoker<T>> invokers;

private final List<Invoker<T>> invokers;

private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
    // 创建RegistryDirectory对象
    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());
    }

    // 根据URL创建调用规则链路
    directory.buildRouterChain(subscribeUrl);
    // 订阅服务提供者信息
    directory.subscribe(subscribeUrl.addParameter(CATEGORY_KEY,
            PROVIDERS_CATEGORY + "," + CONFIGURATORS_CATEGORY + "," + ROUTERS_CATEGORY));

    Invoker invoker = cluster.join(directory);
    return invoker;
}

//该方法我们之前有提过，调用生成路由链路
public void buildRouterChain() {
    RouterChain<T> routerChain = RouterChain.buildChain(getUrl());
    routerChain.setInvokers(invokers);
    this.setRouterChain(routerChain);
}

// 该方法是主方法，处理选择list
@Override
protected List<Invoker<T>> doList(Invocation invocation) throws RpcException {
    List<Invoker<T>> finalInvokers = invokers;
    if (routerChain != null) {
        try {
            finalInvokers = routerChain.route(getConsumerUrl(), invocation);
        } catch (Throwable t) {
            logger.error("Failed to execute router: " + getUrl() + ", cause: " + t.getMessage(), t);
        }
    }
    return finalInvokers == null ? Collections.emptyList() : finalInvokers;
}

this.multiGroup = group != null && (ANY_VALUE.equals(group) || group.contains(","));

this.invokers = multiGroup ? toMergeInvokerList(newInvokers) : newInvokers;

private List<Invoker<T>> toMergeInvokerList(List<Invoker<T>> invokers) {
  List<Invoker<T>> mergedInvokers = new ArrayList<>();
  Map<String, List<Invoker<T>>> groupMap = new HashMap<>();
  // 必须是多注册中心，否则这里即便设置了多组也只会添加一个组
  for (Invoker<T> invoker : invokers) {
      String group = invoker.getUrl().getParameter(GROUP_KEY, "");
      groupMap.computeIfAbsent(group, k -> new ArrayList<>());
      groupMap.get(group).add(invoker);
  }

  if (groupMap.size() == 1) {
      mergedInvokers.addAll(groupMap.values().iterator().next());
  } else if (groupMap.size() > 1) {
      for (List<Invoker<T>> groupList : groupMap.values()) {
          //这里
          StaticDirectory<T> staticDirectory = new StaticDirectory<>(groupList);
          staticDirectory.buildRouterChain();
          mergedInvokers.add(CLUSTER.join(staticDirectory));
      }
  } else {
      mergedInvokers = invokers;
  }
  return mergedInvokers;
}

//org.apache.dubbo.registry.integration.RegistryDirectory#buildRouterChain
public void buildRouterChain(URL url) {
  this.setRouterChain(RouterChain.buildChain(url));
}

//org.apache.dubbo.rpc.cluster.RouterChain#buildChain
public static <T> RouterChain<T> buildChain(URL url) {
    return new RouterChain<>(url);
}

//org.apache.dubbo.rpc.cluster.RouterChain#RouterChain
private RouterChain(URL url) {
  List<RouterFactory> extensionFactories = ExtensionLoader.getExtensionLoader(RouterFactory.class)
          .getActivateExtension(url, "router");

  List<Router> routers = extensionFactories.stream()
          .map(factory -> factory.getRouter(url))
          .collect(Collectors.toList());

  initWithRouters(routers);
}

// org.apache.dubbo.rpc.cluster.RouterChain#initWithRouters
public void initWithRouters(List<Router> builtinRouters) {
    this.builtinRouters = builtinRouters;
    this.routers = new ArrayList<>(builtinRouters);
    this.sort();
}

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())) {
      ...
  } else {
      ...
      // 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);
      }
  }
}

//org.apache.dubbo.rpc.cluster.RouterChain#setInvokers
public void setInvokers(List<Invoker<T>> invokers) {
    this.invokers = (invokers == null ? Collections.emptyList() : invokers);
    routers.forEach(router -> router.notify(this.invokers));
}