Dubbo（四）：深入理解Dubbo源碼之如何實現服務引用

一、前言

　　前面講了服務是如何導出到注冊中心的。其實Dubbo做的一件事就是將服務的URL發布到注冊中心上。那現在我們聊一聊消費者一方如何從注冊中心訂閱服務並進行遠程調用的。

二、引用服務時序圖

　　首先總的來用文字說一遍內部的大致機制

　　Actor：可以當做我們的消費者。當我們使用@Reference注解將對應服務注入到其他類中這時候Spring會第一時間調用getObject方法，而getObject中只有一個方法就是get()。這里可以理解為消費者開始引入服務了。

　　　　餓漢式：在 Spring 容器調用 ReferenceBean 的 afterPropertiesSet 方法時引用服務。

　　　　懶漢式：在 ReferenceBean 對應的服務被注入到其他類中時引用。Dubbo默認使用懶漢式。

　　ReferenceConfig：通過get方法其實是進入到ReferenceConfig類中執行init()方法。在這個方法里主要做了下面幾件事情：

　　　　1,、對@Reference標注的接口查看是否合法，檢查該接口是不是存在泛型

　　　　2、在系統中拿到dubbo.resolve.file這個文件，這個文件是進行配置consumer的接口的。將配置好的consumer信息存到URL中

　　　　3、將配置好的ApplicationConfig、ConsumerConfig、ReferenceConfig、MethodConfig，以及消費者的IP地址存到系統的上下文中

　　　　4、接下來開始創建代理對象進入到ReferenceConfig的createProxy 。這里還是在ReferenceConfig類中。上面的那些配置統統傳入該方法中。上面有提到resolve解析consumer為URL，現在就根據這個URL首先判斷是否遠程調用還是本地調用。

　　　　　　4.1若是本地調用，則調用 InjvmProtocol 的 refer 方法生成 InjvmInvoker 實例

　　　　　　4.2若是遠程調用，則讀取直連配置項，或注冊中心 url，並將讀取到的 url 存儲到 urls 中。然后根據 urls 元素數量進行后續操作。若 urls 元素數量為1，則直接通過 Protocol 自適應拓展類即RegistryProtocol類或者DubboProtocol構建 Invoker 實例接口，這得看URL前面的是registry://開頭還是以dubbo://。若 urls 元素數量大於1，即存在多個注冊中心或服務直連 url，此時先根據 url 構建 Invoker。然后再通過 Cluster 合並即merge多個 Invoker，最后調用 ProxyFactory 生成代理類。

　　RegistryProtocol：在refer方法中首先為 url 設置協議頭，然后根據 url 參數加載注冊中心實例。然后獲取 group 配置，根據 group 配置決定 doRefer 第一個參數的類型。doRefer 方法創建一個 RegistryDirectory 實例，然后生成服務消費者鏈接，通過registry.register方法向注冊中心注冊消費者的鏈接，然后通過directory.subscribe向注冊中心訂閱 providers、configurators、routers 等節點下的數據。完成訂閱后，RegistryDirectory 會收到這幾個節點下的子節點信息。由於一個服務可能部署在多台服務器上，這樣就會在 providers 產生多個節點，這個時候就需要 Cluster 將多個服務節點合並為一個，並生成一個 Invoker。同樣Invoker創建過程先不分析，后面會拿一章專門介紹。

　　ProxyFactory：Invoker 創建完畢后，接下來要做的事情是為服務接口生成代理對象。有了代理對象，即可進行遠程調用。代理對象生成的入口方法為的getProxy。獲取需要創建的接口列表，組合成數組。而后將該接口數組傳入 Proxy 的 getProxy 方法獲取 Proxy 子類，然后創建 InvokerInvocationHandler 對象，並將該對象傳給 newInstance 生成 Proxy 實例。InvokerInvocationHandler 實現 JDK 的 InvocationHandler 接口，具體的用途是攔截接口類調用。可以理解為AOP或攔截器。也就是在獲取該對象之前會調用到Proxy實例而不會調用到服務提供者對應的類。至於如何創建proxy實例，請看后面源碼的注釋。

三、Dubbo源碼

　　服務引用入口源碼ReferenceBean的getObject方法：

public Object getObject() throws Exception {
    return get();
}

public synchronized T get() {
    if (destroyed) {
        throw new IllegalStateException("Already destroyed!");
    }
    // 檢測 ref 是否為空，為空則通過 init 方法創建
    if (ref == null) {
        // init 方法主要用於處理配置，以及調用 createProxy 生成代理類
        init();
    }
    return ref;
}

　　ReferenceConfig 的 init 進行消費者一方的配置：

　　　　對源碼進行了分割，方便理清邏輯

private void init() {
    // 避免重復初始化
    if (initialized) {
        return;
    }
    initialized = true;
    // 檢測接口名合法性
    if (interfaceName == null || interfaceName.length() == 0) {
        throw new IllegalStateException("interface not allow null!");
    }

    // 檢測 consumer 變量是否為空，為空則創建
    checkDefault();
    appendProperties(this);
    if (getGeneric() == null && getConsumer() != null) {
        // 設置 generic
        setGeneric(getConsumer().getGeneric());
    }

    // 檢測是否為泛化接口
    if (ProtocolUtils.isGeneric(getGeneric())) {
        interfaceClass = GenericService.class;
    } else {
        try {
            // 加載類
            interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
                    .getContextClassLoader());
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
        checkInterfaceAndMethods(interfaceClass, methods);
    }
    
    // -------------------------------分割線1------------------------------

    // 從系統變量中獲取與接口名對應的屬性值
    String resolve = System.getProperty(interfaceName);
    String resolveFile = null;
    if (resolve == null || resolve.length() == 0) {
        // 從系統屬性中獲取解析文件路徑
        resolveFile = System.getProperty("dubbo.resolve.file");
        if (resolveFile == null || resolveFile.length() == 0) {
            // 從指定位置加載配置文件
            File userResolveFile = new File(new File(System.getProperty("user.home")), "dubbo-resolve.properties");
            if (userResolveFile.exists()) {
                // 獲取文件絕對路徑
                resolveFile = userResolveFile.getAbsolutePath();
            }
        }
        if (resolveFile != null && resolveFile.length() > 0) {
            Properties properties = new Properties();
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(new File(resolveFile));
                // 從文件中加載配置
                properties.load(fis);
            } catch (IOException e) {
                throw new IllegalStateException("Unload ..., cause:...");
            } finally {
                try {
                    if (null != fis) fis.close();
                } catch (IOException e) {
                    logger.warn(e.getMessage(), e);
                }
            }
            // 獲取與接口名對應的配置
            resolve = properties.getProperty(interfaceName);
        }
    }
    if (resolve != null && resolve.length() > 0) {
        // 將 resolve 賦值給 url
        url = resolve;
    }
    
    // -------------------------------分割線2------------------------------
    if (consumer != null) {
        if (application == null) {
            // 從 consumer 中獲取 Application 實例，下同
            application = consumer.getApplication();
        }
        if (module == null) {
            module = consumer.getModule();
        }
        if (registries == null) {
            registries = consumer.getRegistries();
        }
        if (monitor == null) {
            monitor = consumer.getMonitor();
        }
    }
    if (module != null) {
        if (registries == null) {
            registries = module.getRegistries();
        }
        if (monitor == null) {
            monitor = module.getMonitor();
        }
    }
    if (application != null) {
        if (registries == null) {
            registries = application.getRegistries();
        }
        if (monitor == null) {
            monitor = application.getMonitor();
        }
    }
    
    // 檢測 Application 合法性
    checkApplication();
    // 檢測本地存根配置合法性
    checkStubAndMock(interfaceClass);
    
    // -------------------------------分割線3------------------------------
    
    Map<String, String> map = new HashMap<String, String>();
    Map<Object, Object> attributes = new HashMap<Object, Object>();

    // 添加 side、協議版本信息、時間戳和進程號等信息到 map 中
    map.put(Constants.SIDE_KEY, Constants.CONSUMER_SIDE);
    map.put(Constants.DUBBO_VERSION_KEY, Version.getProtocolVersion());
    map.put(Constants.TIMESTAMP_KEY, String.valueOf(System.currentTimeMillis()));
    if (ConfigUtils.getPid() > 0) {
        map.put(Constants.PID_KEY, String.valueOf(ConfigUtils.getPid()));
    }

    // 非泛化服務
    if (!isGeneric()) {
        // 獲取版本
        String revision = Version.getVersion(interfaceClass, version);
        if (revision != null && revision.length() > 0) {
            map.put("revision", revision);
        }

        // 獲取接口方法列表，並添加到 map 中
        String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
        if (methods.length == 0) {
            map.put("methods", Constants.ANY_VALUE);
        } else {
            map.put("methods", StringUtils.join(new HashSet<String>(Arrays.asList(methods)), ","));
        }
    }
    map.put(Constants.INTERFACE_KEY, interfaceName);
    // 將 ApplicationConfig、ConsumerConfig、ReferenceConfig 等對象的字段信息添加到 map 中
    appendParameters(map, application);
    appendParameters(map, module);
    appendParameters(map, consumer, Constants.DEFAULT_KEY);
    appendParameters(map, this);
    
    // -------------------------------分割線4------------------------------
    
    String prefix = StringUtils.getServiceKey(map);
    if (methods != null && !methods.isEmpty()) {
        // 遍歷 MethodConfig 列表
        for (MethodConfig method : methods) {
            appendParameters(map, method, method.getName());
            String retryKey = method.getName() + ".retry";
            // 檢測 map 是否包含 methodName.retry
            if (map.containsKey(retryKey)) {
                String retryValue = map.remove(retryKey);
                if ("false".equals(retryValue)) {
                    // 添加重試次數配置 methodName.retries
                    map.put(method.getName() + ".retries", "0");
                }
            }
 
            // 添加 MethodConfig 中的“屬性”字段到 attributes
            // 比如 onreturn、onthrow、oninvoke 等
            appendAttributes(attributes, method, prefix + "." + method.getName());
            checkAndConvertImplicitConfig(method, map, attributes);
        }
    }
    
    // -------------------------------✨ 分割線5 ✨------------------------------

    // 獲取服務消費者 ip 地址
    String hostToRegistry = ConfigUtils.getSystemProperty(Constants.DUBBO_IP_TO_REGISTRY);
    if (hostToRegistry == null || hostToRegistry.length() == 0) {
        hostToRegistry = NetUtils.getLocalHost();
    } else if (isInvalidLocalHost(hostToRegistry)) {
        throw new IllegalArgumentException("Specified invalid registry ip from property..." );
    }
    map.put(Constants.REGISTER_IP_KEY, hostToRegistry);

    // 存儲 attributes 到系統上下文中
    StaticContext.getSystemContext().putAll(attributes);

    // 創建代理類
    ref = createProxy(map);

    // 根據服務名，ReferenceConfig，代理類構建 ConsumerModel，
    // 並將 ConsumerModel 存入到 ApplicationModel 中
    ConsumerModel consumerModel = new ConsumerModel(getUniqueServiceName(), this, ref, interfaceClass.getMethods());
    ApplicationModel.initConsumerModel(getUniqueServiceName(), consumerModel);
}

　　ReferenceConfig 的 createProxy 創建代理對象：

　　　　但是不是在這個方法內創建proxy實例，而是對URL進行解析后分三種創建Invoker線路，包括InjvmProtocol中的refer、DubboProtocol的refer與RegistryProtocol中的refer，最后再調用ProxyFactory來對proxy實例進行創建：

private T createProxy(Map<String, String> map) {
    URL tmpUrl = new URL("temp", "localhost", 0, map);
    final boolean isJvmRefer;
    if (isInjvm() == null) {
        // url 配置被指定，則不做本地引用
        if (url != null && url.length() > 0) {
            isJvmRefer = false;
        // 根據 url 的協議、scope 以及 injvm 等參數檢測是否需要本地引用
        // 比如如果用戶顯式配置了 scope=local，此時 isInjvmRefer 返回 true
        } else if (InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl)) {
            isJvmRefer = true;
        } else {
            isJvmRefer = false;
        }
    } else {
        // 獲取 injvm 配置值
        isJvmRefer = isInjvm().booleanValue();
    }

    // 本地引用
    if (isJvmRefer) {
        // 生成本地引用 URL，協議為 injvm
        URL url = new URL(Constants.LOCAL_PROTOCOL, NetUtils.LOCALHOST, 0, interfaceClass.getName()).addParameters(map);
        // 調用 refer 方法構建 InjvmInvoker 實例
        invoker = refprotocol.refer(interfaceClass, url);
        
    // 遠程引用
    } else {
        // url 不為空，表明用戶可能想進行點對點調用
        if (url != null && url.length() > 0) {
            // 當需要配置多個 url 時，可用分號進行分割，這里會進行切分
            String[] us = Constants.SEMICOLON_SPLIT_PATTERN.split(url);
            if (us != null && us.length > 0) {
                for (String u : us) {
                    URL url = URL.valueOf(u);
                    if (url.getPath() == null || url.getPath().length() == 0) {
                        // 設置接口全限定名為 url 路徑
                        url = url.setPath(interfaceName);
                    }
                    
                    // 檢測 url 協議是否為 registry，若是，表明用戶想使用指定的注冊中心
                    if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                        // 將 map 轉換為查詢字符串，並作為 refer 參數的值添加到 url 中
                        urls.add(url.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
                    } else {
                        // 合並 url，移除服務提供者的一些配置（這些配置來源於用戶配置的 url 屬性），
                        // 比如線程池相關配置。並保留服務提供者的部分配置，比如版本，group，時間戳等
                        // 最后將合並后的配置設置為 url 查詢字符串中。
                        urls.add(ClusterUtils.mergeUrl(url, map));
                    }
                }
            }
        } else {
            // 加載注冊中心 url
            List<URL> us = loadRegistries(false);
            if (us != null && !us.isEmpty()) {
                for (URL u : us) {
                    URL monitorUrl = loadMonitor(u);
                    if (monitorUrl != null) {
                        map.put(Constants.MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
                    }
                    // 添加 refer 參數到 url 中，並將 url 添加到 urls 中
                    urls.add(u.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
                }
            }

            // 未配置注冊中心，拋出異常
            if (urls.isEmpty()) {
                throw new IllegalStateException("No such any registry to reference...");
            }
        }

        // 單個注冊中心或服務提供者(服務直連，下同)
        if (urls.size() == 1) {
            // 調用 RegistryProtocol 的 refer 構建 Invoker 實例
            invoker = refprotocol.refer(interfaceClass, urls.get(0));
            
        // 多個注冊中心或多個服務提供者，或者兩者混合
        } else {
            List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
            URL registryURL = null;

            // 獲取所有的 Invoker
            for (URL url : urls) {
                // 通過 refprotocol 調用 refer 構建 Invoker，refprotocol 會在運行時
                // 根據 url 協議頭加載指定的 Protocol 實例，並調用實例的 refer 方法
                invokers.add(refprotocol.refer(interfaceClass, url));
                if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                    registryURL = url;
                }
            }
            if (registryURL != null) {
                // 如果注冊中心鏈接不為空，則將使用 AvailableCluster
                URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME);
                // 創建 StaticDirectory 實例，並由 Cluster 對多個 Invoker 進行合並
                invoker = cluster.join(new StaticDirectory(u, invokers));
            } else {
                invoker = cluster.join(new StaticDirectory(invokers));
            }
        }
    }

    Boolean c = check;
    if (c == null && consumer != null) {
        c = consumer.isCheck();
    }
    if (c == null) {
        c = true;
    }
    
    // invoker 可用性檢查
    if (c && !invoker.isAvailable()) {
        throw new IllegalStateException("No provider available for the service...");
    }

    // 生成代理類
    return (T) proxyFactory.getProxy(invoker);
}

　　　　同樣Invoker的創建后面會專門拿一篇來講。暫時先把Invoker創建看成一個黑盒，只要我們調用即可。

　　RegistryProtocol中的refer：

public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
    // 取 registry 參數值，並將其設置為協議頭
    url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
    // 獲取注冊中心實例
    Registry registry = registryFactory.getRegistry(url);
    if (RegistryService.class.equals(type)) {
        return proxyFactory.getInvoker((T) registry, type, url);
    }

    // 將 url 查詢字符串轉為 Map
    Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded(Constants.REFER_KEY));
    // 獲取 group 配置
    String group = qs.get(Constants.GROUP_KEY);
    if (group != null && group.length() > 0) {
        if ((Constants.COMMA_SPLIT_PATTERN.split(group)).length > 1
                || "*".equals(group)) {
            // 通過 SPI 加載 MergeableCluster 實例，並調用 doRefer 繼續執行服務引用邏輯
            return doRefer(getMergeableCluster(), registry, type, url);
        }
    }
    
    // 調用 doRefer 繼續執行服務引用邏輯
    return doRefer(cluster, registry, type, url);
}
private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
    // 創建 RegistryDirectory 實例
    RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
    // 設置注冊中心和協議
    directory.setRegistry(registry);
    directory.setProtocol(protocol);
    Map<String, String> parameters = new HashMap<String, String>(directory.getUrl().getParameters());
    // 生成服務消費者鏈接
    URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, parameters.remove(Constants.REGISTER_IP_KEY), 0, type.getName(), parameters);

    // 注冊服務消費者，在 consumers 目錄下新節點
    if (!Constants.ANY_VALUE.equals(url.getServiceInterface())
            && url.getParameter(Constants.REGISTER_KEY, true)) {
        registry.register(subscribeUrl.addParameters(Constants.CATEGORY_KEY, Constants.CONSUMERS_CATEGORY,
                Constants.CHECK_KEY, String.valueOf(false)));
    }

    // 訂閱 providers、configurators、routers 等節點數據
    directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
            Constants.PROVIDERS_CATEGORY
                    + "," + Constants.CONFIGURATORS_CATEGORY
                    + "," + Constants.ROUTERS_CATEGORY));

    // 一個注冊中心可能有多個服務提供者，因此這里需要將多個服務提供者合並為一個
    Invoker invoker = cluster.join(directory);
    ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
    return invoker;
}

　　　　在Invoker創建完后會返回到ReferenceConfig中，然后進入ProxyFactory中的getProxy方法。

　　ProxyFactory中的getProxy方法：

public <T> T getProxy(Invoker<T> invoker) throws RpcException {
    // 調用重載方法
    return getProxy(invoker, false);
}

public <T> T getProxy(Invoker<T> invoker, boolean generic) throws RpcException {
    Class<?>[] interfaces = null;
    // 獲取接口列表
    String config = invoker.getUrl().getParameter("interfaces");
    if (config != null && config.length() > 0) {
        // 切分接口列表
        String[] types = Constants.COMMA_SPLIT_PATTERN.split(config);
        if (types != null && types.length > 0) {
            interfaces = new Class<?>[types.length + 2];
            // 設置服務接口類和 EchoService.class 到 interfaces 中
            interfaces[0] = invoker.getInterface();
            interfaces[1] = EchoService.class;
            for (int i = 0; i < types.length; i++) {
                // 加載接口類
                interfaces[i + 1] = ReflectUtils.forName(types[i]);
            }
        }
    }
    if (interfaces == null) {
        interfaces = new Class<?>[]{invoker.getInterface(), EchoService.class};
    }

    // 為 http 和 hessian 協議提供泛化調用支持，參考 pull request #1827
    if (!invoker.getInterface().equals(GenericService.class) && generic) {
        int len = interfaces.length;
        Class<?>[] temp = interfaces;
        // 創建新的 interfaces 數組
        interfaces = new Class<?>[len + 1];
        System.arraycopy(temp, 0, interfaces, 0, len);
        // 設置 GenericService.class 到數組中
        interfaces[len] = GenericService.class;
    }

    // 調用重載方法
    return getProxy(invoker, interfaces);
}

public abstract <T> T getProxy(Invoker<T> invoker, Class<?>[] types);

　　　　在上面的代碼主要是獲取接口數組再通過抽象的getProxy進入到Proxy中的getProxy。

public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
    // 生成 Proxy 子類（Proxy 是抽象類）。並調用 Proxy 子類的 newInstance 方法創建 Proxy 實例
    return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
}

　　　　代碼具體分析上面有寫。接下來進入到Proxy子類的getProxy中

public static Proxy getProxy(Class<?>... ics) {
    // 調用重載方法
    return getProxy(ClassHelper.getClassLoader(Proxy.class), ics);
}

public static Proxy getProxy(ClassLoader cl, Class<?>... ics) {
    if (ics.length > 65535)
        throw new IllegalArgumentException("interface limit exceeded");

    StringBuilder sb = new StringBuilder();
    // 遍歷接口列表
    for (int i = 0; i < ics.length; i++) {
        String itf = ics[i].getName();
        // 檢測類型是否為接口
        if (!ics[i].isInterface())
            throw new RuntimeException(itf + " is not a interface.");

        Class<?> tmp = null;
        try {
            // 重新加載接口類
            tmp = Class.forName(itf, false, cl);
        } catch (ClassNotFoundException e) {
        }

        // 檢測接口是否相同，這里 tmp 有可能為空
        if (tmp != ics[i])
            throw new IllegalArgumentException(ics[i] + " is not visible from class loader");

        // 拼接接口全限定名，分隔符為 ;
        sb.append(itf).append(';');
    }

    // 使用拼接后的接口名作為 key
    String key = sb.toString();

    Map<String, Object> cache;
    synchronized (ProxyCacheMap) {
        cache = ProxyCacheMap.get(cl);
        if (cache == null) {
            cache = new HashMap<String, Object>();
            ProxyCacheMap.put(cl, cache);
        }
    }

    Proxy proxy = null;
    synchronized (cache) {
        do {
            // 從緩存中獲取 Reference<Proxy> 實例
            Object value = cache.get(key);
            if (value instanceof Reference<?>) {
                proxy = (Proxy) ((Reference<?>) value).get();
                if (proxy != null) {
                    return proxy;
                }
            }

            // 並發控制，保證只有一個線程可以進行后續操作
            if (value == PendingGenerationMarker) {
                try {
                    // 其他線程在此處進行等待
                    cache.wait();
                } catch (InterruptedException e) {
                }
            } else {
                // 放置標志位到緩存中，並跳出 while 循環進行后續操作
                cache.put(key, PendingGenerationMarker);
                break;
            }
        }
        while (true);
    }

    long id = PROXY_CLASS_COUNTER.getAndIncrement();
    String pkg = null;
    ClassGenerator ccp = null, ccm = null;
    try {
        // 創建 ClassGenerator 對象
        ccp = ClassGenerator.newInstance(cl);

        Set<String> worked = new HashSet<String>();
        List<Method> methods = new ArrayList<Method>();

        for (int i = 0; i < ics.length; i++) {
            // 檢測接口訪問級別是否為 protected 或 privete
            if (!Modifier.isPublic(ics[i].getModifiers())) {
                // 獲取接口包名
                String npkg = ics[i].getPackage().getName();
                if (pkg == null) {
                    pkg = npkg;
                } else {
                    if (!pkg.equals(npkg))
                        // 非 public 級別的接口必須在同一個包下，否者拋出異常
                        throw new IllegalArgumentException("non-public interfaces from different packages");
                }
            }
            
            // 添加接口到 ClassGenerator 中
            ccp.addInterface(ics[i]);

            // 遍歷接口方法
            for (Method method : ics[i].getMethods()) {
                // 獲取方法描述，可理解為方法簽名
                String desc = ReflectUtils.getDesc(method);
                // 如果方法描述字符串已在 worked 中，則忽略。考慮這種情況，
                // A 接口和 B 接口中包含一個完全相同的方法
                if (worked.contains(desc))
                    continue;
                worked.add(desc);

                int ix = methods.size();
                // 獲取方法返回值類型
                Class<?> rt = method.getReturnType();
                // 獲取參數列表
                Class<?>[] pts = method.getParameterTypes();

                // 生成 Object[] args = new Object[1...N]
                StringBuilder code = new StringBuilder("Object[] args = new Object[").append(pts.length).append("];");
                for (int j = 0; j < pts.length; j++)
                    // 生成 args[1...N] = ($w)$1...N;
                    code.append(" args[").append(j).append("] = ($w)$").append(j + 1).append(";");
                // 生成 InvokerHandler 接口的 invoker 方法調用語句，如下：
                // Object ret = handler.invoke(this, methods[1...N], args);
                code.append(" Object ret = handler.invoke(this, methods[" + ix + "], args);");

                // 返回值不為 void
                if (!Void.TYPE.equals(rt))
                    // 生成返回語句，形如 return (java.lang.String) ret;
                    code.append(" return ").append(asArgument(rt, "ret")).append(";");

                methods.add(method);
                // 添加方法名、訪問控制符、參數列表、方法代碼等信息到 ClassGenerator 中 
                ccp.addMethod(method.getName(), method.getModifiers(), rt, pts, method.getExceptionTypes(), code.toString());
            }
        }

        if (pkg == null)
            pkg = PACKAGE_NAME;

        // 構建接口代理類名稱：pkg + ".proxy" + id，比如 org.apache.dubbo.proxy0
        String pcn = pkg + ".proxy" + id;
        ccp.setClassName(pcn);
        ccp.addField("public static java.lang.reflect.Method[] methods;");
        // 生成 private java.lang.reflect.InvocationHandler handler;
        ccp.addField("private " + InvocationHandler.class.getName() + " handler;");

        // 為接口代理類添加帶有 InvocationHandler 參數的構造方法，比如：
        // porxy0(java.lang.reflect.InvocationHandler arg0) {
        //     handler=$1;
        // }
        ccp.addConstructor(Modifier.PUBLIC, new Class<?>[]{InvocationHandler.class}, new Class<?>[0], "handler=$1;");
        // 為接口代理類添加默認構造方法
        ccp.addDefaultConstructor();
        
        // 生成接口代理類
        Class<?> clazz = ccp.toClass();
        clazz.getField("methods").set(null, methods.toArray(new Method[0]));

        // 構建 Proxy 子類名稱，比如 Proxy1，Proxy2 等
        String fcn = Proxy.class.getName() + id;
        ccm = ClassGenerator.newInstance(cl);
        ccm.setClassName(fcn);
        ccm.addDefaultConstructor();
        ccm.setSuperClass(Proxy.class);
        // 為 Proxy 的抽象方法 newInstance 生成實現代碼，形如：
        // public Object newInstance(java.lang.reflect.InvocationHandler h) { 
        //     return new org.apache.dubbo.proxy0($1);
        // }
        ccm.addMethod("public Object newInstance(" + InvocationHandler.class.getName() + " h){ return new " + pcn + "($1); }");
        // 生成 Proxy 實現類
        Class<?> pc = ccm.toClass();
        // 通過反射創建 Proxy 實例
        proxy = (Proxy) pc.newInstance();
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException(e.getMessage(), e);
    } finally {
        if (ccp != null)
            // 釋放資源
            ccp.release();
        if (ccm != null)
            ccm.release();
        synchronized (cache) {
            if (proxy == null)
                cache.remove(key);
            else
                // 寫緩存
                cache.put(key, new WeakReference<Proxy>(proxy));
            // 喚醒其他等待線程
            cache.notifyAll();
        }
    }
    return proxy;
}

　　　　ccp 用於為服務接口生成代理類，比如我們有一個 DemoService 接口，這個接口代理類就是由 ccp 生成的。ccm 則是用於為 org.apache.dubbo.common.bytecode.Proxy 抽象類生成子類，主要是實現 Proxy 類的抽象方法。

　　　　這里需要重點講一下，因為用到了並發控制。機制是這樣的，synchronized中首先獲取緩存中 Reference<Proxy> 實例。因為緩存是HashMap結構來存取。key是Reference<Proxy> 實例對應的接口名稱，value就是Reference<Proxy> 實例，注意的是接口列表進行拼接了。當第一個線程進入時，key對應的是實例而不是PendingGenerationMarker。所以會進入到else中，else中則設置key的對應的value為標志位PendingGenerationMarker。這樣其他線程只能等待，而后對服務接口生產代理類和抽象類的子類。在最后釋放資源時，會喚醒其他線程，並且把已經生成過的Reference實例標志成弱引用對象，代表可以回收了。（注：弱引用，比軟引用更弱一點，被弱引用關聯的對象只能生存到下一次垃圾收集發生之前。當垃圾收集發生時無論內存是否足夠，都會回收弱引用對象。具體可以看JVM垃圾回收算法）

四、總結：

　　到這里應該算是講完了Dubbo內的服務引用機制。對於Invoker后面會再單獨講。這里還要補充一句如果是集群的話會啟動服務降級以及負載均衡每次只選擇一個Invoker調用，同樣這個后面會再做單獨介紹。