Davids原理探究：Dubbo路由实现原理

朱雀 2023-02-17 03:48 176阅读 0赞

### 文章目录 ###

*   *  Dubbo路由实现原理
     *   *  ConditionRouter（条件路由）
         *   *  参数规则
             *  流程解析
             *  源码解析
         *  FileRouter（文件路由）
         *   *  流程解析
             *  源码解析
         *  ScriptRouter（脚本路由）
         *   *  流程解析
             *  源码解析
         *  总结

## Dubbo路由实现原理 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Rhdmlkc18_size_16_color_FFFFFF_t_70_pic_center]

> **关注可以查看更多粉丝专享blog~**

Dubbo的路由分为条件路由、文件路由和脚本路由，对应的dubbo-admin中三种不同的规则配置方式。条件路由是用户使用Dubbo定义的语法规则去写的路由规则；文件路由则需要用户提交一个文件，里面写着对应的路由规则，框架基于文件读取对应的规则；脚本路由则是使用JDK自身的脚本引擎解析路由规则脚本，所有JDK脚本引擎支持的脚本都能解析，默认是JavaScript。

![Dubbo路由总体结构][Dubbo]

### ConditionRouter（条件路由） ###

#### 参数规则 ####

condition://0.0.0.0/com.foo.BarService?category=routers&dynamic=false&enabled=true&force=true&runtime=false&priority=1&rule=URL.encode("host = 10.20.153.10 => host = 10.20.153.11")

<table> 
 <thead> 
  <tr> 
   <th align="center">参数名称</th> 
   <th align="center">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">condition://</td> 
   <td align="center">（必填）表示路由规则的类型，支持条件路由规则和脚本路由规则，可扩展</td> 
  </tr> 
  <tr> 
   <td align="center">0.0.0.0</td> 
   <td align="center">（必填）表示对所有ip生效，如果只想对某个IP生效，则填入具体IP</td> 
  </tr> 
  <tr> 
   <td align="center">com.foo.BarService</td> 
   <td align="center">（必填）表示只对指定服务生效</td> 
  </tr> 
  <tr> 
   <td align="center">category=routers</td> 
   <td align="center">（必填）表示该数据为动态配置类型</td> 
  </tr> 
  <tr> 
   <td align="center">dynamic=false</td> 
   <td align="center">（必填）表示该数据为持久数据，当注册方退出时，数据依然保存在注册中心</td> 
  </tr> 
  <tr> 
   <td align="center">enabled=true</td> 
   <td align="center">（非必填）覆盖规则是否生效，默认true</td> 
  </tr> 
  <tr> 
   <td align="center">force=true</td> 
   <td align="center">（非必填） 当路由规则为空时，是否强制执行，如果不强制执行，则路由结果为空的的路由规则将自动失效，默认false</td> 
  </tr> 
  <tr> 
   <td align="center">runtime=false</td> 
   <td align="center">（非必填）是否在每次调用时都执行路由规则，否则只在提供者地址列表变更时预先执行并缓存结果，调用时直接从缓存中获取路由结果。如果用了参数路由，则必须设置为true，需要注意设置会影响调用的性能，默认为false</td> 
  </tr> 
  <tr> 
   <td align="center">priority=1</td> 
   <td align="center">（非必填）路由规则优先级，用于排序，优先级越大越靠前，默认为0</td> 
  </tr> 
  <tr> 
   <td align="center">rule= + URL.encode(“host = 10.20.153.10 =&gt; host = 10.20.153.11”)</td> 
   <td align="center">（必填）表示路由规则的内容</td> 
  </tr> 
 </tbody> 
</table>

示例：

method = find* => host = 192.168.1.22,192.168.1.23

上面的路由规则表示，调用方法以find开头的路由到192.168.1.22,192.168.1.23，此时在调用的时候获取到的原始Invoker（RegisterDirectory或者StaticDirectory中的原始InvokerList）会针对route规则进行过滤。

#### 流程解析 ####

1.  校验：如果规则没有启用，则直接返回；如果传入的Invoker为空，则直接返回；如果没有任何whenRule匹配，即没有匹配规则，则直接发怒会传入的Invoker列表；如果whenRule有匹配，但是thenRule为空，即没有匹配上规则的Invoker，则返回空
2.  匹配：遍历Invoker列表，通过thenRule找出所有符合规则的Invoker介入result集合。
3.  返回：如果result不为空则直接返回result结果集；如果结果集为空，则查看force（强制执行）是否为true，如果为true，则表示强制执行，此时打印warn日志，并返回空结果集，否则返回所有的Invoker列表。

#### 源码解析 ####

// ConditionRouter#route
    @Override
    public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation)
            throws RpcException {
        
        // invoker列表为空直接return
        if (invokers == null || invokers.isEmpty()) {
        
            return invokers;
        }
        try {
        
        	// 匹配是否符合条件，不匹配直接return所有Invoker，无需过滤
            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. consumer: " + NetUtils.getLocalHost() + ", service: " + url.getServiceKey());
                return result;
            }
            // 若过滤条件不为空，遍历查找匹配
            for (Invoker<T> invoker : invokers) {
        
                if (matchThen(invoker.getUrl(), url)) {
        
                    result.add(invoker);
                }
            }
            // 查找匹配结果不为空则返回匹配结果
            if (!result.isEmpty()) {
        
                return result;
            } else if (force) {
        
            	// 如果为空且设置了强制执行则打印日志，并返回空结果集
                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;
    }

### FileRouter（文件路由） ###

#### 流程解析 ####

文件路由是把规则写在文件中，文件中写的是自定义脚本规则，可以是JavaScript、Groovy等，URL中的key值填写的是文件路径。文件路由主要做的就是把文件中的路由脚本读出来，然后调用路由的工厂去匹配对应的 **脚本路由** 做解析。

#### 源码解析 ####

// FileRouterFactory#getRouter
    // file:///d:/path/to/route.js?router=script ==> script:///d:/path/to/route.js?type=js&rule=<file-content>
    @Override
    public Router getRouter(URL url) {
        
        try {
        
            // 将文件URL转换为脚本路由URL，并加载
            // 将原来的协议(可能是“file”)替换为“script”
            String protocol = url.getParameter(Constants.ROUTER_KEY, ScriptRouterFactory.NAME); 
            // 使用文件后缀配置脚本类型，如js, groovy…
            String type = null;
            String path = url.getPath();
            if (path != null) {
        
                int i = path.lastIndexOf('.');
                if (i > 0) {
        
                    type = path.substring(i + 1);
                }
            }
            // 读取文件
            String rule = IOUtils.read(new FileReader(new File(url.getAbsolutePath())));
            // 读取是否是运行时的参数
            boolean runtime = url.getParameter(Constants.RUNTIME_KEY, false);
            // 生成路由工厂可以识别的URL，并把参数添加进去
            URL script = url.setProtocol(protocol).addParameter(Constants.TYPE_KEY, type).addParameter(Constants.RUNTIME_KEY, runtime).addParameterAndEncoded(Constants.RULE_KEY, rule);
            // 再次调用路由的工厂，由于前面配置了protocol为script类型，这里会使用脚本路由进行解析
            return routerFactory.getRouter(script);
        } catch (IOException e) {
        
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

### ScriptRouter（脚本路由） ###

#### 流程解析 ####

脚本路由使用JDK自带的脚本解析器解析脚本并运行，默认使用JavaScript解析器，其逻辑分为构造方法和route方法两大部分。

#### 源码解析 ####

// 以官方文档中的JavaScript脚本为例
    function route(invokers) {
        
    	// 创建一个list
        var result = new java.util.ArrayList(invokers.size());
        // 遍历传入的所有Invoker，过滤所有IP不是10.20.153.10的Invoker
        for (i = 0; i < invokers.size(); i ++) {
        
            if ("10.20.153.10".equals(invokers.get(i).getUrl().getHost())) {
        
                result.add(invokers.get(i));
            }
        }
        return result;
    } (invokers); // 表示立即执行方法

> 注意事项：  
> 我们在写JavaScript脚本的时候需要注意，一个服务只能有一条规则，如果有多条规则，并且规则之间没有交集，则会把所有的Invoker都过滤。另外，脚本路由中没有看到沙箱约束，因此会由注入的风险。

1.  构造方法主要负责一些初始化工作。
    
    1.  初始化参数。获取规则的脚本类型、路由优先级。如果没有设置脚本，则默认设置为JavaScript类型，如果没有解析到任何规则，则抛出异常。
    2.  初始化脚本执行引擎。根据脚本的类型，通过Java的ScriptEngineManager创建不同的脚本执行器并缓存起来。

// ScriptRouter#constructor
    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);
        // 如果没有设置脚本，则默认设置为JavaScript类型
        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) {
        
        	// 根据脚本的类型，通过Java的ScriptEngineManager创建不同的脚本执行器
            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;
    }

1.  route方法则负责具体的过滤逻辑执行。  
    route方法的核心逻辑就是调用脚本引擎，获取执行结果并返回。主要是JDK脚本引擎相关知识，不会涉及具体的过滤逻辑，因为逻辑已经下沉到用户自定义的脚本里面了。

@Override
    @SuppressWarnings("unchecked")
    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);
            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;
        }
    }

### 总结 ###

Dubbo的路由规则本质上只有条件路由和脚本路由，文件路由内部其实是读取的文件中的脚本，最终调用脚本路由的路由方法，相对而言，路由规则比较容易理解。

相关文章：  
[Davids原理探究：Dubbo源码编译（2.7.8）][Davids_Dubbo_2.7.8]  
[Davids原理探究：Dubbo SPI和Java SPI实现原理][Davids_Dubbo SPI_Java SPI]  
[Davids原理探究：Dubbo注册中心（ZooKeeper、Redis）实现原理][Davids_Dubbo_ZooKeeper_Redis]  
[Davids原理探究：Dubbo配置解析原理][Davids_Dubbo]  
[Davids原理探究：Dubbo服务暴露原理][Davids_Dubbo 1]  
[Davids原理探究：Dubbo服务消费原理][Davids_Dubbo 2]  
[Davids原理探究：Dubbo优雅停机原理解析][Davids_Dubbo 3]  
[Davids原理探究：Dubbo调用流程图][Davids_Dubbo 4]  
[Davids原理探究：Dubbo路由实现原理][Davids_Dubbo 5]  
[Davids原理探究：Dubbo负载均衡实现原理][Davids_Dubbo 6]  
[Davids原理探究：Dubbo过滤器原理][Davids_Dubbo 7]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Rhdmlkc18_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200817133632521.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Rhdmlkc18=,size_16,color_FFFFFF,t_70#pic_center
[Dubbo]: https://img-blog.csdnimg.cn/20200612103710917.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Rhdmlkc18=,size_16,color_FFFFFF,t_70
[Davids_Dubbo_2.7.8]: https://blog.csdn.net/Davids_/article/details/106603254
[Davids_Dubbo SPI_Java SPI]: https://blog.csdn.net/Davids_/article/details/106611949
[Davids_Dubbo_ZooKeeper_Redis]: https://blog.csdn.net/Davids_/article/details/106590954
[Davids_Dubbo]: https://blog.csdn.net/Davids_/article/details/106951976
[Davids_Dubbo 1]: https://blog.csdn.net/Davids_/article/details/106669184
[Davids_Dubbo 2]: https://blog.csdn.net/Davids_/article/details/106951941
[Davids_Dubbo 3]: https://blog.csdn.net/Davids_/article/details/106952238
[Davids_Dubbo 4]: https://blog.csdn.net/Davids_/article/details/106721401
[Davids_Dubbo 5]: https://blog.csdn.net/Davids_/article/details/106709918
[Davids_Dubbo 6]: https://blog.csdn.net/Davids_/article/details/106720555
[Davids_Dubbo 7]: https://blog.csdn.net/Davids_/article/details/106750014