2.2 服务路由

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

  1. public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException {
  2.     if (invokers == null || invokers.isEmpty()) {
  3.         return invokers;
  4.     }
  5.     try {
  6.         // 先对服务消费者条件进行匹配，如果匹配失败，表明服务消费者 url 不符合匹配规则，
  7.         // 无需进行后续匹配，直接返回 Invoker 列表即可。比如下面的规则：
  8.         //     host = 10.20.153.10 => host = 10.0.0.10
  9.         // 这条路由规则希望 IP 为 10.20.153.10 的服务消费者调用 IP 为 10.0.0.10 机器上的服务。
  10.         // 当消费者 ip 为 10.20.153.11 时，matchWhen 返回 false，表明当前这条路由规则不适用于
  11.         // 当前的服务消费者，此时无需再进行后续匹配，直接返回即可。
  12.         if (!matchWhen(url, invocation)) {
  13.             return invokers;
  14.         }
  15.         List<Invoker<T>> result = new ArrayList<Invoker<T>>();
  16.         // 服务提供者匹配条件未配置，表明对指定的服务消费者禁用服务，也就是服务消费者在黑名单中
  17.         if (thenCondition == null) {
  18.             logger.warn("The current consumer in the service blacklist...");
  19.             return result;
  20.         }
  21.         // 这里可以简单的把 Invoker 理解为服务提供者，现在使用服务提供者匹配规则对 
  22.         // Invoker 列表进行匹配
  23.         for (Invoker<T> invoker : invokers) {
  24.             // 若匹配成功，表明当前 Invoker 符合服务提供者匹配规则。
  25.             // 此时将 Invoker 添加到 result 列表中
  26.             if (matchThen(invoker.getUrl(), url)) {
  27.                 result.add(invoker);
  28.             }
  29.         }
  31.         // 返回匹配结果，如果 result 为空列表，且 force = true，表示强制返回空列表，
  32.         // 否则路由结果为空的路由规则将自动失效
  33.         if (!result.isEmpty()) {
  34.             return result;
  35.         } else if (force) {
  36.             logger.warn("The route result is empty and force execute ...");
  37.             return result;
  38.         }
  39.     } catch (Throwable t) {
  40.         logger.error("Failed to execute condition router rule: ...");
  41.     }
  43.     // 原样返回，此时 force = false，表示该条路由规则失效
  44.     return invokers;
  45. }

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

  1. boolean matchWhen(URL url, Invocation invocation) {
  2.     // 服务消费者条件为 null 或空，均返回 true，比如：
  3.     //     => host != 172.22.3.91
  4.     // 表示所有的服务消费者都不得调用 IP 为 172.22.3.91 的机器上的服务
  5.     return whenCondition == null || whenCondition.isEmpty() 
  6.         || matchCondition(whenCondition, url, null, invocation);  // 进行条件匹配
  7. }
  9. private boolean matchThen(URL url, URL param) {
  10.     // 服务提供者条件为 null 或空，表示禁用服务
  11.     return !(thenCondition == null || thenCondition.isEmpty()) 
  12.         && matchCondition(thenCondition, url, param, null);  // 进行条件匹配
  13. }

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

  1. private List<Invoker<T>> route(List<Invoker<T>> invokers, String method) {
  2.     Invocation invocation = new RpcInvocation(method, new Class<?>[0], new Object[0]);
  3.     List<Router> routers = getRouters();
  4.     if (routers != null) {
  5.         for (Router router : routers) {
  6.             if (router.getUrl() != null) {
  7.                 // 注意第二个参数
  8.                 invokers = router.route(invokers, getConsumerUrl(), invocation);
  9.             }
  10.         }
  11.     }
  12.     return invokers;
  13. }

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

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

  1. private boolean matchCondition(Map<String, MatchPair> condition, URL url, URL param, Invocation invocation) {
  2.     // 将服务提供者或消费者 url 转成 Map
  3.     Map<String, String> sample = url.toMap();
  4.     boolean result = false;
  5.     // 遍历 condition 列表
  6.     for (Map.Entry<String, MatchPair> matchPair : condition.entrySet()) {
  7.         // 获取匹配项名称，比如 host、method 等
  8.         String key = matchPair.getKey();
  9.         String sampleValue;
  10.         // 如果 invocation 不为空，且 key 为 mehtod(s)，表示进行方法匹配
  11.         if (invocation != null && (Constants.METHOD_KEY.equals(key) || Constants.METHODS_KEY.equals(key))) {
  12.             // 从 invocation 获取被调用方法的名称
  13.             sampleValue = invocation.getMethodName();
  14.         } else {
  15.             // 从服务提供者或消费者 url 中获取指定字段值，比如 host、application 等
  16.             sampleValue = sample.get(key);
  17.             if (sampleValue == null) {
  18.                 // 尝试通过 default.xxx 获取相应的值
  19.                 sampleValue = sample.get(Constants.DEFAULT_KEY_PREFIX + key);
  20.             }
  21.         }
  23.         // --------------------✨ 分割线 ✨-------------------- //
  25.         if (sampleValue != null) {
  26.             // 调用 MatchPair 的 isMatch 方法进行匹配
  27.             if (!matchPair.getValue().isMatch(sampleValue, param)) {
  28.                 // 只要有一个规则匹配失败，立即返回 false 结束方法逻辑
  29.                 return false;
  30.             } else {
  31.                 result = true;
  32.             }
  33.         } else {
  34.             // sampleValue 为空，表明服务提供者或消费者 url 中不包含相关字段。此时如果 
  35.             // MatchPair 的 matches 不为空，表示匹配失败，返回 false。比如我们有这样
  36.             // 一条匹配条件 loadbalance = random，假设 url 中并不包含 loadbalance 参数，
  37.             // 此时 sampleValue = null。既然路由规则里限制了 loadbalance 必须为 random，
  38.             // 但 sampleValue = null，明显不符合规则，因此返回 false
  39.             if (!matchPair.getValue().matches.isEmpty()) {
  40.                 return false;
  41.             } else {
  42.                 result = true;
  43.             }
  44.         }
  45.     }
  46.     return result;
  47. }

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

  1. private boolean isMatch(String value, URL param) {
  2.     // 情况一：matches 非空，mismatches 为空
  3.     if (!matches.isEmpty() && mismatches.isEmpty()) {
  4.         // 遍历 matches 集合，检测入参 value 是否能被 matches 集合元素匹配到。
  5.         // 举个例子，如果 value = 10.20.153.11，matches = [10.20.153.*],
  6.         // 此时 isMatchGlobPattern 方法返回 true
  7.         for (String match : matches) {
  8.             if (UrlUtils.isMatchGlobPattern(match, value, param)) {
  9.                 return true;
  10.             }
  11.         }
  13.         // 如果所有匹配项都无法匹配到入参，则返回 false
  14.         return false;
  15.     }
  17.     // 情况二：matches 为空，mismatches 非空
  18.     if (!mismatches.isEmpty() && matches.isEmpty()) {
  19.         for (String mismatch : mismatches) {
  20.             // 只要入参被 mismatches 集合中的任意一个元素匹配到，就返回 false
  21.             if (UrlUtils.isMatchGlobPattern(mismatch, value, param)) {
  22.                 return false;
  23.             }
  24.         }
  25.         // mismatches 集合中所有元素都无法匹配到入参，此时返回 true
  26.         return true;
  27.     }
  29.     // 情况三：matches 非空，mismatches 非空
  30.     if (!matches.isEmpty() && !mismatches.isEmpty()) {
  31.         // matches 和 mismatches 均为非空，此时优先使用 mismatches 集合元素对入参进行匹配。
  32.         // 只要 mismatches 集合中任意一个元素与入参匹配成功，就立即返回 false，结束方法逻辑
  33.         for (String mismatch : mismatches) {
  34.             if (UrlUtils.isMatchGlobPattern(mismatch, value, param)) {
  35.                 return false;
  36.             }
  37.         }
  38.         // mismatches 集合元素无法匹配到入参，此时再使用 matches 继续匹配
  39.         for (String match : matches) {
  40.             // 只要 matches 集合中任意一个元素与入参匹配成功，就立即返回 true
  41.             if (UrlUtils.isMatchGlobPattern(match, value, param)) {
  42.                 return true;
  43.             }
  44.         }
  46.         // 全部失配，则返回 false
  47.         return false;
  48.     }
  50.     // 情况四：matches 和 mismatches 均为空，此时返回 false
  51.     return false;
  52. }

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

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

isMatch 方法是通过 UrlUtils 的 isMatchGlobPattern 方法进行匹配，因此下面我们再来看看 isMatchGlobPattern 方法的逻辑。

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

以上就是 isMatchGlobPattern 两个重载方法的全部逻辑，这两个方法分别对普通的匹配过程，以及”引用消费者参数“和通配符匹配等特性提供了支持。这两个方法的逻辑不是很复杂，且代码中也进行了比较详细的注释，因此就不多说了。