技術標籤：Dubbodubbo

請介紹⼀下Dubbo服務消費者呼叫服務提供者的過程？

1.整體流程圖

通過上面的流程圖可以知道，服務消費者通過代理物件Proxy發起遠端呼叫，接著通過網路客戶端Client將編碼後的請求傳送給服務提供方的網路層上，也就是Server。Server在收到請求後，首先要做的事情是對資料包進行解碼。然後將解碼後的請求傳送至分發器Dispatcher，再由分發器將請求派發到指定的執行緒池上，最後由執行緒池呼叫具體的服務。這就是一個遠端呼叫請求的傳送與接收過程。

2.執行流程

1. 生成動態代理類
   當呼叫服務方法時，會被InvokerInvocationHandler類的invoke⽅法攔截
   

   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{}

2. 將封裝引數到RpcInvocation中執行後續的呼叫
   return invoker.invoke(new RpcInvocation(method, args)).recreate();

3. 沒有服務降級邏輯
   沒有服務降級邏輯，即⽆ mock 邏輯，直接調⽤其他 Invoker 物件的 invoke ⽅法，⽐如
   FailoverClusterInvoker result = this.invoker.invoke(invocation);

4. 抽象方法，由子類實現
   return doInvoke(invocation);

5. 傳送請求
   得到⼀個 ResponseFuture 例項，並調⽤該例項的 get ⽅法進⾏等待
   return (Result) currentClient.request(inv, timeout).get();

6. 寫資料
   (1) channel.request(request, timeout);
   (2) channel.send(req);
   (3) ChannelFuture future = channel.writeAndFlush(message);
   (4) pipeline.writeAndFlush(msg);
   

   (5) ExchangeCodec類對請求資料進⾏編碼和序列化
   (6) next.invokeWrite(m, promise);

請介紹⼀下Dubbo服務提供者接收消費者請求的過程？

預設情況下 Dubbo 使⽤ Netty 作為底層的通訊框架。Netty 檢測到有資料⼊站後，⾸先會通過解碼器對資料進⾏解碼，並將解碼後的資料傳遞給下⼀個⼊站處理器的指定⽅法。

執行過程：

1. 執行ExchangeCodec類解碼⽅法
   public Object decode(Channel channel, ChannelBuffer buffer) throws IOException

2. 解碼後得到⼀個Request物件

3. 解碼器將資料包解析成 Request 物件後，NettyServerHandler 的 channelRead ⽅法緊接著會收到這個物件，並將這個物件繼續向下傳遞。這期間該物件會被依次傳遞給 AbstractPeer、MultiMessageHandler、HeartbeatHandler以及 AllChannelHandler。最後由 AllChannelHandler 將該物件封裝到 Runnable 實現類物件中，並將 Runnable 放⼊執行緒池中執⾏後續的調⽤邏輯。

4. 接下來會調⽤ChannelEventRunnable，ChannelEventRunnable 將會是服務調⽤過程的新起點
   // 將 channel 和 message 傳給 ChannelHandler?物件，進⾏後續的調⽤
   // handler是 DecodeHandler型別物件handler.received(channel, message);

5. 執⾏HeaderExchangeHandler類⽅法
   public void received(Channel channel, Object message)
   在該⽅法內部執⾏handleRequest邏輯
   handleRequest(exchangeChannel, request)

6. 執⾏DubboProtocol類的invoke⽅法
   Result result = invoker.invoke(inv);
   在該⽅法內部，調⽤我們的⽬標實現類內容
   return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
   ⾄此，調⽤到了⽬標實現類的⽅法
   handler.received(channel, message);

簡述dubbo的spi

SPI是什麼？

spi，簡單來說，就是service provider interface。比如你有個介面，現在這個介面有 3 個實現類，那麼在系統執行的時候對這個介面到底選擇哪個實現類呢？這就需要 spi 了，需要根據指定的配置或者是預設的配置，去找到對應的實現類載入進來，然後用這個實現類的例項物件。

Java SPI思想體現

spi 經典的思想體現，大家平時都在用，比如說 jdbc。

Java 定義了一套 jdbc 的介面，但是 Java 並沒有提供 jdbc 的實現類。但是實際上專案跑的時候，要使用 jdbc 介面的哪些實現類呢？一般來說，我們要根據自己使用的資料庫，比如 mysql，你就將 mysql-jdbc-connector.jar 引入進來；oracle，你就將 oracle-jdbc-connector.jar 引入進來。在系統跑的時候，碰到你使用 jdbc 的介面，他會在底層使用你引入的那個 jar 中提供的實現類。

dubbo的SPI思想

dubbo 也用了 spi 思想，不過沒有用 jdk 的 spi 機制，是自己實現的一套 spi 機制。

Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

Protocol 介面，在系統執行的時候，dubbo 會判斷一下應該選用這個 Protocol 介面的哪個實現類來例項化物件來使用。

它會去找一個你配置的 Protocol，將你配置的 Protocol 實現類，載入到 jvm 中來，然後例項化物件，就用你的那個 Protocol 實現類就可以了。

上面那行程式碼就是 dubbo 裡大量使用的，就是對很多元件，都是保留一個介面和多個實現，然後在系統執行的時候動態根據配置去找到對應的實現類。如果你沒配置，那就走預設的實現好了，沒問題。

@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();
}

在 dubbo 自己的 jar 裡，在 /META_INF/dubbo/internal/com.alibaba.dubbo.rpc.Protocol 檔案中：

dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
http=com.alibaba.dubbo.rpc.protocol.http.HttpProtocol 
hessian=com.alibaba.dubbo.rpc.protocol.hessian.HessianProtocol

所以說，這就看到了 dubbo 的 spi 機制預設是怎麼玩兒的了，其實就是 Protocol 介面，

@SPI(“dubbo”) 說的是，通過 SPI 機制來提供實現類，實現類是通過 dubbo 作為預設 key 去配置檔案裡找到的，配置檔名稱與介面全限定名一樣的，通過 dubbo 作為 key 可以找到預設的實現類就是com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol 。

如果想要動態替換掉預設的實現類，需要使用 @Adaptive 介面，Protocol 介面中，有兩個方法加了@Adaptive 註解，就是說那倆介面會被代理實現。

比如這個 Protocol 介面搞了倆 @Adaptive 註解標註了方法，在執行的時候會針對 Protocol 生成代理

類，這個代理類的那倆方法裡面會有代理程式碼，代理程式碼會在執行的時候動態根據 url 中的 protocol 來

獲取那個 key，預設是 dubbo，你也可以自己指定，你如果指定了別的 key，那麼就會獲取別的實現類

的例項了。

自定義dubbo的spi擴充套件

1. 自己寫個工程，要是那種可以打成 jar 包的，裡面的 src/main/resources 目錄下，搞一個 META-INF/services ，裡面放個檔案叫： com.alibaba.dubbo.rpc.Protocol ，檔案裡搞一個my=com.bingo.MyProtocol 。

2. 自己把 jar 弄到 nexus 私服裡去。

3. 然後自己搞一個 dubbo provider 工程，在這個工程裡面依賴你自己搞的那個 jar，然後在 spring 配置檔案裡給個配置：
   <dubbo:protocol name=“my” port=“20000” />

4. provider 啟動的時候，就會載入到我們 jar 包裡的my=com.bingo.MyProtocol 這行配置裡，接著會根據你的配置使用你定義好的 MyProtocol 了，這個就是簡單說明一下；

5. 通過上述方式，可以替換掉大量的 dubbo 內部的元件，就是扔個你自己的 jar 包，然後配置一下即可。

dubbo-spi

dubbo 裡面提供了大量的類似上面的擴充套件點，就是說，你如果要擴充套件一個東西，只要自己寫個 jar，讓

你的 consumer 或者是 provider 工程，依賴你的那個 jar，在你的 jar 裡指定目錄下配置好介面名稱對

應的檔案，裡面通過 key=實現類 。

然後對於對應的元件，類似 dubbo:protocol 用你的那個 key 對應的實現類來實現某個介面，你可以自

己去擴充套件 dubbo 的各種功能，提供你自己的實現。

我只是覺得自己不僅僅如此，所以在努力呀！