Dubbo 源码分析 - 集群容错之 Router

注: 本系列文章已捐赠给 Dubbo 社区，你也可以在 Dubbo 官方文档中阅读本系列文章。

1. 简介

上一篇文章分析了集群容错的第一部分 – 服务目录 Directory。服务目录在刷新 Invoker 列表的过程中，会通过 Router 进行服务路由。上一篇文章关于服务路由相关逻辑没有细致分析，一笔带过了，本篇文章将对此进行详细的分析。首先，先来介绍一下服务目录是什么。服务路由包含一条路由规则，路由规则决定了服务消费者的调用目标，即规定了服务消费者可调用哪些服务提供者。Dubbo 目前提供了三种服务路由实现，分别为条件路由 ConditionRouter、脚本路由 ScriptRouter 和标签路由 TagRouter。其中条件路由是我们最常使用的，标签路由暂未在我所分析的 2.6.4 版本中提供，该实现会在 2.7.0 版本中提供。本篇文章将分析条件路由相关源码，脚本路由和标签路由这里就不分析了。下面进入正题。

2. 源码分析

条件路由规则有两个条件组成，分别用于对服务消费者和提供者进行匹配。比如有这样一条规则：

host = 10.20.153.10 => host = 10.20.153.11

该条规则表示 IP 为 10.20.153.10 的服务消费者只可调用 IP 为 10.20.153.11 机器上的服务，不可调用其他机器上的服务。条件路由规则的格式如下：

[服务消费者匹配条件] => [服务提供者匹配条件]

如果服务消费者匹配条件为空，表示不对服务消费者进行限制。如果服务提供者匹配条件为空，表示对某些服务消费者禁用服务。Dubbo 官方文档对条件路由进行了比较详细的介绍，大家可以参考下，这里就不过多说明了。

条件路由实现类 ConditionRouter 需要对用户配置的路由规则进行解析，得到一系列的条件。然后再根据这些条件对服务进行路由。本章将分两节进行说明，2.1节介绍表达式解析过程。2.2 节介绍服务路由的过程。接下来，我们先从表达式解析过程看起。

2.1 表达式解析

条件路由规则是一条字符串，对于 Dubbo 来说，它并不能直接理解字符串的意思，需要将其解析成内部格式才行。条件表达式的解析过程始于 ConditionRouter 的构造方法，下面一起看一下：

如上，ConditionRouter 构造方法先是对路由规则做预处理，然后调用 parseRule 方法分别对服务提供者和消费者规则进行解析，最后将解析结果赋值给 whenCondition 和 thenCondition 成员变量。ConditionRouter 构造方法不是很复杂，这里就不多说了。下面我们把重点放在 parseRule 方法上，在详细介绍这个方法之前，我们先来看一个内部类。

<table><tbody><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>private static final class MatchPair { final Set<String> matches = new HashSet<String>(); final Set<String> mismatches = new HashSet<String>(); } </pre></td></tr></tbody></table>

MatchPair 内部包含了两个 Set 型的成员变量，分别用于存放匹配和不匹配的条件。这个类两个成员变量会在 parseRule 方法中被用到，下面来看一下。

<table><tbody><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 </pre></td><td class="code"><pre>private static Map<String, MatchPair> parseRule(String rule) throws ParseException { // 定义条件映射集合 Map<String, MatchPair> condition = new HashMap<String, MatchPair>(); if (StringUtils.isBlank(rule)) { return condition; } MatchPair pair = null; Set<String> values = null; // 通过正则表达式匹配路由规则，ROUTE_PATTERN = ([&!=,]*)\s*([^&!=,\s]+) // 这个表达式看起来不是很好理解，第一个括号内的表达式用于匹配"&", "!", "=" 和 "," 等符号。 // 第二括号内的用于匹配英文字母，数字等字符。举个例子说明一下： // host = 2.2.2.2 & host != 1.1.1.1 & method = hello // 匹配结果如下： // 括号一括号二 // 1. null host // 2. = 2.2.2.2 // 3. & host // 4. != 1.1.1.1 // 5. & method // 6. = hello final Matcher matcher = ROUTE_PATTERN.matcher(rule); while (matcher.find()) { // 获取括号一内的匹配结果 String separator = matcher.group(1); // 获取括号二内的匹配结果 String content = matcher.group(2); // 分隔符为空，表示匹配的是表达式的开始部分 if (separator == null || separator.length() == 0) { // 创建 MatchPair 对象 pair = new MatchPair(); // 存储 <匹配项, MatchPair> 键值对，比如 <host, MatchPair> condition.put(content, pair); } // 如果分隔符为 &，表明接下来也是一个条件 else if ("&".equals(separator)) { // 尝试从 condition 获取 MatchPair if (condition.get(content) == null) { // 未获取到 MatchPair，重新创建一个，并放入 condition 中 pair = new MatchPair(); condition.put(content, pair); } else { pair = condition.get(content); } } // 分隔符为 = else if ("=".equals(separator)) { if (pair == null) throw new ParseException("Illegal route rule ..."); values = pair.matches; // 将 content 存入到 MatchPair 的 matches 集合中 values.add(content); } // 分隔符为 != else if ("!=".equals(separator)) { if (pair == null) throw new ParseException("Illegal route rule ..."); values = pair.mismatches; // 将 content 存入到 MatchPair 的 mismatches 集合中 values.add(content); } // 分隔符为 , else if (",".equals(separator)) { if (values == null || values.isEmpty()) throw new ParseException("Illegal route rule ..."); // 将 content 存入到上一步获取到的 values 中，可能是 matches，也可能是 mismatches values.add(content); } else { throw new ParseException("Illegal route rule ..."); } } return condition; } </pre></td></tr></tbody></table>

以上就是路由规则的解析逻辑，该逻辑由正则表达式 + 一个 while 循环 + 数个条件分支组成。下面使用一个示例对解析逻辑进行演绎。示例为 host = 2.2.2.2 & host != 1.1.1.1 & method = hello。正则解析结果如下：

现在线程进入 while 循环：

第一次循环：分隔符 separator = null，content = “host”。此时创建 MatchPair 对象，并存入到 condition 中，condition = {“host”: MatchPair@123}

第二次循环：分隔符 separator = “=”，content = “2.2.2.2”，pair = MatchPair@123。此时将 2.2.2.2 放入到 MatchPair@123 对象的 matches 集合中。

第三次循环：分隔符 separator = “&”，content = “host”。host 已存在于 condition 中，因此 pair = MatchPair@123。

第四次循环：分隔符 separator = “!=”，content = “1.1.1.1”，pair = MatchPair@123。此时将 1.1.1.1 放入到 MatchPair@123 对象的 mismatches 集合中。

第五次循环：分隔符 separator = “&”，content = “method”。condition.get(“method”) = null，因此新建一个 MatchPair 对象，并放入到 condition 中。此时 condition = {“host”: MatchPair@123, “method”: MatchPair@ 456}

第六次循环：分隔符 separator = “=”，content = “2.2.2.2”，pair = MatchPair@456。此时将 hello 放入到 MatchPair@456 对象的 matches 集合中。

循环结束，此时 condition 的内容如下：

路由规则的解析过程稍微有点复杂，大家可通过 ConditionRouter 的测试类对该逻辑进行测试。并且找一个表达式，对照上面的代码走一遍，加深理解。关于路由规则的解析过程就先到这，我们继续往下看。

2.2 服务路由

服务路由的入口方法是 ConditionRouter 的 router 方法，该方法定义在 Router 接口中。实现代码如下：

router 方法先是调用 matchWhen 对服务消费者进行匹配，如果匹配失败，直接返回 Invoker 列表。如果匹配成功，再对服务提供者进行匹配，匹配逻辑封装在了 matchThen 方法中。下面来看一下这两个方法的逻辑：

这两个方法长的有点像，不过逻辑上还是有差别的，大家注意看。这两个方法均调用了 matchCondition 方法，不过它们所传入的参数是不同的，这个需要特别注意。不然后面的逻辑不好弄懂。下面我们对这几个参数进行溯源。matchWhen 方法向 matchCondition 方法传入的参数为 [whenCondition, url, null, invocation]，第一个参数 whenCondition 为服务消费者匹配条件，这个前面分析过。第二个参数 url 源自 route 方法的参数列表，该参数由外部类调用 route 方法时传入。有代码为证，如下：

上面这段代码来自 RegistryDirectory，第二个参数表示的是服务消费者 url。matchCondition 的 invocation 参数也是从这里传入的。

接下来再来看看 matchThen 向 matchCondition 方法传入的参数 [thenCondition, url, param, null]。第一个参数不用解释了。第二个和第三个参数来自 matchThen 方法的参数列表，这两个参数分别为服务提供者 url 和服务消费者 url。搞清楚这些参数来源后，接下俩就可以分析 matchCondition 了。

如上，matchCondition 方法看起来有点复杂，这里简单缕缕。分割线以上的代码实际上主要是用于获取 sampleValue 的值，分割线以下才是进行条件匹配。条件匹配调用的逻辑封装在 isMatch 中，代码如下：

isMatch 方法逻辑比较清晰，由三个条件分支组成，用于处理四种情况。这里对四种情况下的匹配逻辑进行简单的总结，如下：

	条件	动作
情况一	matches 非空，mismatches 为空	遍历 matches 集合元素，并与入参进行匹配。只要有一个元素成功匹配入参，即可返回 true。若全部失配，则返回 false。
情况二	matches 为空，mismatches 非空	遍历 mismatches 集合元素，并与入参进行匹配。只要有一个元素成功匹配入参，立即 false。若全部失配，则返回 true。
情况三	matches 非空，mismatches 非空	优先使用 mismatches 集合元素对入参进行匹配，只要任一元素与入参匹配成功，就立即返回 false，结束方法逻辑。否则再使用 matches 中的集合元素进行匹配，只要有任意一个元素匹配成功，即可返回 true。若全部失配，则返回 false
情况四	matches 为空，mismatches 为空	直接返回 false

isMatch 方法逻辑不是很难理解，大家自己再看看。下面继续分析 isMatchGlobPattern 方法。

<table><tbody><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 </pre></td><td class="code"><pre>public static boolean isMatchGlobPattern(String pattern, String value, URL param) { if (param != null && pattern.startsWith("$")) { // 引用服务消费者参数，param 参数为服务消费者 url pattern = param.getRawParameter(pattern.substring(1)); } // 调用重载方法继续比较 return isMatchGlobPattern(pattern, value); } public static boolean isMatchGlobPattern(String pattern, String value) { // 对 * 通配符提供支持 if ("*".equals(pattern)) // 匹配规则为通配符 *，直接返回 true 即可 return true; if ((pattern == null || pattern.length() == 0) && (value == null || value.length() == 0)) // pattern 和 value 均为空，此时可认为两者相等，返回 true return true; if ((pattern == null || pattern.length() == 0) || (value == null || value.length() == 0)) // pattern 和 value 其中有一个为空，两者不相等，返回 false return false; // 查找 * 通配符位置 int i = pattern.lastIndexOf('*'); if (i == -1) { // 匹配规则中不包含通配符，此时直接比较 value 和 pattern 是否相等即可，并返回比较结果 return value.equals(pattern); } // 通配符 "*" 在匹配规则尾部，比如 10.0.21.* else if (i == pattern.length() - 1) { // 检测 value 是否以不含通配符的匹配规则开头，并返回结果。比如: // pattern = 10.0.21.*，value = 10.0.21.12，此时返回 true return value.startsWith(pattern.substring(0, i)); } // 通配符 "*" 在匹配规则头部 else if (i == 0) { // 检测 value 是否以不含通配符的匹配规则结尾，并返回结果 return value.endsWith(pattern.substring(i + 1)); } // 通配符 "*" 在匹配规则中间位置 else { // 通过通配符将 pattern 分成两半，得到 prefix 和 suffix String prefix = pattern.substring(0, i); String suffix = pattern.substring(i + 1); // 检测 value 是否以 prefix 变量开头，且以 suffix 变量结尾，并返回结果 return value.startsWith(prefix) && value.endsWith(suffix); } } </pre></td></tr></tbody></table>

以上就是 isMatchGlobPattern 两个重载方法的全部逻辑，这两个方法分别对普通的匹配，以及”引用消费者参数“和通配符匹配做了支持。这两个方法的逻辑并不是很复杂，而且我也在代码上进行了比较详细的注释，大家自己看看吧，就不多说了。

3. 总结

本篇文章对条件路由的表达式解析和服务路由过程进行了较为细致的分析。总的来说，条件路由的代码还是有一些复杂的，需要静下心来看。在阅读条件路由代码的过程中，要多调试。一般的框架都会有单元测试，Dubbo 也不例外，因此大家可以直接通过 ConditionRouterTest 对条件路由进行调试，无需自己手写测试用例。

好了，关于条件路由就先分析到这，谢谢阅读。

本文链接： https://www.tianxiaobo.com/2018/11/20/Dubbo-源码分析-集群容错之-Router/

版权声明： 本博客所有文章除特别声明外，均采用知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议许可协议。转载请注明出处！

田小波

勿在浮沙筑高台

本文转自 http://www.tianxiaobo.com/2018/11/20/Dubbo-%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90-%E9%9B%86%E7%BE%A4%E5%AE%B9%E9%94%99%E4%B9%8B-Router/，如有侵权，请联系删除。