摘要：服務調用過程比較復雜，包含眾多步驟。源碼分析在進行源碼分析之前，我們先來通過一張圖了解服務調用過程。服務調用方式支持同步和異步兩種調用方式，其中異步調用還可細分為有返回值的異步調用和無返回值的異步調用。

注: 本系列文章已捐贈給 Dubbo 社區(qū)，你也可以在 Dubbo 官方文檔中閱讀本系列文章。

在前面的文章中，我們分析了 Dubbo SPI、服務導出與引入、以及集群容錯方面的代碼。經過前文的鋪墊，本篇文章我們終于可以分析服務調用過程了。Dubbo 服務調用過程比較復雜，包含眾多步驟。比如發(fā)送請求、編解碼、服務降級、過濾器鏈處理、序列化、線程派發(fā)以及響應請求等步驟。限于篇幅原因，本篇文章無法對所有的步驟一一進行分析。本篇文章將會重點分析請求的發(fā)送與接收、編解碼、線程派發(fā)以及響應的發(fā)送與接收等過程，至于服務降級、過濾器鏈和序列化大家自行進行分析，也可以將其當成一個黑盒，暫時忽略也沒關系。介紹完本篇文章要分析的內容，接下來我們進入正題吧。

在進行源碼分析之前，我們先來通過一張圖了解 Dubbo 服務調用過程。

首先服務消費者通過代理對象 Proxy 發(fā)起遠程調用，接著通過網絡客戶端 Client 將編碼后的請求發(fā)送給服務提供方的網絡層上，也就是 Server。Server 在收到請求后，首先要做的事情是對數(shù)據(jù)包進行解碼。然后將解碼后的請求發(fā)送至分發(fā)器 Dispatcher，再由分發(fā)器將請求派發(fā)到指定的線程池上，最后由線程池調用具體的服務。這就是一個遠程調用請求的發(fā)送與接收過程。至于響應的發(fā)送與接收過程，這張圖中沒有表現(xiàn)出來。對于這兩個過程，我們也會進行詳細分析。

Dubbo 支持同步和異步兩種調用方式，其中異步調用還可細分為“有返回值”的異步調用和“無返回值”的異步調用。所謂“無返回值”異步調用是指服務消費方只管調用，但不關心調用結果，此時 Dubbo 會直接返回一個空的 RpcResult。若要使用異步特性，需要服務消費方手動進行配置。默認情況下，Dubbo 使用同步調用方式。

本節(jié)以及其他章節(jié)將會使用 Dubbo 官方提供的 Demo 分析整個調用過程，下面我們從 DemoService 接口的代理類開始進行分析。Dubbo 默認使用 Javassist 框架為服務接口生成動態(tài)代理類，因此我們需要先將代理類進行反編譯才能看到源碼。這里使用阿里開源 Java 應用診斷工具 Arthas 反編譯代理類，結果如下：

/**
 * Arthas 反編譯步驟：
 * 1. 啟動 Arthas
 *    java -jar arthas-boot.jar
 *
 * 2. 輸入編號選擇進程
 *    Arthas 啟動后，會打印 Java 應用進程列表，比如：
 *    [1]: 11232 org.jetbrains.jps.cmdline.Launcher
 *    [2]: 22370 org.jetbrains.jps.cmdline.Launcher
 *    [3]: 22371 com.alibaba.dubbo.demo.consumer.Consumer
 *    [4]: 22362 com.alibaba.dubbo.demo.provider.Provider
 *    [5]: 2074 org.apache.zookeeper.server.quorum.QuorumPeerMain
 * 這里輸入編號 3，讓 Arthas 關聯(lián)到啟動類為 com.....Consumer 的 Java 進程上
 *
 * 3. 由于 Demo 項目中只有一個服務接口，因此此接口的代理類類名為 proxy0，此時使用 sc 命令搜索這個類名。
 *    $ sc *.proxy0
 *    com.alibaba.dubbo.common.bytecode.proxy0
 *
 * 4. 使用 jad 命令反編譯 com.alibaba.dubbo.common.bytecode.proxy0
 *    $ jad com.alibaba.dubbo.common.bytecode.proxy0
 *
 * 更多使用方法請參考 Arthas 官方文檔：
 *   https://alibaba.github.io/arthas/quick-start.html
 */
public class proxy0 implements ClassGenerator.DC, EchoService, DemoService {
    // 方法數(shù)組
    public static Method[] methods;
    private InvocationHandler handler;

    public proxy0(InvocationHandler invocationHandler) {
        this.handler = invocationHandler;
    }

    public proxy0() {
    }

    public String sayHello(String string) {
        // 將參數(shù)存儲到 Object 數(shù)組中
        Object[] arrobject = new Object[]{string};
        // 調用 InvocationHandler 實現(xiàn)類的 invoke 方法得到調用結果
        Object object = this.handler.invoke(this, methods[0], arrobject);
        // 返回調用結果
        return (String)object;
    }

    /** 回聲測試方法 */
    public Object $echo(Object object) {
        Object[] arrobject = new Object[]{object};
        Object object2 = this.handler.invoke(this, methods[1], arrobject);
        return object2;
    }
}

如上，代理類的邏輯比較簡單。首先將運行時參數(shù)存儲到數(shù)組中，然后調用 InvocationHandler 接口實現(xiàn)類的 invoke 方法，得到調用結果，最后將結果轉型并返回給調用方。關于代理類的邏輯就說這么多，繼續(xù)向下分析。

public class InvokerInvocationHandler implements InvocationHandler {

    private final Invoker invoker;

    public InvokerInvocationHandler(Invoker handler) {
        this.invoker = handler;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        Class[] parameterTypes = method.getParameterTypes();
        
        // 攔截定義在 Object 類中的方法（未被子類重寫），比如 wait/notify
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(invoker, args);
        }
        
        // 如果 toString、hashCode 和 equals 等方法被子類重寫了，這里也直接調用
        if ("toString".equals(methodName) && parameterTypes.length == 0) {
            return invoker.toString();
        }
        if ("hashCode".equals(methodName) && parameterTypes.length == 0) {
            return invoker.hashCode();
        }
        if ("equals".equals(methodName) && parameterTypes.length == 1) {
            return invoker.equals(args[0]);
        }
        
        // 將 method 和 args 封裝到 RpcInvocation 中，并執(zhí)行后續(xù)的調用
        return invoker.invoke(new RpcInvocation(method, args)).recreate();
    }
}

InvokerInvocationHandler 中的 invoker 成員變量類型為 MockClusterInvoker，MockClusterInvoker 內部封裝了服務降級邏輯。下面簡單看一下：

public class MockClusterInvoker implements Invoker {
    
    private final Invoker invoker;
    
    public Result invoke(Invocation invocation) throws RpcException {
        Result result = null;

        // 獲取 mock 配置值
        String value = directory.getUrl().getMethodParameter(invocation.getMethodName(), Constants.MOCK_KEY, Boolean.FALSE.toString()).trim();
        if (value.length() == 0 || value.equalsIgnoreCase("false")) {
            // 無 mock 邏輯，直接調用其他 Invoker 對象的 invoke 方法，
            // 比如 FailoverClusterInvoker
            result = this.invoker.invoke(invocation);
        } else if (value.startsWith("force")) {
            // force:xxx 直接執(zhí)行 mock 邏輯，不發(fā)起遠程調用
            result = doMockInvoke(invocation, null);
        } else {
            // fail:xxx 表示消費方對調用服務失敗后，再執(zhí)行 mock 邏輯，不拋出異常
            try {
                // 調用其他 Invoker 對象的 invoke 方法
                result = this.invoker.invoke(invocation);
            } catch (RpcException e) {
                if (e.isBiz()) {
                    throw e;
                } else {
                    // 調用失敗，執(zhí)行 mock 邏輯
                    result = doMockInvoke(invocation, e);
                }
            }
        }
        return result;
    }
    
    // 省略其他方法
}

服務降級不是本文重點，因此這里就不分析 doMockInvoke 方法了。考慮到前文已經詳細分析過 FailoverClusterInvoker，因此本節(jié)略過 FailoverClusterInvoker，直接分析 DubboInvoker。

public abstract class AbstractInvoker implements Invoker {
    
    public Result invoke(Invocation inv) throws RpcException {
        if (destroyed.get()) {
            throw new RpcException("Rpc invoker for service ...");
        }
        RpcInvocation invocation = (RpcInvocation) inv;
        // 設置 Invoker
        invocation.setInvoker(this);
        if (attachment != null && attachment.size() > 0) {
            // 設置 attachment
            invocation.addAttachmentsIfAbsent(attachment);
        }
        Map contextAttachments = RpcContext.getContext().getAttachments();
        if (contextAttachments != null && contextAttachments.size() != 0) {
            // 添加 contextAttachments 到 RpcInvocation#attachment 變量中
            invocation.addAttachments(contextAttachments);
        }
        if (getUrl().getMethodParameter(invocation.getMethodName(), Constants.ASYNC_KEY, false)) {
            // 設置異步信息到 RpcInvocation#attachment 中
            invocation.setAttachment(Constants.ASYNC_KEY, Boolean.TRUE.toString());
        }
        RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);

        try {
            // 抽象方法，由子類實現(xiàn)
            return doInvoke(invocation);
        } catch (InvocationTargetException e) {
            // ...
        } catch (RpcException e) {
            // ...
        } catch (Throwable e) {
            return new RpcResult(e);
        }
    }

    protected abstract Result doInvoke(Invocation invocation) throws Throwable;
    
    // 省略其他方法
}

上面的代碼來自 AbstractInvoker 類，其中大部分代碼用于添加信息到 RpcInvocation#attachment 變量中，添加完畢后，調用 doInvoke 執(zhí)行后續(xù)的調用。doInvoke 是一個抽象方法，需要由子類實現(xiàn)，下面到 DubboInvoker 中看一下。

public class DubboInvoker extends AbstractInvoker {
    
    private final ExchangeClient[] clients;
    
    protected Result doInvoke(final Invocation invocation) throws Throwable {
        RpcInvocation inv = (RpcInvocation) invocation;
        final String methodName = RpcUtils.getMethodName(invocation);
        // 設置 path 和 version 到 attachment 中
        inv.setAttachment(Constants.PATH_KEY, getUrl().getPath());
        inv.setAttachment(Constants.VERSION_KEY, version);

        ExchangeClient currentClient;
        if (clients.length == 1) {
            // 從 clients 數(shù)組中獲取 ExchangeClient
            currentClient = clients[0];
        } else {
            currentClient = clients[index.getAndIncrement() % clients.length];
        }
        try {
            // 獲取異步配置
            boolean isAsync = RpcUtils.isAsync(getUrl(), invocation);
            // isOneway 為 true，表示“單向”通信
            boolean isOneway = RpcUtils.isOneway(getUrl(), invocation);
            int timeout = getUrl().getMethodParameter(methodName, Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);

            // 異步無返回值
            if (isOneway) {
                boolean isSent = getUrl().getMethodParameter(methodName, Constants.SENT_KEY, false);
                // 發(fā)送請求
                currentClient.send(inv, isSent);
                // 設置上下文中的 future 為 null
                RpcContext.getContext().setFuture(null);
                // 返回一個空的 RpcResult
                return new RpcResult();
            } 

            // 異步有返回值
            else if (isAsync) {
                // 發(fā)送請求，獲得 ResponseFuture 實例
                ResponseFuture future = currentClient.request(inv, timeout);
                // 設置 future 到上下文中
                RpcContext.getContext().setFuture(new FutureAdapter