Dubbo源码分析 之 netty调用获取返回值

最新推荐文章于 2024-05-24 14:51:44 发布
最新推荐文章于 2024-05-24 14:51:44 发布
阅读量4k 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rewerma/article/details/76446583
版权

netty作为异步非阻塞的rpc框架，也是dubbo默认的远程rpc协议，让我们来看一下dubbo的客户端是实现同步获取返回信息的效果的：

在调用发送请求之前，如果我们设置断点进行跟踪的话会进入一连串的Invoker ，因为在dubbo客户端只有接口没有具体的实现类，所以dubbo使用反向代理的方式实现类方法的代理调用，最终会进入 DubboInvoker 类的 doInvoke 方法：

    @Override
    protected Result doInvoke(final Invocation invocation) throws Throwable {
        RpcInvocation inv = (RpcInvocation) invocation;
        final String methodName = RpcUtils.getMethodName(invocation);
        inv.setAttachment(Constants.PATH_KEY, getUrl().getPath());
        inv.setAttachment(Constants.VERSION_KEY, version);
        
        ExchangeClient currentClient;
        if (clients.length == 1) {
            currentClient = clients[0];
        } else {
            currentClient = clients[index.getAndIncrement() % clients.length];
        }
        try {
            boolean isAsync = RpcUtils.isAsync(getUrl(), invocation);
            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);
                currentClient.send(inv, isSent);
                RpcContext.getContext().setFuture(null);
                return new RpcResult();
            } else if (isAsync) {
            	ResponseFuture future = currentClient.request(inv, timeout) ;
                RpcContext.getContext().setFuture(new FutureAdapter<Object>(future));
                return new RpcResult();
            } else {
            	RpcContext.getContext().setFuture(null);
                return (Result) currentClient.request(inv, timeout).get();
            }
        } catch (TimeoutException e) {
            throw new RpcException(RpcException.TIMEOUT_EXCEPTION, "Invoke remote method timeout. method: " + invocation.getMethodName() + ", provider: " + getUrl() + ", cause: " + e.getMessage(), e);
        } catch (RemotingException e) {
            throw new RpcException(RpcException.NETWORK_EXCEPTION, "Failed to invoke remote method: " + invocation.getMethodName() + ", provider: " + getUrl() + ", cause: " + e.getMessage(), e);
        }
    }

因为是异步调用，所以程序会进入：

else {
    RpcContext.getContext().setFuture(null);
    return (Result) currentClient.request(inv, timeout).get();
}
这段操作。经过断点跟踪，可以看到 currentClient的类型为：ReferenceCountExchangeClient，继续进入该类的request方法： 

    public ResponseFuture request(Object request) throws RemotingException {
        return client.request(request);
    }

其中client的类型为：HeaderExchangeClient，再进入该类的request方法： 

    public ResponseFuture request(Object request) throws RemotingException {
        return channel.request(request);
    }

其中channel的类型就是最终的要查看的类：HeaderExchangeChannel，让我们看看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!");
        }
        // create request.
        Request req = new Request();
        req.setVersion("2.0.0");
        req.setTwoWay(true);
        req.setData(request);
        DefaultFuture future = new DefaultFuture(channel, req, timeout);
        try{
            channel.send(req);
        }catch (RemotingException e) {
            future.cancel();
            throw e;
        }
        return future;
    }
这个方法分两步操作：new一个DefaultFuture，然后通过封装的channel发送信息，最后吧future返回。然后我们看看这个DefaultFuture里面有些啥： 

/*
 * Copyright 1999-2011 Alibaba Group.
 *  
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *  
 *      http://www.apache.org/licenses/LICENSE-2.0
 *  
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.dubbo.remoting.exchange.support;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import com.alibaba.dubbo.common.Constants;
import com.alibaba.dubbo.common.logger.Logger;
import com.alibaba.dubbo.common.logger.LoggerFactory;
import com.alibaba.dubbo.remoting.Channel;
import com.alibaba.dubbo.remoting.RemotingException;
import com.alibaba.dubbo.remoting.TimeoutException;
import com.alibaba.dubbo.remoting.exchange.Request;
import com.alibaba.dubbo.remoting.exchange.Response;
import com.alibaba.dubbo.remoting.exchange.ResponseCallback;
import com.alibaba.dubbo.remoting.exchange.ResponseFuture;

/**
 * DefaultFuture.
 * 
 * @author qian.lei
 * @author chao.liuc
 */
public class DefaultFuture implements ResponseFuture {

    private static final Logger                   logger = LoggerFactory.getLogger(DefaultFuture.class);

    private static final Map<Long, Channel>       CHANNELS   = new ConcurrentHashMap<Long, Channel>();

    private static final Map<Long, DefaultFuture> FUTURES   = new ConcurrentHashMap<Long, DefaultFuture>();

    // invoke id.
    private final long                            id;

    private final Channel                         channel;
    
    private final Request                         request;

    private final int                             timeout;

    private final Lock                            lock = new ReentrantLock();

    private final Condition                       done = lock.newCondition();

    private final long                            start = System.currentTimeMillis();

    private volatile long                         sent;
    
    private volatile Response                     response;

    private volatile ResponseCallback             callback;

    public DefaultFuture(Channel channel, Request request, int timeout){
        this.channel = channel;
        this.request = request;
        this.id = request.getId();
        this.timeout = timeout > 0 ? timeout : channel.getUrl().getPositiveParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
        // put into waiting map.
        FUTURES.put(id, this);
        CHANNELS.put(id, channel);
    }
    
    public Object get() throws RemotingException {
        return get(timeout);
    }

    public Object get(int timeout) throws RemotingException {
        if (timeout <= 0) {
            timeout = Constants.DEFAULT_TIMEOUT;
        }
        if (! isDone()) {
            long start = System.currentTimeMillis();
            lock.lock();
            try {
                while (! isDone()) {
                    done.await(timeout, TimeUnit.MILLISECONDS);
                    if (isDone() || System.currentTimeMillis() - start > timeout) {
                        break;
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
            if (! isDone()) {
                throw new TimeoutException(sent > 0, channel, getTimeoutMessage(false));
            }
        }
        return returnFromResponse();
    }
    
    public void cancel(){
        Response errorResult = new Response(id);
        errorResult.setErrorMessage("request future has been canceled.");
        response = errorResult ;
        FUTURES.remove(id);
        CHANNELS.remove(id);
    }

    public boolean isDone() {
        return response != null;
    }

    public void setCallback(ResponseCallback callback) {
        if (isDone()) {
            invokeCallback(callback);
        } else {
            boolean isdone = false;
            lock.lock();
            try{
                if (!isDone()) {
                    this.callback = callback;
                } else {
                    isdone = true;
                }
            }finally {
                lock.unlock();
            }
            if (isdone){
                invokeCallback(callback);
            }
        }
    }
    private void invokeCallback(ResponseCallback c){
        ResponseCallback callbackCopy = c;
        if (callbackCopy == null){
            throw new NullPointerException("callback cannot be null.");
        }
        c = null;
        Response res = response;
        if (res == null) {
            throw new IllegalStateException("response cannot be null. url:"+channel.getUrl());
        }
        
        if (res.getStatus() == Response.OK) {
            try {
                callbackCopy.done(res.getResult());
            } catch (Exception e) {
                logger.error("callback invoke error .reasult:" + res.getResult() + ",url:" + channel.getUrl(), e);
            }
        } else if (res.getStatus() == Response.CLIENT_TIMEOUT || res.getStatus() == Response.SERVER_TIMEOUT) {
            try {
                TimeoutException te = new TimeoutException(res.getStatus() == Response.SERVER_TIMEOUT, channel, res.getErrorMessage());
                callbackCopy.caught(te);
            } catch (Exception e) {
                logger.error("callback invoke error ,url:" + channel.getUrl(), e);
            }
        } else {
            try {
                RuntimeException re = new RuntimeException(res.getErrorMessage());
                callbackCopy.caught(re);
            } catch (Exception e) {
                logger.error("callback invoke error ,url:" + channel.getUrl(), e);
            }
        }
    }

    private Object returnFromResponse() throws RemotingException {
        Response res = response;
        if (res == null) {
            throw new IllegalStateException("response cannot be null");
        }
        if (res.getStatus() == Response.OK) {
            return res.getResult();
        }
        if (res.getStatus() == Response.CLIENT_TIMEOUT || res.getStatus() == Response.SERVER_TIMEOUT) {
            throw new TimeoutException(res.getStatus() == Response.SERVER_TIMEOUT, channel, res.getErrorMessage());
        }
        throw new RemotingException(channel, res.getErrorMessage());
    }

    private long getId() {
        return id;
    }
    
    private Channel getChannel() {
        return channel;
    }
    
    private boolean isSent() {
        return sent > 0;
    }

    public Request getRequest() {
        return request;
    }

    private int getTimeout() {
        return timeout;
    }

    private long getStartTimestamp() {
        return start;
    }

    public static DefaultFuture getFuture(long id) {
        return FUTURES.get(id);
    }

    public static boolean hasFuture(Channel channel) {
        return CHANNELS.containsValue(channel);
    }

    public static void sent(Channel channel, Request request) {
        DefaultFuture future = FUTURES.get(request.getId());
        if (future != null) {
            future.doSent();
        }
    }

    private void doSent() {
        sent = System.currentTimeMillis();
    }

    public static void received(Channel channel, Response response) {
        try {
            DefaultFuture future = FUTURES.remove(response.getId());
            if (future != null) {
                future.doReceived(response);
            } else {
                logger.warn("The timeout response finally returned at " 
                            + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date())) 
                            + ", response " + response 
                            + (channel == null ? "" : ", channel: " + channel.getLocalAddress() 
                                + " -> " + channel.getRemoteAddress()));
            }
        } finally {
            CHANNELS.remove(response.getId());
        }
    }

    private void doReceived(Response res) {
        lock.lock();
        try {
            response = res;
            if (done != null) {
                done.signal();
            }
        } finally {
            lock.unlock();
        }
        if (callback != null) {
            invokeCallback(callback);
        }
    }

    private String getTimeoutMessage(boolean scan) {
        long nowTimestamp = System.currentTimeMillis();
        return (sent > 0 ? "Waiting server-side response timeout" : "Sending request timeout in client-side")
                    + (scan ? " by scan timer" : "") + ". start time: " 
                    + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date(start))) + ", end time: " 
                    + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date())) + ","
                    + (sent > 0 ? " client elapsed: " + (sent - start) 
                        + " ms, server elapsed: " + (nowTimestamp - sent)
                        : " elapsed: " + (nowTimestamp - start)) + " ms, timeout: "
                    + timeout + " ms, request: " + request + ", channel: " + channel.getLocalAddress()
                    + " -> " + channel.getRemoteAddress();
    }

    private static class RemotingInvocationTimeoutScan implements Runnable {

        public void run() {
            while (true) {
                try {
                    for (DefaultFuture future : FUTURES.values()) {
                        if (future == null || future.isDone()) {
                            continue;
                        }
                        if (System.currentTimeMillis() - future.getStartTimestamp() > future.getTimeout()) {
                            // create exception response.
                            Response timeoutResponse = new Response(future.getId());
                            // set timeout status.
                            timeoutResponse.setStatus(future.isSent() ? Response.SERVER_TIMEOUT : Response.CLIENT_TIMEOUT);
                            timeoutResponse.setErrorMessage(future.getTimeoutMessage(true));
                            // handle response.
                            DefaultFuture.received(future.getChannel(), timeoutResponse);
                        }
                    }
                    Thread.sleep(30);
                } catch (Throwable e) {
                    logger.error("Exception when scan the timeout invocation of remoting.", e);
                }
            }
        }
    }

    static {
        Thread th = new Thread(new RemotingInvocationTimeoutScan(), "DubboResponseTimeoutScanTimer");
        th.setDaemon(true);
        th.start();
    }

}

可以看到有两个静态属性： 

private static final Map<Long, Channel>       CHANNELS   = new ConcurrentHashMap<Long, Channel>();

private static final Map<Long, DefaultFuture> FUTURES   = new ConcurrentHashMap<Long, DefaultFuture>();
这两个静态属性就是记录了当前request的id->channel和id->defaultFuture。记录id->defaultFuture呢因为里面包含一个lock的condition，还有response这个两个主要属性： 

private final Condition   done = lock.newCondition();
private volatile Response response;
其中这个condition是用来做锁等待信息返回用的，定位到DefaultFuture的 get() 方法上（该方法在DubboInvoker中的doInvoke中调用，也就是currentClient.request()方法之后直接调的.get()方法）： 
    public Object get(int timeout) throws RemotingException {
        if (timeout <= 0) {
            timeout = Constants.DEFAULT_TIMEOUT;
        }
        if (! isDone()) {
            long start = System.currentTimeMillis();
            lock.lock();
            try {
                while (! isDone()) {
                    done.await(timeout, TimeUnit.MILLISECONDS);
                    if (isDone() || System.currentTimeMillis() - start > timeout) {
                        break;
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
            if (! isDone()) {
                throw new TimeoutException(sent > 0, channel, getTimeoutMessage(false));
            }
        }
        return returnFromResponse();
    }
这里可比较清晰地看到做了一个锁等待，并设置了超时时间timeout，也就是在规定时间内如果接收到response的话跳出等待，或者超时的话也跳出等待并抛出超时异常。如果是正常接收到response的话返回这个response。
那么dubbo是怎么监听这个response的呢，可以看到DefaultFuture这个类中有个doReceived私有方法： 

    private void doReceived(Response res) {
        lock.lock();
        try {
            response = res;
            if (done != null) {
                done.signal();
            }
        } finally {
            lock.unlock();
        }
        if (callback != null) {
            invokeCallback(callback);
        }
    }

可以看到该方法在接收到response后调用done对象也就是Lock.Condition对象的signa方法，也就是通知等待线程跳出等待，并回调invokeCallback方法。

doReceived这个私有方法被该类中的静态方法received方法调用：

    public static void received(Channel channel, Response response) {
        try {
            DefaultFuture future = FUTURES.remove(response.getId());
            if (future != null) {
                future.doReceived(response);
            } else {
                logger.warn("The timeout response finally returned at "
                        + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()))
                        + ", response " + response
                        + (channel == null ? "" : ", channel: " + channel.getLocalAddress()
                        + " -> " + channel.getRemoteAddress()));
            }
        } finally {
            CHANNELS.remove(response.getId());
        }
    }
这个静态方法在ChannelEventRunnable这个线程类中被调到： 

    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);
        }
    }

其中的case RECEIVED就是。而这个线程类在netty客户端接收到信息的时候会被线程池run，这里不在赘述。

以上便是dubbo的netty客户端发送请求并同步等待返回响应的主要流程，其核心类便是DefaultFutrue，使用了concurrentHashMap来记录id和对应的defaultFuture对象，并使用锁等待和线程通知来达到同步调用的效果。







rewerma
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
dubbo源码分析pdf.zip
05-09
《Dubbo源码分析》是一套深入探讨Apache Dubbo这一著名Java开源框架的书籍，旨在帮助开发者更好地理解和应用Dubbo。Dubbo是一个高性能、轻量级的服务治理框架，广泛应用于微服务架构中，以实现服务的发布、发现、...
dubbo源码分析系列
04-06
《Dubbo源码分析系列》是一份深入探讨Java开源框架Dubbo核心原理和技术细节的资料。Dubbo，作为阿里巴巴的一款高性能、轻量级的服务治理框架，它为分布式系统提供了服务发现、调用、负载均衡、容错等关键功能。这份...
错误提示:send request timeout_Python爬虫入门-request库
weixin_35540825的博客
01-24 1317
对于网络爬虫，我们最常用的应该是request库，首先熟悉一下request库的基本用法：import requests # requests库的基本使用方法 # requests.request()获取HTML网页的方法 """ requests.get(url, params=None, **kwargs)获取网页的主要方法，params：url中的额外参数，可选，**kwargs: 12个...
Dubbo超时生效原理以及服务端配置推送
07-10 892
Dubbo目录1. Dubbo超时参数是设置1.1 一般的超时时间1.2 timeoutCountDown2. 服务端怎么到客户端的merge配置到客户端的代码3. 超时之后的异常是从哪里出来的1. dubbo的超时参数是从那设置的1.1 一般的超时时间1.2 timeoutCountDown2. 服务端怎么到客户端的merge配置到客户端的代码3. 超时之后的异常是从哪里出来的 Dubbo 客户端超时设置是Dubbo 客户端参数最常用设置参数。本文介绍了超时参数的配置方式，超时异常的相关排查和Dubbo里
Netty 和 Dubbo 的关系：入门讲解
最新发布
LiamHong_的博客
05-24 521
Netty 是一个基于 Java 的异步事件驱动的网络应用程序框架，用于快速开发高性能、高可靠性的网络服务器和客户端。Socket 编程：Netty 支持 TCP、UDP、HTTP等多种协议，极大地简化了复杂的底层网络编程。事件驱动模型：通过 Reactor 模式处理并发连接，提升系统的扩展性。高性能：使用零拷贝、池化缓存等技术，最大限度地提升性能。Netty 的核心特点包括高吞吐量、低延迟和高度的可扩展性，这使它成为许多高性能网络服务的首选框架。Dubbo。
从dubbo看Netty使用
热门推荐
Ydoing的专栏
05-11 2万+
Netty是个高性能的Java网络传输框架，在很多中间件或者分布式框架中几乎都能看到它的身影。既然Netty这么受欢迎，那到底怎么把netty嵌入到我们的系统中了？笔者在几年前就接触了Netty，也开发了个小项目。一直问题困扰自己，Netty使用场景是什么？怎么使用Netty？我们可以从dubbo中找到些答案。dubbo是高性能轻量级的RPC框架。netty本质的功能负责网络传输，dubbo使用ne
Dubbo进阶（十四）- Dubbo中参数回调 Callback 实现深究
anLA_的专栏
10-15 2712
Dubbo 中 参数回调Callback 到底有什么用？ 到底是个怎么样的代码逻辑？
dubbo报：Waiting server-side response timeout by scan timer.
G_whang的博客
09-16 3149
今天上线功能，使用package -Pprd打生产包，上线后启动服务，竟然报： Caused by: com.alibaba.dubbo.remoting.TimeoutException: Waiting server-side response timeout by scan timer. start time: 2019-09-16 18:32:54.066, end time: 2019-...
Dubbo源码分析之SPI
01-31
总的来说，Dubbo的SPI机制是其强大功能背后的关键技术之一，它不仅提供了类似Java SPI的服务发现能力，还通过一系列的增强，使得服务的扩展和管理变得更加高效和便捷。在深入研究`dubbo-spi`和`java-spi`这两个...
netty手写dubbo源码分享
01-20
《深入剖析Netty实现Dubbo源码解析》 在当今的分布式系统中，Dubbo作为一款优秀的服务治理框架，被广泛应用于微服务架构之中。它提供了高性能、透明化的RPC调用，以及服务发现、负载均衡、流量控制等功能。而Netty...
Dubbo的两种调用模式和超时异常
weixin_34315485的博客
05-31 1898
先推荐大家阅读dubbo官网源码解读服务调用流程一节,传送门： dubbo.apache.org/zh-cn/docs/… 一、调用模式 Dubbo同步调用还是异步调用的逻辑是在DubboInvoker中，Dubbo 实现同步和异步调用比较关键的一点就在于由谁调用 ResponseFuture 的 get方法。 同步调用模式下，由框架自身调用 ResponseFuture 的 get 方法。 异...
Netty同步获取返回结果
qq_42703153的博客
04-17 3992
netty阻塞式获取返回值
使用netty编写客户端，实现同步发送消息并接收返回结果
chenmin_test的博客
09-06 9499
使用netty实现发送消息并返回结果功能
linux send 失败_实例化链码，sendPeersProposal-承诺被拒绝：错误：REQUEST_TIMEOUT，Hyperledger Fabric，Linux...
weixin_34162253的博客
01-27 386
求助中联盟链超级账本智能合约实例化链码，sendPeersProposal-承诺被拒绝：错误：REQUEST_TIMEOUT，Hyperledger Fabric，Linux10在从Linux OS上的结构节点sdk实例化特定对等点的链码时，我从对等点收到超时错误。error:[Peer.js]:sendProposal-timedoutafter:90000error:[clien...
Qt Modbus request timeout异常解决
Hello___Sunshine的专栏
06-14 3019
问题： 1、项目中使用Modbus 232进行串口通讯，QT版本Qt 5.6.3，通讯过程中频繁的出现Modbus request timeout。 2、使用QModbusClient->sendWriteRequest发送长度为205的数据时，出现类似丢包的情况，发送不完整导致响应错误。解决办法： 1、将QT版本升级到Qt5.13.1时，发送数据过去没问题，但是无法相应数据，同时两次连续发送时第二次不生效， 2、将QT版本升级到Qt5.14及以后的版
netty4 服务端同步客户端返回的结果
hzf1993的专栏
10-11 1万+
 netty是一个异步通信框架，在有的时候我们想使用服务端向客户端发送消息，服务端同步等待客户端返回结果然进行下一步的业务逻辑操作。那要怎么做才能同步获取客户端返回的数据呢？这里我用到了JDK中的闭锁等待 CountDownLatch，接下来看看代码如何实现： 服务端： package com.example.demo.server; import com.example.demo.cac...
[Netty实践] 请求响应同步实现
Staba的博客
03-22 1806
本片文章将实现请求响应同步，什么是请求响应同步呢？就是当我们发起一个请求时，希望能够在一定时间内同步（线程阻塞）等待响应结果。我们通过netty实现rpc调用时，由于客户端和服务端保持连接，在此期间客户端会有无数的接口调用（并发），而此时，每次发送的请求需要能够及时响应获取调用结果，服务端一次次返回调用结果，客户端在处理响应结果时，需要与请求建立联系，确保每一次的请求能够正确获取到对应的调用结果。
客户端发送HTTP请求后报超时错误timeout的几种排查思路
weixin_42926060的博客
01-25 1万+
一种典型场景是确实没有收到来自服务端的response。可以通过查看日志，抓包等定位，排除是否是传输过程中出现了问题。tcpdump+wireshark组合使用可以提高排查效率。 另一种则是客户端确实收到了response，但服务端返回的response的status状态不正确，导致httpclient无法识别。服务器返回http不同的状态码比如200、201、0等等。如果服务器返回的respon...
dubbo源码解析（十一） dubbo服务端返回及消费端接收原理
chaoyuehu的博客
03-28 1925
当客户端发送请求时，服务端接受的代码为NettyHandler的messageReceived方法： @Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { NettyChannel channel = NettyChannel.g...
dubbo源码分析资料
02-06
如果你想进行 Dubbo 源码分析，可以从以下几个方面入手： 1. Dubbo 的整体架构：Dubbo 采用了基于 RPC 框架的分布式服务架构，其中包含服务提供者、服务消费者、注册中心和监控中心等组件。了解这些组件的功能和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值