首先看一段代码

nettyClient = new NettyClient(url);
nettyClient.open();
RpcContext.getContext().putAttribute(MotanConstants.ASYNC_SUFFIX, true);
Response response;
try {
    response = nettyClient.request(request);
    Assert.assertTrue(response instanceof ResponseFuture);
    Object result = response.getValue();//获取返回结果会阻塞
    RpcContext.destroy();
    Assert.assertNotNull(result);
    Assert.assertEquals("method: " + request.getMethodName() + " requestId: " + request.getRequestId(), result);
} catch (MotanServiceException e) {
    e.printStackTrace();
    assertTrue(false);
} catch (Exception e) {
    e.printStackTrace();
    assertTrue(false);
}

主要是建立一个客户端的连接，发送请求，然后获取返回。

nettyClient.open();
open的时候会去创建一个channel的连接池，可以点进去看
所以当调用request的时候最终会走到这样一个方法
private Response request(Request request, boolean async) throws TransportException {
    Channel channel;
    Response response;
    try {
        channel = getChannel();//从连接池获取channel
        if (channel == null) {
            LoggerUtil.error("NettyClient borrowObject null: url=" + url.getUri() + " " + MotanFrameworkUtil.toString(request));
            return null;
        }
        // async request
        response = channel.request(request);
    } catch (Exception e) {
       
    }
    // aysnc or sync result
    response = asyncResponse(response, async);
    return response;
}

最终发起调用是在com.weibo.api.motan.transport.netty4.NettyChannel中的request方法
@Override
public Response request(Request request) throws TransportException {
    int timeout = nettyClient.getUrl().getMethodParameter(request.getMethodName(), request.getParamtersDesc(), URLParamType.requestTimeout.getName(), URLParamType.requestTimeout.getIntValue());
    if (timeout 

当服务端返回数据后会调用处理返回的handler
com.weibo.api.motan.transport.netty4.NettyClient中的handler
new MessageHandler() {
    @Override
    public Object handle(Channel channel, Object message) {
        Response response = (Response) message;
        System.out.println("获取到message");
        ResponseFuture responseFuture = NettyClient.this.removeCallback(response.getRequestId());

        if (responseFuture == null) {
            LoggerUtil.warn("NettyClient has response from server, but responseFuture not exist, requestId={}", response.getRequestId());
            return null;
        }
        if (response.getException() != null) {
            responseFuture.onFailure(response);
        } else {
            responseFuture.onSuccess(response);
        }
        return null;
    }
}

可以看到如果服务端返回了，就会获取到响应的DefaultResponse
然后将返回结果传入到之前构建的responseFuture
if (response.getException() != null) {
    responseFuture.onFailure(response);
} else {
    responseFuture.onSuccess(response);
}

onSuccess中会调用之前的listener，执行listen回调方法
关于
DefaultResponseFuture
通过对象锁protected Object lock = new Object();来保证等待结果的返回


获取返回结果会阻塞，如果服务端还没有返回
 Object result = response.getValue();//获取返回结果会阻塞
 
@Override
public Object getValue() {
    System.out.println("getValue");
    synchronized (lock) {
        if (!isDoing()) {
            return getValueOrThrowable();//如果不是在运行就报错
        }
        System.out.println("timeout:"+timeout);
        if (timeout  0) {
                for (; ; ) {
                    try {
                        lock.wait(waitTime);
                    } catch (InterruptedException e) {
                    }

                    if (!isDoing()) {
                        break;
                    } else {
                        waitTime = timeout - (System.currentTimeMillis() - createTime);
                        if (waitTime