ocketMQ源码5-producer 同步发送和单向发送

逃离我推掉我的手 2023-09-24 23:47 24阅读 0赞

RocketMQ生产者发送消息分为三种模式，分别是同步发送，异步发送和单向发送。

*  单向发送，这个就是发送之后不用接收结果的，就是你发出去一个消息，然后就返回了，就算有结果返回也不会接收了，这是站在消息生产者的角度；

*  同步发送的话，就是发出去一个消息，这个线程要等着它返回消息发送结果，然后你这个线程再根据这个消息发送结果再做一些业务操作等等；

*  异步发送，这个就是在你发送消息之前要给一个callback，发送的时候，你这个线程就不用等着，该干什么就干什么，然后发送结果回来的时候，是由其他线程调用你这个callback来处理的，你可以把这个callback看作是一个回调函数，回调方法，这个方法里面的业务逻辑就是你对这个消息发送结果的处理。注意，本文介绍的消息发送只是普通的消息发送，那种事务类型的消息，我们以后会有介绍。

## 1. 同步发送 ##

producer同步发送消息的示例在org.apache.rocketmq.example.simple.Producer类中，代码如下：

publicclassProducer {
        publicstaticvoidmain(String[] args)throws MQClientException, InterruptedException {
            // 1. 创建 DefaultMQProducer 对象DefaultMQProducerproducer=newDefaultMQProducer("please_rename_unique_group_name");
    
           
            producer.setNamesrvAddr("127.0.0.1:9876");
            /*
             * Launch the instance.
             */// todo 2. 启动 producer
            producer.start();
    
            for (inti=0; i < 1000; i++) {
                try {
    
                  
                    Messagemsg=newMessage("TopicTest"/* Topic */,
                        "TagA"/* Tag */,
                        ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
                    );
    
    
                    // 3. 发送消息SendResultsendResult= producer.send(msg);
    
                    System.out.printf("%s%n", sendResult);
                } 
                ...
            }
            producer.shutdown();
        }
    }
    复制代码

我们可以看到这个代码，你是同步消息你是需要在你自己的业务线程里面接收这个sendResult的，然后在做一些业务处理，比如我这里就是打印了一下这个sendResult。

接下来我们看下它是怎样发送的，这里是调用了这个producer的send方法。

@Overridepublic SendResult send(
        Message msg)throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        // topic 和消息长度 校验
        Validators.checkMessage(msg, this);
        msg.setTopic(withNamespace(msg.getTopic()));
        // todoreturnthis.defaultMQProducerImpl.send(msg);
    }
    复制代码

我们可以看到，这个 DefaultMQProducer 将这个消息给了defaultMQProducerImpl 这个实现的send方法来处理了。

public SendResult send(
        Message msg)throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        // todo 默认超时时间3sreturn send(msg, this.defaultMQProducer.getSendMsgTimeout());
    }
    复制代码

defaultMQProducerImpl的send方法，加了个超时时间 ，然后有调用它的重载方法send(msg,timeout)

public SendResult send(Message msg,
        long timeout)throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        // todo 同步模式returnthis.sendDefaultImpl(msg, CommunicationMode.SYNC, null, timeout);
    }
    复制代码

这个send(msg,timeout)又调用了sendDefaultImpl 方法，然后他这里加了个通信模式是同步，CommunicationMode.SYNC。

### 1.1 DefaultMQProducerImpl\#sendDefaultImpl ###

sendDefaultImpl 方法就比较长了了我们分成几部分来介绍：

private SendResult sendDefaultImpl(
        Message msg,
        final CommunicationMode communicationMode,
        final SendCallback sendCallback,
        finallong timeout
    )throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        // 判断状态是否是runningthis.makeSureStateOK();
        // 检查消息合法性
        Validators.checkMessage(msg, this.defaultMQProducer);
        // 随机的invokeIDfinallonginvokeID= random.nextLong();
        longbeginTimestampFirst= System.currentTimeMillis();
        longbeginTimestampPrev= beginTimestampFirst;
        longendTimestamp= beginTimestampFirst;
        // todo 获取topic信息TopicPublishInfotopicPublishInfo=this.tryToFindTopicPublishInfo(msg.getTopic());
        ...
    }
    复制代码

这一小段代码其实就是做了一些准备检查工作，注意第二行的个检查消息合法性，它要检查你topic，消息长度的，你不能发空消息，消息长度也不能太长，默认是不超过4m，接下来这些就是记录一下时间了，再看最后一行，就是根据你这个消息发送的topic，然后获取topic 发送消息的这么一个信息，这里面就有这topic 有几个MessageQueue，然后每个MessageQueue对应在哪个broker上面，broker 的地址又是啥的，它这个方法会先从本地的一个缓存中获取下，没有的话就从nameserv更新下这个本地缓存，再找找，要是再找不到，它就认为你没有这个topic了，然后就去nameserv上面拉取一个默认topic的一些配置信息给你用（这个其实就是在新建一个topic）。 接着这个方法往下看，接着就是判断 这个TopicPublishInfo 是否存在了，如果不存在的话就抛出异常了，没有后续了就，如果存在的话：

...
    if (topicPublishInfo != null && topicPublishInfo.ok()) {
        booleancallTimeout=false;
        MessageQueuemq=null;
        Exceptionexception=null;
        SendResultsendResult=null;
        // 重试次数 区分同步、其他inttimesTotal= communicationMode == CommunicationMode.SYNC ? 1 + this.defaultMQProducer.getRetryTimesWhenSendFailed() : 1;
        inttimes=0;
        // 存放发送过的broker name
        String[] brokersSent = newString[timesTotal];
        // 重试发送for (; times < timesTotal; times++) {
            StringlastBrokerName=null == mq ? null : mq.getBrokerName();
            // todo 选择message queueMessageQueuemqSelected=this.selectOneMessageQueue(topicPublishInfo, lastBrokerName);
            if (mqSelected != null) {
                mq = mqSelected;
                brokersSent[times] = mq.getBrokerName();
                try {
                    beginTimestampPrev = System.currentTimeMillis();
                    if (times > 0) {
                        //Reset topic with namespace during resend.
                        msg.setTopic(this.defaultMQProducer.withNamespace(msg.getTopic()));
                    }
                    longcostTime= beginTimestampPrev - beginTimestampFirst;
                    if (timeout < costTime) {
                        callTimeout = true;
                        break;
                    }
    
                    // todo 进行发送
                    sendResult = this.sendKernelImpl(msg, mq, communicationMode, sendCallback, topicPublishInfo, timeout - costTime);
                    endTimestamp = System.currentTimeMillis();
                    // todo isolation 参数为false(看一下异常情况)this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, false);
                    switch (communicationMode) {
                        case ASYNC:
                            returnnull;
                        case ONEWAY:
                            returnnull;
                        case SYNC:
                            if (sendResult.getSendStatus() != SendStatus.SEND_OK) {
                                if (this.defaultMQProducer.isRetryAnotherBrokerWhenNotStoreOK()) {
                                    continue;
                                }
                            }
    
                            return sendResult;
                        default:
                            break;
                    }
                } catch (RemotingException e) {
                    endTimestamp = System.currentTimeMillis();
                    this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, true);
                    log.warn(String.format("sendKernelImpl exception, resend at once, InvokeID: %s, RT: %sms, Broker: %s", invokeID, endTimestamp - beginTimestampPrev, mq), e);
                    log.warn(msg.toString());
                ...
    复制代码

其实下面还有许多处理异常的操作没有放上，不过不影响我们的主流程，先是判断你这个通信模式，如果是同步的话，默认重试次数就是2 ，然后加上本身这次请求，也就是最查请求3次。这个for循环就是失败重试的代码，再看下代码selectOneMessageQueue这个就是选择一个MesssageQueue的方法了，这个是比较重要的，这里我们先不说，你可以把它理解为 我们的负载均衡。接着往下走，就是判断一下时间了，计算一下剩下的时间， 如果这一堆前面的内容耗时很长，然后已经超了之前设置的默认超时时间，这个时候就会超时了，然后将这个calltimeout设置成true了。

### 1.2 DefaultMQProducerImpl\#sendKernelImpl ###

接着就是进行发送了调用sendKernelImpl 方法：

private SendResult sendKernelImpl(final Message msg,
        final MessageQueue mq,
        final CommunicationMode communicationMode,
        final SendCallback sendCallback,
        final TopicPublishInfo topicPublishInfo,
        finallong timeout)throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        longbeginStartTime= System.currentTimeMillis();
    
        // 根据MessageQueue获取Broker的网络地址StringbrokerAddr=this.mQClientFactory.findBrokerAddressInPublish(mq.getBrokerName());
        if (null == brokerAddr) {
            tryToFindTopicPublishInfo(mq.getTopic());
            brokerAddr = this.mQClientFactory.findBrokerAddressInPublish(mq.getBrokerName());
        }
    
        SendMessageContextcontext=null;
        ...
    复制代码

这个sendKernelImpl 也是有点长，然后我们一部分一部分的看下，这就是根据MessageQueue里面的broker name 获取一下broker addr，他这个broker addr 选的是master的，比如说我们 broker使用的是 master/slave 高可用架构，这个时候只会选择那个master，毕竟是往里面写消息，然后只能用master，等到介绍消息消费者的时候，消息消费者是可以向slave node 获取消息消费的，前提是 master 负载比较大，然后消息消费者下次获取消费的消息已经在slave里面了，然后消息消费者获取到消息之后，它里面有个字段是告诉你下次可以去xxx 地址的broker 拉取消息，这个我们介绍到消息消费者的时候再说。

接着回来，如果没有获取到这个broker 地址的话，就是去nameserv上更新下本地缓存，然后再获取下。接着再往下就是再次判断一下这个broker addr 了，如果还没有就抛出异常，如果有的话 就执行下面的代码了：

...
    SendMessageContextcontext=null;
    if (brokerAddr != null) {
        brokerAddr = MixAll.brokerVIPChannel(this.defaultMQProducer.isSendMessageWithVIPChannel(), brokerAddr);
    
        byte[] prevBody = msg.getBody();
        try {
            //for MessageBatch,ID has been set in the generating process// 给消息设置全局唯一id， 对于MessageBatch在生成过程中已设置了idif (!(msg instanceof MessageBatch)) {
                MessageClientIDSetter.setUniqID(msg);
            }
    
            booleantopicWithNamespace=false;
            if (null != this.mQClientFactory.getClientConfig().getNamespace()) {
                msg.setInstanceId(this.mQClientFactory.getClientConfig().getNamespace());
                topicWithNamespace = true;
            }
    
            intsysFlag=0;
            // 消息体是否压缩booleanmsgBodyCompressed=false;
            // 压缩消息 内容部分超了4k就会压缩if (this.tryToCompressMessage(msg)) {
                sysFlag |= MessageSysFlag.COMPRESSED_FLAG;
                msgBodyCompressed = true;
            }
    
            finalStringtranMsg= msg.getProperty(MessageConst.PROPERTY_TRANSACTION_PREPARED);
            if (tranMsg != null && Boolean.parseBoolean(tranMsg)) {
                sysFlag |= MessageSysFlag.TRANSACTION_PREPARED_TYPE;
            }
    
            // 判断有没有hookif (hasCheckForbiddenHook()) {
                CheckForbiddenContextcheckForbiddenContext=newCheckForbiddenContext();
                checkForbiddenContext.setNameSrvAddr(this.defaultMQProducer.getNamesrvAddr());
                checkForbiddenContext.setGroup(this.defaultMQProducer.getProducerGroup());
                checkForbiddenContext.setCommunicationMode(communicationMode);
                checkForbiddenContext.setBrokerAddr(brokerAddr);
                checkForbiddenContext.setMessage(msg);
                checkForbiddenContext.setMq(mq);
                checkForbiddenContext.setUnitMode(this.isUnitMode());
                // 执行Forbidden 钩子this.executeCheckForbiddenHook(checkForbiddenContext);
            }
            ...
    复制代码

第一句，这个其实就是进行一个vip通道地址的转换，这个比较有意思，如果你这个支持vip channel的话，它会把broker addr 里面的端口改变一下，这个所谓的vip channel ，其实就是与它的另一个端口建立连接，这个端口就是当前端口-2 ；

接着，如果这个消息不是批量消息的话，我们就给这个消息设置一个唯一的消息id，再往下就是 sysflag的处理了，这个sysflag里面记录了好几个属性值，使用二进制来处理的，比如说消息是否压缩了（这个压缩，就是你消息内容超过了默认的4k之后，就会进行压缩，这个压缩的阈值你是可以配置的），是否是个事务消息等等。接下来就是执行hook了，这个hook就是forbidenHook ，其实就是对消息进行过滤。

...
    if (this.hasSendMessageHook()) {
        context = newSendMessageContext();
        context.setProducer(this);
        context.setProducerGroup(this.defaultMQProducer.getProducerGroup());
        context.setCommunicationMode(communicationMode);
        context.setBornHost(this.defaultMQProducer.getClientIP());
        context.setBrokerAddr(brokerAddr);
        context.setMessage(msg);
        context.setMq(mq);
        context.setNamespace(this.defaultMQProducer.getNamespace());
        StringisTrans= msg.getProperty(MessageConst.PROPERTY_TRANSACTION_PREPARED);
        if (isTrans != null && isTrans.equals("true")) {
            context.setMsgType(MessageType.Trans_Msg_Half);
        }
    
        if (msg.getProperty("__STARTDELIVERTIME") != null || msg.getProperty(MessageConst.PROPERTY_DELAY_TIME_LEVEL) != null) {
            context.setMsgType(MessageType.Delay_Msg);
        }
        this.executeSendMessageHookBefore(context);
    }
    
    // 封装消息头SendMessageRequestHeaderrequestHeader=newSendMessageRequestHeader();
    // 设置group
    requestHeader.setProducerGroup(this.defaultMQProducer.getProducerGroup());
    // topic
    requestHeader.setTopic(msg.getTopic());
    // 设置默认topic
    requestHeader.setDefaultTopic(this.defaultMQProducer.getCreateTopicKey());
    // 设置默认topic的队列数量 默认4个
    requestHeader.setDefaultTopicQueueNums(this.defaultMQProducer.getDefaultTopicQueueNums());
    // 队列id
    requestHeader.setQueueId(mq.getQueueId());
    // 消息系统标记
    requestHeader.setSysFlag(sysFlag);
    // 消息发送时间
    requestHeader.setBornTimestamp(System.currentTimeMillis());
    // 消息标记（RocketMQ对消息标记不做任何处理，供应用程序使用）
    requestHeader.setFlag(msg.getFlag());
    // 设置扩展属性
    requestHeader.setProperties(MessageDecoder.messageProperties2String(msg.getProperties()));
    requestHeader.setReconsumeTimes(0);
    requestHeader.setUnitMode(this.isUnitMode());
    // 是否批量
    requestHeader.setBatch(msg instanceof MessageBatch);
    // 判断消息是否是 %RETRY% 开头if (requestHeader.getTopic().startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
        StringreconsumeTimes= MessageAccessor.getReconsumeTime(msg);
        if (reconsumeTimes != null) {
            requestHeader.setReconsumeTimes(Integer.valueOf(reconsumeTimes));
            MessageAccessor.clearProperty(msg, MessageConst.PROPERTY_RECONSUME_TIME);
        }
    
        StringmaxReconsumeTimes= MessageAccessor.getMaxReconsumeTimes(msg);
        if (maxReconsumeTimes != null) {
            requestHeader.setMaxReconsumeTimes(Integer.valueOf(maxReconsumeTimes));
            MessageAccessor.clearProperty(msg, MessageConst.PROPERTY_MAX_RECONSUME_TIMES);
        }
    }
    ...
    复制代码

在往下就是执行一下发送消息之前的hook，再往下就是封装发送消息请求头，然后这个请求头里面就涵盖了很多的参数，比如说topic，MessageQueue 队列Id， 出生日期，flag等等。再往下就是消息发送了

...
    SendResultsendResult=null;
    // 同步 异步  单向switch (communicationMode) {
        // 异步case ASYNC:
            MessagetmpMessage= msg;
            booleanmessageCloned=false;
            if (msgBodyCompressed) {
                //If msg body was compressed, msgbody should be reset using prevBody.//Clone new message using commpressed message body and recover origin massage.//Fix bug:https://github.com/apache/rocketmq-externals/issues/66
                tmpMessage = MessageAccessor.cloneMessage(msg);
                messageCloned = true;
                msg.setBody(prevBody);
            }
    
            if (topicWithNamespace) {
                if (!messageCloned) {
                    tmpMessage = MessageAccessor.cloneMessage(msg);
                    messageCloned = true;
                }
                msg.setTopic(NamespaceUtil.withoutNamespace(msg.getTopic(), this.defaultMQProducer.getNamespace()));
            }
    
            // 判断超时时间longcostTimeAsync= System.currentTimeMillis() - beginStartTime;
            if (timeout < costTimeAsync) {
                thrownewRemotingTooMuchRequestException("sendKernelImpl call timeout");
            }
            // todo
            sendResult = this.mQClientFactory.getMQClientAPIImpl().sendMessage(
                brokerAddr,
                mq.getBrokerName(),
                tmpMessage,
                requestHeader,
                timeout - costTimeAsync,
                communicationMode,
                sendCallback,
                topicPublishInfo,
                this.mQClientFactory,
                this.defaultMQProducer.getRetryTimesWhenSendAsyncFailed(),
                context,
                this);
            break;
            // 单向case ONEWAY:
            // 同步case SYNC:
            longcostTimeSync= System.currentTimeMillis() - beginStartTime;
            // 判判是否超时if (timeout < costTimeSync) {
                thrownewRemotingTooMuchRequestException("sendKernelImpl call timeout");
            }
            // todo 交给 mq api去发送消息
            sendResult = this.mQClientFactory.getMQClientAPIImpl().sendMessage(
                brokerAddr,
                mq.getBrokerName(),
                msg,
                requestHeader,
                timeout - costTimeSync,
                communicationMode,
                context,
                this);
            break;
        default:
            assertfalse;
            break;
    }
    
    // 是否注册了消息发送钩子函数if (this.hasSendMessageHook()) {
        context.setSendResult(sendResult);
        this.executeSendMessageHookAfter(context);
    }
    ...
    复制代码

因为本小节主要是介绍下这个同步发送消息，然后我们就主要介绍下这个sync的代码逻辑：首先是判断超时，然后交给 MQClientAPI层去处理，然后返回sendResult。

### 1.3 MQClientAPIImpl\#sendMessage ###

我们这里接着看下MQClientAPIImpl里面的sendMessage 实现：

public SendResult sendMessage(
        final String addr,
        final String brokerName,
        final Message msg,
        final SendMessageRequestHeader requestHeader,
        finallong timeoutMillis,
        final CommunicationMode communicationMode,
        final SendCallback sendCallback,
        final TopicPublishInfo topicPublishInfo,
        final MQClientInstance instance,
        finalint retryTimesWhenSendFailed,
        final SendMessageContext context,
        final DefaultMQProducerImpl producer
    )throws RemotingException, MQBrokerException, InterruptedException {
        longbeginStartTime= System.currentTimeMillis();
        RemotingCommandrequest=null;
        StringmsgType= msg.getProperty(MessageConst.PROPERTY_MESSAGE_TYPE);
        booleanisReply= msgType != null && msgType.equals(MixAll.REPLY_MESSAGE_FLAG);
        if (isReply) {
            if (sendSmartMsg) {
                SendMessageRequestHeaderV2requestHeaderV2= SendMessageRequestHeaderV2.createSendMessageRequestHeaderV2(requestHeader);
                request = RemotingCommand.createRequestCommand(RequestCode.SEND_REPLY_MESSAGE_V2, requestHeaderV2);
            } else {
                request = RemotingCommand.createRequestCommand(RequestCode.SEND_REPLY_MESSAGE, requestHeader);
            }
        } else {
            // sendSmartMsg默认开启，也算一种优化吧 批量消息if (sendSmartMsg || msg instanceof MessageBatch) {
                SendMessageRequestHeaderV2requestHeaderV2= SendMessageRequestHeaderV2.createSendMessageRequestHeaderV2(requestHeader);
                request = RemotingCommand.createRequestCommand(msg instanceof MessageBatch ? RequestCode.SEND_BATCH_MESSAGE : RequestCode.SEND_MESSAGE_V2, requestHeaderV2);
            } else {
                // 普通消息
                request = RemotingCommand.createRequestCommand(RequestCode.SEND_MESSAGE, requestHeader);
            }
        }
        // 设置消息体
        request.setBody(msg.getBody());
    
        switch (communicationMode) {
            case ONEWAY:
                // todothis.remotingClient.invokeOneway(addr, request, timeoutMillis);
                returnnull;
            case ASYNC:
                finalAtomicIntegertimes=newAtomicInteger();
                longcostTimeAsync= System.currentTimeMillis() - beginStartTime;
                // 判断超时时间if (timeoutMillis < costTimeAsync) {
                    thrownewRemotingTooMuchRequestException("sendMessage call timeout");
                }
                // todothis.sendMessageAsync(addr, brokerName, msg, timeoutMillis - costTimeAsync, request, sendCallback, topicPublishInfo, instance,
                    retryTimesWhenSendFailed, times, context, producer);
                returnnull;
            case SYNC:
                longcostTimeSync= System.currentTimeMillis() - beginStartTime;
                // 判断超时时间if (timeoutMillis < costTimeSync) {
                    thrownewRemotingTooMuchRequestException("sendMessage call timeout");
                }
                // todo 同步发送returnthis.sendMessageSync(addr, brokerName, msg, timeoutMillis - costTimeSync, request);
            default:
                assertfalse;
                break;
        }
    
        returnnull;
    }
    复制代码

这里先生成一个RemotingCommand 这么个实体对象，然后RequestCode就是SEND\_MESSAGE，其实这里判断了一下sendSmartMsg 这个参数，把requestHeader优化了一下，然后换成了requestHeaderV2，其实这个requestHeaderV2 内容跟requestHeader一样，但是变量名是单个字母的，然后序列化，反序列化，传输内容都有所优化，其实他这个序列化使用是json形式的，然后想想就知道有些哪些好处了， 唯一的缺点就是可读性差点，但是这个玩意是对用户透明的，用户不需要关心。

接着就是判断通信类型，然后发送消息了，这里是同步发送，先是判断一下超时时间，接着就是调用sendMessageSync 进行同步发送了，我们接着来看下这个sendMessageSync 方法实现。

### 1.4 MQClientAPIImpl\#sendMessageSync ###

private SendResult sendMessageSync(
        final String addr,
        final String brokerName,
        final Message msg,
        finallong timeoutMillis,
        final RemotingCommand request
    )throws RemotingException, MQBrokerException, InterruptedException {
        // todo 同步调用RemotingCommandresponse=this.remotingClient.invokeSync(addr, request, timeoutMillis);
        assert response != null;
        // 处理响应returnthis.processSendResponse(brokerName, msg, response,addr);
    }
    复制代码

这里就调用到了client 模块（这个client其实就是直接操作netty了）来处理了，然后返回响应，调用processSendResponse 方法来处理响应。

### 1.5 NettyRemotingClient\#invokeSync ###

我们再来看下client的 invokeSync 方法：

public RemotingCommand invokeSync(String addr, final RemotingCommand request, long timeoutMillis)throws InterruptedException, RemotingConnectException, RemotingSendRequestException, RemotingTimeoutException {
        // 开始时间longbeginStartTime= System.currentTimeMillis();
        // todo 轮询获取namesrv地址ChannelfinalChannelchannel=this.getAndCreateChannel(addr);
        if (channel != null && channel.isActive()) {
            try {
                // 执行开始之前的rpchook
                doBeforeRpcHooks(addr, request);
                longcostTime= System.currentTimeMillis() - beginStartTime;
                // 判断超时 之前有获取链接的操作，可能会出现超时的情况if (timeoutMillis < costTime) {
                    thrownewRemotingTimeoutException("invokeSync call timeout");
                }
                // todo 进行同步执行，获取响应RemotingCommandresponse=this.invokeSyncImpl(channel, request, timeoutMillis - costTime);
                // 执行之后的rpchook
                doAfterRpcHooks(RemotingHelper.parseChannelRemoteAddr(channel), request, response);
                return response;
                // 远程发送请求异常
            } catch (RemotingSendRequestException e) {
                log.warn("invokeSync: send request exception, so close the channel[{}]", addr);
                // 关闭channelthis.closeChannel(addr, channel);
                throw e;
                // 超时异常
            } catch (RemotingTimeoutException e) {
                // 如果超时 就关闭cahnnel话，就关闭channel 默认是不关闭的if (nettyClientConfig.isClientCloseSocketIfTimeout()) {
                    this.closeChannel(addr, channel);
                    log.warn("invokeSync: close socket because of timeout, {}ms, {}", timeoutMillis, addr);
                }
                log.warn("invokeSync: wait response timeout exception, the channel[{}]", addr);
                throw e;
            }
        } else {
            this.closeChannel(addr, channel);
            thrownewRemotingConnectException(addr);
        }
    }
    复制代码

这里有两个点需要关注下，首先是根据broker addr 这个地址获取一下对应的channel ，如果不存在的话就创建一下这个连接， 稍微看下这块的代码:

private Channel getAndCreateChannel(final String addr)throws RemotingConnectException, InterruptedException {
        // 如果地址不存在，就返回namesrv 的channelif (null == addr) {
            return getAndCreateNameserverChannel();
        }
    
        ChannelWrappercw=this.channelTables.get(addr);
        if (cw != null && cw.isOK()) {
            return cw.getChannel();
        }
        // 创建channelreturnthis.createChannel(addr);
    }
    复制代码

如果你这个addr是空的话，这个就是默认找nameserv的addr ，然后找对应channel就可以了，如果不是null ，然后它会去这个channelTable 这个map中去找，如果没有的话就创建一个对应的channel

接着回到这个invokeSync 方法中，获得channel之后，就是执行一下rpcHook了，这东西就是你在创建MQProducer的时候设置的，在调用前执行一次，调用后执行一次，其实你就可以通过这个hook来实现很多功能，监控的功能比较多些。接着就是调用了invokeSyncImpl 这个实现方法来发送消息了，这个方法是它的一个父类里面的：

public RemotingCommand invokeSyncImpl(final Channel channel, final RemotingCommand request,
        finallong timeoutMillis)throws InterruptedException, RemotingSendRequestException, RemotingTimeoutException {
        // 获取 请求idfinalintopaque= request.getOpaque();
    
        try {
            // 创建ResponseFuturefinalResponseFutureresponseFuture=newResponseFuture(channel, opaque, timeoutMillis, null, null);
            // 放入responseTable 表中this.responseTable.put(opaque, responseFuture);
            // 获取远程地址finalSocketAddressaddr= channel.remoteAddress();
            channel.writeAndFlush(request).addListener(newChannelFutureListener() {
                @OverridepublicvoidoperationComplete(ChannelFuture f)throws Exception {
                    // 成功if (f.isSuccess()) {
                        responseFuture.setSendRequestOK(true);
                        return;
                    // 失败
                    } else {
                        responseFuture.setSendRequestOK(false);
                    }
                    // 移除response中的缓存
                    responseTable.remove(opaque);
                    responseFuture.setCause(f.cause());
                    responseFuture.putResponse(null);
                    log.warn("send a request command to channel <" + addr + "> failed.");
                }
            });
    
            RemotingCommandresponseCommand= responseFuture.waitResponse(timeoutMillis);
            if (null == responseCommand) {
                // 成功了还是null  还是超时if (responseFuture.isSendRequestOK()) {
                    thrownewRemotingTimeoutException(RemotingHelper.parseSocketAddressAddr(addr), timeoutMillis,
                        responseFuture.getCause());
                } else {
                    // 没发出去，就排除异常thrownewRemotingSendRequestException(RemotingHelper.parseSocketAddressAddr(addr), responseFuture.getCause());
                }
            }
    
            // 返回响应结果return responseCommand;
        } finally {
            // 移除this.responseTable.remove(opaque);
        }
    }
    复制代码

这个方法其实就是最终往 channel里面写内容的方法了，我们来看下，先是为这次request创建一个id 吧，这个id主要用来返回响应的时候用的。

接着创建一个ResposeFuture ，这个东西异步，同步都可以用，这个一会介绍一下它的原理，接着就是将这个id 与这个 ResposeFuture 关联起来放到这个 responseTable 里面的， 接着就是往channel里面发送消息了，这里它添加一个listener ，这listener的执行时机就是发送出去的时候，最后就是等待这个响应了。

我们来解释下这个ResposeFuture 原理， 当执行了responseFuture.waitResponse(timeoutMillis); 这行代码，当前线程就会wait ，然后被阻塞，然后等着响应回来的时候，netty处理响应的线程会从响应里面获取一下这个opaque这个id，就是请求之前在request生成的，broker 在响应的时候会会把这个id 放回到response 中， 然后会根据这个opaque 从responseTable中找到这个 ResposeFuture ，然后把响应设置到这个里面，最后唤醒一下wait在这个对象里面的线程就可以了，这样你这个业务线程就得到了这个RemotingResponse 了。 好了，到这我们就解释清楚了，然后我们看下他这个代码是怎样实现的:

publicvoidprocessResponseCommand(ChannelHandlerContext ctx, RemotingCommand cmd) {
        finalintopaque= cmd.getOpaque();
        // 获取对应id 的responseFuturefinalResponseFutureresponseFuture= responseTable.get(opaque);
        if (responseFuture != null) {
            // 设置
            responseFuture.setResponseCommand(cmd);
    
            // 从响应表中移除
            responseTable.remove(opaque);
    
            if (responseFuture.getInvokeCallback() != null) {
                // todo 执行回调
                executeInvokeCallback(responseFuture);
            } else {
                responseFuture.putResponse(cmd);
                responseFuture.release();
            }
        } else {
            log.warn("receive response, but not matched any request, " + RemotingHelper.parseChannelRemoteAddr(ctx.channel()));
            log.warn(cmd.toString());
        }
    }
    复制代码

不过它这个ResposeFuture 是使用CountDownLatch 来实现这个wait与唤醒的。我们来具体看下这个 waitResponse方法与这个putResponse方法:

public RemotingCommand waitResponse(finallong timeoutMillis)throws InterruptedException {
        this.countDownLatch.await(timeoutMillis, TimeUnit.MILLISECONDS);
        returnthis.responseCommand;
    }
    
    publicvoidputResponse(final RemotingCommand responseCommand) {
        this.responseCommand = responseCommand;
        this.countDownLatch.countDown();
    }
    复制代码

## 2. 单向发送 ##

单向发送其实这块跟同步发送的流程差不多，我们来看下它的生产者代码是怎样写的：org.apache.rocketmq.example.openmessaging.SimpleProducer：

publicstaticvoidmain(String[] args) {
        finalMessagingAccessPointmessagingAccessPoint=
            OMS.getMessagingAccessPoint("oms:rocketmq://localhost:9876/default:default");
    
        finalProducerproducer= messagingAccessPoint.createProducer();
    
        messagingAccessPoint.startup();
        System.out.printf("MessagingAccessPoint startup OK%n");
    
        producer.startup();
        System.out.printf("Producer startup OK%n");
        ...
        
        {
            producer.sendOneway(producer.createBytesMessage("OMS_HELLO_TOPIC", "OMS_HELLO_BODY".getBytes(Charset.forName("UTF-8"))));
            System.out.printf("Send oneway message OK%n");
        }
    
       ...
    }
    复制代码

可以看到我们最后发送的时候调用的是sendOneway方法，这个方法是没有返回值的。

publicvoidsendOneway(Message msg)throws MQClientException, RemotingException, InterruptedException {
        msg.setTopic(withNamespace(msg.getTopic()));
        this.defaultMQProducerImpl.sendOneway(msg);
    }
    复制代码

### 2.1 DefaultMQProducerImpl\#sendOneway ###

这里就是调用了defaultMQProducerImpl的 sendOneway方法

这里需要注意的是它也是调用了sendDefaultImpl 方法，然后通信方式是oneway 。这里我们就不细说了，可以看下同步方法解析这个方法的说明，这里唯一要提一点是单向发送是没有这个重试的，然后就发送一次。下面的流程都是一样的，然后就到了这个MQClientAPIImpl 的 sendMessage 方法

...
    switch (communicationMode) {
        case ONEWAY:
            // todothis.remotingClient.invokeOneway(addr, request, timeoutMillis);
            returnnull;
        ...
    复制代码

然后他这个是又调用了NettyRemotingClient 的 invokeOneway 方法:

publicvoidinvokeOneway(String addr, RemotingCommand request, long timeoutMillis)throws InterruptedException,
        RemotingConnectException, RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException {
        finalChannelchannel=this.getAndCreateChannel(addr);
        if (channel != null && channel.isActive()) {
            try {
                doBeforeRpcHooks(addr, request);
                this.invokeOnewayImpl(channel, request, timeoutMillis);
            } catch (RemotingSendRequestException e) {
                log.warn("invokeOneway: send request exception, so close the channel[{}]", addr);
                this.closeChannel(addr, channel);
                throw e;
            }
        } else {
            this.closeChannel(addr, channel);
            thrownewRemotingConnectException(addr);
        }
    }
    复制代码

这里也是根据broker addr 获取channel， 如果没有的话，也是创建一个，接着就是执行这个rpc调用前的hook ，注意这里没有调用后的一个hook，因为我们并不知道它是什么情况。接着又调用了invokeOnewayImpl 方法:

publicvoidinvokeOnewayImpl(final Channel channel, final RemotingCommand request, finallong timeoutMillis)throws InterruptedException, RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException {
        // 请求体， 标记是一个单向调用
        request.markOnewayRPC();
        // 获取凭证booleanacquired=this.semaphoreOneway.tryAcquire(timeoutMillis, TimeUnit.MILLISECONDS);
        if (acquired) {
            finalSemaphoreReleaseOnlyOnceonce=newSemaphoreReleaseOnlyOnce(this.semaphoreOneway);
            try {
                channel.writeAndFlush(request).addListener(newChannelFutureListener() {
                    @OverridepublicvoidoperationComplete(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.");
                thrownewRemotingSendRequestException(RemotingHelper.parseChannelRemoteAddr(channel), e);
            }
        } else {
            if (timeoutMillis <= 0) {
                thrownewRemotingTooMuchRequestException("invokeOnewayImpl invoke too fast");
            } else {
                Stringinfo= String.format(
                    "invokeOnewayImpl tryAcquire semaphore timeout, %dms, waiting thread nums: %d semaphoreAsyncValue: %d",
                    timeoutMillis,
                    this.semaphoreOneway.getQueueLength(),
                    this.semaphoreOneway.availablePermits()
                );
                log.warn(info);
                thrownewRemotingTimeoutException(info);
            }
        }
    }
    复制代码

这里使用了semaphore进行限流，然后默认的话是同时支持65535 个请求发送的，这个semaphore 限流只有单向发送与这个异步发送会有，接着就会将这个request写入channel中，然后add了一个listener ，这个listener执行时机就是消息发送出去了，这个时候就会释放 信号量。

到这我们这个单向发送就解析完成了。