Dubbo学习笔记：Dubbo-Spring整合demo及浅析

Dubbo整合demo

• 需要使用zookeeper作为注册中心，使用maven作为包管理，配合spring/springboot搭建项目
• demo地址：https://github.com/chen-TR/gmall-dubbo

dubbo高可用

zookeeper宕机与dubbo直连

现象：zookeeper注册中心宕机，还可以消费dubbo暴露的服务。
原因：健壮性

• 监控中心宕机不影响使用，只是丢失部分采集数据
• 数据库宕掉后，注册中心仍能通过缓存提供服务列表查询。但不能注册新服务
• 注册中心对等集群，任意一台宕机后，将自动切换到另外一台可用服务器
• 注册中心全部宕机后，服务提供者（provider）和服务消费者（consumer）仍能通过本地缓存通讯
• 服务提供者无状态，任意一台宕机后，不影响使用
• 服务提供者全部宕机后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复

高可用：通过设计，减少系统不能提供服务的时间。

集群下dubbo负载均衡配置

在集群负载均衡时，Dubbo 提供了多种均衡策略，缺省为 random 随机调用。

负载均衡策略

• Random LoadBalance
  随机，按权重设置随机概率。
  在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。
• RoundRobin LoadBalance
  轮循，按公约后的权重设置轮循比率。
  存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。
• LeastActive LoadBalance
  最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
  使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。
• ConsistentHash LoadBalance
  一致性 Hash，相同参数的请求总是发到同一提供者。
  当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。算法参见：http://en.wikipedia.org/wiki/Consistent_hashing
  缺省只对第一个参数 Hash，如果要修改，请配置 <dubbo:parameter key=“hash.arguments” value=“0,1” />
  缺省用 160 份虚拟节点，如果要修改，请配置 <dubbo:parameter key=“hash.nodes” value=“320” />
• 一致性哈希和哈希的区别
  可参考该博客

整合hystrix，服务熔断与降级处理

1. 服务降级

什么是服务降级？

当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。

可以通过服务降级功能临时屏蔽某个出错的非关键服务，并定义降级后的返回策略。

向注册中心写入动态配置覆盖规则：

RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
registry.register(URL.valueOf("override://0.0.0.0/com.foo.BarService?category=configurators&dynamic=false&application=foo&mock=force:return+null"));

其中：

• mock=force:return+null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
• 还可以改为 mock=fail:return+null 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

2.集群容错

在集群调用失败时，Dubbo 提供了多种容错方案，缺省为 failover 重试。

Failover Cluster
失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过 retries="2" 来设置重试次数(不含第一次)。

重试次数配置如下：
<dubbo:service retries="2" />
或
<dubbo:reference retries="2" />
或
<dubbo:reference>
    <dubbo:method name="findFoo" retries="2" />
</dubbo:reference>

Failfast Cluster
快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。

Failsafe Cluster
失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。

Failback Cluster
失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。

Forking Cluster
并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks="2" 来设置最大并行数。

Broadcast Cluster
广播调用所有提供者，逐个调用，任意一台报错则报错 [2]。通常用于通知所有提供者更新缓存或日志等本地资源信息。

集群模式配置
按照以下示例在服务提供方和消费方配置集群模式
<dubbo:service cluster="failsafe" />
或
<dubbo:reference cluster="failsafe" />

3.整合hystrix 服务熔断

Hystrix 旨在通过控制那些访问远程系统、服务和第三方库的节点，从而对延迟和故障提供更强大的容错能力。Hystrix具备拥有回退机制和断路器功能的线程和信号隔离，请求缓存和请求打包，以及监控和配置等功能（spring Cloud内置）

1. 配置spring-cloud-starter-netflix-hystrix

spring boot官方提供了对hystrix的集成，直接在pom.xml里加入依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>1.4.4.RELEASE</version>
</dependency>

然后在Application类上增加@EnableHystrix来启用hystrix starter：

@SpringBootApplication
@EnableHystrix
public class ProviderApplication {

2. 配置Provider端

在Dubbo的Provider上增加@HystrixCommand配置，这样子调用就会经过Hystrix代理。

@Service(version = "1.0.0")
public class HelloServiceImpl implements HelloService {
    @HystrixCommand(commandProperties = {
     @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
     @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2000") })
    @Override
    public String sayHello(String name) {
        // System.out.println("async provider received: " + name);
        // return "annotation: hello, " + name;
        throw new RuntimeException("Exception to show hystrix enabled.");
    }
}

3. 配置Consumer端

对于Consumer端，则可以增加一层method调用，并在method上配置@HystrixCommand。当调用出错时，会走到fallbackMethod = "reliable"的调用里。

@Reference(version = "1.0.0")
private HelloService demoService;

@HystrixCommand(fallbackMethod = "reliable")
public String doSayHello(String name) {
    return demoService.sayHello(name);
}
public String reliable(String name) {
    return "hystrix fallback value";
}

dubbo原理 详见文档

1.RPC原理

2.netty通信原理

3.dubbo原理

3.1框架设计

• service业务层：用户关心的业务层，面向接口编程
• RPC 远程调用层：
  • config 配置层：对外配置接口，以 ServiceConfig, ReferenceConfig 为中心，可以直接初始化配置类，也可以通过 spring 解析配置生成配置类
  • proxy 服务代理层：服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中心，扩展接口为 ProxyFactory
  • registry 注册中心层：封装服务地址的注册与发现，以服务 URL 为中心，扩展接口为 RegistryFactory, Registry, RegistryService
  • cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中心，以 Invoker 为中心，扩展接口为 Cluster, Directory, Router, LoadBalance
  • monitor 监控层：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory, Monitor, MonitorService
  • protocol 远程调用层：封装 RPC 调用，以 Invocation, Result 为中心，扩展接口为 Protocol, Invoker, Exporter
• Remoting远程通信层：
  • exchange 信息交换层：封装请求响应模式，同步转异步，以 Request, Response 为中心，扩展接口为 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer
  • transport 网络传输层：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel, Transporter, Client, Server, Codec
  • serialize 数据序列化层：可复用的一些工具，扩展接口为 Serialization, ObjectInput, ObjectOutput, ThreadPool

3.2启动解析、加载配置信息(标签解析)

• Dubbo通过public class DubboBeanDefinitionParser implements BeanDefinitionParser类中的paese方法解析dubbo配置文件中的标签

private static BeanDefinition parse(Element element, ParserContext parserContext, Class<?> beanClass, boolean required) {
        RootBeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClass(beanClass);
        beanDefinition.setLazyInit(false);
        String id = element.getAttribute("id");
    	....
       // 判断bean的类型，做出相应的解析
       if (ProtocolConfig.class.equals(beanClass)) {
            for (String name : parserContext.getRegistry().getBeanDefinitionNames()) {
                BeanDefinition definition = parserContext.getRegistry().getBeanDefinition(name);
                PropertyValue property = definition.getPropertyValues().getPropertyValue("protocol");
                if (property != null) {
                    Object value = property.getValue();
                    if (value instanceof ProtocolConfig && id.equals(((ProtocolConfig) value).getName())) {
                        definition.getPropertyValues().addPropertyValue("protocol", new RuntimeBeanReference(id));
                    }
                }
            }
        } else if (ServiceBean.class.equals(beanClass)) {
            String className = element.getAttribute("class");
            if (className != null && className.length() > 0) {
                RootBeanDefinition classDefinition = new RootBeanDefinition();
                classDefinition.setBeanClass(ReflectUtils.forName(className));
                classDefinition.setLazyInit(false);
                parseProperties(element.getChildNodes(), classDefinition);
                beanDefinition.getPropertyValues().addPropertyValue("ref", new BeanDefinitionHolder(classDefinition, id + "Impl"));
            }
        } else if (ProviderConfig.class.equals(beanClass)) 
            parseNested(element, parserContext, ServiceBean.class, true, "service", "provider", id, beanDefinition);
        } else if (ConsumerConfig.class.equals(beanClass)) {
            parseNested(element, parserContext, ReferenceBean.class, false, "reference", "consumer", id, beanDefinition);
        }
    	....
        return beanDefinition;

• 而DubboDefinitionParser中的beanclass是通过DubboNameSpaceHandler注册到容器中的-

@Override
public void init() {
    registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
    registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
    registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
    registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
    registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
    registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
    registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
    registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
    registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
    registerBeanDefinitionParser("annotation", new AnnotationBeanDefinitionParser());
}

DubboDefinitionParser将配置文件中的每一个标签解析成一个xxxConfig或者是xxxBean，由于dubbo是在spring应用的基础上运行的，所以将解析出来的config和bean也和spring应用一样会生成一个对应的BeanDefinition。

3.3服务暴露

• Dubbo服务的暴露主要和ServiceBean的生命周期有关系，ServiceBean实现了InitializingBean以及ApplicationListener<ContextRefreshedEvent>的接口。

• InitializingBean接口定义了一个afterPropertiesSet方法，可以在bean初始化属性设置之后执行。

      if (!providerConfigs.isEmpty()) {
          setProviders(providerConfigs);
      }
  ...
      if (applicationConfig != null) {
          setApplication(applicationConfig);
      }
  ...
      if (moduleConfig != null) {
          setModule(moduleConfig);
      }
  ...
      if (registryConfigs != null && !registryConfigs.isEmpty()) {
          super.setRegistries(registryConfigs);
      }
  ...
      if (getPath() == null || getPath().length() == 0) {
          if (beanName != null && beanName.length() > 0
              && getInterface() != null && getInterface().length() > 0
              && beanName.startsWith(getInterface())) {
              setPath(beanName);
          }
  	if (!isDelay()) {
  		export();  //当未开启延迟暴露的时候serviceBean初始化属性设置完成后暴露服务
      }
  

• ApplicationListener<ContextRefreshedEvent>中定义了onApplicationEvent可以在容器加载完成之后执行，监听的事件是ContextRefreshedEvent。

  @Override
  public void onApplicationEvent(ContextRefreshedEvent event) {
      if (isDelay() && !isExported() && !isUnexported()) {
          if (logger.isInfoEnabled()) {
              logger.info("The service ready on spring started. service: " + getInterface());
          }
          export(); //对于设置了延迟暴露并且尚未暴露的服务，会在ioc容器加载完成后暴露服务
      }
  

• export()方法中会调用doExport()方法,doExport()方法又会执行doExportUrls()方法

  @SuppressWarnings({"unchecked", "rawtypes"})
  private void doExportUrls() {
      List<URL> registryURLs = loadRegistries(true); // 读取注册中心
      for (ProtocolConfig protocolConfig : protocols) {
          doExportUrlsFor1Protocol(protocolConfig, registryURLs); // 暴露一个协议的Urls
      }
  }
  
  private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
      ...
          // 创建一个invoker，包含了执行的对象，方法，url地址等等信息
          Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
      	DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
  
     		Exporter<?> exporter = protocol.export(wrapperInvoker); //暴露invoker
      	exporters.add(exporter);
      ...
  }
  

  Protocol是一个接口，这里的protocol属性是通过Dubbo实现的SPI机制获得的,在这里会调用RegistryProtocol以及DubboProtocol中的exprot方法。

  private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
  
  /* 在registryProtocol中的export方法
  	1.在本地暴露服务，其中会调用DubboProtocol中的export方法
  	2.会在一个服务服务者消费者的注册表中注册provider
  */
  final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
  ...
  ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl，registedProviderUrl);
  }
  
  /*
  	调用了ProviderConsumerRegTable中维护了两个map，保存了providerInvokers和
      consumerInvokers的信息，set是由于一个服务可以由多个实现，例如一个userservice
      可以开启多个主机端口，一起进行服务，然后再通过负载均衡策列选择不同的端口进行负载等等
  */
  public class ProviderConsumerRegTable {
      public static ConcurrentHashMap<String, Set<ProviderInvokerWrapper>> providerInvokers = new ConcurrentHashMap<String, Set<ProviderInvokerWrapper>>();
      public static ConcurrentHashMap<String, Set<ConsumerInvokerWrapper>> consumerInvokers = new ConcurrentHashMap<String, Set<ConsumerInvokerWrapper>>();
  
      public static void registerProvider(Invoker invoker, URL registryUrl, URL providerUrl) {
          ProviderInvokerWrapper wrapperInvoker = new ProviderInvokerWrapper(invoker, registryUrl, providerUrl);
          String serviceUniqueName = providerUrl.getServiceKey();
          Set<ProviderInvokerWrapper> invokers = providerInvokers.get(serviceUniqueName);
          if (invokers == null) {
              providerInvokers.putIfAbsent(serviceUniqueName, new ConcurrentHashSet<ProviderInvokerWrapper>());
              invokers = providerInvokers.get(serviceUniqueName);
          }
          invokers.add(wrapperInvoker);
      }
  
  /* 在DubboProtocol中的export方法
  	1. 获取invoker的url，后续通过netty底层监听这个端口
  	2. 将invoker封装成一个exporter
  	3. openServer(url)
  */
  @Override
  public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
      URL url = invoker.getUrl();
  
      // export service.
      String key = serviceKey(url);
      DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
      exporterMap.put(key, exporter);
  
      //export an stub service for dispatching event
      Boolean isStubSupportEvent = url.getParameter(Constants.STUB_EVENT_KEY, Constants.DEFAULT_STUB_EVENT);
      Boolean isCallbackservice = url.getParameter(Constants.IS_CALLBACK_SERVICE, false);
      if (isStubSupportEvent && !isCallbackservice) {
          String stubServiceMethods = url.getParameter(Constants.STUB_EVENT_METHODS_KEY);
          if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
              if (logger.isWarnEnabled()) {
                  logger.warn(new IllegalStateException("consumer [" + url.getParameter(Constants.INTERFACE_KEY) + "], has set stubproxy support event ,but no stub methods founded."));
              }
          } else {
              stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
          }
      }
  
      openServer(url);
      optimizeSerialization(url);
      return exporter;
  }
  /*
  	底层是启动了netty服务器，监听20880端口等操作
  */
  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(Constants.IS_SERVER_KEY, true);
      if (isServer) {
          ExchangeServer server = serverMap.get(key);
          if (server == null) {
              serverMap.put(key, createServer(url));
          } else {
              // server supports reset, use together with override
              server.reset(url);
          }
      }
  }
  /*
  	bind绑定url，监听端口，底层会调用Transporters的bind方法，也就是到了netty的底层方法中了
  */
  private ExchangeServer createServer(URL url) {
      // send readonly event when server closes, it's enabled by default
      url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());
      // enable heartbeat by default
      url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
      String str = url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_SERVER);
  
      if (str != null && str.length() > 0 && !ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str))
          throw new RpcException("Unsupported server type: " + str + ", url: " + url);
  
      url = url.addParameter(Constants.CODEC_KEY, DubboCodec.NAME);
      ExchangeServer server;
      try {
          server = Exchangers.bind(url, requestHandler);  
      } catch (RemotingException e) {
          throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
      }
      str = url.getParameter(Constants.CLIENT_KEY);
      if (str != null && str.length() > 0) {
          Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
          if (!supportedTypes.contains(str)) {
              throw new RpcException("Unsupported client type: " + str);
          }
      }
      return server;
  }
  

3.4服务引用

• Dubbo服务的引用主要与ReferenceBean相关，ReferenceBean是一个FactoryBean，在获取service的时候通过ReferenceBean的get方法获得对象。

      public synchronized T get() {
          if (destroyed) {
              throw new IllegalStateException("Already destroyed!");
          }
          if (ref == null) {
              init(); // 如果组件为空，则初始化
          }
          return ref;
      }
  /*
  	在init()方法中会调用CreatProxy方法创建代理对象
  */
  ...
      ref = createProxy(map);
  ...
  /*
  	在creatProxy方法中会待用refprotocol的refer方法引用远程接口，
  	并且通过返回的invoker对象创建Proxy代理对象
  */ 
      if (urls.size() == 1) {
          invoker = refprotocol.refer(interfaceClass, urls.get(0));
      } else {
          List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
          URL registryURL = null;
          for (URL url : urls) {
              invokers.add(refprotocol.refer(interfaceClass, url));
              if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                  registryURL = url; // use last registry url
              }
          }
          if (registryURL != null) { // registry url is available
              // use AvailableCluster only when register's cluster is available
              URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME);
              invoker = cluster.join(new StaticDirectory(u, invokers));
          } else { // not a registry url
              invoker = cluster.join(new StaticDirectory(invokers));
          }
       ...
       // create service proxy
       return (T) proxyFactory.getProxy(invoker);  
  

  • 创建代理对象也是通过jdk动态代理等方法实现的
    

• refprotocol的实现机制也是跟上面服务暴露中类似的SPI机制，在这里会调用RegistryProtocol以及DubboProtocol中的refer方法。

  /*
  	RegistryProtocol中的refer方法
  */
  @Override
  @SuppressWarnings("unchecked")
  public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
      url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
      Registry registry = registryFactory.getRegistry(url);  // 获取注册中心
      if (RegistryService.class.equals(type)) {
          return proxyFactory.getInvoker((T) registry, type, url);
      }
  
      // group="a,b" or group="*"
      Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded(Constants.REFER_KEY));
      String group = qs.get(Constants.GROUP_KEY);
      if (group != null && group.length() > 0) {
          if ((Constants.COMMA_SPLIT_PATTERN.split(group)).length > 1
              || "*".equals(group)) {
              return doRefer(getMergeableCluster(), registry, type, url);
          }
      }
      return doRefer(cluster, registry, type, url);
  }
  
  /*	
  	在doRefer()方法中会在注册中心中订阅提供者服务,
  	subscribe()方法会进入DubboProtocol中的refer方法
  */
  directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
                      Constants.PROVIDERS_CATEGORY
                       + "," + Constants.CONFIGURATORS_CATEGORY
                       + "," + Constants.ROUTERS_CATEGORY));
  Invoker invoker = cluster.join(directory);
  // 注册消费者invoker
  ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
  
  /*
  	DubboProtocol中的refer方法
  */
  @Override
  public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
      optimizeSerialization(url);
      // create rpc invoker. 
      // 在getClicents方法中机会创建一个netty客户端，连接引用服务的端口了。
      DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);
      invokers.add(invoker);
      return invoker; // 返回invoker
  }
  

3.5服务调用

• dubbo官方文档中有关于dubbo服务调用的调用链

  

• 代理对象Proxy中的invoker对象是一个InvokerInvocationHandler实例，待用代理对象invoker的invoke方法会调用其中封装的invoker的invoke方法

  public class InvokerInvocationHandler implements InvocationHandler {
      private final Invoker<?> invoker;
      public InvokerInvocationHandler(Invoker<?> handler) {
          this.invoker = handler;
      }
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          String methodName = method.getName();
          Class<?>[] parameterTypes = method.getParameterTypes();
          if (method.getDeclaringClass() == Object.class) {
              return method.invoke(invoker, args);
          }
          if ("toString".equals(methodName) && parameterTypes.length == 0) {
              return invoker.toString();
          }
          if ("hashCode".equals(methodName) && parameterTypes.length == 0) {
              return invoker.hashCode();
          }
          if ("equals".equals(methodName) && parameterTypes.length == 1) {
              return invoker.equals(args[0]);
          }
          return invoker.invoke(new RpcInvocation(method, args)).recreate();
      }
  }
  

  invoker的调用链式类似于责任链/过滤器链的设计模式，其中会包括dubbo很多扩展功能的调用。在AbstractClusterInvoker中会获取服务的可以调用的服务的列表，提供给后续的负载均衡功能调用

  @Override
  public Result invoke(final Invocation invocation) throws RpcException {
      checkWhetherDestroyed();
      LoadBalance loadbalance = null;
      List<Invoker<T>> invokers = list(invocation);
      if (invokers != null && !invokers.isEmpty()) {
          loadbalance =           ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(invokers.get(0).getUrl().                                                                   getMethodParameter(invocation.getMethodName(), Constants.LOADBALANCE_KEY,Constants.DEFAULT_LOADBALANCE));
      }
      RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
      return doInvoke(invocation, invokers, loadbalance);
  }
  

  最终会进入到DubboInvoker中调用doInvoke方法：

  @Override
  protected Result doInvoke(final Invocation invocation) throws Throwable {
      RpcInvocation inv = (RpcInvocation) invocation;
      final String methodName = RpcUtils.getMethodName(invocation);
      inv.setAttachment(Constants.PATH_KEY, getUrl().getPath());
      inv.setAttachment(Constants.VERSION_KEY, version);
  
      ExchangeClient currentClient;
      if (clients.length == 1) {
          currentClient = clients[0];
      } else {
          currentClient = clients[index.getAndIncrement() % clients.length];
      }
      try {
          boolean isAsync = RpcUtils.isAsync(getUrl(), invocation);
          boolean isOneway = RpcUtils.isOneway(getUrl(), invocation);
          int timeout = getUrl().getMethodParameter(methodName, Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
          if (isOneway) {
              boolean isSent = getUrl().getMethodParameter(methodName, Constants.SENT_KEY, false);
              currentClient.send(inv, isSent);
              RpcContext.getContext().setFuture(null);
              return new RpcResult();
          } else if (isAsync) {
              ResponseFuture future = currentClient.request(inv, timeout);
              RpcContext.getContext().setFuture(new FutureAdapter<Object>(future));
              return new RpcResult();
          } else {
              RpcContext.getContext().setFuture(null);
              return (Result) currentClient.request(inv, timeout).get();
          }
      } catch (TimeoutException e) {
          throw new RpcException(RpcException.TIMEOUT_EXCEPTION, "Invoke remote method timeout. method: " + invocation.getMethodName() + ", provider: " + getUrl() + ", cause: " + e.getMessage(), e);
      } catch (RemotingException e) {
          throw new RpcException(RpcException.NETWORK_EXCEPTION, "Failed to invoke remote method: " + invocation.getMethodName() + ", provider: " + getUrl() + ", cause: " + e.getMessage(), e);
      }
  }