# 一、Dubbo分層整體設計概述

我們先從下圖開始簡單介紹Dubbo分層設計概念：

![](https://static001.geekbang.org/infoq/00/0002dcd8c58403f7d11d9f86d586764b.png)

（引用自Duboo開發指南-框架設計文件）

如圖描述Dubbo實現的RPC整體分10層：service、config、proxy、registry、cluster、monitor、protocol、exchange、transport、serialize。

> **service**：使用方定義的介面和實現類；
> 
> **config**：負責解析Dubbo定義的配置，比如註解和xml配置，各種引數；
> 
> **proxy**：主要負責生成消費者和提供者的代理物件，載入框架功能，比如提供者過濾器鏈，擴充套件點；
> 
> **registry**：負責註冊服務的定義和實現類的裝載；
> 
> **cluster**：只有消費者有這麼一層，負責包裝多個服務提供者成一個‘大提供者’，載入負載均衡、路有等擴充套件點；
> 
> **monitor**：定義監控服務，載入監控實現提供者；
> 
> **protocol**：封裝RPC呼叫介面，管理呼叫實體的生命週期；
> 
> **exchange**：封裝請求響應模式，同步轉非同步；
> 
> **transport**：抽象傳輸層模型，相容netty、mina、grizzly等通訊框架；
> 
> **serialize**：抽象序列化模型，相容多種序列化框架，包括：fastjson、fst、hessian2、kryo、kryo2、protobuf等，透過序列化支援跨語言的方式，支援跨語言的rpc呼叫；

Dubbo這麼分層的目的在於實現層與層之間的解耦，每一層都定義了介面規範，也可以根據不同的業務需求定製、載入不同的實現，具有極高的擴充套件性。

## 1.1. RPC呼叫過程

接下來結合上圖簡單描述一次完整的rpc呼叫過程：

從Dubbo分層的角度看，詳細時序圖如下，藍色部分是服務消費端，淺綠色部分是服務提供端，時序圖從消費端一次Dubbo方法呼叫開始，到服務端本地方法執行結束。

![](https://static001.geekbang.org/infoq/6e/6e2a387953f22a9ef076b3900904a31a.jpeg)

從Dubbo核心領域物件的角度看，我們引用[Dubbo官方文件說明](https://dubbo.apache.org/zh/docs/v2.7/dev/implementation/)，如下圖所示。Dubbo核心領域物件是Invoker，消費端代理物件是proxy，包裝了Invoker的呼叫；服務端代理物件是一個Invoker，他透過exporter包裝，當服務端接收到呼叫請求後，透過exporter找到Invoker，Invoker去實際執行使用者的業務邏輯。

![](https://static001.geekbang.org/infoq/22/224325b6c2715d53b21e30d47f9363f2.png)

（引用自Dubbo官方文件）

## 1.2 Dubbo服務的註冊和發現流程

下圖出自[開發指南-框架設計-引用服務時序](https://dubbo.apache.org/zh/docs/v2.7/dev/design/)，主要流程是：從註冊中心訂閱服務提供者，然後啟動tcp服務連線遠端提供者，將多個服務提供者合併成一個Invoker，用這個Invoker建立代理物件。

![](https://static001.geekbang.org/infoq/32/327f95adeb2d39a22de294a4bde7decb.jpeg)

下圖出自[開發指南-框架設計-暴露服務時序](https://dubbo.apache.org/zh/docs/v2.7/dev/design/)，主要流程是：建立本地服務的代理Invoker，啟動tcp服務暴露服務，然後將服務註冊到註冊中心。

![](https://static001.geekbang.org/infoq/11/1180b58e4ac796a8627a59fa790b3de1.jpeg)

接下來我們結合Dubbo服務的註冊和發現，從配置層開始解釋每一層的作用和原理。

示例服務介面定義如下：

```java
public interface CouponServiceViewFacade {
 
    /**
     * 查詢單張優惠券
     */
    CouponViewDTO query(String code);
}
```

# 二、配置層

## 2.1. 做什麼

配置層提供配置處理工具類，在容器啟動的時候，透過ServiceConfig.export例項化服務提供者，ReferenceConfig.get例項化服務消費者物件。

Dubbo應用使用spring容器啟動時，Dubbo服務提供者配置處理器透過ServiceConfig.export啟動Dubbo遠端服務暴露本地服務。Dubbo服務消費者配置處理器透過ReferenceConfig.get例項化一個代理物件，並透過註冊中心服務發現，連線遠端服務提供者。

Dubbo配置可以使用註解和xml兩種形式，本文采用註解的形式進行說明。

## 2.2. 怎麼做

### 2.2.1 服務消費端的解析

Spring容器啟動過程中，填充bean屬性時，對含有Dubbo引用註解的屬性使用org.apache.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor進行初始化。如下是ReferenceAnnotationBeanPostProcessor的構造方法，Dubbo服務消費者註解處理器處理以下三個註解：DubboReference.class、Reference.class、com.alibaba.dubbo.config.annotation.Reference.class修飾的類。

ReferenceAnnotationBeanPostProcessor類定義：

```java
public class ReferenceAnnotationBeanPostProcessor extends AbstractAnnotationBeanPostProcessor implements
        ApplicationContextAware {
 
    public ReferenceAnnotationBeanPostProcessor() {
        super(DubboReference.class, Reference.class, com.alibaba.dubbo.config.annotation.Reference.class);
    }
}
```

Dubbo服務發現到這一層，Dubbo即將開始構建服務消費者的代理物件，CouponServiceViewFacade介面的代理實現類。

### 2.2.2 服務提供端的解析

Spring容器啟動的時候，載入註解@org.apache.dubbo.config.spring.context.annotation.DubboComponentScan指定範圍的類，並初始化；初始化使用dubbo實現的擴充套件點org.apache.dubbo.config.spring.beans.factory.annotation.ServiceClassPostProcessor。

ServiceClassPostProcessor處理的註解類有DubboService.class,Service.class,com.alibaba.dubbo.config.annotation.Service.class。

如下是ServiceClassPostProcessor類定義：

```java
public class ServiceClassPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware,
        ResourceLoaderAware, BeanClassLoaderAware {
 
    private final static List<class extends="" annotation="">> serviceAnnotationTypes = asList(
            DubboService.class,Service.class,com.alibaba.dubbo.config.annotation.Service.class
    );
。。。
}
```

等待Spring容器ContextRefreshedEvent事件，啟動Dubbo應用服務監聽埠，暴露本地服務。

Dubbo服務註冊到這一層，Dubbo即將開始構建服務提供者的代理物件，CouponServiceViewFacade實現類的反射代理類。

# 三、 代理層

## 3.1 做什麼

為服務消費者生成代理實現例項，為服務提供者生成反射代理例項。

CouponServiceViewFacade的代理實現例項，消費端在呼叫query方法的時候，實際上是呼叫代理實現例項的query方法，透過他呼叫遠端服務。

```java
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
 
package org.apache.dubbo.common.bytecode;
 
public class proxy1 implements DC, Destroyable, CouponServiceViewFacade, EchoService {
    public static Method[] methods;
    private InvocationHandler handler;
 
    public proxy1(InvocationHandler var1) {
        this.handler = var1;
    }
 
    public proxy1() {
    }
 
    public CouponViewDTO query(String var1) {
        Object[] var2 = new Object[]{var1};
        Object var3 = this.handler.invoke(this, methods[0], var2);
        return (CouponViewDTO)var3;
    }
}
```

CouponServiceViewFacade的反射代理例項，服務端接收到請求後，透過該例項的Invoke方法最終執行本地方法query。

```java
/**
 * InvokerWrapper
 */
public class AbstractProxyInvoker<couponserviceviewfacade> implements Invoker<couponserviceviewfacade> {
        // 。。。
 
    public AbstractProxyInvoker(CouponServiceViewFacade proxy, Class<couponserviceviewfacade> type, URL url) {
        //。。。
        this.proxy = proxy;
        this.type = type;
        this.url = url;
    }
 
    @Override
    public Result invoke(Invocation invocation) throws RpcException {
        //。。。
        Object value = doInvoke(proxy, invocation.getMethodName(), invocation.getParameterTypes(), invocation.getArguments());
        //。。。
    }
 
    protected Object doInvoke(CouponServiceViewFacade proxy, String methodName, Class>[] parameterTypes, Object[] arguments) throws Throwable{
        //。。。
        return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
    }
 
}
```

## 3.2 怎麼做

Dubbo代理工廠介面定義如下，定義了服務提供者和服務消費者的代理物件工廠方法。服務提供者代理物件和服務消費者代理物件都是透過工廠方法建立，工廠實現類可以透過SPI自定義擴充套件。

```java
@SPI("javassist")
public interface ProxyFactory {
 
    // 生成服務消費者代理物件
    @Adaptive({PROXY_KEY})
    <t> T getProxy(Invoker<t> invoker) throws RpcException;
 
    // 生成服務消費者代理物件
    @Adaptive({PROXY_KEY})
    <t> T getProxy(Invoker<t> invoker, boolean generic) throws RpcException;
 
     
    // 生成服務提供者代理物件
    @Adaptive({PROXY_KEY})
    <t> Invoker<t> getInvoker(T proxy, Class<t> type, URL url) throws RpcException;
 
}
```

### 3.2.1 服務消費者

#### 3.2.1.1 建立服務消費者代理類

預設採用Javaassist代理工廠實現，Proxy.getProxy(interfaces)建立代理工廠類，newInstance建立具體代理物件。

```java
public class JavassistProxyFactory extends AbstractProxyFactory {
 
    @Override
    @SuppressWarnings("unchecked")
    public <t> T getProxy(Invoker<t> invoker, Class>[] interfaces) {
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }
 
    。。。
 
}
```

#### 3.2.1.2 服務消費者代理

Dubbo為每個服務消費者生成兩個代理類：代理工廠類，介面代理類。

CouponServiceViewFacade代理工廠類：

```java
public class Proxy1 extends Proxy implements DC {
    public Proxy1() {
    }
 
    public Object newInstance(InvocationHandler var1) {
        return new proxy1(var1);
    }
}
```

**最終生成的CouponServiceViewFacade的代理物件**如下，其中handler的實現類是InvokerInvocationHandler，this.handler.invoke方法發起Dubbo呼叫。

```java
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
 
package org.apache.dubbo.common.bytecode;
 
public class proxy1 implements DC, Destroyable, CouponServiceViewFacade, EchoService {
    public static Method[] methods;
    private InvocationHandler handler;
 
    public proxy1(InvocationHandler var1) {
        this.handler = var1;
    }
 
    public proxy1() {
    }
 
    public CouponViewDTO query(String var1) {
        Object[] var2 = new Object[]{var1};
        Object var3 = this.handler.invoke(this, methods[0], var2);
        return (CouponViewDTO)var3;
    }
}
```

### 3.2.2 服務提供者

#### 3.2.2.1 建立服務提供者代理類

預設Javaassist代理工廠實現，使用Wrapper包裝本地服務提供者。proxy是實際的服務提供者例項，即CouponServiceViewFacade的本地實現類，type是介面類定義，URL是injvm協議URL。

```java
public class JavassistProxyFactory extends AbstractProxyFactory {
 
    。。。
 
    @Override
    public <t> Invoker<t> getInvoker(T proxy, Class<t> type, URL url) {
        // 代理包裝類，包裝了本地的服務提供者
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
        // 代理類入口
        return new AbstractProxyInvoker<t>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class>[] parameterTypes,
                                      Object[] arguments) throws Throwable {
                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }
 
}
```

#### 3.2.2.2 Wrapper包裝類

Dubbo為每個服務提供者的本地實現生成一個Wrapper代理類，抽象Wrapper類定義如下：

```java
public abstract class Wrapper {
    。。。
 
    abstract public Object invokeMethod(Object instance, String mn, Class>[] types, Object[] args) throws NoSuchMethodException, InvocationTargetException;
}
```

具體Wrapper代理類使用位元組碼技術動態生成，本地服務CouponServiceViewFacade的代理包裝類舉例：

```java
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
 
package org.apache.dubbo.common.bytecode;
 
import com.xxx.CouponServiceViewFacade;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import org.apache.dubbo.common.bytecode.ClassGenerator.DC;
 
public class Wrapper25 extends Wrapper implements DC {
  。。。
 
    public Wrapper25() {
    }
 
    public Object invokeMethod(Object var1, String var2, Class[] var3, Object[] var4) throws InvocationTargetException {
        CouponServiceViewFacade var5;
        try {
            var5 = (CouponServiceViewFacade)var1;
        } catch (Throwable var8) {
            throw new IllegalArgumentException(var8);
        }
 
        try {
            if ("query".equals(var2) && var3.length == 1) {
                return var5.query((String)var4[0]);
            }
        } catch (Throwable var9) {
            throw new InvocationTargetException(var9);
        }
 
        throw new NoSuchMethodException("Not found method \"" + var2 + "\" in class com.xxx.CouponServiceViewFacade.");
    }

。。。
 
}

```

在服務初始化流程中，服務消費者代理物件生成後初始化就完成了，服務消費端的初始化順序：ReferenceConfig.get->從註冊中心訂閱服務->啟動客戶端->建立DubboInvoker->構建ClusterInvoker→建立服務代理物件；

而服務提供端的初始化才剛開始，**服務提供端的初始化順序**：ServiceConfig.export->建立AbstractProxyInvoker，透過Injvm協議關聯本地服務->啟動服務端→註冊服務到註冊中心。

接下來我們講註冊層。

# 四、註冊層

## 4.1 做什麼

封裝服務地址的註冊與發現，以服務 URL 為配置中心。服務提供者本地服務啟動成功後，監聽Dubbo埠成功後，透過註冊協議釋出到註冊中心；服務消費者透過註冊協議訂閱服務，啟動本地應用連線遠端服務。

註冊協議URL舉例：

> zookeeper://xxx/org.apache.dubbo.registry.RegistryService?application=xxx&...

## 4.2 怎麼做

註冊服務工廠介面定義如下，註冊服務實現透過SPI擴充套件，預設是zk作為註冊中心。

```java
@SPI("dubbo")
public interface RegistryFactory {
 
    @Adaptive({"protocol"})
    Registry getRegistry(URL url);
 
}
```

註冊服務介面定義；

```java
public interface RegistryService {
 
    
    void register(URL url);
 
    
    void unregister(URL url);
 
    
    void subscribe(URL url, NotifyListener listener);
 
    
    void unsubscribe(URL url, NotifyListener listener);
 
    
    List<url> lookup(URL url);
 
}
```

# 五、叢集層

## 5.1 做什麼

服務消費方從註冊中心訂閱服務提供者後，將多個提供者包裝成一個提供者，並且封裝路由及負載均衡策略；並橋接註冊中心，以 Invoker 為中心，擴充套件介面為 Cluster, Directory, Router, LoadBalance；

服務提供端不存在叢集層。

## 5.2 怎麼做

### 5.2.1 Cluster

叢集領域主要負責將多個服務提供者包裝成一個ClusterInvoker，注入路由處理器鏈和負載均衡策略。主要策略有：failover、failfast、failsafe、failback、forking、available、mergeable、broadcast、zone-aware。

叢集介面定義如下，只有一個方法：從服務目錄中的多個服務提供者構建一個ClusterInvoker。

作用是對上層-代理層遮蔽叢集層的邏輯；代理層呼叫服務方法只需執行Invoker.invoke，然後透過ClusterInvoker內部的路由策略和負載均衡策略計算具體執行哪個遠端服務提供者。

```java
@SPI(Cluster.DEFAULT)
public interface Cluster {
    String DEFAULT = FailoverCluster.NAME;
 
    @Adaptive
    <t> Invoker<t> join(Directory<t> directory) throws RpcException;
 
  。。。
}
```

ClusterInvoker執行邏輯，先路由策略過濾，然後負載均衡策略選擇最終的遠端服務提供者。示例代理如下：

```java
   public abstract class AbstractClusterInvoker<t> implements ClusterInvoker<t> {
 
。。。
    @Override
    public Result invoke(final Invocation invocation) throws RpcException {
        checkWhetherDestroyed();
 
        // binding attachments into invocation.
        Map<string object=""> contextAttachments = RpcContext.getContext().getObjectAttachments();
        if (contextAttachments != null && contextAttachments.size() != 0) {
            ((RpcInvocation) invocation).addObjectAttachments(contextAttachments);
        }
 
        // 叢集invoker執行時，先使用路由鏈過濾服務提供者
        List<invoker>> invokers = list(invocation);
        LoadBalance loadbalance = initLoadBalance(invokers, invocation);
        RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
        return doInvoke(invocation, invokers, loadbalance);
    }
。。。
 
}
```

### 5.2.2 Directory

服務目錄介面定義如下，Dubbo方法介面呼叫時，將方法資訊包裝成invocation，透過Directory.list過濾可執行的遠端服務。

透過org.apache.dubbo.registry.integration.RegistryDirectory橋接註冊中心，監聽註冊中心的路由配置修改、服務治理等事件。

```java
public interface Directory<t> extends Node {
 
    
    Class<t> getInterface();
 
    List<invoker>> list(Invocation invocation) throws RpcException;
 
    List<invoker>> getAllInvokers();
 
    URL getConsumerUrl();
 
}
```

### 5.2.3 Router

從已知的所有服務提供者中根據路由規則刷選服務提供者。

服務訂閱的時候初始化路由處理器鏈，呼叫遠端服務的時候先使用路由鏈過濾服務提供者，再透過負載均衡選擇具體的服務節點。

路由處理器鏈工具類，提供路由篩選服務，監聽更新服務提供者。

```java
public class RouterChain<t> {
 
。。。
     
    public List<invoker>> route(URL url, Invocation invocation) {
        List<invoker>> finalInvokers = invokers;
        for (Router router : routers) {
            finalInvokers = router.route(finalInvokers, url, invocation);
        }
        return finalInvokers;
    }
 
    /**
     * Notify router chain of the initial addresses from registry at the first time.
     * Notify whenever addresses in registry change.
     */
    public void setInvokers(List<invoker>> invokers) {
        //路由鏈監聽更新服務提供者
        this.invokers = (invokers == null ? Collections.emptyList() : invokers);
        routers.forEach(router -> router.notify(this.invokers));
    }
 
}
```

訂閱服務的時候，將路由鏈注入到RegistryDirectory中；

```java
public class RegistryProtocol implements Protocol {
    。。。
 
    private <t> Invoker<t> doRefer(Cluster cluster, Registry registry, Class<t> type, URL url) {
        。。。
        // 服務目錄初始化路由鏈
        directory.buildRouterChain(subscribeUrl);
        directory.subscribe(toSubscribeUrl(subscribeUrl));
         。。。
        return registryInvokerWrapper;
    }
 
    。。。
 
}
```

### 5.2.4 LoadBalance

根據不同的負載均衡策略從可使用的遠端服務例項中選擇一個，負責均衡介面定義如下：

```java
@SPI(RandomLoadBalance.NAME)
public interface LoadBalance {
 
    @Adaptive("loadbalance")
    <t> Invoker<t> select(List<invoker>> invokers, URL url, Invocation invocation) throws RpcException;
 
}
```

# 六、監控層

## 6.1 做什麼

監控RPC呼叫次數和呼叫時間，以Statistics為中心，擴充套件介面為 MonitorFactory, Monitor, MonitorService。

## 6.2 怎麼做

監控工廠介面定義，透過SPI方式進行擴充套件；

```java
@SPI("dubbo")
public interface MonitorFactory {
 
    
    @Adaptive("protocol")
    Monitor getMonitor(URL url);
 
}

@Adaptive("protocol")
Monitor getMonitor(URL url);
```

監控服務介面定義如下，定義了一些預設的監控維度和指標項；

```java
public interface MonitorService {
 
    // 監控維度
 
    String APPLICATION = "application";
 
    String INTERFACE = "interface";
 
    String METHOD = "method";
 
    String GROUP = "group";
 
    String VERSION = "version";
 
    String CONSUMER = "consumer";
 
    String PROVIDER = "provider";
 
    String TIMESTAMP = "timestamp";
 
    //監控指標項
 
    String SUCCESS = "success";
 
    String FAILURE = "failure";
 
    String INPUT = INPUT_KEY;
 
    String OUTPUT = OUTPUT_KEY;
 
    String ELAPSED = "elapsed";
 
    String CONCURRENT = "concurrent";
 
    String MAX_INPUT = "max.input";
 
    String MAX_OUTPUT = "max.output";
 
    String MAX_ELAPSED = "max.elapsed";
 
    String MAX_CONCURRENT = "max.concurrent";

void collect(URL statistics);
 
    List<url> lookup(URL query);
 
}
```

### 6.2.1 MonitorFilter

透過過濾器的方式收集服務的呼叫次數和呼叫時間，預設實現：

org.apache.dubbo.monitor.dubbo.DubboMonitor。

# 七、協議層

## 7.1 做什麼

封裝 RPC 呼叫，以 Invocation, Result 為中心，擴充套件介面為 Protocol, Invoker, Exporter。

接下來介紹Dubbo RPC過程中的常用概念：

> 1）Invocation是請求會話領域模型，每次請求有相應的Invocation例項，負責包裝dubbo方法資訊為請求引數；
> 
> 2）Result是請求結果領域模型，每次請求都有相應的Result例項，負責包裝dubbo方法響應；
> 
> 3）Invoker是實體域，代表一個可執行實體，有本地、遠端、叢集三類；
> 
> 4）Exporter服務提供者Invoker管理實體；
> 
> 5）Protocol是服務域，管理Invoker的生命週期，提供服務的暴露和引用入口；

服務初始化流程中，從這一層開始進行遠端服務的暴露和連線引用。

對於CouponServiceViewFacade服務來說，服務提供端會監聽Dubbo埠啟動tcp服務；服務消費端透過註冊中心發現服務提供者資訊，啟動tcp服務連線遠端提供者。

## 7.2 怎麼做

協議介面定義如下，統一抽象了不同協議的服務暴露和引用模型，比如InjvmProtocol只需將Exporter，Invoker關聯本地實現。DubboProtocol暴露服務的時候，需要監控本地埠啟動服務；引用服務的時候，需要連線遠端服務。

```java
@SPI("dubbo")
public interface Protocol {
 
    
    int getDefaultPort();
 
    
    @Adaptive
    <t> Exporter<t> export(Invoker<t> invoker) throws RpcException;
 
    
    @Adaptive
    <t> Invoker<t> refer(Class<t> type, URL url) throws RpcException;
 
    
    void destroy();
 
    
    default List<protocolserver> getServers() {
        return Collections.emptyList();
    }
 
}
```

Invoker介面定義

Invocation是RPC呼叫的會話物件，負責包裝請求引數；Result是RPC呼叫的結果物件，負責包裝RPC呼叫的結果物件，包括異常類資訊；

```java
public interface Invoker<t> extends Node {
 
    
    Class<t> getInterface();
 
    
    Result invoke(Invocation invocation) throws RpcException;
 
}
```

### 7.2.1 服務的暴露和引用

服務暴露的時候，開啟RPC服務端；引用服務的時候，開啟RPC客戶端。

```java
public class DubboProtocol extends AbstractProtocol {
 
。。。
 
    @Override
    public <t> Exporter<t> export(Invoker<t> invoker) throws RpcException {
        。。。
        // 開啟rpc服務端
        openServer(url);
        optimizeSerialization(url);
 
        return exporter;
    }
 
    @Override
    public <t> Invoker<t> protocolBindingRefer(Class<t> serviceType, URL url) throws RpcException {
        optimizeSerialization(url);
 
        // 建立dubbo invoker,開啟rpc客戶端
        DubboInvoker<t> invoker = new DubboInvoker<t>(serviceType, url, getClients(url), invokers);
        invokers.add(invoker);
 
        return invoker;
    }
 。。。
 
}
```

### 7.2.2 服務端響應請求

接收響應請求；

```java
private ExchangeHandler requestHandler = new ExchangeHandlerAdapter() {
 
        @Override
        public CompletableFuture<object> reply(ExchangeChannel channel, Object message) throws RemotingException {
                           。。。
            Invocation inv = (Invocation) message;
            Invoker> invoker = getInvoker(channel, inv);

RpcContext.getContext().setRemoteAddress(channel.getRemoteAddress());
            //呼叫本地服務
            Result result = invoker.invoke(inv);
            return result.thenApply(Function.identity());
        }
 
        。。。
    };
```

### 7.2.3 客戶端傳送請求

呼叫遠端服務；

```java
public class DubboInvoker<t> extends AbstractInvoker<t> {
 
    。。。
 
    @Override
    protected Result doInvoke(final Invocation invocation) throws Throwable {
        。。。
            boolean isOneway = RpcUtils.isOneway(getUrl(), invocation);
            int timeout = calculateTimeout(invocation, methodName);
            if (isOneway) {
                boolean isSent = getUrl().getMethodParameter(methodName, Constants.SENT_KEY, false);
                currentClient.send(inv, isSent);
                return AsyncRpcResult.newDefaultAsyncResult(invocation);
            } else {
                ExecutorService executor = getCallbackExecutor(getUrl(), inv);
                CompletableFuture<appresponse> appResponseFuture =
                        currentClient.request(inv, timeout, executor).thenApply(obj -> (AppResponse) obj);
                FutureContext.getContext().setCompatibleFuture(appResponseFuture);
                AsyncRpcResult result = new AsyncRpcResult(appResponseFuture, inv);
                result.setExecutor(executor);
                return result;
            }

}
 
}
```

# 八、交換層

## 8.1 做什麼

封裝請求響應模式，同步轉非同步，以 Request, Response 為中心，擴充套件介面為 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer。

使用request包裝Invocation作為完整的請求物件，使用response包裝result作為完整的響應物件；Request、Response相比Invocation、Result新增了Dubbo的協議頭。

## 8.2 怎麼做

交換器物件介面定義，定義了遠端服務的繫結和連線，使用SPI方式進行擴充套件；

```java
@SPI(HeaderExchanger.NAME)
public interface Exchanger {
 
    
    @Adaptive({Constants.EXCHANGER_KEY})
    ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException;
 
    
    @Adaptive({Constants.EXCHANGER_KEY})
    ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException;
 
}

@Adaptive({Constants.EXCHANGER_KEY})
ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException;

@Adaptive({Constants.EXCHANGER_KEY})
ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException;

```

交換層模型類圖：

![](https://static001.geekbang.org/infoq/80/8003608ce973879b7104436b83f589e5.png)

### 8.2.1 服務提供者

服務提供端接收到請求後，本地執行，傳送響應結果；

```java
public class HeaderExchangeHandler implements ChannelHandlerDelegate {

。。。

void handleRequest(final ExchangeChannel channel, Request req) throws RemotingException {
       //封裝響應
        Response res = new Response(req.getId(), req.getVersion());
   。。。
        Object msg = req.getData();
        try {
            CompletionStage<object> future = handler.reply(channel, msg);
            future.whenComplete((appResult, t) -> {
                try {
                    if (t == null) {
                        res.setStatus(Response.OK);
                        res.setResult(appResult);
                    } else {
                        res.setStatus(Response.SERVICE_ERROR);
                        res.setErrorMessage(StringUtils.toString(t));
                    }
                    channel.send(res);
                } catch (RemotingException e) {
                    logger.warn("Send result to consumer failed, channel is " + channel + ", msg is " + e);
                }
            });
        } catch (Throwable e) {
            res.setStatus(Response.SERVICE_ERROR);
            res.setErrorMessage(StringUtils.toString(e));
            channel.send(res);
        }
    }
。。。
}
```

### 8.2.2 服務消費者

服務消費端發起請求的封裝，方法執行成功後，返回一個future；

```java
final class HeaderExchangeChannel implements ExchangeChannel {
 
。。。
 
   //封裝請求實體
    @Override
    public CompletableFuture<object> request(Object request, int timeout, ExecutorService executor) throws RemotingException {
       。。。

// create request.
        Request req = new Request();
        req.setVersion(Version.getProtocolVersion());
        req.setTwoWay(true);
        //RpcInvocation
        req.setData(request);
        DefaultFuture future = DefaultFuture.newFuture(channel, req, timeout, executor);
        try {
            channel.send(req);
        } catch (RemotingException e) {
            future.cancel();
            throw e;
        }
        return future;
    }
。。。
 
}
```

# 九、傳輸層

## 9.1 做什麼

抽象傳輸層模型，相容netty、mina、grizzly等通訊框架。

## 9.2 怎麼做

傳輸器介面定義如下,它與交換器Exchanger介面定義相似，區別在於Exchanger是圍繞Dubbo的Request和Response封裝的操作門面介面，而Transporter更加的底層，Exchanger用於隔離Dubbo協議層和通訊層。

```java
@SPI("netty")
public interface Transporter {
 
    
    @Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY})
    RemotingServer bind(URL url, ChannelHandler handler) throws RemotingException;
 
    
    @Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})
    Client connect(URL url, ChannelHandler handler) throws RemotingException;
 
}
```

自定義傳輸層模型

![](https://static001.geekbang.org/infoq/4a/4a762bb3082e45990b99a9fef818e639.png)

透過SPI的方式，動態選擇具體的傳輸框架，預設是netty；

```java
public class Transporters {
 
    。。。
 
    public static RemotingServer bind(URL url, ChannelHandler... handlers) throws RemotingException {
        。。。

return getTransporter().bind(url, handler);
    }
 
 
    public static Client connect(URL url, ChannelHandler... handlers) throws RemotingException {
        。。。
        return getTransporter().connect(url, handler);
    }
 
    public static Transporter getTransporter() {
        return ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();
    }
 
}
```

netty框架的channel適配如下，採用裝飾模式，使用netty框架的channel作為Dubbo自定義的channel做實現；

```java
final class NettyChannel extends AbstractChannel {
 
    private NettyChannel(Channel channel, URL url, ChannelHandler handler) {
        super(url, handler);
        if (channel == null) {
            throw new IllegalArgumentException("netty channel == null;");
        }
        this.channel = channel;
    }
 
}
```

# 十、序列化

## 10.1 做什麼

抽象序列化模型，相容多種序列化框架，包括：fastjson、fst、hessian2、kryo、kryo2、protobuf等，透過序列化支援跨語言的方式，支援跨語言的RPC呼叫。

## 10.2 怎麼做

定義Serialization擴充套件點，預設hessian2，支援跨語言。Serialization介面實際是一個工廠介面，透過SPI擴充套件；實際序列化和反序列化工作由ObjectOutput，ObjectInput完成，透過裝飾模式讓hessian2完成實際工作。

```java
@SPI("hessian2")
public interface Serialization {
 
    
    byte getContentTypeId();
 
    
    String getContentType();
 
 
    @Adaptive
    ObjectOutput serialize(URL url, OutputStream output) throws IOException;
 
    
    @Adaptive
    ObjectInput deserialize(URL url, InputStream input) throws IOException;
 
}
```

### 10.2.1 通訊協議設計

下圖出自開發指南-實現細節-遠端通訊細節，描述Dubbo協議頭設計；

![](https://static001.geekbang.org/infoq/07/0769f758ff97ccfbcd8dba87fbdbc842.png)

-   0-15bit表示Dubbo協議魔法數字，值：0xdabb；
    
-   16bit請求響應標記，Request - 1; Response - 0；
    
-   17bit請求模式標記，只有請求訊息才會有，1表示需要服務端返回響應；
    
-   18bit是事件訊息標記，1表示該訊息是事件訊息，比如心跳訊息；
    
-   19-23bit是序列化型別標記，hessian序列化id是2，fastjson是6，詳見org.apache.dubbo.common.serialize.Constants；
    
-   24-31bit表示狀態，只有響應訊息才有用；
    
-   32-64bit是RPC請求ID；
    
-   96-128bit是會話資料長度；
    
-   128是訊息體位元組序列；

# 十一、總結

Dubbo將RPC整個過程分成核心的代理層、註冊層、叢集層、協議層、傳輸層等，層與層之間的職責邊界明確；核心層都透過介面定義，不依賴具體實現，這些介面串聯起來形成了Dubbo的骨架；這個骨架也可以看作是Dubbo的核心，核心使用SPI 機制載入外掛（擴充套件點），達到高度可擴充套件。

> vivo網際網路伺服器團隊-Wang Genfu</object></object></appresponse></t></t></object></t></t></t></t></t></t></t></t></t></t></protocolserver></t></t></t></t></t></t></url></invoker></t></t></t></t></t></invoker></invoker></invoker></t></invoker></invoker></t></t></invoker></string></t></t></t></t></t></url></t></t></t></t></t></t></t></t></t></t></t></t></t></couponserviceviewfacade></couponserviceviewfacade></couponserviceviewfacade></class>

原始碼解讀Dubbo分層設計思想

相關文章