RocketMQ(五) - RemotingServer服务端请求调用方法源码分析

上一篇 《RocketMQ(三) - RemotingServer服务端启动》 中分析了 NettyRemotingServer 的启动源码，同时也对其继承接口 RemotingServer方法做了简单的注释说明，本篇主要详细分析其中三个请求方法在NettyRemotingServer 中的实现细节。

先回顾下三个请求调用方法，分别如下：

   

	/**
     *  1. 同步调用
     * @param channel   通信通道
     * @param request   业务请求对象
     * @param timeoutMillis   超时时间
     * @return  响应结果封装
     */
    RemotingCommand invokeSync(final Channel channel, final RemotingCommand request,
        final long timeoutMillis) throws InterruptedException, RemotingSendRequestException,RemotingTimeoutException;



    /**
     *  2. 异步调用
     * @param channel  通信通道
     * @param request  业务请求对象
     * @param timeoutMillis  超时时间
     * @param invokeCallback  响应结果回调对象
     */
    void invokeAsync(final Channel channel, final RemotingCommand request, final long timeoutMillis,
        final InvokeCallback invokeCallback) throws InterruptedException,
        RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException;



    /**
     *  3. 单向调用 (不关注返回结果)
     * @param channel   通信通道
     * @param request   业务请求对象
     * @param timeoutMillis  超时时间
     */
    void invokeOneway(final Channel channel, final RemotingCommand request, final long timeoutMillis)
        throws InterruptedException, RemotingTooMuchRequestException, RemotingTimeoutException,RemotingSendRequestException;

注意本篇讲述的这三个调用是建立在 服务端主动向客户端发送请求的情况下。

在 NettyRemotingServer中的三个请求调用方法实际上都是又一次调用了其父类 NettyRemotingAbstract 的对应方法，因此我们直接来看 NettyRemotingAbstract 类中这三个方法的具体实现。

1.同步调用

    /**
     *  服务器 主动向客户端 发起请求时 使用的方法。(当前方法 同步调用)
     *   什么是同步调用？
     *      服务器业务线程  需要在这里 等待client 返回结果之后 整个调用才完毕
     * @param channel        客户端ch
     * @param request        网络请求对象  remotingCommand
     * @param timeoutMillis  超时时长
     */
	public RemotingCommand invokeSyncImpl(final Channel channel, final RemotingCommand request,
        final long timeoutMillis)
        throws InterruptedException, RemotingSendRequestException, RemotingTimeoutException {

        // 获取请求ID  Opaque
        final int opaque = request.getOpaque();

        try {
			
            // 封装 响应结果 对象 (之后请求的返回结果会 存入该对象中)
            // 参数1： 客户端ch
            // 参数2： 请求ID
            // 参数3： 超时时间
            final ResponseFuture responseFuture = new ResponseFuture(channel, opaque, timeoutMillis, null, null);

            
            // 加入到 映射表 内
            // key: opaque  value: 响应结果对象
            this.responseTable.put(opaque, responseFuture);

            // 获取 客户端 地址信息
            final SocketAddress addr = channel.remoteAddress();

            // 将数据 写入 客户端 ch， 并设置个 回调监听器
            channel.writeAndFlush(request).addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture f) throws Exception {
                   
                     //条件成立： 请求写成功
                    if (f.isSuccess()) {
                       // 设置 请求写状态 ok
                        responseFuture.setSendRequestOK(true);
                        return;
                    } 
                    // 条件成立： 请求写失败
                    else {
                        // 设置 请求写状态 false
                        responseFuture.setSendRequestOK(false);
                    }

                    // 写失败 才会走到这...

                    // 将当前请求的 responseFuture 从映射表 移除
                    responseTable.remove(opaque);
                    // 设置失败原因..
                    responseFuture.setCause(f.cause());
                    responseFuture.putResponse(null);
                    log.warn("send a request command to channel <" + addr + "> failed.");
                }
            });

            // 同步调用的关键代码
            // 业务线程 在这里 进入挂起状态...    => countDownLatch.await()
            RemotingCommand responseCommand = responseFuture.waitResponse(timeoutMillis);

            // 线程执行到这，有两种情况
            // 1. 正常情况， 客户端 返回数据了， IO线程 将业务线程 唤醒
            // 2. 超时


            if (null == responseCommand) {
                // 执行进这里， 说明 超时 或 其它异常情况..
                if (responseFuture.isSendRequestOK()) {
                    throw new RemotingTimeoutException(RemotingHelper.parseSocketAddressAddr(addr), timeoutMillis,
                        responseFuture.getCause());
                } else {
                    throw new RemotingSendRequestException(RemotingHelper.parseSocketAddressAddr(addr), responseFuture.getCause());
                }
            }

            // 正常..  这里返回 客户端的 请求结果。
            return responseCommand;
        } finally {
            // 从 响应结果映射表 移除该 响应结果对象
            this.responseTable.remove(opaque);
        }
    }

2.异步调用

    /**
     *  服务器 主动 向客户端 发起请求时， 使用的方法 (异步)
     * @param channel     客户端ch
     * @param request      网络请求对象 remotingCommand
     * @param timeoutMillis  超时时长
     * @param invokeCallback  请求结果回调处理对象
     */
    public void invokeAsyncImpl(final Channel channel, final RemotingCommand request, final long timeoutMillis,
        final InvokeCallback invokeCallback)
        throws InterruptedException, RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException {

        // 获取 开始时间
        long beginStartTime = System.currentTimeMillis();

        // 请求ID
        final int opaque = request.getOpaque();

        // 获取信号量
        boolean acquired = this.semaphoreAsync.tryAcquire(timeoutMillis, TimeUnit.MILLISECONDS);

        if (acquired) {
            // 执行到这， 说明抢到了信号量， 当前线程可以发起请求， 服务器请求客户端的 并发 ,并未达到上限

            // once 对象 封装了 释放信号量的操作
            final SemaphoreReleaseOnlyOnce once = new SemaphoreReleaseOnlyOnce(this.semaphoreAsync);

            // 计算 到这一步为止， 耗费的时间
            long costTime = System.currentTimeMillis() - beginStartTime;

            // 条件成立： 说明 已经超时了.. 就不用 再发起RPC了
            if (timeoutMillis < costTime) {
                once.release();
                throw new RemotingTimeoutException("invokeAsyncImpl call timeout");
            }

            //  参数1： 客户端ch
            //  参数2： 请求ID
            //  参数3:  剩余的超时时间
            //  参数4： 回调处理对象
            //  参数5： 信号量释放操作封装对象
            final ResponseFuture responseFuture = new ResponseFuture(channel, opaque, timeoutMillis - costTime, invokeCallback, once);

            // 将 responseFuture 加入 响应 映射表，key 其实是 RequestId
            this.responseTable.put(opaque, responseFuture);
            try {

                // 1. 业务线程 将数据 交给netty， netty IO线程 接管 写 和 刷 数据的操作。
                // 2. 注册 写 刷 操作的 监听器。 监听器由IO线程回调
                channel.writeAndFlush(request).addListener(new ChannelFutureListener() {
                    @Override
                    public void operationComplete(ChannelFuture f) throws Exception {
                        if (f.isSuccess()) {
                            // 写刷 成功 ，设置 responseFutrue 发生状态为 true
                            responseFuture.setSendRequestOK(true);
                            return;
                        }
                        // 执行到这， 发送失败
                        requestFail(opaque);
                        log.warn("send a request command to channel <{}> failed.", RemotingHelper.parseChannelRemoteAddr(channel));
                    }
                });
            } catch (Exception e) {
                responseFuture.release();
                log.warn("send a request command to channel <" + RemotingHelper.parseChannelRemoteAddr(channel) + "> Exception", e);
                throw new RemotingSendRequestException(RemotingHelper.parseChannelRemoteAddr(channel), e);
            }
        } else {
            // 执行到这， 说明获取 信号量失败， 说明当前并发高
            if (timeoutMillis <= 0) {
                throw new RemotingTooMuchRequestException("invokeAsyncImpl invoke too fast");
            } else {
                String info =
                    String.format("invokeAsyncImpl tryAcquire semaphore timeout, %dms, waiting thread nums: %d semaphoreAsyncValue: %d",
                        timeoutMillis,
                        this.semaphoreAsync.getQueueLength(),
                        this.semaphoreAsync.availablePermits()
                    );
                log.warn(info);
                throw new RemotingTimeoutException(info);
            }
        }
    }

3.单向调用

/**
     *   服务器 主动向 客户端 发起请求时，(此方法 不关注结果  单向请求)
     * @param channel    客户端ch
     * @param request    网络请求对象 remotingCommand
     * @param timeoutMillis  超时时长
     */
    public void invokeOnewayImpl(final Channel channel, final RemotingCommand request, final long timeoutMillis)
        throws InterruptedException, RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException {

        // 设置 标记， 对端 检查标记  就可以知道 这个请求是一个单向请求
        request.markOnewayRPC();

        // 申请信号量
        boolean acquired = this.semaphoreOneway.tryAcquire(timeoutMillis, TimeUnit.MILLISECONDS);
        if (acquired) {

            // 释放信号量逻辑的封装对象
            final SemaphoreReleaseOnlyOnce once = new SemaphoreReleaseOnlyOnce(this.semaphoreOneway);
            try {

                // 1. 将数据交给ch, 这里数据处理发送的逻辑 由netty 线程完成
                // 2. 添加 写刷数据操作的 监听器。 由Netty IO线程回调
                channel.writeAndFlush(request).addListener(new ChannelFutureListener() {
                    @Override
                    public void operationComplete(ChannelFuture f) throws Exception {
                        // 释放信号量
                        once.release();
                        if (!f.isSuccess()) {
                            log.warn("send a request command to channel <" + channel.remoteAddress() + "> failed.");
                        }
                    }
                });
            } catch (Exception e) {
                once.release();
                log.warn("write send a request command to channel <" + channel.remoteAddress() + "> failed.");
                throw new RemotingSendRequestException(RemotingHelper.parseChannelRemoteAddr(channel), e);
            }
        } 
        
        // 条件成立： 说明并发高，达到了限制
        else {
            if (timeoutMillis <= 0) {
                throw new RemotingTooMuchRequestException("invokeOnewayImpl invoke too fast");
            } else {
                String info = String.format(
                    "invokeOnewayImpl tryAcquire semaphore timeout, %dms, waiting thread nums: %d semaphoreAsyncValue: %d",
                    timeoutMillis,
                    this.semaphoreOneway.getQueueLength(),
                    this.semaphoreOneway.availablePermits()
                );
                log.warn(info);
                throw new RemotingTimeoutException(info);
            }
        }
    }