@SPI
public interface RouterFactory {

    /**
     * Create router.
     *
     * 创建 Router 对象
     *
     * @param url
     * @return router
     */
    @Adaptive("protocol")
    Router getRouter(URL url);

}

public class ConditionRouterFactory implements RouterFactory {

    public static final String NAME = "condition";

    @Override
    public Router getRouter(URL url) {
        return new ConditionRouter(url);
    }

}

public class ScriptRouterFactory implements RouterFactory {

    public static final String NAME = "script";

    @Override
    public Router getRouter(URL url) {
        return new ScriptRouter(url);
    }

}

 1: public class FileRouterFactory implements RouterFactory {
 2: 
 3:     public static final String NAME = "file";
 4: 
 5:     /**
 6:      * RouterFactory$Adaptive 对象
 7:      */
 8:     private RouterFactory routerFactory;
 9: 
10:     public void setRouterFactory(RouterFactory routerFactory) {
11:         this.routerFactory = routerFactory;
12:     }
13: 
14:     @Override
15:     public Router getRouter(URL url) {
16:         try {
17:             // Transform File URL into Script Route URL, and Load
18:             // file:///d:/path/to/route.js?router=script ==> script:///d:/path/to/route.js?type=js&rule=<file-content>
19:             // 获得 router 配置项，默认为 script
20:             String protocol = url.getParameter(Constants.ROUTER_KEY, ScriptRouterFactory.NAME); // Replace original protocol (maybe 'file') with 'script'
21:             // 使用文件后缀做为类型
22:             String type = null; // Use file suffix to config script type, e.g., js, groovy ...
23:             String path = url.getPath();
24:             if (path != null) {
25:                 int i = path.lastIndexOf('.');
26:                 if (i > 0) {
27:                     type = path.substring(i + 1);
28:                 }
29:             }
30:             // 读取规则内容
31:             String rule = IOUtils.read(new FileReader(new File(url.getAbsolutePath())));
32: 
33:             // 创建路由规则 URL
34:             boolean runtime = url.getParameter(Constants.RUNTIME_KEY, false);
35:             URL script = url.setProtocol(protocol).addParameter(Constants.TYPE_KEY, type)
36:                     .addParameter(Constants.RUNTIME_KEY, runtime)
37:                     .addParameterAndEncoded(Constants.RULE_KEY, rule);
38: 
39:             // 通过 Dubbo SPI Adaptive 机制，获得 Router 对象
40:             return routerFactory.getRouter(script);
41:         } catch (IOException e) {
42:             throw new IllegalStateException(e.getMessage(), e);
43:         }
44:     }
45: 
46: }

public interface Router extends Comparable<Router> {

    /**
     * get the router url.
     * <p>
     * 路由规则 URL
     *
     * @return url
     */
    URL getUrl();

    /**
     * route.
     *
     * 路由，筛选匹配的 Invoker 集合
     *
     * @param invokers   Invoker 集合
     * @param url        refer url
     * @param invocation
     * @return routed invokers 路由后的 Invoker 集合
     * @throws RpcException
     */
    <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException;

}

/**
 * 分组正则匹配，详细见 {@link #parseRule(String)} 方法
 *
 * 前 [] 为匹配，分隔符
 * 后 [] 为匹配，内容
 */
private static Pattern ROUTE_PATTERN = Pattern.compile("([&!=,]*)\\s*([^&!=,\\s]+)");

/**
 * 路由规则 URL
 */
private final URL url;
/**
 * 路由规则的优先级，用于排序，优先级越大越靠前执行，可不填，缺省为 0 。
 */
private final int priority;
/**
 * 当路由结果为空时，是否强制执行，如果不强制执行，路由结果为空的路由规则将自动失效，可不填，缺省为 false 。
 */
private final boolean force;
/**
 * 消费者匹配条件集合，通过解析【条件表达式 rule 的 `=>` 之前半部分】
 */
private final Map<String, MatchPair> whenCondition;
/**
 * 提供者地址列表的过滤条件，通过解析【条件表达式 rule 的 `=>` 之后半部分】
 */
private final Map<String, MatchPair> thenCondition;

public ConditionRouter(URL url) {
    this.url = url;
    this.priority = url.getParameter(Constants.PRIORITY_KEY, 0);
    this.force = url.getParameter(Constants.FORCE_KEY, false);
    try {
        // 拆分条件变大时为 when 和 then 两部分
        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();
        // 解析 `whenCondition`
        Map<String, MatchPair> when = StringUtils.isBlank(whenRule) || "true".equals(whenRule) ? new HashMap<String, MatchPair>() : parseRule(whenRule);
        // 解析 `thenCondition`
        Map<String, MatchPair> then = StringUtils.isBlank(thenRule) || "false".equals(thenRule) ? null : parseRule(thenRule);
        // NOTE: It should be determined on the business level whether the `When condition` can be empty or not.
        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>();

    /**
     * 判断 value 是否匹配 matches + mismatches
     *
     * @param value 值
     * @param param URL
     * @return 是否匹配
     */
    private boolean isMatch(String value, URL param) {
        // 只匹配 matches
        if (!matches.isEmpty() && mismatches.isEmpty()) {
            for (String match : matches) {
                if (UrlUtils.isMatchGlobPattern(match, value, param)) {
                    return true;
                }
            }
            return false; // 如果没匹配上，认为为 false ，即不匹配
        }

        // 只匹配 mismatches
        if (!mismatches.isEmpty() && matches.isEmpty()) {
            for (String mismatch : mismatches) {
                if (UrlUtils.isMatchGlobPattern(mismatch, value, param)) {
                    return false;
                }
            }
            return true; // 注意，这里和上面不同。原因，你懂的。
        }

        // 匹配 mismatches + matches
        if (!matches.isEmpty()) {
            //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; // 如果没匹配上，认为为 false ，即不匹配
        }
        return false;
    }
}

 1: private static Map<String, MatchPair> parseRule(String rule) throws ParseException {
 2: //    System.out.println("rule: " + rule); // add by 芋艿，方便大家看
 3:     Map<String, MatchPair> condition = new HashMap<String, MatchPair>();
 4:     if (StringUtils.isBlank(rule)) {
 5:         return condition;
 6:     }
 7:     // Key-Value pair, stores both match and mismatch conditions
 8:     MatchPair pair = null;
 9:     // Multiple values
10:     Set<String> values = null;
11:     final Matcher matcher = ROUTE_PATTERN.matcher(rule);
12:     while (matcher.find()) { // Try to match one by one
13:         String separator = matcher.group(1);
14:         String content = matcher.group(2);
15: //        System.out.println(separator + "\t" + content); // add by 芋艿，方便大家看
16:         // Start part of the condition expression.
17:         if (separator == null || separator.length() == 0) {
18:             pair = new MatchPair();
19:             condition.put(content, pair);
20:         }
21:         // The KV part of the condition expression
22:         else if ("&".equals(separator)) {
23:             if (condition.get(content) == null) {
24:                 pair = new MatchPair();
25:                 condition.put(content, pair);
26:             } else {
27:                 pair = condition.get(content);
28:             }
29:         }
30:         // The Value in the KV part.
31:         else if ("=".equals(separator)) {
32:             if (pair == null) {
33:                 throw new ParseException("Illegal route rule \"" + rule + "\", The error char '" + separator + "' at index " + matcher.start() + " before \"" + content + "\".", matcher.start());
34:             }
35:             values = pair.matches;
36:             values.add(content);
37:         }
38:         // The Value in the KV part.
39:         else if ("!=".equals(separator)) {
40:             if (pair == null) {
41:                 throw new ParseException("Illegal route rule \"" + rule + "\", The error char '" + separator + "' at index " + matcher.start() + " before \"" + content + "\".", matcher.start());
42:             }
43:             values = pair.mismatches;
44:             values.add(content);
45:         }
46:         // The Value in the KV part, if Value have more than one items.
47:         else if (",".equals(separator)) { // Should be seperateed by ','
48:             if (values == null || values.isEmpty()) {
49:                 throw new ParseException("Illegal route rule \"" + rule + "\", The error char '" + separator + "' at index " + matcher.start() + " before \"" + content + "\".", matcher.start());
50:             }
51:             values.add(content);
52:         } else {
53:             throw new ParseException("Illegal route rule \"" + rule + "\", The error char '" + separator + "' at index " + matcher.start() + " before \"" + content + "\".", matcher.start());
54:         }
55:     }
56:     return condition;
57: }

 1: @Override
 2: public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException {
 3:     // 为空，直接返回空 Invoker 集合
 4:     if (invokers == null || invokers.isEmpty()) {
 5:         return invokers;
 6:     }
 7:     try {
 8:         // 不匹配 `whenCondition` ，直接返回 `invokers` 集合，因为不需要走 `whenThen` 的匹配
 9:         if (!matchWhen(url, invocation)) {
10:             return invokers;
11:         }
12:         List<Invoker<T>> result = new ArrayList<Invoker<T>>();
13:         // `whenThen` 为空，则返回空 Invoker 集合
14:         if (thenCondition == null) {
15:             logger.warn("The current consumer in the service blacklist. consumer: " + NetUtils.getLocalHost() + ", service: " + url.getServiceKey());
16:             return result;
17:         }
18:         // 使用 `whenThen` ，匹配 `invokers` 集合。若符合，添加到 `result` 中
19:         for (Invoker<T> invoker : invokers) {
20:             if (matchThen(invoker.getUrl(), url)) {
21:                 result.add(invoker);
22:             }
23:         }
24:         // 若 `result` 非空，返回它
25:         if (!result.isEmpty()) {
26:             return result;
27:         // 如果 `force=true` ，代表强制执行，返回空 Invoker 集合
28:         } else if (force) {
29:             logger.warn("The route result is empty and force execute. consumer: " + NetUtils.getLocalHost() + ", service: " + url.getServiceKey() + ", router: " + url.getParameterAndDecoded(Constants.RULE_KEY));
30:             return result;
31:         }
32:     } catch (Throwable t) {
33:         logger.error("Failed to execute condition router rule: " + getUrl() + ", invokers: " + invokers + ", cause: " + t.getMessage(), t);
34:     }
35:     // 如果 `force=false` ，代表不强制执行，返回 `invokers` 集合，即忽略路由规则
36:     return invokers;
37: }

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 {
            sampleValue = sample.get(key);
            if (sampleValue == null) {
                sampleValue = sample.get(Constants.DEFAULT_KEY_PREFIX + key);
            }
        }
        // 匹配条件值
        if (sampleValue != null) {
            if (!matchPair.getValue().isMatch(sampleValue, param)) { // 返回不匹配
                return false;
            } else {
                result = true;
            }
        } else {
            // not pass the condition
            if (!matchPair.getValue().matches.isEmpty()) { // 无条件值，但是有匹配条件 `matches` ，则返回不匹配。
                return false;
            } else {
                result = true;
            }
        }
    }
    return result;
}

@Override
public int compareTo(Router o) {
    if (o == null || o.getClass() != ConditionRouter.class) {
        return 1;
    }
    ConditionRouter c = (ConditionRouter) o;
    return this.priority == c.priority ? url.toFullString().compareTo(c.url.toFullString()) : (this.priority > c.priority ? 1 : -1);
}

/**
 * 脚本类型 与 ScriptEngine 的映射缓存
 */
private static final Map<String, ScriptEngine> engines = new ConcurrentHashMap<String, ScriptEngine>();

/**
 * 路由规则 URL
 */
private final ScriptEngine engine;
/**
 * 路由规则的优先级，用于排序，优先级越大越靠前执行，可不填，缺省为 0 。
 */
private final int priority;
/**
 * 路由规则内容
 */
private final String rule;
/**
 * 路由规则 URL
 */
private final URL url;

public ScriptRouter(URL url) {
    this.url = url;
    String type = url.getParameter(Constants.TYPE_KEY);
    this.priority = url.getParameter(Constants.PRIORITY_KEY, 0);
    String rule = url.getParameterAndDecoded(Constants.RULE_KEY);
    // 初始化 `engine`
    if (type == null || type.length() == 0) {
        type = Constants.DEFAULT_SCRIPT_TYPE_KEY;
    }
    if (rule == null || rule.length() == 0) {
        throw new IllegalStateException(new IllegalStateException("route rule can not be empty. rule:" + rule));
    }
    ScriptEngine engine = engines.get(type);
    if (engine == null) { // 在缓存中不存在，则进行创建 ScriptEngine 对象
        engine = new ScriptEngineManager().getEngineByName(type);
        if (engine == null) {
            throw new IllegalStateException(new IllegalStateException("Unsupported route rule type: " + type + ", rule: " + rule));
        }
        engines.put(type, engine);
    }
    this.engine = engine;
    this.rule = rule;
}

@Override
public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException {
    try {
        // 执行脚本
        List<Invoker<T>> invokersCopy = new ArrayList<Invoker<T>>(invokers);
        Compilable compilable = (Compilable) engine;
        Bindings bindings = engine.createBindings();
        bindings.put("invokers", invokersCopy);
        bindings.put("invocation", invocation);
        bindings.put("context", RpcContext.getContext());
        CompiledScript function = compilable.compile(rule); // 编译
        Object obj = function.eval(bindings); // 执行
        // 根据结果类型，转换成 (List<Invoker<T>> 类型返回
        if (obj instanceof Invoker[]) {
            invokersCopy = Arrays.asList((Invoker<T>[]) obj);
        } else if (obj instanceof Object[]) {
            invokersCopy = new ArrayList<Invoker<T>>();
            for (Object inv : (Object[]) obj) {
                invokersCopy.add((Invoker<T>) inv);
            }
        } else {
            invokersCopy = (List<Invoker<T>>) obj;
        }
        return invokersCopy;
    } catch (ScriptException e) {
        // 发生异常，忽略路由规则，返回全 `invokers` 集合
        logger.error("route error , rule has been ignored. rule: " + rule + ", method:" + invocation.getMethodName() + ", url: " + RpcContext.getContext().getUrl(), e);
        return invokers;
    }
}

@Override
public int compareTo(Router o) {
    if (o == null || o.getClass() != ScriptRouter.class) {
        return 1;
    }
    ScriptRouter c = (ScriptRouter) o;
    return this.priority == c.priority ? rule.compareTo(c.rule) : (this.priority > c.priority ? 1 : -1);
}

 1: protected void setRouters(List<Router> routers) {
 2:     // copy list // 复制 routers ，因为下面要修改
 3:     routers = routers == null ? new ArrayList<Router>() : new ArrayList<Router>(routers);
 4:     // append url router
 5:     // 拼接 `url` 中，配置的路由规则
 6:     String routerkey = url.getParameter(Constants.ROUTER_KEY);
 7:     if (routerkey != null && routerkey.length() > 0) {
 8:         RouterFactory routerFactory = ExtensionLoader.getExtensionLoader(RouterFactory.class).getExtension(routerkey);
 9:         routers.add(routerFactory.getRouter(url));
10:     }
11:     // append mock invoker selector
12:     routers.add(new MockInvokersSelector());
13:     // 排序
14:     Collections.sort(routers);
15:     // 赋值给属性
16:     this.routers = routers;
17: }

 1: @Override
 2: public List<Invoker<T>> list(Invocation invocation) throws RpcException {
 3:     if (destroyed) {
 4:         throw new RpcException("Directory already destroyed .url: " + getUrl());
 5:     }
 6:     // 获得所有 Invoker 集合
 7:     List<Invoker<T>> invokers = doList(invocation);
 8:     // 根据路由规则，筛选 Invoker 集合
 9:     List<Router> localRouters = this.routers; // local reference 本地引用，避免并发问题
10:     if (localRouters != null && !localRouters.isEmpty()) {
11:         for (Router router : localRouters) {
12:             try {
13:                 if (router.getUrl() == null || router.getUrl().getParameter(Constants.RUNTIME_KEY, false)) {
14:                     invokers = router.route(invokers, getConsumerUrl(), invocation);
15:                 }
16:             } catch (Throwable t) {
17:                 logger.error("Failed to execute router: " + getUrl() + ", cause: " + t.getMessage(), t);
18:             }
19:         }
20:     }
21:     return invokers;
22: }

 1: @Override
 2: public synchronized void notify(List<URL> urls) {
 3:     // 【省略无关代码】根据 URL 的分类或协议，分组成三个集合 。
 4:     List<URL> invokerUrls = new ArrayList<URL>(); // 服务提供者 URL 集合
 5:     List<URL> routerUrls = new ArrayList<URL>();
 6:     List<URL> configuratorUrls = new ArrayList<URL>();
 7:     
 8:     //  【省略无关代码】处理配置规则 URL 集合
 9:     // configurators
10: 
11:     // 处理路由规则 URL 集合
12:     if (!routerUrls.isEmpty()) {
13:         List<Router> routers = toRouters(routerUrls);
14:         if (routers != null) { // null - do nothing
15:             setRouters(routers);
16:         }
17:     }
18:     
19:     //  【省略无关代码】合并配置规则，到 `directoryUrl` 中，形成 `overrideDirectoryUrl` 变量。
20:     //  【省略无关代码】处理服务提供者 URL 集合
21: }

 1: private Map<String, List<Invoker<T>>> toMethodInvokers(Map<String, Invoker<T>> invokersMap) {
 2:     // 创建新的 `methodInvokerMap`
 3:     Map<String, List<Invoker<T>>> newMethodInvokerMap = new HashMap<String, List<Invoker<T>>>();
 4:     // 创建 Invoker 集合
 5:     List<Invoker<T>> invokersList = new ArrayList<Invoker<T>>();
 6:     //  【省略无关代码】按服务提供者 URL 所声明的 methods 分类，兼容注册中心执行路由过滤掉的 methods
 7:     // 路由全 `invokersList` ，匹配合适的 Invoker 集合
 8:     List<Invoker<T>> newInvokersList = route(invokersList, null);
 9:     // 添加 `newInvokersList` 到 `newMethodInvokerMap` 中，表示该服务提供者的全量 Invoker 集合
10:     newMethodInvokerMap.put(Constants.ANY_VALUE, newInvokersList);
11:     // 循环，基于每个方法路由，匹配合适的 Invoker 集合
12:     if (serviceMethods != null && serviceMethods.length > 0) {
13:         for (String method : serviceMethods) {
14:             List<Invoker<T>> methodInvokers = newMethodInvokerMap.get(method);
15:             if (methodInvokers == null || methodInvokers.isEmpty()) {
16:                 methodInvokers = newInvokersList;
17:             }
18:             newMethodInvokerMap.put(method, route(methodInvokers, method));
19:         }
20:     }
21:     // 【省略无关代码】循环排序每个方法的 Invoker 集合，并设置为不可变
22: }