dubbo路由代码分析3（condition路由器）

public class ConditionRouterFactory implements RouterFactory {

    public static final String NAME = "condition";
    //返回ConditionRouter类型路由器
    public Router getRouter(URL url) {
        return new ConditionRouter(url);
    }

}

/**
 * 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;
    }

 "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"

/***
     * 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;
        }
    }

/**
     * 解析规则字串解析后放到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;
    }

/***
     * 对服务调用方的匹配
     * @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;
    }

 /***
     * 路由器的排序
     * @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);
    }