Dubbo 系列（07-2）集群容错 - 服务路由

Dubbo 系列（07-2）集群容错 - 服务路由
- 1. 背景介绍
  - 1.1 继承体系
  - 1.2 SPI
- 2. 源码分析

1. 背景介绍

相关文档推荐：

在上一节 Dubbo 系列（06-1）集群容错 - 服务字典中分析服务字典的源码，服务字典是 Dubbo 集群容错的基础，这节只在服务字典的基础上继续分析服务路由策略。

Dubbo 服务路由分为条件路由 ConditionRouter、脚本路由 ScriptRouter 和标签路由 TagRouter。其中条件路由是我们最常使用的。

条件路由：用户使用 Dubbo 定义的语法规则定义路由规则；
文件路由：需要提交一个文件，里面定义的路由规则；
脚本路由：使用 JDK 自身的脚本引擎解析路由规则脚本。

路由配置规则： [服务消费者匹配条件] => [服务提供者匹配条件] 。如果服务消费者匹配条件为空，表示不对服务消费者进行限制。如果服务提供者匹配条件为空，表示对某些服务消费者禁用服务。如 host = 10.20.153.10 => host = 10.20.153.11 ，表示 IP 为 10.20.153.10 的消费者会路由到 IP 为 10.20.153.11 的服务者。

1.1 继承体系

图1 Dubbo服务路由继承体系图

总结： Dubbo 设计的核心理念是：微内核富插件。和其它组件一样，路由策略也是通过 Dubbo SPI 动态生成的。每一个路由规则都对应一个工厂类，工厂类则是 SPI 自适应扩展点。

public interface Router extends Comparable<Router> {

    <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException;

    // routerUrl

    URL getUrl();

    boolean isForce();

    ...

}

总结： Router 最核心的方法是 route，会根据路由规则过滤 invokers，返回可用的 Invoker。

1.2 SPI

RouterFactory 是一个 SPI 接口，没有默认值，通过获取 URL.protocol 协议来创建对应的 Router 路由规则。

@SPI

public interface RouterFactory {

    @Adaptive("protocol")

    Router getRouter(URL url);

}

总结： 在 Dubbo-2.7.3 中默认的 org.apache.dubbo.rpc.cluster.RouterFactory 规则有以下几个。

file=org.apache.dubbo.rpc.cluster.router.file.FileRouterFactory

script=org.apache.dubbo.rpc.cluster.router.script.ScriptRouterFactory

condition=org.apache.dubbo.rpc.cluster.router.condition.ConditionRouterFactory

service=org.apache.dubbo.rpc.cluster.router.condition.config.ServiceRouterFactory

app=org.apache.dubbo.rpc.cluster.router.condition.config.AppRouterFactory

tag=org.apache.dubbo.rpc.cluster.router.tag.TagRouterFactory

mock=org.apache.dubbo.rpc.cluster.router.mock.MockRouterFactory

其中自适应扩展点有四个（也就是默认会加载的路由规则策略），按优先级依次为：mock > tag > app > service。

2. 源码分析

在上一节的分析服务字典源码时，当注册信息更新时会调用 notify 方法通知 RegistryDirectory 更新服务列表，其中一步就是根据配置的路由 routerURLs 解析 Router。先回顾一下之前的代码：

// 1. 路由规则创建

@Override

public synchronized void notify(List<URL> urls) {

    // routerURLs

    List<URL> routerURLs = categoryUrls.getOrDefault(ROUTERS_CATEGORY, Collections.emptyList());

    toRouters(routerURLs).ifPresent(this::addRouters);

	...

}

// 2. 路由规则使用，过滤 invokers

@Override

public List<Invoker<T>> doList(Invocation invocation) {

  	...

    List<Invoker<T>> invokers = routerChain.route(getConsumerUrl(), invocation);

    return invokers == null ? Collections.emptyList() : invokers;

}

总结： toRouters(routerURLs) 实际上在解析路由规则，如果有更新则重新设置 routeChain 的路由规则。而 doList 方法时会根据路由规则过滤服务。routeChain 会依次调用 routers，最终得到可用的 invokers。

2.1 创建路由规则

ROUTER_FACTORY 会读取 routerUrl.protocol 参数，决定使用那种路由策略，再根据 routerUrl.rule 参数解析对应的路由规则。

private static final RouterFactory ROUTER_FACTORY = ExtensionLoader.getExtensionLoader(RouterFactory.class)

            .getAdaptiveExtension();

// routerUrl 中 router 定义路由类型，rule 定义具体的路由规则

private Optional<List<Router>> toRouters(List<URL> urls) {

    if (urls == null || urls.isEmpty()) {

        return Optional.empty();

    }

    List<Router> routers = new ArrayList<>();

    for (URL url : urls) {

        if (EMPTY_PROTOCOL.equals(url.getProtocol())) {

            continue;

        }

        // 将 url.router 参数设置为 protocol

        String routerType = url.getParameter(ROUTER_KEY);

        if (routerType != null && routerType.length() > 0) {

            url = url.setProtocol(routerType);

        }

        try {

            Router router = ROUTER_FACTORY.getRouter(url);

            if (!routers.contains(router)) {

                routers.add(router);

            }

        } catch (Throwable t) {

            logger.error("convert router url to router error, url: " + url, t);

        }

    }

    return Optional.of(routers);

}

总结： toRouters 最核心的代码就是 Router router = ROUTER_FACTORY.getRouter(url) 创建路由规则。路由规则类型是由 url.router 决定的。

2.2 RouteChain

RouteChain 用于管理所有的路由规则，内部维护有几个重要的集合：

// 1. Dubbo 内部默认的路由规则（四种）：

//    MockInvokersSelector > TagRouter > AppRouter > ServiceRouter

private List<Router> builtinRouters = Collections.emptyList();

// 2. 自定义的路由规则

private volatile List<Router> routers = Collections.emptyList();

// 3. 所有可用的服务（Invoker 可简单理解为一个可执行的服务）

private List<Invoker<T>> invokers = Collections.emptyList();

2.2.1 内建路由规则

RouterChain#buildChain 会调用私有的构造函数，在初始化时会创建默认的路由规则。

// url: 订阅者URL

// 默认有四个路由规则：MockInvokersSelector/TagRouter/AppRouter/ServiceRouter

private RouterChain(URL url) {

    List<RouterFactory> extensionFactories = ExtensionLoader.getExtensionLoader(RouterFactory.class)

        .getActivateExtension(url, (String[]) null);

    // 创建内建的路由规则

    List<Router> routers = extensionFactories.stream()

        .map(factory -> factory.getRouter(url))

        .collect(Collectors.toList());

    initWithRouters(routers);

}

public void initWithRouters(List<Router> builtinRouters) {

    this.builtinRouters = builtinRouters;

    this.routers = new ArrayList<>(builtinRouters);

    this.sort();

}

2.2.2 更新路由规则

当路由规则更新时会调用 addRouters 更新路由规则，更新时仍保留内建的路由规则。

public void addRouters(List<Router> routers) {

    List<Router> newRouters = new ArrayList<>();

    newRouters.addAll(builtinRouters);

    newRouters.addAll(routers);

    CollectionUtils.sort(newRouters);

    this.routers = newRouters;

}

总结： 可以看到 builtinRouters 内建的路由规则仍会保留，路由规则的会通过排序来保证执行顺序。其实 Spring 的 BeanPostProcessor 也是保存在一个 List 中通过排序来保证执行顺序的。路由规则的更新是在 RegistryDirectory#notify 通知时。

2.2.3 更新服务列表

同路由规则的更新一样，也是在 RegistryDirectory#notify 时更新服务列表。

public void setInvokers(List<Invoker<T>> invokers) {

    this.invokers = (invokers == null ? Collections.emptyList() : invokers);

    routers.forEach(router -> router.notify(this.invokers));

}

2.2.4 执行服务路由

public List<Invoker<T>> route(URL url, Invocation invocation) {

    List<Invoker<T>> finalInvokers = invokers;

    for (Router router : routers) {

        finalInvokers = router.route(finalInvokers, url, invocation);

    }

    return finalInvokers;

}

总结： 逐个调用 Router 进行路由，这个就很简单了。

2.3 条件路由

路由规则使用见 Dubbo 路由使用手册。

"condition://0.0.0.0/org.apache.demo.DemoService?category=routers&dynamic=false&rule=" + URL.encode("host=10.20.153.10 => host=10.20.153.11")

2.3.1 条件路由规则解析

在 ConditionRouterFactory#getRouter(URL url) 直接 new ConditionRouter(url) 后就返回了，Dubbo SPI 的工厂类一般都很简单。

public ConditionRouter(URL url) {

    this.url = url;

    this.priority = url.getParameter(PRIORITY_KEY, 0);	// 优先级

    this.force = url.getParameter(FORCE_KEY, false);	// 过滤后没有服务可用，是否强制执行

    this.enabled = url.getParameter(ENABLED_KEY, true);	// enabled是否启动

    init(url.getParameterAndDecoded(RULE_KEY));			// 解析路由规则 url.rule

}

总结： ConditionRouter 解析 url.rule 配置的路由规则。条件路由配置示例如下：host = 10.20.153.10 => host = 10.20.153.11，左侧是消费者配置规则，右侧是服务者配置规则，表示消费者 host=10.20.153.10 会路由到服务者 host=10.20.153.11。

// host = 10.20.153.10 => host = 10.20.153.11

public void init(String rule) {

    try {

        if (rule == null || rule.trim().length() == 0) {

            throw new IllegalArgumentException("Illegal route rule!");

        }

        rule = rule.replace("consumer.", "")

            .replace("provider.", "");

        int i = rule.indexOf("=>");

        String whenRule = i < 0 ? null : rule.substring(0, i).trim();

        String thenRule = i < 0 ? rule.trim() : rule.substring(i + 2).trim();

        // 消费者规则解析

        Map<String, MatchPair> when = StringUtils.isBlank(whenRule) || "true".equals(whenRule) ?

            new HashMap<String, MatchPair>() : parseRule(whenRule);

        // 服务者规则解析

        Map<String, MatchPair> then = StringUtils.isBlank(thenRule) || "false".equals(thenRule) ?

            null : parseRule(thenRule);

        this.whenCondition = when;

        this.thenCondition = then;

    } catch (ParseException e) {

        throw new IllegalStateException(e.getMessage(), e);

    }

}

总结： 在 ConditionRouter 中使用两个 Map 保存了对应的匹配规则，最终解析都是在 parseRule(thenRule) 方法中完成的。

Map<String, MatchPair> when;

Map<String, MatchPair> then;

private static final class MatchPair {

    final Set<String> matches = new HashSet<String>();

    final Set<String> mismatches = new HashSet<String>();

}

这个 Map 的 key 表示匹配项，最终将匹配规则解析成如下结构：

// host = 2.2.2.2 & host != 1.1.1.1 & method = hello

{

    "host": {

        "matches": ["2.2.2.2"],

        "mismatches": ["1.1.1.1"]

    },

    "method": {

        "matches": ["hello"],

        "mismatches": []

    }

}

2.3.2 执行条件路由

执行条件路由其实就是路由规则的匹配过程：

如果禁用路由规则，直接返回原列表。
如果服务消费者匹配上，就匹配其可用的服务列表。
服务消费者匹配条件为空，表示不对服务消费者进行限制。
如果服务提供者匹配条件为空，表示对某些服务消费者禁用服务。
如果匹配后没有可用的服务，force=true表示强制执行路由规则，返回空列表，否则返回原列表。

@Override

public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException {

    // 1.1 禁用路由规则

    if (!enabled) {

        return invokers;

    }

    // 1.2 没有可用的服务

    if (CollectionUtils.isEmpty(invokers)) {

        return invokers;

    }

    try {

        // 先对服务消费者条件进行匹配，如果匹配失败，表明服务消费者 url 不符合匹配规则，

        // 无需进行后续匹配，直接返回 Invoker 列表即可。比如下面的规则：

        //     host = 10.20.153.10 => host = 10.0.0.10

        // 这条路由规则希望 IP 为 10.20.153.10 的服务消费者调用 IP 为 10.0.0.10 机器上的服务。

        // 当消费者 ip 为 10.20.153.11 时，matchWhen 返回 false，表明当前这条路由规则不适用于

        // 当前的服务消费者，此时无需再进行后续匹配，直接返回即可。

        // 2.1 消费者规则无法匹配，表示不对服务消费者进行限制

        if (!matchWhen(url, invocation)) {

            return invokers;

        }

        List<Invoker<T>> result = new ArrayList<Invoker<T>>();

        // 2.2 服务者规则放弃匹配，表明对指定的服务消费者禁用服务

        if (thenCondition == null) {

            return result;

        }

        // 2.3 服务提供者匹配规则，匹配成功表示进行服务路由

        for (Invoker<T> invoker : invokers) {

            // 若匹配成功，表明当前 Invoker 符合服务提供者匹配规则

            if (matchThen(invoker.getUrl(), url)) {

                result.add(invoker);

            }

        }

        // 2.4 匹配后没有服务可用，是否强制执行，也就是没有服务可用

        //     force=false 表示路由规则将自动失效

        if (!result.isEmpty()) {

            return result;

        } else if (force) {

            return result;

        }

    } catch (Throwable t) {

    }

    // 2.5 出现异常或force=false，表示该条路由规则失效

    return invokers;

}

总结： 具体的匹配逻辑都委托给了 matchWhen(url, invocation) 方法。

关于条件路由，规则的解析和具体的匹配过程都没有深入分析，目前来说，了解路由规则的整个运行流程更重要，如果以后用到 Dubbo 的路由规则，出了问题再做具体的深入研究，现在就到此为至。感兴趣的朋友可以参考：Dubbo 源码解读 - 服务路由。

每天用心记录一点点。内容也许不重要，但习惯很重要！