Dubbo 原始碼分析 - 叢集容錯之 Router

public ConditionRouter(URL url) {
this.url = url;
// 獲取 priority 和 force 配置
this.priority = url.getParameter(Constants.PRIORITY_KEY, 0);
this.force = url.getParameter(Constants.FORCE_KEY, false);
try {
// 獲取路由規則
String rule = url.getParameterAndDecoded(Constants.RULE_KEY);
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);
}
}

private static final class MatchPair {
final Set<String> matches = new HashSet<String>();
final Set<String> mismatches = new HashSet<String>();
}

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.nullhost
// 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;
}

括號一括號二
1.nullhost
2.=2.2.2.2
3.&host
4.!=1.1.1.1
5.&method
6.=hello

{
"host": {
"matches": ["2.2.2.2"],
"mismatches": ["1.1.1.1"]
},
"method": {
"matches": ["hello"],
"mismatches": []
}
}

public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation)
throws RpcException {
if (invokers == null || invokers.isEmpty()) {
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，表明當前這條路由規則不適用於
// 當前的服務消費者，此時無需再進行後續匹配，直接返回即可。
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...");
return result;
}
// 這裡可以簡單的把 Invoker 理解為服務提供者，現在使用服務消費者匹配規則對 
// Invoker 列表進行匹配
for (Invoker<T> invoker : invokers) {
// 匹配成功，表明當前 Invoker 符合服務提供者匹配規則。
// 此時將 Invoker 新增到 result 列表中
if (matchThen(invoker.getUrl(), url)) {
result.add(invoker);
}
}

// 返回匹配結果，如果 result 為空列表，且 force = true，表示強制返回空列表，
// 否則路由結果為空的路由規則將自動失效
if (!result.isEmpty()) {
return result;
} else if (force) {
logger.warn("The route result is empty and force execute ...");
return result;
}
} catch (Throwable t) {
logger.error("Failed to execute condition router rule: ...");
}

// 原樣返回，此時 force = false，表示該條路由規則失效
return invokers;
}

boolean matchWhen(URL url, Invocation invocation) {
// 服務消費者條件為 null 或空，均返回 true，比如：
//=> host != 172.22.3.91
// 表示所有的服務消費者都不得呼叫 IP 為 172.22.3.91 的機器上的服務
return whenCondition == null || whenCondition.isEmpty() 
|| matchCondition(whenCondition, url, null, invocation);// 進行條件匹配
}

private boolean matchThen(URL url, URL param) {
// 服務提供者條件為 null 或空，表示禁用服務
return !(thenCondition == null || thenCondition.isEmpty()) 
&& matchCondition(thenCondition, url, param, null);// 進行條件匹配
}

private List<Invoker<T>> route(List<Invoker<T>> invokers, String method) {
Invocation invocation = new RpcInvocation(method, new Class<?>[0], new Object[0]);
List<Router> routers = getRouters();
if (routers != null) {
for (Router router : routers) {
if (router.getUrl() != null) {
// 注意第二個引數
invokers = router.route(invokers, getConsumerUrl(), invocation);
}
}
}
return invokers;
}

private boolean matchCondition(Map<String, MatchPair> condition, URL url, URL param, Invocation invocation) {
// 將服務提供者或消費者 url 轉成 Map
Map<String, String> sample = url.toMap();
boolean result = false;
// 遍歷 condition 列表
for (Map.Entry<String, MatchPair> matchPair : condition.entrySet()) {
// 獲取匹配項名稱，比如 host、method 等
String key = matchPair.getKey();
String sampleValue;
// 如果 invocation 不為空，且 key 為 mehtod(s)，表示進行方法匹配
if (invocation != null && (Constants.METHOD_KEY.equals(key) || Constants.METHODS_KEY.equals(key))) {
// 從 invocation 獲取呼叫方法名稱
sampleValue = invocation.getMethodName();
} else {
// 從服務提供者或消費者 url 中獲取指定欄位值，比如 host、application 等
sampleValue = sample.get(key);
if (sampleValue == null) {
// 嘗試通過 default.xxx 獲取相應的值
sampleValue = sample.get(Constants.DEFAULT_KEY_PREFIX + key);
}
}

// --------------------:sparkles: 分割線 :sparkles:-------------------- //

if (sampleValue != null) {
// 呼叫 MatchPair 的 isMatch 方法進行匹配
if (!matchPair.getValue().isMatch(sampleValue, param)) {
// 只要有一個規則匹配失敗，立即返回 false 結束方法邏輯
return false;
} else {
result = true;
}
} else {
// sampleValue 為空，表明服務提供者或消費者 url 中不包含相關欄位。此時如果 
// MatchPair 的 matches 不為空，表示匹配失敗，返回 false。比如我們有這樣
// 一條匹配條件 loadbalance = random，假設 url 中並不包含 loadbalance 引數，
// 此時 sampleValue = null。既然路由規則裡限制了 loadbalance = random，
// 但 sampleValue = null，明顯不符合規則，因此返回 false
if (!matchPair.getValue().matches.isEmpty()) {
return false;
} else {
result = true;
}
}
}
return result;
}

private boolean isMatch(String value, URL param) {
// 情況一：matches 非空，mismatches 為空
if (!matches.isEmpty() && mismatches.isEmpty()) {
// 遍歷 matches 集合，檢測入參 value 是否能被 matches 集合元素匹配到。
// 舉個例子，如果 value = 10.20.153.11，matches = [10.20.153.*],
// 此時 isMatchGlobPattern 方法返回 true
for (String match : matches) {
if (UrlUtils.isMatchGlobPattern(match, value, param)) {
return true;
}
}

// 如果所有匹配項都無法匹配到入參，則返回 false
return false;
}

// 情況二：matches 為空，mismatches 非空
if (!mismatches.isEmpty() && matches.isEmpty()) {
for (String mismatch : mismatches) {
// 只要入參被 mismatches 集合中的任意一個元素匹配到，就返回 false
if (UrlUtils.isMatchGlobPattern(mismatch, value, param)) {
return false;
}
}
// mismatches 集合中所有元素都無法匹配到入參，此時返回 true
return true;
}

// 情況三：matches 非空，mismatches 非空
if (!matches.isEmpty() && !mismatches.isEmpty()) {
// matches 和 mismatches 均為非空，此時優先使用 mismatches 集合元素對入參進行匹配。
// 只要 mismatches 集合中任意一個元素與入參匹配成功，就立即返回 false，結束方法邏輯
for (String mismatch : mismatches) {
if (UrlUtils.isMatchGlobPattern(mismatch, value, param)) {
return false;
}
}
// mismatches 集合元素無法匹配到入參，此時使用 matches 繼續匹配
for (String match : matches) {
// 只要 matches 集合中任意一個元素與入參匹配成功，就立即返回 true
if (UrlUtils.isMatchGlobPattern(match, value, param)) {
return true;
}
}
return false;
}

// 情況四：matches 和 mismatches 均為空，此時返回 false
return false;
}

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);
}
}