dubbo路由代码分析3（condition路由器）
这篇说说，dubbo condition类型路由器的路由解析和执行过程
由http://www.javashuo.com/article/p-gnjacrbl-du.html这篇咱们能够看到
condition类型路由器是由condition路由工厂获取，源码以下java
public class ConditionRouterFactory implements RouterFactory {
public static final String NAME = "condition";
//返回ConditionRouter类型路由器
public Router getRouter(URL url) {
return new ConditionRouter(url);
}
}
ConditionRouterFactory是RouterFactory 经过spi机制的一种实现。具体看下，condition路由器的源码,这里先贴出两个个方法，一个构造方法，一个是路由方法正则表达式
/**
* ConditionRouter 类生命
* 实现了Comparable接口，是为了路由排序用的
* @author william.liangf
*/
public class ConditionRouter implements Router, Comparable<Router>{}
属性数据结构
private static final Logger logger = LoggerFactory.getLogger(ConditionRouter.class);
private static Pattern ROUTE_PATTERN = Pattern.compile("([&!=,]*)\\s*([^&!=,\\s]+)");
//路由器的信息来源:url
private final URL url;
//路由器优先级，在多个路由排序用的
private final int priority;
//是否强制执行路由规则，哪怕没有合适的invoker
private final boolean force;
//存放consumer路由规则
private final Map<String, MatchPair> whenCondition;
//存放provider路由规则
private final Map<String, MatchPair> thenCondition;
/***
* pulibc 构造函数，为各个属性赋值
* @param url
*/
public ConditionRouter(URL url) {
this.url = url;
this.priority = url.getParameter(Constants.PRIORITY_KEY, 0);
this.force = url.getParameter(Constants.FORCE_KEY, false);
try {
//经过rule key获取路由规则字串
String rule = url.getParameterAndDecoded(Constants.RULE_KEY);
if (rule == null || rule.trim().length() == 0) {
throw new IllegalArgumentException("Illegal route rule!");
}
//把字符串里的"consumer." "provider." 替换掉，方便解析
rule = rule.replace("consumer.", "").replace("provider.", "");
int i = rule.indexOf("=>");
//以"=>"为分割线，前面是consumer规则，后面是provider 规则
String whenRule = i < 0 ? null : rule.substring(0, i).trim();
String thenRule = i < 0 ? rule.trim() : rule.substring(i + 2).trim();
//parseRule 方法解析规则，放在Map<String, MatchPair>里
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);
// NOTE: When条件是容许为空的，外部业务来保证相似的约束条件
//解析构造的规则放在condition变量里
this.whenCondition = when;
this.thenCondition = then;
} catch (ParseException e) {
throw new IllegalStateException(e.getMessage(), e);
}
}
//代码略...
/***
* 路由方法,执行路由规则
* @param invokers
* @param url refer url
* @param invocation
* @param <T>
* @return
* @throws RpcException
*/
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 {
//前置条件不匹配，说明consumer不在限制之列。说明，路由不针对当前客户，这样就所有放行，全部提供者均可以调用。
//这是consumer的url
if (!matchWhen(url, invocation)) {
return invokers;
}
List<Invoker<T>> result = new ArrayList<Invoker<T>>();
//thenCondition为null表示拒绝一切请求
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) {
//调用放匹配才放行。服务提供者，只要符合路由才，能提供服务，这里的url改成invoker.getUrl()
//都不匹配，这里result多是空的。
if (matchThen(invoker.getUrl(), url)) {
result.add(invoker);
}
}
if (result.size() > 0) {
return result;
} else if (force) {
//force强制执行路由。哪怕result是空的，也要返回给上层方法。若是为false,最后放回全部的invokers，等于不执行路由
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;
}
总的来讲，构造函数，初始化路由规则。路由方法，根据路由规则对，调用方（一个）和服务提供方（多个）执行路由规则。
让符合规则的调用方，能够调用，
让不符合规则的调用方不能调用。
让符合规则的服务提供方，留着服务提供者列表。
让不符合路由规则的服务提供方，从服务者列表中除去。ide
先看下，存放路由规则的数据结构。也就是下面量个属性
//存放consumer路由规则
private final Map<String, MatchPair> whenCondition;
//存放provider路由规则
private final Map<String, MatchPair> thenCondition;
我以，以下的路由规则为例函数
"host !=4.4.4.4 & host = 2.2.2.2,1.1.1.1,3.3.3.3 &method =sayHello => host = 1.2.3.4&host !=4.4.4.4"
看到通过规则解析后，存放在上面两个对象的内容以下图：this
能够看到，路由条件，可分为host和method的两类。
每一类，又可分为容许类(match)和不容许(diamatch)两类规则，
每一类规则有，能够包含多条路由信息。 路由规则存放，经过，Map结合MatchPair数据结构完成。
MatchPair结构以下：url
/***
* MatchPiar 数据结构，它包含类具体匹配方法isMatch
* 是个私有，静态类，为何静态？？
*/
private static final class MatchPair {
//容许列表,内部用Set集合类型，防止重复。
final Set<String> matches = new HashSet<String>();
//拒绝规则
final Set<String> mismatches = new HashSet<String>();
//具体执行匹配规则的方法
private boolean isMatch(String value, URL param) {
//只有容许项目
if (matches.size() > 0 && mismatches.size() == 0) {
for (String match : matches) {
//value只要知足一项，容许，就为匹配，经过
if (UrlUtils.isMatchGlobPattern(match, value, param)) {
return true;
}
}
return false;
}
//只有不容许项目
if (mismatches.size() > 0 && matches.size() == 0) {
//value是要知足一项，不容许。就是不匹配
for (String mismatch : mismatches) {
if (UrlUtils.isMatchGlobPattern(mismatch, value, param)) {
return false;
}
}
//必须所有不知足不匹配。才经过
return true;
}
if (matches.size() > 0 && mismatches.size() > 0) {
//when both mismatches and matches contain the same value, then using mismatches first
//当匹配项和不匹配项包含一样的值，不匹配项优先
for (String mismatch : mismatches) {
if (UrlUtils.isMatchGlobPattern(mismatch, value, param)) {
return false;
}
}
for (String match : matches) {
if (UrlUtils.isMatchGlobPattern(match, value, param)) {
return true;
}
}
return false;
}
return false;
}
}
路由规则的解析，由parseRule方法完成。把规则字符串放到condition对象里。.net
/**
* 解析规则字串解析后放到map里
* 这里有个数据结构类MatchPair 用set放着，容许规则matches，和不容许规则mismatches，他们都是set结构
* @param rule
* @return
* @throws ParseException
*/
private static Map<String, MatchPair> parseRule(String rule)
throws ParseException {
Map<String, MatchPair> condition = new HashMap<String, MatchPair>();
if (StringUtils.isBlank(rule)) {
return condition;
}
// 匹配或不匹配Key-Value对
MatchPair pair = null;
// 多个Value值
Set<String> values = null;
//用java的正则表达式Pattern的matcher去分割字符串到Matcher类，而后逐个匹配。
//这个要熟悉正则，和Matcher，Pattern
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) {
pair = new MatchPair();
condition.put(content, pair);
}
// KV开始
else if ("&".equals(separator)) {
if (condition.get(content) == null) {
pair = new MatchPair();
condition.put(content, pair);
} else {
pair = condition.get(content);
}
}
// KV的Value部分开始
else if ("=".equals(separator)) {
if (pair == null)
throw new ParseException("Illegal route rule \""
+ rule + "\", The error char '" + separator
+ "' at index " + matcher.start() + " before \""
+ content + "\".", matcher.start());
values = pair.matches;
values.add(content);
}
// KV的Value部分开始
else if ("!=".equals(separator)) {
if (pair == null)
throw new ParseException("Illegal route rule \""
+ rule + "\", The error char '" + separator
+ "' at index " + matcher.start() + " before \""
+ content + "\".", matcher.start());
values = pair.mismatches;
values.add(content);
}
// KV的Value部分的多个条目
else if (",".equals(separator)) { // 若是为逗号表示
if (values == null || values.size() == 0)
throw new ParseException("Illegal route rule \""
+ rule + "\", The error char '" + separator
+ "' at index " + matcher.start() + " before \""
+ content + "\".", matcher.start());
values.add(content);
} else {
throw new ParseException("Illegal route rule \"" + rule
+ "\", The error char '" + separator + "' at index "
+ matcher.start() + " before \"" + content + "\".", matcher.start());
}
}
return condition;
}
而后是，理由规则的执行。code
/***
* 对服务调用方的匹配
* @param url
* @param invocation
* @return
*/
boolean matchWhen(URL url, Invocation invocation) {
return whenCondition == null || whenCondition.isEmpty() || matchCondition(whenCondition, url, null, invocation);
}
/***
* 对服务提供者的匹配
* @param url
* @param param
* @return
*/
private boolean matchThen(URL url, URL param) {
return !(thenCondition == null || thenCondition.isEmpty()) && matchCondition(thenCondition, url, param, null);
}
/***
* 具体执行匹配规则，遍历condition里全部的规则，执行规则。
* @param condition
* @param url
* @param param
* @param invocation
* @return
*/
private boolean matchCondition(Map<String, MatchPair> condition, URL url, URL param, Invocation invocation) {
Map<String, String> sample = url.toMap();
boolean result = false;
for (Map.Entry<String, MatchPair> matchPair : condition.entrySet()) {
String key = matchPair.getKey();
String sampleValue;
//get real invoked method name from invocation
//路由规则支持到方法级别
if (invocation != null && (Constants.METHOD_KEY.equals(key) || Constants.METHODS_KEY.equals(key))) {
sampleValue = invocation.getMethodName();//获取方法名
} else {//key 是host 获取host值
sampleValue = sample.get(key);
}
if (sampleValue != null) {
//调用MatchPair的isMatch方法
if (!matchPair.getValue().isMatch(sampleValue, param)) {
return false;
} else {
result = true;
}
} else {
//not pass the condition
//若是sampleValue没有值，但匹配项有值。不经过
if (matchPair.getValue().matches.size() > 0) {
return false;
} else {
result = true;
}
}
}
return result;
}
最后，是路由器的排序router
/***
* 路由器的排序
* @param o
* @return
*/
public int compareTo(Router o) {
if (o == null || o.getClass() != ConditionRouter.class) {
return 1;
}
ConditionRouter c = (ConditionRouter) o;
//若是优先级相同，经过rul字符串比较
return this.priority == c.priority ? url.toFullString().compareTo(c.url.toFullString()) : (this.priority > c.priority ? 1 : -1);
}
相关文章
- 1. dubbo路由代码分析4（script路由器file路由器）
- 2. dubbo路由机制代码分析1
- 3. dubbo路由机制分析2（路由设置存储）
- 4. express源码分析-路由
- 5. 华为路由器分析
- 6. Dubbo 路由规则之标签路由
- 7. 4、IP包头分析、3层网络层路由器、静态路由
- 8. 路由器集成桥接路由（IRB）模式分析
- 9. 3-高级路由：RIP路由认证
- 10. Packet Tracer6.0静态路由,rip路由,ospf路由配置(3)
- 更多相关文章...
- • traceroute命令进行路由跟踪 - TCP/IP教程
- • CIDR（无类域间路由）是什么？ - TCP/IP教程
- • 适用于PHP初学者的学习线路和建议
- • IntelliJ IDEA代码格式化设置
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
