Dubbo源码学习总结系列三 dubbo-cluster集群模块

Dubbo集群模块的目的是将集群Invokers构造一个透明的Invoker对象，其中包含了容错机制、负载均衡、目录服务（服务地址集合）、路由机制等，为RPC层提供高可用、高并发、自动发现、可治理的SOA特性。

本文我们主要讨论以下八个问题：

一、集群模块的需求功能点有哪些？

二、集群模块的总体设计框架是什么样的？

三、Dubbo提供了哪些容错机制？如何实现的？

四、Dubbo提供了哪些负载均衡机制？如何实现的？

五、Dubbo目录服务是干什么的？提供了哪几种类型的目录服务？

六、Dubbo提供了哪些路由机制？如何实现的？

七、总结集群模块如何带来高可用、自动发现、可治理的特性？

        一、集群模块的需求功能点有哪些？

基于文章开头讨论的目标内容，我认为集群模块的需求功能点主要有以下几点：

1、将集群Invokers构造一个透明的Invoker对象提供给Rpc模块调用；

2、提供容错机制，包括Failover（失败自动切换，尝试其他服务器）、Failfast（失败立即返回并抛出异常）、Failsafe（失败忽略异常）、Failback（失败自动恢复，记录日志并定时重试）、Forking(并行调用多个服务，一个成功立即返回)、Broadcast(广播调用所有提供者，任意一个报错则报错)；

3、提供负载均衡机制，包括Random(带权重的随机访问)、RoundRobin（带权重的轮训访问）、LeastActive（选择最少活跃者）、ConsistentHash(一致性哈希，相同参数的请求总是发到同一提供者)；

4、提供目录服务，包括静态目录服务（将调用地址存到本地）、注册中心注册目录服务两种方式；

5、提供路由机制，包括条件路由（在URL配置条件表达式）和脚本路由（使用脚本语言编写脚本，返回路由结果）；

        二、集群模块的总体设计框架是什么样的？

调用关系如下图所示：

接口声明如下图所示：

        

Cluster接口：声明join()方法，从Directory实例中的Invoker列表中返回一个Invoker；

Directory接口：list()方法，可查询Invoker列表；

LoadBalance接口：select()方法，可从一个Invoker集合中结合负载均衡策略选择一个Invoker返回；

Router接口：route()方法，从给定的Invoker集合路由选择一个Invoker返回；

Merger接口：merge(T)方法，将多个调用返回的结果合并起来返回；

Configurator接口：configure(URL)方法，配置加工URL参数并返回；

三、Dubbo提供了哪些集群容错机制？如何实现的？

        由于篇幅过程，我将其内容单独写了一篇博客，详见 《集群容错机制》。

        

四、Dubbo提供了哪些负载均衡机制？如何实现的?

        由于篇幅过长，我又将内容拆分到另一片博客，见《集群负载均衡》。

五、Dubbo目录服务是干什么的？提供了哪几种类型的目录服务？

        dubbo目录服务提供了获取提供者服务地址列表的功能，目录服务的调用者是com.alibaba.dubbo.rpc.cluster.Cluster的join()方法。目前dubbo提供了静态目录服务和注册中心目录服务。静态目录服务实现了一个静态的地址列表本地内存缓存。注册中心目录服务提供了分布式注册检索服务地址的功能。在提供目录服务返回服务地址的时候，调用dubbo的路由服务，实现了请求服务的路由功能。接下来，我们来讨论目录服务的实现细节。

1、Directory接口

Directory接口中，

Class<T> getInterface()方法返回服务的接口类；

list(Invocation invocation)就是获取服务地址列表的方法；

父接口Node中，

getUrl()方法返回了服务声明的URL信息，

isAvailable()方法判断目录服务是否可用，或者是否存在可用的服务提供者；

destroy()销毁目录服务及所有提供者服务。

2、AbstractDirectory，目录服务的默认实现抽象类；

（1）将路由对象引入目录服务，方法setRouters()设置了路由对象，实现见如下代码：

     protected void setRouters(List<Router> routers) {
         // copy list
         routers = routers == null ? new ArrayList<Router>() : new ArrayList<Router>(routers);
         // append url router
         String routerkey = url.getParameter(Constants.ROUTER_KEY);
         if (routerkey != null && routerkey.length() > 0) {
               //通过SPI实例化配置的路由对象工厂对象
             RouterFactory routerFactory = ExtensionLoader.getExtensionLoader(RouterFactory.class).getExtension(routerkey);
             routers.add(routerFactory.getRouter(url));
         }
         // append mock invoker selector
         routers.add(new MockInvokersSelector());
         Collections.sort(routers);
         this.routers = routers;
     }

（2）得到服务对象列表，主要通过doList()实现得到服务列表，此方法由子类实现，然后依次调用router列表做路由筛选，实现如下：

     public List<Invoker<T>> list(Invocation invocation) throws RpcException {
         if (destroyed) {
             throw new RpcException("Directory already destroyed .url: " + getUrl());
         }
         List<Invoker<T>> invokers = doList(invocation);
         List<Router> localRouters = this.routers; // local reference
         if (localRouters != null && localRouters.size() > 0) {
             for (Router router : localRouters) {
                 try {
                     if (router.getUrl() == null || router.getUrl().getParameter(Constants.RUNTIME_KEY, false)) {
                         invokers = router.route(invokers, getConsumerUrl(), invocation);
                     }
                 } catch (Throwable t) {
                     logger.error("Failed to execute router: " + getUrl() + ", cause: " + t.getMessage(), t);
                 }
             }
         }
         return invokers;
     }

3、StaticDirectory静态目录服务，doList()将构造方法中传入的invoker列表原样返回。

4、RegistryDirectory 类整合了注册中心和目录服务，具体实现实在dubbo-register模块，我将另外写一篇博客讨论。

        六、Dubbo提供了哪些路由机制？如何实现的？

路由机制为用户提供了灵活可配置的服务筛选功能，通过用户自定义配置路由规则，决定一次 dubbo 服务调用的目标服务器。使用场景例如：提供差异化服务，给重要的请求提供性能好的服务器，反之给次要的服务提供性能差的服务器；读写分离，根据方法名字add,update,delete等分为一组，查询方法分为一组，分别映射到不同的服务器上；对客户端设置白名单、黑名单；更多场景及具体的应用说明详见dubbo用户手册路由规则篇。

dubbo提供了两种路由机制：条件路由和脚本路由。

1、向注册中心写入路由规则，通常由监控中心或服务治理页面完成，代码实现主要在dubb-register模块：

 RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
 Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
 registry.register(URL.valueOf("condition://0.0.0.0/com.foo.BarService?category=routers&dynamic=false&rule=" + URL.encode("host = 10.20.153.10 => host = 10.20.153.11") + "));

其中：

• condition:// 表示路由规则的类型，支持条件路由规则和脚本路由规则，可扩展，必填。
• 0.0.0.0 表示对所有 IP 地址生效，如果只想对某个 IP 的生效，请填入具体 IP，必填。
• com.foo.BarService 表示只对指定服务生效，必填。
• category=routers 表示该数据为动态配置类型，必填。
• dynamic=false 表示该数据为持久数据，当注册方退出时，数据依然保存在注册中心，必填。
• enabled=true 覆盖规则是否生效，可不填，缺省生效。
• force=false 当路由结果为空时，是否强制执行，如果不强制执行，路由结果为空的路由规则将自动失效，可不填，缺省为 flase。
• runtime=false 是否在每次调用时执行路由规则，否则只在提供者地址列表变更时预先执行并缓存结果，调用时直接从缓存中获取路由结果。如果用了参数路由，必须设为 true，需要注意设置会影响调用的性能，可不填，缺省为 flase。
• priority=1 路由规则的优先级，用于排序，优先级越大越靠前执行，可不填，缺省为 0。
• rule=URL.encode("host = 10.20.153.10 => host = 10.20.153.11") 表示路由规则的内容，必填。

2、条件路由

基于条件表达式的路由规则，如：host = 10.20.153.10 => host = 10.20.153.11。=>左边的表达式表示消费端信息（matchWhen），右边的表达式表示服务提供者的服务信息(matchThen)。

代码实现中，解析=>左右的条件表达式，左侧消费端条件表达式解析成when，右侧服务端条件表达式解析成then，封装matchWhen()和matchThen()分别匹配消费端和服务端表达式。

我们看看源码如何实现路由逻辑的。

条件路由实现主要靠两个类，ConditionRouterFactory，实现了ConditionRouter实例化的过程；ConditionRouter，实现了具体的路由机制，其中route方法实现如下，实现主要靠解析和匹配条件表达式。

     public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation)
             throws RpcException {
         if (invokers == null || invokers.size() == 0) {
             return invokers;
         }
         try {
               //消费端条件不匹配规则，就全部返回
             if (!matchWhen(url, invocation)) {
                 return invokers;
             }
             List<Invoker<T>> result = new ArrayList<Invoker<T>>();
             if (thenCondition == null) {
                 logger.warn("The current consumer in the service blacklist. consumer: " + NetUtils.getLocalHost() + ", service: " + url.getServiceKey());
                 return result;
             }
             for (Invoker<T> invoker : invokers) {
                   //遍历invokers，找到匹配规则的invoker(服务端)加入result
                 if (matchThen(invoker.getUrl(), url)) {
                     result.add(invoker);
                 }
             }
             if (result.size() > 0) {
                 return result;
             } else if (force) { //如果结果为空，force=true，则返回空的列表，否则返回所有的invokers（不执行route规则）
                 logger.warn("The route result is empty and force execute. consumer: " + NetUtils.getLocalHost() + ", service: " + url.getServiceKey() + ", router: " + url.getParameterAndDecoded(Constants.RULE_KEY));
                 return result;
             }
         } catch (Throwable t) {
             logger.error("Failed to execute condition router rule: " + getUrl() + ", invokers: " + invokers + ", cause: " + t.getMessage(), t);
         }
         return invokers;
     }

3、脚本路由

通过配置脚本或脚本文件设置路由规则rule，程序编译执行脚本函数，得到脚本筛选后的invokers数组。具体逻辑很简单，就是加载脚本，加载对应脚本引擎，执行脚本，得到结果后转换输出的过程。

     public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException {
         try {
             List<Invoker<T>> invokersCopy = new ArrayList<Invoker<T>>(invokers);
             Compilable compilable = (Compilable) engine;
             Bindings bindings = engine.createBindings();
             bindings.put("invokers", invokersCopy);
             bindings.put("invocation", invocation);
             bindings.put("context", RpcContext.getContext());
             CompiledScript function = compilable.compile(rule);
             Object obj = function.eval(bindings);
             if (obj instanceof Invoker[]) {
                 invokersCopy = Arrays.asList((Invoker<T>[]) obj);
             } else if (obj instanceof Object[]) {
                 invokersCopy = new ArrayList<Invoker<T>>();
                 for (Object inv : (Object[]) obj) {
                     invokersCopy.add((Invoker<T>) inv);
                 }
             } else {
                 invokersCopy = (List<Invoker<T>>) obj;
             }
             return invokersCopy;
         } catch (ScriptException e) {
             //fail then ignore rule .invokers.
             logger.error("route error , rule has been ignored. rule: " + rule + ", method:" + invocation.getMethodName() + ", url: " + RpcContext.getContext().getUrl(), e);
             return invokers;
         }
     }

七、总结集群模块如何带来高可用、自动发现、可治理的特性？

集群模块在dubbo中非常重要，提供了基于RPC功能的高可用特性，此特性主要是通过集群容错和负载均衡策略支持的，在服务提供者出现异常时，可配置的容错特性确保服务能按照配置的策略返回，或切换到其他服务并重试，或立即抛出异常，满足了不同服务不同场景的异常后处理需要。可配置的负载均衡策略满足了不同场景、需求的服务实现负载均衡，在不同场景下均匀的分摊负载，在负载不够用的情况下灵活的增加机器节点承担多余的负载，保证了集群的高可用特性。并且可以灵活配置节点的权重，实现针对不同配置的服务节点承担的请求不同。

可配置的路由功能满足了很多场景下的灵活路由需求，如读写分离，消费端请求的白名单、黑名单，针对不同配置的服务提供给不同的消费者等等。由于可配置性强，可以针对不同的需求做不同的配置，可提供很灵活的功能特性。通过配置规则，实现服务降级，可以屏蔽有问题的服务，并定义服务响应。这些都体现了Dubbo可治理的特性。

目录服务简单的定义了对服务地址列表的查询功能，配合dubb-register注册中心模块功能可以实现服务注册、自动发现功能。详见注册中心模块的源码分析章节。

集群模块就讨论到这里了，如有不当之处，欢迎大家提出异议和宝贵的意见，这样有助于我技术上的提升。