Dubbo的RPC呼叫在客戶端觸發，配置檔案中定義：

<dubbo:reference id="xxxService" interface="xxx.xxx.Service"/>

這一行定義會為xxx.xxx.Service在本地生成一個遠端代理。在Dubbo中這個代理用com.alibaba.dubbo.common.bytecode.proxy0的例項表示。這個代理存在於本地可以像本地Bean一樣呼叫該服務，具體通訊過程由代理負責。

代理例項僅僅包含一個handler物件（實現InvokerInvocationHandler介面），handler中包含RPC呼叫核心介面Invoker < T >的實現。

public interface Invoker<T> extends Node {
    Class<T> getInterface();
    //呼叫過程的具體表示形式
    Result invoke(Invocation invocation) throws
    RpcException;
}

其中核心方法invoker(Invocation invocation)引數Invocation是一個呼叫過程的抽象，也是Dubbo框架的核心介面。

public interface Invocation { 
//呼叫的方法名稱
String getMethodName(); 
//呼叫方法的引數的型別列表 
 

Class<?>[] getParameterTypes(); 
//呼叫方法的引數列表
Object[] getArguments();
//呼叫時附加的資料，用 map 儲存
Map<String, String> getAttachments();
//根據 key 來獲取附加的資料
String getAttachment(String key); 
//getAttachment(String key)的拓展，支援預設值獲取 
String getAttachment(String key, String defaultValue); 
//獲取真實的呼叫者實現
Invoker<?> getInvoker();
}
 

Invocation和Invoker相互依存，如果是RPC呼叫，Invocation的具體實現就是RPCInvocation，該方法異常時丟擲RpcException。

代理的handler例項中實現Invoker< T >的介面的是MockClusterInvoker，它僅僅是一個Invoker的包裝，只是用於Dubbo框架的mock功能，它的invoke方法實現：

public Result invoke(Invocation invocation) throws RpcException {
    Result result = null;
    /*這一行程式碼用於獲取該服務是否 供 mock 功能，如果 供，則 url 中會包 含 mock 關鍵字*/
    String value = directory.getUrl().getMethodParameter(invocation. getMethodName(), Constants.MOCK_KEY, Boolean.FALSE.toString()).trim();
    if (value.length() == 0 || value.equalsIgnoreCase("false")){
        //沒有 mock 的過程，直接呼叫
        result = this.invoker.invoke(invocation);
    } else if (value.startsWith("force")) {
        //日誌記錄程式碼部分省略
        //force:direct mock，這裡用於處理強制 mock 的情況，不執行遠端呼叫 
        result = doMockInvoke(invocation, null);
    } else {
        //fail-mock，這裡處理失敗後 mock 的情況，即出現呼叫異常時執行 mock 
        try {
            result = this.invoker.invoke(invocation);               } catch (RpcException e) {
            if (e.isBiz()) { throw e;
            } else {
                //省略日誌記錄部分的程式碼
                //這裡執行 mockInvoke 的邏輯，在本地偽裝結果 
                result = doMockInvoke(invocation, e);
            } 
        }
}
return result; }

MockClusterInvoker實現來Invoker< T >介面但是沒有實現invoke的邏輯，只是包裝了一個Invoker的真實實現。如下：

public class MockClusterInvoker<T> implements Invoker<T>{
    private final Directory<T> directory ;
    private final Invoker<T> invoker;
    public MockClusterInvoker(Directory<T> directory, Invoker<T> invoker) {
        this.directory = directory;
        this.invoker = invoker; }
}

其中真實的Invoker實現包含了叢集容錯的功能，可知Dubbo的叢集容錯是在Invoker中實現的。

Dubbo預設的容錯實現FailoverClusterInvoker即失敗重試。在FailoverClusterInvoker的實現中核心方法invoke(Invocation invocation)繼承自AbstractClusterInvoker< T > 抽象類。AbstractClusterInvoker< T >中的invoke(Invocation invocation)方法的實現如下：

public Result invoke(final Invocation invocation) throws RpcException { 
    checkWheatherDestoried();
    LoadBalance loadbalance;
    List<Invoker<T>> invokers = list(invocation);
    if (invokers != null && invokers.size() > 0) {
        //這裡省略了獲取 loadbalance 例項的實現程式碼，具體思路就是用拓展類載入器根據配置載入 loadbalance 例項
    } else {
        loadbalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).
getExtension(Constants.DEFAULT_LOADBALANCE);
    }
    RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation); 
    return doInvoke(invocation, invokers, loadbalance);
}

list(invocation) 獲取 Invoker 的列表List< Invoker< T > >，這個列表可以對應到服務 供者的列表。其中，list(invocation)方法的實現程式碼如下:

protected List<Invoker<T>> list(Invocation invocation) throws RpcException { 
    List<Invoker<T>> invokers = directory.list(invocation);
    return invokers;
}

list(invocation)方法中用到關鍵的介面 Directory，它是 Dubbo 框架中用於封裝服務供者列表的一個數據結構。
Directory 的定義程式碼如下:

public interface Directory<T> extends Node {
    Class<T> getInterface();
    List<Invoker<T>> list(Invocation invocation) throws RpcException; 
    }

list(Invocation invocation)的引數是一個Invocation 物件表示的是一次(遠端)呼叫過程，list 方法返回一個呼叫者的列表 List< Invoker< T > >，directory 介面的例項例項是 RegistryDirectory類的物件 ，RegistryDirectory的list(invocation)方法繼承自 AbstractDirectory，具體實現如下：

public List<Invoker<T>> list(Invocation invocation) throws RpcException { 
    if (destroyed)
throw new RpcException("Directory already destroyed .url: "+ getUrl()); 
    //獲取呼叫列表
    List<Invoker<T>> invokers = doList(invocation);
    List<Router> localRouters = this.routers; // local reference
    if (localRouters != null && localRouters.size() > 0) {
        for (Router router: localRouters){ 
            try {
                if (router.getUrl() == null || router.getUrl(). getParameter(Constants.RUNTIME_KEY, true)) {
                    invokers = router.route(invokers, getConsumerUrl(), invocation);
                }
            } catch (Throwable t) {
                logger.error("Failed to execute router: " + getUrl() + ", cause: " + t.getMessage(), t);
            }
         }
    }
    return invokers;
}

每個 Consumer 會在本地快取(或者從註冊中心獲取)路由集合 List< Router > localRouters，然後判斷集合中的每一個路由規則是否可以對當前調 用進行過濾，如果路由規則符合當前呼叫，就對呼叫列表 List< Invoker< T > >進行 篩選，去除不符合的呼叫者。
Router 介面的定義程式碼如下:

public interface Router extends Comparable<Router> {
    //獲取當前路由的 url
    URL getUrl();
    //路由方法，對傳入的 List<Invoker<T>>進行路由篩選，篩選的條件包括 Invocation 物件和 consumer 的 url
    <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException;
}