前言

在前面的章節(jié)中症杏，我們已經(jīng)完成Dubbo服務(wù)暴露的流程分析。今天我們一起來看Dubbo怎么引用這些服務(wù)的走芋。

關(guān)于服務(wù)引用溉仑，Dubbo有兩種方式。一種是基于注冊中心進(jìn)行服務(wù)引用振定，一種是服務(wù)直連進(jìn)行引用。服務(wù)直連主要用于測試聯(lián)調(diào)階段，生產(chǎn)環(huán)境不推薦使用。它的配置也比較簡單毫痕，在消費(fèi)者端指定服務(wù)url即可。

<dubbo:reference id="infoUserService"
    interface="com.viewscenes.netsupervisor.service.InfoUserService"
    url="dubbo://192.168.139.129:20880"/>

本文將重點(diǎn)分析通過注冊中心方式，服務(wù)引用的過程七婴。開始之前，我們再回顧一下消費(fèi)者端項(xiàng)目整體的XML文件配置户盯。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
       http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    <!-- 消費(fèi)者方應(yīng)用信息吃靠，用于計(jì)算依賴關(guān)系 -->
    <dubbo:application name="dubbo_consumer"/>
    <!-- 用于配置連接注冊中心相關(guān)信息 -->
    <dubbo:registry protocol="zookeeper" address="192.168.139.131:2181" client="zkclient" />
    <!-- 引用配置   用于創(chuàng)建一個(gè)遠(yuǎn)程接口服務(wù)代理 -->
    <dubbo:reference id="infoUserService"
        interface="com.viewscenes.netsupervisor.service.InfoUserService"/>
</beans>

一、引用的是什么姥闭？

在上述配置文件中弥姻，infoUserService只是Spring中的一個(gè)Bean疼进。在代碼中，我們通過getBean()來獲取它，然后調(diào)用它的方法区丑。

我們在RPC基本原理以及如何用Netty來實(shí)現(xiàn)RPC這篇文章中已經(jīng)分析過，這里的bean其實(shí)是一個(gè)FactoryBean癣朗，通過它可以返回一個(gè)接口的代理對象扁达，完成調(diào)用邏輯的處理穗酥。

在代碼中骏啰，我們通過這樣來獲取這個(gè)Bean。

InfoUserService infoUserService = (InfoUserService) context.getBean("infoUserService");

這里的infoUserService就是一個(gè)代理對象帚豪，比如像proxy@2903這種昌执。當(dāng)然了煤禽，它必然會(huì)包含一個(gè)InvocationHandler，如下所示：

infoUserService代理對象

服務(wù)引用就是其實(shí)通過動(dòng)態(tài)代理給接口創(chuàng)建代理對象并返回。當(dāng)我們調(diào)用接口方法時(shí)，則調(diào)用到InvocationHandler相關(guān)方法菩混，處理相關(guān)請求亿柑。

二疟游、從哪里開始卧须？

在上面的配置文件中笋籽，dubbo:reference對應(yīng)的是ReferenceBean處理類隘击。那么Spring在實(shí)例化這個(gè)Bean的時(shí)候竭贩，就調(diào)用到里面方法。我們先看看它的類結(jié)構(gòu)

package com.alibaba.dubbo.config.spring;

public class ReferenceBean<T> extends ReferenceConfig<T> implements 
        FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean {

    private transient ApplicationContext applicationContext;

    public ReferenceBean() {
        super();
    }
    public ReferenceBean(Reference reference) {
        super(reference);
    }
    //設(shè)置applicationContext
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
    //返回代理對象
    public Object getObject() throws Exception {
        return get();
    }
    //返回代理對象接口類型
    public Class<?> getObjectType() {
        return getInterfaceClass();
    }
    //是否為單例
    @Parameter(excluded = true)
    public boolean isSingleton() {
        return true;
    }
    //Bean初始化方法
    public void afterPropertiesSet() throws Exception {
        if(isInit()){
            getObject();
        }
    }
}

首先，映入眼簾的是FactoryBean接口。有了它，則證明當(dāng)前bean是一個(gè)工廠Bean，所以我們重點(diǎn)關(guān)注它的getObject方法，當(dāng)我們的服務(wù)被注入到其他類中時(shí)晚凿，就會(huì)調(diào)用到此方法扣墩。

其次滥比，是InitializingBean接口濒持。它是Bean的初始化方法村视，當(dāng)Bean完成實(shí)例化之后被調(diào)用奶赔。在上述代碼中，當(dāng)init()條件判斷成立后調(diào)用getObject。我們可以在配置文件中以這種方式來激活它：init="true"

以上就是服務(wù)引用的兩個(gè)不同時(shí)機(jī)。再專業(yè)點(diǎn)來講，一個(gè)是懶漢式，一個(gè)是餓漢式。Dubbo默認(rèn)是懶漢式引用，需要時(shí)才會(huì)調(diào)用。

上述代碼中，getObject方法會(huì)調(diào)用到父類的init方法。這個(gè)方法內(nèi)容比較多，前面的部分是各種配置檢查黍氮、賦值，然后就是創(chuàng)建代理對象返回。

private void init() {
    //避免重復(fù)初始化
    if (initialized) {
        return;
    }   
    //省略相關(guān)配置檢查攀痊、賦值等代碼... 
    
    //創(chuàng)建代理
    ref = createProxy(map);
}

上述代碼中，重點(diǎn)是createProxy方法拄显。它負(fù)責(zé)創(chuàng)建Invoker實(shí)例和創(chuàng)建代理對象苟径。

也許我們還記得躬审，在服務(wù)暴露的時(shí)候棘街，會(huì)分為本地暴露和遠(yuǎn)程暴露。在這里承边，服務(wù)引用也是這樣遭殉。Dubbo首先判斷服務(wù)引用是本地引用還是遠(yuǎn)程引用，默認(rèn)是遠(yuǎn)程引用博助。然后判斷是否為直連服務(wù)险污，根據(jù)協(xié)議調(diào)用refer方法創(chuàng)建invoker對象 。最后創(chuàng)建服務(wù)代理對象并返回富岳。

private T createProxy(Map<String, String> map) {
    URL tmpUrl = new URL("temp", "localhost", 0, map);
    final boolean isJvmRefer;
    //獲取配置判斷是否為本地引用
    if (isInjvm() == null) {
        if (url != null && url.length() > 0) {
            isJvmRefer = false;
        } else if (InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl)) {
            // by default, reference local service if there is
            isJvmRefer = true;
        } else {
            isJvmRefer = false;
        }
    } else {
        isJvmRefer = isInjvm().booleanValue();
    }
    //本地引用
    if (isJvmRefer) {
        URL url = new URL(Constants.LOCAL_PROTOCOL, NetUtils.LOCALHOST, 0, interfaceClass.getName()).addParameters(map);
        invoker = refprotocol.refer(interfaceClass, url);
        if (logger.isInfoEnabled()) {
            logger.info("Using injvm service " + interfaceClass.getName());
        }
    //遠(yuǎn)程引用
    } else {
        //url不為空則代表是服務(wù)直連
        if (url != null && url.length() > 0) {
            //切割多個(gè)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.setPath(interfaceName);
                    }
                    if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                        urls.add(url.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
                    } else {
                        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()));
                    }
                    urls.add(u.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
                }
            }
        }
        //單個(gè)注冊中心
        if (urls.size() == 1) {
            invoker = refprotocol.refer(interfaceClass, urls.get(0));
        //多個(gè)注冊中心
        } else {
            List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
            URL registryURL = null;
            for (URL url : urls) {
                invokers.add(refprotocol.refer(interfaceClass, url));
                if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                    registryURL = url; 
                }
            }
            if (registryURL != null) {
                // use AvailableCluster only when register's cluster is available
                URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME);
                invoker = cluster.join(new StaticDirectory(u, invokers));
            } else { 
                invoker = cluster.join(new StaticDirectory(invokers));
            }
        }
    }
    //創(chuàng)建代理類
    return (T) proxyFactory.getProxy(invoker);
}

前面的整個(gè)流程我們可以分為兩大部分：創(chuàng)建Invoker和創(chuàng)建代理蛔糯。

三、創(chuàng)建Invoker

1窖式、連接注冊中心

我們以本文開頭的XML配置文件為例蚁飒，它是基于單個(gè)注冊中心的遠(yuǎn)程服務(wù)引用。所以脖镀，我們重點(diǎn)分析invoker = refprotocol.refer(interfaceClass, urls.get(0));

我們需要清楚的認(rèn)識到，urls.get(0)獲取到的是注冊中心的地址狼电。內(nèi)容如下：registry://192.168.139.131:2181/org.apache.dubbo.registry.RegistryService?...

所以蜒灰，我們先來看RegistryProtocol.refer方法。它主要是獲取注冊中心肩碟，并執(zhí)行服務(wù)引用强窖。

public class RegistryProtocol implements Protocol {
    
    public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        //轉(zhuǎn)換協(xié)議
        url = url.setProtocol(url.getParameter("registry", "dubbo")).removeParameter("registry");
        //通過zookeeper連接到注冊中心
        Registry registry = registryFactory.getRegistry(url);
        if (RegistryService.class.equals(type)) {
            return proxyFactory.getInvoker((T) registry, type, url);
        }
        // group="a,b" or group="*"
        Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded("refer"));
        String group = qs.get(Constants.GROUP_KEY);
        if (group != null && group.length() > 0) {
            if ((Constants.COMMA_SPLIT_PATTERN.split(group)).length > 1
                    || "*".equals(group)) {
                return doRefer(getMergeableCluster(), registry, type, url);
            }
        }
        return doRefer(cluster, registry, type, url);
    }
}

我們接著看doRefer(cluster, registry, type, url);我們可以認(rèn)為它主要做了3件事：

• 向注冊中心注冊服務(wù)消費(fèi)者(本身)
• 向注冊中心訂閱服務(wù)提供者
• 通過Cluster創(chuàng)建Invoker對象

private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
    // 創(chuàng)建 RegistryDirectory 對象，并設(shè)置注冊中心
    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());
    //創(chuàng)建訂閱 URL
    URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, parameters.
        remove("register.ip"), 0, type.getName(), parameters);
    if (!Constants.ANY_VALUE.equals(url.getServiceInterface())
            && url.getParameter(Constants.REGISTER_KEY, true)) {
        //向注冊中心注冊服務(wù)消費(fèi)者
        registry.register(subscribeUrl.addParameters("category", "consumers",
                "check", String.valueOf(false)));
    }
    // 向注冊中心訂閱服務(wù)提供者
    directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
            Constants.PROVIDERS_CATEGORY
                    + "," + Constants.CONFIGURATORS_CATEGORY
                    + "," + Constants.ROUTERS_CATEGORY));

    //創(chuàng)建Invoker對象
    Invoker invoker = cluster.join(directory);
    ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
    return invoker;
}

如上代碼削祈， 它的重點(diǎn)在于directory.subscribe 翅溺，它通過訂閱注冊中心的服務(wù)提供者脑漫，調(diào)用相關(guān)協(xié)議的引用方法。比如DubboProtocol.refer咙崎，下面我們來看它是怎么調(diào)用的优幸。

2、訂閱服務(wù)提供者

我們通過directory.subscribe這句代碼褪猛， 會(huì)定位到ZookeeperRegistry.doSubscribe方法网杆。

public class ZookeeperRegistry extends FailbackRegistry {
    
    protected void doSubscribe(final URL url, final NotifyListener listener) {
        
        List<URL> urls = new ArrayList<URL>();
        //獲取注冊中心除了消費(fèi)者信息之外的所有節(jié)點(diǎn)
        //比如configurators, routers, providers
        String[] paths = toCategoriesPath(url);
        for (String path :paths) {
            //獲取節(jié)點(diǎn)監(jiān)聽器管理容器
            ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url);
            if (listeners == null) {
                zkListeners.putIfAbsent(url, 
                    new ConcurrentHashMap<NotifyListener, ChildListener>());
                listeners = zkListeners.get(url);
            }
            //獲取節(jié)點(diǎn)監(jiān)聽器
            ChildListener zkListener = listeners.get(listener);
            //如果為空，則創(chuàng)建一個(gè)監(jiān)聽器
            if (zkListener == null) {
                listeners.putIfAbsent(listener, new ChildListener() {
                    @Override
                    public void childChanged(String parentPath, List<String> currentChilds) {
                        ZookeeperRegistry.this.notify(url, listener, 
                                toUrlsWithEmpty(url, parentPath, currentChilds));
                    }
                });
                zkListener = listeners.get(listener);
            }
            //創(chuàng)建節(jié)點(diǎn)
            zkClient.create(path, false);
            //訂閱節(jié)點(diǎn)path 數(shù)據(jù)變化伊滋，通知到zkListener
            //即通知到ZookeeperRegistry.this.notify
            List<String> children = zkClient.addChildListener(path, zkListener);
            if (children != null) {
                urls.addAll(toUrlsWithEmpty(url, path, children));
            }
        }
        //通知
        notify(url, listener, urls);  
    }
}

如上代碼碳却，重點(diǎn)就是通過注冊中心獲取到服務(wù)提供者的url，調(diào)用notify方法笑旺。同時(shí)還訂閱了服務(wù)提供者的節(jié)點(diǎn)數(shù)據(jù)變化昼浦，如果有變化也調(diào)用notify方法。
而在notify方法中筒主，最終會(huì)根據(jù)url調(diào)用服務(wù)引用方法refer关噪，再封裝成InvokerDelegate對象。
invoker = new InvokerDelegate<T>(protocol.refer(serviceType, url), url, providerUrl);

這樣不僅完成了本次的服務(wù)引用物舒，而且當(dāng)服務(wù)提供者上下線的時(shí)候色洞，消費(fèi)者也可以動(dòng)態(tài)感知。

3冠胯、Listener和Filter

以DubboProtocol為例火诸，它是Wrapper包裝類的對象，關(guān)于這一點(diǎn)我們一定要牢記荠察。

回憶服務(wù)暴露的過程置蜀，我們可以監(jiān)聽服務(wù)暴露的過程，在構(gòu)建調(diào)用鏈的時(shí)候可以增加Filter悉盆。在這里盯荤，服務(wù)引用也是一樣的。

• 服務(wù)引用監(jiān)聽

在InvokerListener 接口中焕盟，有兩個(gè)方法秋秤。分別是服務(wù)引用后調(diào)用和服務(wù)銷毀時(shí)調(diào)用。

@SPI
public interface InvokerListener {  
    //服務(wù)引用
    void referred(Invoker<?> invoker) throws RpcException;
    //服務(wù)銷毀
    void destroyed(Invoker<?> invoker);
}

我們先自定義監(jiān)聽器脚翘，來實(shí)現(xiàn)接口的方法灼卢。

public class MyInvokerListener1 implements InvokerListener{

    public void referred(Invoker<?> invoker) throws RpcException {      
        System.out.println("服務(wù)引用111.."+invoker.getUrl());
    }
    public void destroyed(Invoker<?> invoker) {
        System.out.println("服務(wù)銷毀111.."+invoker.getUrl());
    }
}

然后創(chuàng)建擴(kuò)展點(diǎn)配置文件，文件名稱為：
com.alibaba.dubbo.rpc.InvokerListener
內(nèi)容為：
listener1=com.viewscenes.netsupervisor.listener.MyInvokerListener1

最后来农，修改XML配置文件
<dubbo:consumer listener="listener1"/>

• Filter過濾器

首先自定義過濾器

public class MyFilter implements Filter{

    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        System.out.println("調(diào)用之前-----------");
        Result result = invoker.invoke(invocation);
        System.out.println("調(diào)用之后-----------");
        return result;
    }
}

然后創(chuàng)建擴(kuò)展點(diǎn)配置文件鞋真，文件名稱為：
com.alibaba.dubbo.rpc.Filter
內(nèi)容為：
myfilter1=com.viewscenes.netsupervisor.filter.MyFilter

最后，修改XML配置文件沃于，說明自定義的過濾器在默認(rèn)過濾器之前涩咖。
filter="myfilter1,default""/>

4海诲、DubboProtocol

前面啰啰嗦嗦一大堆，終于來到正主檩互。這里主要是獲取通信客戶端特幔，拿到ExchangeClient，然后封裝為DubboInvoker對象并返回盾似。

public class DubboProtocol extends AbstractProtocol {
    
    public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
        optimizeSerialization(url);
        //獲取通信客戶端
        ExchangeClient[] client = getClients(url);
        //創(chuàng)建DubboInvoker對象
        DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, client, invokers);
        invokers.add(invoker);
        return invoker;
    }
}

這里主要分為兩個(gè)步驟：

• 創(chuàng)建通信客戶端

在getClients方法里面敬辣，主要判斷是否為共享連接的客戶端。

private ExchangeClient[] getClients(URL url) {
    // 是否共享連接
    boolean service_share_connect = false;
    // 獲取連接數(shù)零院，默認(rèn)為0溉跃，表示未配置
    int connections = url.getParameter(Constants.CONNECTIONS_KEY, 0);
    // 如果未配置 connections，則共享連接
    if (connections == 0) {
        service_share_connect = true;
        connections = 1;
    }
    ExchangeClient[] clients = new ExchangeClient[connections];
    for (int i = 0; i < clients.length; i++) {
        if (service_share_connect) {
            // 獲取共享客戶端
            clients[i] = getSharedClient(url);
        } else {
            //初始化新的客戶端
            clients[i] = initClient(url);
        }
    }
    return clients;
}

如果未配置告抄，Dubbo默認(rèn)創(chuàng)建共享連接客戶端撰茎。我們繼續(xù)看getSharedClient方法。

private ExchangeClient getSharedClient(URL url) {
    //服務(wù)地址
    String key = url.getAddress();
    //查詢緩存是否已經(jīng)創(chuàng)建了客戶端
    ReferenceCountExchangeClient client = referenceClientMap.get(key);
    if (client != null) {
        if (!client.isClosed()) {
            client.incrementAndGetCount();
            return client;
        } else {
            referenceClientMap.remove(key);
        }
    }
    synchronized (key.intern()) {
        //初始化客戶端
        ExchangeClient exchangeClient = initClient(url);
        //封裝成ReferenceCountExchangeClient對象打洼，用于引用計(jì)數(shù)
        client = new ReferenceCountExchangeClient(exchangeClient, ghostClientMap);
        //放入緩存并返回
        referenceClientMap.put(key, client);
        ghostClientMap.remove(key);
        return client;
    }
}

如上代碼龄糊，先從緩存中獲取客戶端，未命中則調(diào)用initClient方法初始化客戶端募疮。并將它封裝成ReferenceCountExchangeClient 對象返回炫惩。在initClient方法中，設(shè)置客戶端類型阿浓、編解碼和心跳信息他嚷，并調(diào)用connect創(chuàng)建客戶端。

private ExchangeClient initClient(URL url) {

    //客戶端類型 默認(rèn)為netty
    String str = url.getParameter("client", url.getParameter("server","netty"));
    //編解碼
    url = url.addParameter("codes", "dubbo");
    //心跳
    url = url.addParameterIfAbsent("heartbeat","60000");

    ExchangeClient client;
    try {
        if (url.getParameter("lazy", false)) {
            client = new LazyConnectExchangeClient(url, requestHandler);
        } else {
            //創(chuàng)建連接客戶端
            client = Exchangers.connect(url, requestHandler);
        }
    } catch (RemotingException e) {
        throw new RpcException("Fail to create remoting 
            client for service(" + url + "): " + e.getMessage(), e);
    }
    return client;
}

如上代碼芭毙，connect會(huì)調(diào)用到HeaderExchangeClient.connect方法筋蓖。

public class HeaderExchanger implements Exchanger {

    public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
        HeaderExchangeHandler headerExchangeHandler = new HeaderExchangeHandler(handler);
        DecodeHandler decodeHandler = new DecodeHandler(headerExchangeHandler);
        Client client = Transporters.connect(url, decodeHandler);
        return new HeaderExchangeClient(client,true);
    }
}

我們重點(diǎn)來看Transporters.connect，它會(huì)調(diào)用到NettyClient的構(gòu)造方法退敦。最終調(diào)用doOpen和doConnect方法粘咖，連接通信服務(wù)器。

public class NettyClient extends AbstractClient {

    protected void doOpen() throws Throwable {
        NettyHelper.setNettyLoggerFactory();
        bootstrap = new ClientBootstrap(channelFactory);
        bootstrap.setOption("keepAlive", true);
        bootstrap.setOption("tcpNoDelay", true);
        bootstrap.setOption("connectTimeoutMillis", getTimeout());
        
        //處理器
        final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
        bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            @Override
            public ChannelPipeline getPipeline() {
                NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), 
                        getUrl(), NettyClient.this);
                ChannelPipeline pipeline = Channels.pipeline();
                pipeline.addLast("decoder", adapter.getDecoder());
                pipeline.addLast("encoder", adapter.getEncoder());
                pipeline.addLast("handler", nettyHandler);
                return pipeline;
            }
        });
    }
    
    
    protected void doConnect() throws Throwable {
        long start = System.currentTimeMillis();
        //獲取服務(wù)器地址侈百，并連接
        ChannelFuture future = bootstrap.connect(getConnectAddress());
        try {
            boolean ret = future.awaitUninterruptibly(getConnectTimeout(), TimeUnit.MILLISECONDS);
            //連接成功后獲取Channel
            if (ret && future.isSuccess()) {
                Channel newChannel = future.getChannel();
                newChannel.setInterestOps(Channel.OP_READ_WRITE);
                try {
                    // Close old channel
                    Channel oldChannel = NettyClient.this.channel; // copy reference
                    if (oldChannel != null) {
                        try {                  
                            oldChannel.close();
                        } finally {
                            NettyChannel.removeChannelIfDisconnected(oldChannel);
                        }
                    }
                } finally {
                    if (NettyClient.this.isClosed()) {
                        try {                           
                            newChannel.close();
                        } finally {
                            NettyClient.this.channel = null;
                            NettyChannel.removeChannelIfDisconnected(newChannel);
                        }
                    } else {
                        //設(shè)置當(dāng)前Channel
                        NettyClient.this.channel = newChannel;
                    }
                }
            }
        }
    }
}

以上大部分都是Netty的代碼瓮下，連接服務(wù)器成功后獲取到Channel保存。 我們重點(diǎn)看NettyHandler钝域，它是事件處理器讽坏。這里的messageReceived負(fù)責(zé)接收處理返回的消息。接收到消息后网梢，通過線程池拿到線程去執(zhí)行后續(xù)的處理震缭。不同的是赂毯，這里的線程池類型是CachedThreadPool 战虏，即緩存型線程池拣宰。

這里的流程處理完畢，我們再把目光回到DubboInvoker烦感，它通過一個(gè)構(gòu)造方法返回Invoker對象巡社。

public DubboInvoker(Class<T> serviceType, URL url, 
            ExchangeClient[] clients, Set<Invoker<?>> invokers) {
    this.clients = clients;
    this.version = url.getParameter(Constants.VERSION_KEY, "0.0.0");
    this.invokers = invokers;
}

至此，Invoker對象已經(jīng)創(chuàng)建完畢手趣。我們回到開頭的createProxy方法晌该。最后一步是為這個(gè)Invoker對象創(chuàng)建代理。

五绿渣、創(chuàng)建代理

在Dubbo朝群，默認(rèn)使用Javassist來創(chuàng)建代理。

public class JavassistProxyFactory extends AbstractProxyFactory {

    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        //調(diào)用處理程序
        InvocationHandler invocationHandler = new InvokerInvocationHandler(invoker)
        //創(chuàng)建代理
        return (T) Proxy.getProxy(interfaces).newInstance(invocationHandler);
    }
}

創(chuàng)建的過程很簡單中符，我們主要來看InvocationHandler 姜胖。既然是代理對象，我們每次調(diào)用接口方法的時(shí)候淀散，會(huì)調(diào)用到這個(gè)對象的invoke方法右莱。

public class InvokerInvocationHandler implements InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        Class<?>[] parameterTypes = method.getParameterTypes();
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(invoker, args);
        }
        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]);
        }
        //把請求的方法名和參數(shù)等封裝成RpcInvocation對象
        //調(diào)用invoke
        return invoker.invoke(new RpcInvocation(method, args)).recreate();
    }
}

至此，服務(wù)引用的大體流程我們已經(jīng)分析完了档插。我們再來總結(jié)一下它的過程：

• 通過FactoryBean觸發(fā)服務(wù)引用方法
• 連接注冊中心慢蜓，獲取服務(wù)提供者列表，創(chuàng)建invoker
• 訂閱服務(wù)提供者節(jié)點(diǎn)郭膛，數(shù)據(jù)變更時(shí)獲得通知
• 連接服務(wù)器晨抡，獲得客戶端
• 創(chuàng)建代理