dubo服务注册与调用流程

　　在《ServiceBean与ReferenceBean创建流程》中的第4.1步说了，在获取invoker时就进行了与注册中心的连接，注册，订阅等一系列操作，由于提供者与消费者大致流程一致，所以这里以消费者端为例，提供者可以以相同的方式分析。
其入口的地方为ReferenceConfig#createProxy方法中的这一行代码：

invoker = refprotocol.refer(interfaceClass, urls.get(0));

　　refprotocol是一个SPI，这里以dubbo协议，zookeeper注册中心为例。我们在DubboProtocol类的refer方法中打一个断点，然后我们可以调用栈里面看到从上面这一行代码到断点之间有非常长的调用链，本文不关心它如何生成的，需要了解的是其中大致流程过程。

服务注册

一、

@Override
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
　　// REGISTRY_PROTOCOL = "registry"
　　if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
　　　　return protocol.refer(type, url);
　　}
　　return buildInvokerChain(protocol.refer(type, url), Constants.REFERENCE_FILTER_KEY, Constants.CONSUMER);
}

　　ReferenceConfig#createProxy方法中，url的protocol被初始化成了registry，然后会进入到QosProtocolWrapper#refer。

二、

@Override
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
　　if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
　　　　// 启动qos服务
　　　　startQosServer(url);
　　　　return protocol.refer(type, url);
　　}
　　return protocol.refer(type, url);
}

　　该类是用于启动dubbo qos服务的包装类，然后进入ProtocolListenerWrapper#refer

@Override
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
　　if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
　　　　return protocol.refer(type, url);
　　}
　　return new ListenerInvokerWrapper<T>(protocol.refer(type, url),
　　　　Collections.unmodifiableList(
　　　　　　ExtensionLoader.getExtensionLoader(InvokerListener.class)
　　　　　　　　.getActivateExtension(url, Constants.INVOKER_LISTENER_KEY)));
}

　　该类是用于将invoker封装成ListenerInvokerWrapper，ListenerInvokerWrapper的作用是调用invoker的某些方法时触发listener。然后进入到RegistryProtocol#refer。

三、

public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
　　// 获取注册中心协议，这里是zookeeper
　　url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
　　// 3.1 获取registry对象，在获取对象中就进行了连接
　　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(Constants.REFER_KEY));
　　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);
　　　　}
17　　 }
18　　 return doRefer(cluster, registry, type, url);
}

　　由于注册中心是zookeeper，所以这里的RegistryFactory对象是ZooKeeperRegistryFactory对象，Registry对象是ZooKeeperRegistry。在创建ZooKeeperRegistry对象的过程中就会连接ZooKeeper，详细流程代码可以自行debug。

创建完Registry对象后就会调用本类的doRefer方法：

private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
　　// 创建注册发现类
　　RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
　　directory.setRegistry(registry);
　　directory.setProtocol(protocol);
　　// all attributes of REFER_KEY
　　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);
　　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)));
　　}
　　// 订阅
　　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;
}

　　RegistryDirectory类中包含了注册中心信息、路由信息、消费者信息等等。同时该类实现了NotifyListener接口，会将该类进行包装为ZooKeeper的Listener，然后注册到ZooKeeper上。

接下来就是调用该类的subscribe方法进行订阅。该方法最终会调用到ZookeeperRegistry#doSubscribe方法。

四、

@Override
protected void doSubscribe(final URL url, final NotifyListener listener) {
　　try {
　　　　// 省略部分代码

　　　　// 调用listener
　　　　notify(url, listener, urls);
　　} catch (Throwable e) {
　　　　throw new RpcException("Failed to subscribe " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
　　}
}

　　这里省略了一大段代码，这一大段代码无非就是在ZooKeeper上创建节点，并且将listener注册到这些节点上。这里的listener就是上一步中的RegistryDirectory对象。最终会调用到RegistryDirectory#notify方法。

五、

@Override
public synchronized void notify(List<URL> urls) {
　　// provider url
　　List<URL> invokerUrls = new ArrayList<URL>();
　　List<URL> routerUrls = new ArrayList<URL>();
　　List<URL> configuratorUrls = new ArrayList<URL>();
　　for (URL url : urls) {
　　　　String protocol = url.getProtocol();
　　　　String category = url.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY);
　　　　if (Constants.ROUTERS_CATEGORY.equals(category)
　　　　　　|| Constants.ROUTE_PROTOCOL.equals(protocol)) {
　　　　　　routerUrls.add(url);
　　　　} else if (Constants.CONFIGURATORS_CATEGORY.equals(category)
　　　　　　|| Constants.OVERRIDE_PROTOCOL.equals(protocol)) {
15　　　　 　　configuratorUrls.add(url);
　　　　} else if (Constants.PROVIDERS_CATEGORY.equals(category)) {
　　　　　　invokerUrls.add(url);
　　　　} else {
　　　　　　logger.warn("Unsupported category " + category + " in notified url: " + url + " from registry " + getUrl().getAddress() + " to consumer " + NetUtils.getLocalHost());
　　　　}
　　}
　　// configurators
　　if (configuratorUrls != null && !configuratorUrls.isEmpty()) {
　　　　this.configurators = toConfigurators(configuratorUrls);
　　}
　　// routers
　　if (routerUrls != null && !routerUrls.isEmpty()) {
　　　　List<Router> routers = toRouters(routerUrls);
　　　　if (routers != null) { // null - do nothing
　　　　　　setRouters(routers);
　　　　}
　　}
　　List<Configurator> localConfigurators = this.configurators; // local reference
　　// merge override parameters
　　this.overrideDirectoryUrl = directoryUrl;
　　if (localConfigurators != null && !localConfigurators.isEmpty()) {
　　　　for (Configurator configurator : localConfigurators) {
　　　　　　this.overrideDirectoryUrl = configurator.configure(overrideDirectoryUrl);
　　　　}
　　}
　　// providers
　　// 刷新invoker
　　refreshInvoker(invokerUrls);
}

　　该方法除了最后一行，其他都是在更新信息，核心是最后一行。

private void refreshInvoker(List<URL> invokerUrls) {
　　// 省略部分代码

　　// 将provider的url转换成invoker
　　Map<String, Invoker<T>> newUrlInvokerMap = toInvokers(invokerUrls);// Translate url list to Invoker map
　　Map<String, List<Invoker<T>>> newMethodInvokerMap = toMethodInvokers(newUrlInvokerMap); // Change method name to map Invoker Map

　　// 省略部分代码
}

private Map<String, Invoker<T>> toInvokers(List<URL> urls) {
　　// 省略部分代码

　　if (invoker == null) { // Not in the cache, refer again
　　　　try {
　　　　　　boolean enabled = true;
　　　　　　if (url.hasParameter(Constants.DISABLED_KEY)) {
　　　　　　　　enabled = !url.getParameter(Constants.DISABLED_KEY, false);
　　　　　　} else {
　　　　　　　　enabled = url.getParameter(Constants.ENABLED_KEY, true);
　　　　　　}
　　　　　　if (enabled) {
　　　　　　// 这里的protocol是一个SPI
　　　　　　　　invoker = new InvokerDelegate<T>(protocol.refer(serviceType, url), url, providerUrl);
　　　　　　}
　　　　} catch (Throwable t) {
　　　　　　logger.error("Failed to refer invoker for interface:" + serviceType + ",url:(" + url + ")" + t.getMessage(), t);
　　　　}
　　　　if (invoker != null) { // Put new invoker in cache
　　　　　　newUrlInvokerMap.put(key, invoker);
　　　　}

　　}34 
　　// 省略部分代码
}

　　第24行又重新通过SPI获取invoker对象，与最开始的入口一样，所以这里又会从第一步开始往下走，不过不一样的是，url的registry字段不再是registry而是我们设置的dubbo协议。所以他最后会进入到DubboProtocol#refer方法。

六、

@Override
public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
　　// 是否优化
　　optimizeSerialization(url);
　　// create rpc invoker.
　　DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);
　　invokers.add(invoker);
　　return invoker;
}

　　该方法创建了一个DubboInvoker对象并返回，需要注意的是代码中调用了getClients方法，该方法会创建一个指向提供者的单向的长连接，这部分在后续的文章做讨论。

　　以此便完成了注册中心的连接、注册以及invoker的创建。

服务调用　　

　　我们通过上文可以知道，invoker被封装成了一个非常长的调用链，每一个调用都会有不同的功能，这里不细说，我们直接进入最后一个调用链节点DubboInvoker。 整个流程如下图所示：

消费者

　　DubboInvoker是具体调用逻辑的实现类，所以我们直接来看DubboInvoker的doInvoke方法，代码如下：

protected Result doInvoke(final Invocation invocation) throws Throwable {
    // 省略部分代码
    // 获取client
    ExchangeClient currentClient;
    if (clients.length == 1) {
        currentClient = clients[0];
    } else {
        currentClient = clients[index.getAndIncrement() % clients.length];
    }
    // 发起请求
    return (Result) currentClient.request(inv, timeout).get();
}

　　重点代码只有如上的一行，其中currentClient.request(inv, timeout)返回值是一个Future，所以在服务端返回之前，当前线程会阻塞等待结果返回或者超时。

该方法最终会调用到HeaderExchangeChannel#request方法，代码如下：

public ResponseFuture request(Object request, int timeout) throws RemotingException {
    if (closed) {
        throw new RemotingException(this.getLocalAddress(), null, "Failed to send request " + request + ", cause: The channel " + this + " is closed!");
    }
    // 创建Request对象
    Request req = new Request();
    req.setVersion("2.0.0");
    req.setTwoWay(true);
    req.setData(request);
    // 创建Future
    DefaultFuture future = new DefaultFuture(channel, req, timeout);
    try {
        // 发送请求
        channel.send(req);
    } catch (RemotingException e) {
        future.cancel();
        throw e;
    }
    return future;
}

　　需要注意的是，在DefaultFuture的构造方法中，会将该实例放到一个static的map中，key是request.id，value是该实例，用于后续唤醒线程。其中channel是NettyClient实例，所以会调用到NettyChannel#send方法，代码如下：

public void send(Object message, boolean sent) throws RemotingException {
    super.send(message, sent);

    boolean success = true;
    int timeout = 0;
    try {
        // 写数据
        // 这里的channel就是Netty的NioSocketChannel
        ChannelFuture future = channel.write(message);
        if (sent) {
            timeout = getUrl().getPositiveParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
            success = future.await(timeout);
        }
        Throwable cause = future.getCause();
        if (cause != null) {
            throw cause;
        }
    } catch (Throwable e) {
        throw new RemotingException(this, "Failed to send message " + message + " to " + getRemoteAddress() + ", cause: " + e.getMessage(), e);
    }

    if (!success) {
        throw new RemotingException(this, "Failed to send message " + message + " to " + getRemoteAddress()
                + "in timeout(" + timeout + "ms) limit");
    }
}

　　以上消费者就把请求发送给了提供者，并且将自身线程挂起，等待服务器返回或者超时。

提供者

　　提供者对于接受到的请求处理逻辑在AllChannelHandler#received方法中，代码如下：

public void received(Channel channel, Object message) throws RemotingException {
    // 省略部分代码
    // 获取线程池
    ExecutorService cexecutor = getExecutorService();
    // 提交任务到线程池处理
    cexecutor.execute(new ChannelEventRunnable(channel, handler, ChannelState.RECEIVED, message));
   
}

　　ChannelEventRunnable#run方法代码如下：

public void run() {
    switch (state) {
        case CONNECTED:
            try {
                handler.connected(channel);
            } catch (Exception e) {
                logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel, e);
            }
            break;
        case DISCONNECTED:
            try {
                handler.disconnected(channel);
            } catch (Exception e) {
                logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel, e);
            }
            break;
        case SENT:
            try {
                handler.sent(channel, message);
            } catch (Exception e) {
                logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel
                        + ", message is " + message, e);
            }
            break;
        case RECEIVED:
            try {
                handler.received(channel, message);
            } catch (Exception e) {
                logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel
                        + ", message is " + message, e);
            }
            break;
        case CAUGHT:
            try {
                handler.caught(channel, exception);
            } catch (Exception e) {
                logger.warn("ChannelEventRunnable handle " + state + " operation error, channel is " + channel
                        + ", message is: " + message + ", exception is " + exception, e);
            }
            break;
        default:
            logger.warn("unknown state: " + state + ", message is " + message);
    }
}

　　我们只关注其中的RECEIVED代码块，这里的handler调用也是一个调用链，依次是DecodeHandler->HeaderExchangeHandler->ExchangeHandlerAdapter。

　　DecodeHandler：用于解码数据。

　　HeaderExchangeHandler：校验请求数据，将处理结果发送给消费者。

　　ExchangeHandlerAdapter：调用Service方法，将处理结果构造成Response对象。

　　其中流程简单，不再赘述。

消费者

消费者对于接受到的结果处理流程同样也在AllChannelHandler#received方法中，其流程相同，其区别在于HeaderExchangeHandler#received方法，代码如下：

public void received(Channel channel, Object message) throws RemotingException {
    channel.setAttribute(KEY_READ_TIMESTAMP, System.currentTimeMillis());
    ExchangeChannel exchangeChannel = HeaderExchangeChannel.getOrAddChannel(channel);
    try {
        // 处理Request
        if (message instanceof Request) {
            // handle request.
            Request request = (Request) message;
            if (request.isEvent()) {
                handlerEvent(channel, request);
            } else {
                if (request.isTwoWay()) {
                    // 处理普通请求
                    Response response = handleRequest(exchangeChannel, request);
                    channel.send(response);
                } else {
                    handler.received(exchangeChannel, request.getData());
                }
            }
            // 处理Response
        } else if (message instanceof Response) {
            handleResponse(channel, (Response) message);
        } 
        // 省略部分代码
    } finally {
        HeaderExchangeChannel.removeChannelIfDisconnected(channel);
    }
}

　　其中handleRequest方法用于处理普通请求，提供者会进入到该方法。

　　handleResponse方法用于处理响应结果，消费者就会进入到该方法，该方法就会通过Response的id（Response的id与Request的id相同）从future的map中找到发起请求的future，并将future唤醒，即完成了整个调用流程。