RocketMQ（二）：producer客户端实践

/** * This class demonstrates how to send messages to brokers using provided {@link DefaultMQProducer}. */public class Producer {    public static void main(String[] args) throws MQClientException, InterruptedException {
        DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");        producer.setNamesrvAddr("localhost:9876");        producer.start();
        for (int i = 0; i < 1000; i++) {            try {                Message msg = new Message("TopicTest" /* Topic */,                    "TagA" /* Tag */,                    ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */                );                // 发送逻辑，将组装好的 Message 发送到消息服务器即某个 broker                SendResult sendResult = producer.send(msg);                System.out.printf("%s%n", sendResult);            } catch (Exception e) {                e.printStackTrace();                Thread.sleep(1000);            }        }        producer.shutdown();    }}

// org.apache.rocketmq.client.producer.DefaultMQProducer#send(org.apache.rocketmq.common.message.Message)    /**     * Send message in synchronous mode. This method returns only when the sending procedure totally completes.     * 
     *     * Warn: this method has internal retry-mechanism, that is, internal implementation will retry     * {@link #retryTimesWhenSendFailed} times before claiming failure. As a result, multiple messages may potentially     * delivered to broker(s). It's up to the application developers to resolve potential duplication issue.     *     * @param msg Message to send.     * @return {@link SendResult} instance to inform senders details of the deliverable, say Message ID of the message,     * {@link SendStatus} indicating broker storage/replication status, message queue sent to, etc.     * @throws MQClientException if there is any client error.     * @throws RemotingException if there is any network-tier error.     * @throws MQBrokerException if there is any error with broker.     * @throws InterruptedException if the sending thread is interrupted.     */    @Override    public SendResult send(        Message msg) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {        // 检查消息有效性，如topic名称，消息体大小等        Validators.checkMessage(msg, this);        // 包装topic名称，比如添加 %RETRY%, %DLQ%, 等        msg.setTopic(withNamespace(msg.getTopic()));        // 发送消息        return this.defaultMQProducerImpl.send(msg);    }    // org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#send(org.apache.rocketmq.common.message.Message)    public SendResult send(        Message msg) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {        return send(msg, this.defaultMQProducer.getSendMsgTimeout());    }
    public SendResult send(Message msg,        long timeout) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {        return this.sendDefaultImpl(msg, CommunicationMode.SYNC, null, timeout);    }
    private SendResult sendDefaultImpl(        Message msg,        final CommunicationMode communicationMode,        final SendCallback sendCallback,        final long timeout    ) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {        // 重复检测状态        this.makeSureStateOK();        Validators.checkMessage(msg, this.defaultMQProducer);
        final long invokeID = random.nextLong();        long beginTimestampFirst = System.currentTimeMillis();        long beginTimestampPrev = beginTimestampFirst;        long endTimestamp = beginTimestampFirst;        // 找到可以发布消息的路径        TopicPublishInfo topicPublishInfo = this.tryToFindTopicPublishInfo(msg.getTopic());        if (topicPublishInfo != null && topicPublishInfo.ok()) {            boolean callTimeout = false;            MessageQueue mq = null;            Exception exception = null;            SendResult sendResult = null;            int timesTotal = communicationMode == CommunicationMode.SYNC ? 1 + this.defaultMQProducer.getRetryTimesWhenSendFailed() : 1;            int times = 0;            String[] brokersSent = new String[timesTotal];            for (; times < timesTotal; times++) {                String lastBrokerName = null == mq ? null : mq.getBrokerName();                // 选择一个 队列，客户端侧负载均衡                MessageQueue mqSelected = 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()));                        }                        long costTime = beginTimestampPrev - beginTimestampFirst;                        if (timeout < costTime) {                            callTimeout = true;                            break;                        }
                        // 发送消息                        sendResult = this.sendKernelImpl(msg, mq, communicationMode, sendCallback, topicPublishInfo, timeout - costTime);                        endTimestamp = System.currentTimeMillis();                        this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, false);                        switch (communicationMode) {                            case ASYNC:                                return null;                            case ONEWAY:                                return null;                            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());                        exception = e;                        continue;                    } catch (MQClientException 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());                        exception = e;                        continue;                    } catch (MQBrokerException 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());                        exception = e;                        switch (e.getResponseCode()) {                            case ResponseCode.TOPIC_NOT_EXIST:                            case ResponseCode.SERVICE_NOT_AVAILABLE:                            case ResponseCode.SYSTEM_ERROR:                            case ResponseCode.NO_PERMISSION:                            case ResponseCode.NO_BUYER_ID:                            case ResponseCode.NOT_IN_CURRENT_UNIT:                                continue;                            default:                                if (sendResult != null) {                                    return sendResult;                                }
                                throw e;                        }                    } catch (InterruptedException e) {                        endTimestamp = System.currentTimeMillis();                        this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, false);                        log.warn(String.format("sendKernelImpl exception, throw exception, InvokeID: %s, RT: %sms, Broker: %s", invokeID, endTimestamp - beginTimestampPrev, mq), e);                        log.warn(msg.toString());
                        log.warn("sendKernelImpl exception", e);                        log.warn(msg.toString());                        throw e;                    }                } else {                    break;                }            }
            if (sendResult != null) {                return sendResult;            }
            String info = String.format("Send [%d] times, still failed, cost [%d]ms, Topic: %s, BrokersSent: %s",                times,                System.currentTimeMillis() - beginTimestampFirst,                msg.getTopic(),                Arrays.toString(brokersSent));
            info += FAQUrl.suggestTodo(FAQUrl.SEND_MSG_FAILED);
            MQClientException mqClientException = new MQClientException(info, exception);            if (callTimeout) {                throw new RemotingTooMuchRequestException("sendDefaultImpl call timeout");            }
            if (exception instanceof MQBrokerException) {                mqClientException.setResponseCode(((MQBrokerException) exception).getResponseCode());            } else if (exception instanceof RemotingConnectException) {                mqClientException.setResponseCode(ClientErrorCode.CONNECT_BROKER_EXCEPTION);            } else if (exception instanceof RemotingTimeoutException) {                mqClientException.setResponseCode(ClientErrorCode.ACCESS_BROKER_TIMEOUT);            } else if (exception instanceof MQClientException) {                mqClientException.setResponseCode(ClientErrorCode.BROKER_NOT_EXIST_EXCEPTION);            }
            throw mqClientException;        }
        List nsList = this.getmQClientFactory().getMQClientAPIImpl().getNameServerAddressList();        if (null == nsList || nsList.isEmpty()) {            throw new MQClientException(                "No name server address, please set it." + FAQUrl.suggestTodo(FAQUrl.NAME_SERVER_ADDR_NOT_EXIST_URL), null).setResponseCode(ClientErrorCode.NO_NAME_SERVER_EXCEPTION);        }
        throw new MQClientException("No route info of this topic, " + msg.getTopic() + FAQUrl.suggestTodo(FAQUrl.NO_TOPIC_ROUTE_INFO),            null).setResponseCode(ClientErrorCode.NOT_FOUND_TOPIC_EXCEPTION);    }
    // org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#tryToFindTopicPublishInfo    private TopicPublishInfo tryToFindTopicPublishInfo(final String topic) {        TopicPublishInfo topicPublishInfo = this.topicPublishInfoTable.get(topic);        // 没有获取到 topic 信息，要么是因为确实没有，要么是因为获取到的topic信息过期了        if (null == topicPublishInfo || !topicPublishInfo.ok()) {            this.topicPublishInfoTable.putIfAbsent(topic, new TopicPublishInfo());            this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic);            topicPublishInfo = this.topicPublishInfoTable.get(topic);        }
        if (topicPublishInfo.isHaveTopicRouterInfo() || topicPublishInfo.ok()) {            return topicPublishInfo;        } else {            this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic, true, this.defaultMQProducer);            topicPublishInfo = this.topicPublishInfoTable.get(topic);            return topicPublishInfo;        }    }
    // 真实发送消息    // org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#sendKernelImpl    private SendResult sendKernelImpl(final Message msg,                                      final MessageQueue mq,                                      final CommunicationMode communicationMode,                                      final SendCallback sendCallback,                                      final TopicPublishInfo topicPublishInfo,                                      final long timeout) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {        long beginStartTime = System.currentTimeMillis();        String brokerAddr = this.mQClientFactory.findBrokerAddressInPublish(mq.getBrokerName());        if (null == brokerAddr) {            tryToFindTopicPublishInfo(mq.getTopic());            brokerAddr = this.mQClientFactory.findBrokerAddressInPublish(mq.getBrokerName());        }
        SendMessageContext context = 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                if (!(msg instanceof MessageBatch)) {                    MessageClientIDSetter.setUniqID(msg);                }
                boolean topicWithNamespace = false;                if (null != this.mQClientFactory.getClientConfig().getNamespace()) {                    msg.setInstanceId(this.mQClientFactory.getClientConfig().getNamespace());                    topicWithNamespace = true;                }
                int sysFlag = 0;                boolean msgBodyCompressed = false;                // 压缩数据                if (this.tryToCompressMessage(msg)) {                    sysFlag |= MessageSysFlag.COMPRESSED_FLAG;                    msgBodyCompressed = true;                }
                final String tranMsg = msg.getProperty(MessageConst.PROPERTY_TRANSACTION_PREPARED);                if (tranMsg != null && Boolean.parseBoolean(tranMsg)) {                    sysFlag |= MessageSysFlag.TRANSACTION_PREPARED_TYPE;                }
                // 存在禁止提交钩子                if (hasCheckForbiddenHook()) {                    CheckForbiddenContext checkForbiddenContext = new CheckForbiddenContext();                    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());                    this.executeCheckForbiddenHook(checkForbiddenContext);                }
                // 存在发送消息钩子                if (this.hasSendMessageHook()) {                    context = new SendMessageContext();                    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());                    String isTrans = 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);                }
                SendMessageRequestHeader requestHeader = new SendMessageRequestHeader();                requestHeader.setProducerGroup(this.defaultMQProducer.getProducerGroup());                requestHeader.setTopic(msg.getTopic());                requestHeader.setDefaultTopic(this.defaultMQProducer.getCreateTopicKey());                requestHeader.setDefaultTopicQueueNums(this.defaultMQProducer.getDefaultTopicQueueNums());                requestHeader.setQueueId(mq.getQueueId());                requestHeader.setSysFlag(sysFlag);                requestHeader.setBornTimestamp(System.currentTimeMillis());                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)) {                    String reconsumeTimes = MessageAccessor.getReconsumeTime(msg);                    if (reconsumeTimes != null) {                        requestHeader.setReconsumeTimes(Integer.valueOf(reconsumeTimes));                        MessageAccessor.clearProperty(msg, MessageConst.PROPERTY_RECONSUME_TIME);                    }
                    String maxReconsumeTimes = MessageAccessor.getMaxReconsumeTimes(msg);                    if (maxReconsumeTimes != null) {                        requestHeader.setMaxReconsumeTimes(Integer.valueOf(maxReconsumeTimes));                        MessageAccessor.clearProperty(msg, MessageConst.PROPERTY_MAX_RECONSUME_TIMES);                    }                }
                SendResult sendResult = null;                switch (communicationMode) {                    case ASYNC:                        Message tmpMessage = msg;                        boolean messageCloned = 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()));                        }
                        long costTimeAsync = System.currentTimeMillis() - beginStartTime;                        if (timeout < costTimeAsync) {                            throw new RemotingTooMuchRequestException("sendKernelImpl call timeout");                        }                        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:                        // 同步发送消息                        long costTimeSync = System.currentTimeMillis() - beginStartTime;                        if (timeout < costTimeSync) {                            throw new RemotingTooMuchRequestException("sendKernelImpl call timeout");                        }                        sendResult = this.mQClientFactory.getMQClientAPIImpl().sendMessage(                            brokerAddr,                            mq.getBrokerName(),                            msg,                            requestHeader,                            timeout - costTimeSync,                            communicationMode,                            context,                            this);                        break;                    default:                        assert false;                        break;                }
                if (this.hasSendMessageHook()) {                    context.setSendResult(sendResult);                    this.executeSendMessageHookAfter(context);                }
                return sendResult;            } catch (RemotingException e) {                if (this.hasSendMessageHook()) {                    context.setException(e);                    this.executeSendMessageHookAfter(context);                }                throw e;            } catch (MQBrokerException e) {                if (this.hasSendMessageHook()) {                    context.setException(e);                    this.executeSendMessageHookAfter(context);                }                throw e;            } catch (InterruptedException e) {                if (this.hasSendMessageHook()) {                    context.setException(e);                    this.executeSendMessageHookAfter(context);                }                throw e;            } finally {                msg.setBody(prevBody);                msg.setTopic(NamespaceUtil.withoutNamespace(msg.getTopic(), this.defaultMQProducer.getNamespace()));            }        }
        throw new MQClientException("The broker[" + mq.getBrokerName() + "] not exist", null);    }

// org.apache.rocketmq.client.impl.MQClientAPIImpl#sendMessage    public SendResult sendMessage(        final String addr,        final String brokerName,        final Message msg,        final SendMessageRequestHeader requestHeader,        final long timeoutMillis,        final CommunicationMode communicationMode,        final SendMessageContext context,        final DefaultMQProducerImpl producer    ) throws RemotingException, MQBrokerException, InterruptedException {        return sendMessage(addr, brokerName, msg, requestHeader, timeoutMillis, communicationMode, null, null, null, 0, context, producer);    }
    public SendResult sendMessage(            final String addr,            final String brokerName,            final Message msg,            final SendMessageRequestHeader requestHeader,            final long timeoutMillis,            final CommunicationMode communicationMode,            final SendCallback sendCallback,            final TopicPublishInfo topicPublishInfo,            final MQClientInstance instance,            final int retryTimesWhenSendFailed,            final SendMessageContext context,            final DefaultMQProducerImpl producer    ) throws RemotingException, MQBrokerException, InterruptedException {        long beginStartTime = System.currentTimeMillis();        RemotingCommand request = null;        if (sendSmartMsg || msg instanceof MessageBatch) {            SendMessageRequestHeaderV2 requestHeaderV2 = 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:                this.remotingClient.invokeOneway(addr, request, timeoutMillis);                return null;            case ASYNC:                final AtomicInteger times = new AtomicInteger();                long costTimeAsync = System.currentTimeMillis() - beginStartTime;                if (timeoutMillis < costTimeAsync) {                    throw new RemotingTooMuchRequestException("sendMessage call timeout");                }                this.sendMessageAsync(addr, brokerName, msg, timeoutMillis - costTimeAsync, request, sendCallback, topicPublishInfo, instance,                        retryTimesWhenSendFailed, times, context, producer);                return null;            case SYNC:                long costTimeSync = System.currentTimeMillis() - beginStartTime;                if (timeoutMillis < costTimeSync) {                    throw new RemotingTooMuchRequestException("sendMessage call timeout");                }                return this.sendMessageSync(addr, brokerName, msg, timeoutMillis - costTimeSync, request);            default:                assert false;                break;        }
        return null;    }
    // org.apache.rocketmq.client.impl.MQClientAPIImpl#sendMessageSync    private SendResult sendMessageSync(        final String addr,        final String brokerName,        final Message msg,        final long timeoutMillis,        final RemotingCommand request    ) throws RemotingException, MQBrokerException, InterruptedException {        RemotingCommand response = this.remotingClient.invokeSync(addr, request, timeoutMillis);        assert response != null;        return this.processSendResponse(brokerName, msg, response);    }
    // 封装基于 netty 的远程调用    // org.apache.rocketmq.remoting.netty.NettyRemotingClient#invokeSync    @Override    public RemotingCommand invokeSync(String addr, final RemotingCommand request, long timeoutMillis)        throws InterruptedException, RemotingConnectException, RemotingSendRequestException, RemotingTimeoutException {        long beginStartTime = System.currentTimeMillis();        final Channel channel = this.getAndCreateChannel(addr);        if (channel != null && channel.isActive()) {            try {                doBeforeRpcHooks(addr, request);                long costTime = System.currentTimeMillis() - beginStartTime;                if (timeoutMillis < costTime) {                    throw new RemotingTimeoutException("invokeSync call timeout");                }                RemotingCommand response = this.invokeSyncImpl(channel, request, timeoutMillis - costTime);                doAfterRpcHooks(RemotingHelper.parseChannelRemoteAddr(channel), request, response);                return response;            } catch (RemotingSendRequestException e) {                log.warn("invokeSync: send request exception, so close the channel[{}]", addr);                this.closeChannel(addr, channel);                throw e;            } catch (RemotingTimeoutException e) {                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);            throw new RemotingConnectException(addr);        }    }    // 带超时的同步调用    public RemotingCommand invokeSyncImpl(final Channel channel, final RemotingCommand request,        final long timeoutMillis)        throws InterruptedException, RemotingSendRequestException, RemotingTimeoutException {        final int opaque = request.getOpaque();
        try {            final ResponseFuture responseFuture = new ResponseFuture(channel, opaque, timeoutMillis, null, null);            this.responseTable.put(opaque, responseFuture);            final SocketAddress addr = channel.remoteAddress();            // 基于netty的连接写数据，长连接            channel.writeAndFlush(request).addListener(new ChannelFutureListener() {                @Override                public void operationComplete(ChannelFuture f) throws Exception {                    if (f.isSuccess()) {                        responseFuture.setSendRequestOK(true);                        return;                    } else {                        responseFuture.setSendRequestOK(false);                    }
                    responseTable.remove(opaque);                    responseFuture.setCause(f.cause());                    responseFuture.putResponse(null);                    log.warn("send a request command to channel <" + addr + "> failed.");                }            });
            RemotingCommand responseCommand = responseFuture.waitResponse(timeoutMillis);            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);        }    }
    // 包装服务端返回值    // org.apache.rocketmq.client.impl.MQClientAPIImpl#processSendResponse    private SendResult processSendResponse(        final String brokerName,        final Message msg,        final RemotingCommand response    ) throws MQBrokerException, RemotingCommandException {        switch (response.getCode()) {            case ResponseCode.FLUSH_DISK_TIMEOUT:            case ResponseCode.FLUSH_SLAVE_TIMEOUT:            case ResponseCode.SLAVE_NOT_AVAILABLE: {            }            case ResponseCode.SUCCESS: {                SendStatus sendStatus = SendStatus.SEND_OK;                switch (response.getCode()) {                    case ResponseCode.FLUSH_DISK_TIMEOUT:                        sendStatus = SendStatus.FLUSH_DISK_TIMEOUT;                        break;                    case ResponseCode.FLUSH_SLAVE_TIMEOUT:                        sendStatus = SendStatus.FLUSH_SLAVE_TIMEOUT;                        break;                    case ResponseCode.SLAVE_NOT_AVAILABLE:                        sendStatus = SendStatus.SLAVE_NOT_AVAILABLE;                        break;                    case ResponseCode.SUCCESS:                        sendStatus = SendStatus.SEND_OK;                        break;                    default:                        assert false;                        break;                }
                SendMessageResponseHeader responseHeader =                    (SendMessageResponseHeader) response.decodeCommandCustomHeader(SendMessageResponseHeader.class);
                //If namespace not null , reset Topic without namespace.                String topic = msg.getTopic();                if (StringUtils.isNotEmpty(this.clientConfig.getNamespace())) {                    topic = NamespaceUtil.withoutNamespace(topic, this.clientConfig.getNamespace());                }
                MessageQueue messageQueue = new MessageQueue(topic, brokerName, responseHeader.getQueueId());
                String uniqMsgId = MessageClientIDSetter.getUniqID(msg);                if (msg instanceof MessageBatch) {                    StringBuilder sb = new StringBuilder();                    for (Message message : (MessageBatch) msg) {                        sb.append(sb.length() == 0 ? "" : ",").append(MessageClientIDSetter.getUniqID(message));                    }                    uniqMsgId = sb.toString();                }                SendResult sendResult = new SendResult(sendStatus,                    uniqMsgId,                    responseHeader.getMsgId(), messageQueue, responseHeader.getQueueOffset());                sendResult.setTransactionId(responseHeader.getTransactionId());                String regionId = response.getExtFields().get(MessageConst.PROPERTY_MSG_REGION);                String traceOn = response.getExtFields().get(MessageConst.PROPERTY_TRACE_SWITCH);                if (regionId == null || regionId.isEmpty()) {                    regionId = MixAll.DEFAULT_TRACE_REGION_ID;                }                if (traceOn != null && traceOn.equals("false")) {                    sendResult.setTraceOn(false);                } else {                    sendResult.setTraceOn(true);                }                sendResult.setRegionId(regionId);                return sendResult;            }            default:                break;        }
        throw new MQBrokerException(response.getCode(), response.getRemark());    }

  // org.apache.rocketmq.client.impl.factory.MQClientInstance#updateTopicRouteInfoFromNameServer(java.lang.String)    public boolean updateTopicRouteInfoFromNameServer(final String topic) {        return updateTopicRouteInfoFromNameServer(topic, false, null);    }    // 线程安全地更新topic的路由信息    public boolean updateTopicRouteInfoFromNameServer(final String topic, boolean isDefault,        DefaultMQProducer defaultMQProducer) {        try {            if (this.lockNamesrv.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) {                try {                    TopicRouteData topicRouteData;                    if (isDefault && defaultMQProducer != null) {                        topicRouteData = this.mQClientAPIImpl.getDefaultTopicRouteInfoFromNameServer(defaultMQProducer.getCreateTopicKey(),                            1000 * 3);                        if (topicRouteData != null) {                            for (QueueData data : topicRouteData.getQueueDatas()) {                                int queueNums = Math.min(defaultMQProducer.getDefaultTopicQueueNums(), data.getReadQueueNums());                                data.setReadQueueNums(queueNums);                                data.setWriteQueueNums(queueNums);                            }                        }                    } else {                        // 从 nameServer 获取topic信息                        topicRouteData = this.mQClientAPIImpl.getTopicRouteInfoFromNameServer(topic, 1000 * 3);                    }                    if (topicRouteData != null) {                        TopicRouteData old = this.topicRouteTable.get(topic);                        // 比较topic是否发生变化                        boolean changed = topicRouteDataIsChange(old, topicRouteData);                        if (!changed) {                            changed = this.isNeedUpdateTopicRouteInfo(topic);                        } else {                            log.info("the topic[{}] route info changed, old[{}] ,new[{}]", topic, old, topicRouteData);                        }
                        if (changed) {                            TopicRouteData cloneTopicRouteData = topicRouteData.cloneTopicRouteData();
                            for (BrokerData bd : topicRouteData.getBrokerDatas()) {                                this.brokerAddrTable.put(bd.getBrokerName(), bd.getBrokerAddrs());                            }
                            // Update Pub info                            {                                // 将获取到 topicRouteData 转换为 publishInfo 发布路由信息，更新                                TopicPublishInfo publishInfo = topicRouteData2TopicPublishInfo(topic, topicRouteData);                                publishInfo.setHaveTopicRouterInfo(true);                                Iterator> it = this.producerTable.entrySet().iterator();                                while (it.hasNext()) {                                    Entry entry = it.next();                                    MQProducerInner impl = entry.getValue();                                    if (impl != null) {                                        impl.updateTopicPublishInfo(topic, publishInfo);                                    }                                }                            }
                            // Update sub info                            {                                // 将获取到 topicRouteData 转换为 subscribeInfo 订阅路由信息，更新                                Set subscribeInfo = topicRouteData2TopicSubscribeInfo(topic, topicRouteData);                                Iterator> it = this.consumerTable.entrySet().iterator();                                while (it.hasNext()) {                                    Entry entry = it.next();                                    MQConsumerInner impl = entry.getValue();                                    if (impl != null) {                                        impl.updateTopicSubscribeInfo(topic, subscribeInfo);                                    }                                }                            }                            log.info("topicRouteTable.put. Topic = {}, TopicRouteData[{}]", topic, cloneTopicRouteData);                            this.topicRouteTable.put(topic, cloneTopicRouteData);                            return true;                        }                    } else {                        log.warn("updateTopicRouteInfoFromNameServer, getTopicRouteInfoFromNameServer return null, Topic: {}", topic);                    }                } catch (Exception e) {                    if (!topic.startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX) && !topic.equals(MixAll.AUTO_CREATE_TOPIC_KEY_TOPIC)) {                        log.warn("updateTopicRouteInfoFromNameServer Exception", e);                    }                } finally {                    this.lockNamesrv.unlock();                }            } else {                log.warn("updateTopicRouteInfoFromNameServer tryLock timeout {}ms", LOCK_TIMEOUT_MILLIS);            }        } catch (InterruptedException e) {            log.warn("updateTopicRouteInfoFromNameServer Exception", e);        }
        return false;    }

// org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#selectOneMessageQueue    public MessageQueue selectOneMessageQueue(final TopicPublishInfo tpInfo, final String lastBrokerName) {        return this.mqFaultStrategy.selectOneMessageQueue(tpInfo, lastBrokerName);    }    // org.apache.rocketmq.client.latency.MQFaultStrategy#selectOneMessageQueue    public MessageQueue selectOneMessageQueue(final TopicPublishInfo tpInfo, final String lastBrokerName) {        if (this.sendLatencyFaultEnable) {            try {                // 支持容错时                int index = tpInfo.getSendWhichQueue().getAndIncrement();                for (int i = 0; i < tpInfo.getMessageQueueList().size(); i++) {                    int pos = Math.abs(index++) % tpInfo.getMessageQueueList().size();                    if (pos < 0)                        pos = 0;                    MessageQueue mq = tpInfo.getMessageQueueList().get(pos);                    if (latencyFaultTolerance.isAvailable(mq.getBrokerName())) {                        if (null == lastBrokerName || mq.getBrokerName().equals(lastBrokerName))                            return mq;                    }                }
                final String notBestBroker = latencyFaultTolerance.pickOneAtLeast();                int writeQueueNums = tpInfo.getQueueIdByBroker(notBestBroker);                if (writeQueueNums > 0) {                    final MessageQueue mq = tpInfo.selectOneMessageQueue();                    if (notBestBroker != null) {                        mq.setBrokerName(notBestBroker);                        mq.setQueueId(tpInfo.getSendWhichQueue().getAndIncrement() % writeQueueNums);                    }                    return mq;                } else {                    latencyFaultTolerance.remove(notBestBroker);                }            } catch (Exception e) {                log.error("Error occurred when selecting message queue", e);            }
            // 没有找到合适的 队列， 默认轮询选择一个就好            return tpInfo.selectOneMessageQueue();        }
        return tpInfo.selectOneMessageQueue(lastBrokerName);    }    // org.apache.rocketmq.client.impl.producer.TopicPublishInfo#selectOneMessageQueue    public MessageQueue selectOneMessageQueue(final String lastBrokerName) {        if (lastBrokerName == null) {            return selectOneMessageQueue();        } else {            int index = this.sendWhichQueue.getAndIncrement();            for (int i = 0; i < this.messageQueueList.size(); i++) {                // 轮询式选择队列                int pos = Math.abs(index++) % this.messageQueueList.size();                if (pos < 0)                    pos = 0;                MessageQueue mq = this.messageQueueList.get(pos);                // 找到第一次不一样的进行发送                if (!mq.getBrokerName().equals(lastBrokerName)) {                    return mq;                }            }            // 如果没有找到，比如只有一队列的情况，只能重新选择了            return selectOneMessageQueue();        }    }    // 重新选择一个队列进行发送时，就直接求余就好，不判断    public MessageQueue selectOneMessageQueue() {        int index = this.sendWhichQueue.getAndIncrement();        int pos = Math.abs(index) % this.messageQueueList.size();        if (pos < 0)            pos = 0;        return this.messageQueueList.get(pos);    }

 // org.apache.rocketmq.client.impl.factory.MQClientInstance#findBrokerAddressInPublish    public String findBrokerAddressInPublish(final String brokerName) {        // 直接从 brokerAddrTable 中根据 brokerName 查找，然后返回 master 地址即可        HashMap map = this.brokerAddrTable.get(brokerName);        if (map != null && !map.isEmpty()) {            return map.get(MixAll.MASTER_ID);        }        // 如果没有找到，说明需要进行broker更新，或者就是一个不存在的broker        return null;    }    // 更新topic的路由信息    // org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#tryToFindTopicPublishInfo    private TopicPublishInfo tryToFindTopicPublishInfo(final String topic) {        TopicPublishInfo topicPublishInfo = this.topicPublishInfoTable.get(topic);        if (null == topicPublishInfo || !topicPublishInfo.ok()) {            this.topicPublishInfoTable.putIfAbsent(topic, new TopicPublishInfo());            this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic);            topicPublishInfo = this.topicPublishInfoTable.get(topic);        }
        if (topicPublishInfo.isHaveTopicRouterInfo() || topicPublishInfo.ok()) {            return topicPublishInfo;        } else {            // 从 nameServer 更新broker路由信息            this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic, true, this.defaultMQProducer);            topicPublishInfo = this.topicPublishInfoTable.get(topic);            return topicPublishInfo;        }    }    // 从nameServer中获取路由信息, 通过发送 GET_ROUTEINTO_BY_TOPIC 命令    // org.apache.rocketmq.client.impl.MQClientAPIImpl#getTopicRouteInfoFromNameServer    public TopicRouteData getTopicRouteInfoFromNameServer(final String topic, final long timeoutMillis,        boolean allowTopicNotExist) throws MQClientException, InterruptedException, RemotingTimeoutException, RemotingSendRequestException, RemotingConnectException {        GetRouteInfoRequestHeader requestHeader = new GetRouteInfoRequestHeader();        requestHeader.setTopic(topic);
        RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.GET_ROUTEINTO_BY_TOPIC, requestHeader);
        RemotingCommand response = this.remotingClient.invokeSync(null, request, timeoutMillis);        assert response != null;        switch (response.getCode()) {            case ResponseCode.TOPIC_NOT_EXIST: {                if (allowTopicNotExist && !topic.equals(MixAll.AUTO_CREATE_TOPIC_KEY_TOPIC)) {                    log.warn("get Topic [{}] RouteInfoFromNameServer is not exist value", topic);                }
                break;            }            case ResponseCode.SUCCESS: {                byte[] body = response.getBody();                if (body != null) {                    return TopicRouteData.decode(body, TopicRouteData.class);                }            }            default:                break;        }
        throw new MQClientException(response.getCode(), response.getRemark());    }

 // 默认的消费方式，只指定 producerGroup, 其他参数都为空    // org.apache.rocketmq.client.producer.DefaultMQProducer    /**     * Constructor specifying namespace, producer group and RPC hook.     *     * @param namespace Namespace for this MQ Producer instance.     * @param producerGroup Producer group, see the name-sake field.     * @param rpcHook RPC hook to execute per each remoting command execution.     */    public DefaultMQProducer(final String namespace, final String producerGroup, RPCHook rpcHook) {        this.namespace = namespace;        this.producerGroup = producerGroup;        defaultMQProducerImpl = new DefaultMQProducerImpl(this, rpcHook);    }    // 默认的 start 方法，也仅是开户 defaultMQProducerImpl 的必备属性    /**     * Start this producer instance.     * 
     *     *      * Much internal initializing procedures are carried out to make this instance prepared, thus, it's a must to invoke     * this method before sending or querying messages.     *      * 
     *     * @throws MQClientException if there is any unexpected error.     */    @Override    public void start() throws MQClientException {        this.setProducerGroup(withNamespace(this.producerGroup));        this.defaultMQProducerImpl.start();        if (null != traceDispatcher) {            try {                traceDispatcher.start(this.getNamesrvAddr(), this.getAccessChannel());            } catch (MQClientException e) {                log.warn("trace dispatcher start failed ", e);            }        }    }    // org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#start    public void start() throws MQClientException {        this.start(true);    }    // start 过程由 serviceState 来控制生命周期    public void start(final boolean startFactory) throws MQClientException {        switch (this.serviceState) {            case CREATE_JUST:                this.serviceState = ServiceState.START_FAILED;                // 检查配置项，实际只是检查 producerGroup 名字而已                this.checkConfig();                // CLIENT_INNER_PRODUCER                if (!this.defaultMQProducer.getProducerGroup().equals(MixAll.CLIENT_INNER_PRODUCER_GROUP)) {                    this.defaultMQProducer.changeInstanceNameToPID();                }                // 创建 mQClientFactory                this.mQClientFactory = MQClientManager.getInstance().getAndCreateMQClientInstance(this.defaultMQProducer, rpcHook);
                // 注册producer到 mQClientFactory 中                boolean registerOK = mQClientFactory.registerProducer(this.defaultMQProducer.getProducerGroup(), this);                if (!registerOK) {                    this.serviceState = ServiceState.CREATE_JUST;                    throw new MQClientException("The producer group[" + this.defaultMQProducer.getProducerGroup()                        + "] has been created before, specify another name please." + FAQUrl.suggestTodo(FAQUrl.GROUP_NAME_DUPLICATE_URL),                        null);                }
                this.topicPublishInfoTable.put(this.defaultMQProducer.getCreateTopicKey(), new TopicPublishInfo());
                if (startFactory) {                    // 开启 client 服务                    mQClientFactory.start();                }
                log.info("the producer [{}] start OK. sendMessageWithVIPChannel={}", this.defaultMQProducer.getProducerGroup(),                    this.defaultMQProducer.isSendMessageWithVIPChannel());                this.serviceState = ServiceState.RUNNING;                break;            case RUNNING:            case START_FAILED:            case SHUTDOWN_ALREADY:                throw new MQClientException("The producer service state not OK, maybe started once, "                    + this.serviceState                    + FAQUrl.suggestTodo(FAQUrl.CLIENT_SERVICE_NOT_OK),                    null);            default:                break;        }        // 环境准备好后，给所有 broker 发送心跳，可以确保所有连接正常        this.mQClientFactory.sendHeartbeatToAllBrokerWithLock();    }    // org.apache.rocketmq.client.impl.factory.MQClientInstance#start    public void start() throws MQClientException {
        synchronized (this) {            switch (this.serviceState) {                case CREATE_JUST:                    this.serviceState = ServiceState.START_FAILED;                    // If not specified,looking address from name server                    if (null == this.clientConfig.getNamesrvAddr()) {                        this.mQClientAPIImpl.fetchNameServerAddr();                    }                    // Start request-response channel                    this.mQClientAPIImpl.start();                    // Start various schedule tasks                    this.startScheduledTask();                    // Start pull service                    this.pullMessageService.start();                    // Start rebalance service                    this.rebalanceService.start();                    // Start push service                    this.defaultMQProducer.getDefaultMQProducerImpl().start(false);                    log.info("the client factory [{}] start OK", this.clientId);                    this.serviceState = ServiceState.RUNNING;                    break;                case RUNNING:                    break;                case SHUTDOWN_ALREADY:                    break;                case START_FAILED:                    throw new MQClientException("The Factory object[" + this.getClientId() + "] has been created before, and failed.", null);                default:                    break;            }        }    }

// org.apache.rocketmq.client.impl.MQClientManager#getAndCreateMQClientInstance    public MQClientInstance getAndCreateMQClientInstance(final ClientConfig clientConfig, RPCHook rpcHook) {        // like as 192.168.1.2@177676        String clientId = clientConfig.buildMQClientId();        MQClientInstance instance = this.factoryTable.get(clientId);        if (null == instance) {            // MQClientInstance 是个重要的实例，后续将由它进行实际的网络连接、负载均衡等操作            // 这个类 会在 各种 producer/consumer 中得到重用            instance =                new MQClientInstance(clientConfig.cloneClientConfig(),                    this.factoryIndexGenerator.getAndIncrement(), clientId, rpcHook);            MQClientInstance prev = this.factoryTable.putIfAbsent(clientId, instance);            if (prev != null) {                instance = prev;                log.warn("Returned Previous MQClientInstance for clientId:[{}]", clientId);            } else {                log.info("Created new MQClientInstance for clientId:[{}]", clientId);            }        }
        return instance;    }    // org.apache.rocketmq.client.impl.factory.MQClientInstance    public MQClientInstance(ClientConfig clientConfig, int instanceIndex, String clientId, RPCHook rpcHook) {        this.clientConfig = clientConfig;        this.instanceIndex = instanceIndex;        this.nettyClientConfig = new NettyClientConfig();        this.nettyClientConfig.setClientCallbackExecutorThreads(clientConfig.getClientCallbackExecutorThreads());        this.nettyClientConfig.setUseTLS(clientConfig.isUseTLS());        this.clientRemotingProcessor = new ClientRemotingProcessor(this);        // api调用实例        this.mQClientAPIImpl = new MQClientAPIImpl(this.nettyClientConfig, this.clientRemotingProcessor, rpcHook, clientConfig);
        if (this.clientConfig.getNamesrvAddr() != null) {            this.mQClientAPIImpl.updateNameServerAddressList(this.clientConfig.getNamesrvAddr());            log.info("user specified name server address: {}", this.clientConfig.getNamesrvAddr());        }
        this.clientId = clientId;
        // 管理类操作服务        this.mQAdminImpl = new MQAdminImpl(this);        // pull模式消费服务，由 pullRequestQueue LinkedBlockingQueue 进行消息传递        this.pullMessageService = new PullMessageService(this);        // 负载均衡管理服务，默认会20s做一次再平衡状态的检测        this.rebalanceService = new RebalanceService(this);        // 系统的生产者        this.defaultMQProducer = new DefaultMQProducer(MixAll.CLIENT_INNER_PRODUCER_GROUP);        this.defaultMQProducer.resetClientConfig(clientConfig);        // 消费状态统计，如 tps, rt        this.consumerStatsManager = new ConsumerStatsManager(this.scheduledExecutorService);
        log.info("Created a new client Instance, InstanceIndex:{}, ClientID:{}, ClientConfig:{}, ClientVersion:{}, SerializerType:{}",            this.instanceIndex,            this.clientId,            this.clientConfig,            MQVersion.getVersionDesc(MQVersion.CURRENT_VERSION), RemotingCommand.getSerializeTypeConfigInThisServer());    }
    // 远程连接管理    // org.apache.rocketmq.client.impl.MQClientAPIImpl#MQClientAPIImpl    public MQClientAPIImpl(final NettyClientConfig nettyClientConfig,        final ClientRemotingProcessor clientRemotingProcessor,        RPCHook rpcHook, final ClientConfig clientConfig) {        this.clientConfig = clientConfig;        topAddressing = new TopAddressing(MixAll.getWSAddr(), clientConfig.getUnitName());        this.remotingClient = new NettyRemotingClient(nettyClientConfig, null);        this.clientRemotingProcessor = clientRemotingProcessor;
        this.remotingClient.registerRPCHook(rpcHook);        this.remotingClient.registerProcessor(RequestCode.CHECK_TRANSACTION_STATE, this.clientRemotingProcessor, null);
        this.remotingClient.registerProcessor(RequestCode.NOTIFY_CONSUMER_IDS_CHANGED, this.clientRemotingProcessor, null);
        this.remotingClient.registerProcessor(RequestCode.RESET_CONSUMER_CLIENT_OFFSET, this.clientRemotingProcessor, null);
        this.remotingClient.registerProcessor(RequestCode.GET_CONSUMER_STATUS_FROM_CLIENT, this.clientRemotingProcessor, null);
        this.remotingClient.registerProcessor(RequestCode.GET_CONSUMER_RUNNING_INFO, this.clientRemotingProcessor, null);
        this.remotingClient.registerProcessor(RequestCode.CONSUME_MESSAGE_DIRECTLY, this.clientRemotingProcessor, null);    }
    // 此处并没有与远程建立连接，只是创造了一些环境，包括后续的 start() 方法，仍然没有打开连接    // org.apache.rocketmq.remoting.netty.NettyRemotingClient#NettyRemotingClient    public NettyRemotingClient(final NettyClientConfig nettyClientConfig,        final ChannelEventListener channelEventListener) {        super(nettyClientConfig.getClientOnewaySemaphoreValue(), nettyClientConfig.getClientAsyncSemaphoreValue());        this.nettyClientConfig = nettyClientConfig;        this.channelEventListener = channelEventListener;
        int publicThreadNums = nettyClientConfig.getClientCallbackExecutorThreads();        if (publicThreadNums <= 0) {            publicThreadNums = 4;        }
        this.publicExecutor = Executors.newFixedThreadPool(publicThreadNums, new ThreadFactory() {            private AtomicInteger threadIndex = new AtomicInteger(0);
            @Override            public Thread newThread(Runnable r) {                return new Thread(r, "NettyClientPublicExecutor_" + this.threadIndex.incrementAndGet());            }        });
        this.eventLoopGroupWorker = new NioEventLoopGroup(1, new ThreadFactory() {            private AtomicInteger threadIndex = new AtomicInteger(0);
            @Override            public Thread newThread(Runnable r) {                return new Thread(r, String.format("NettyClientSelector_%d", this.threadIndex.incrementAndGet()));            }        });
        if (nettyClientConfig.isUseTLS()) {            try {                sslContext = TlsHelper.buildSslContext(true);                log.info("SSL enabled for client");            } catch (IOException e) {                log.error("Failed to create SSLContext", e);            } catch (CertificateException e) {                log.error("Failed to create SSLContext", e);                throw new RuntimeException("Failed to create SSLContext", e);            }        }    }    // org.apache.rocketmq.remoting.netty.NettyRemotingClient#start    @Override    public void start() {        this.defaultEventExecutorGroup = new DefaultEventExecutorGroup(            nettyClientConfig.getClientWorkerThreads(),            new ThreadFactory() {
                private AtomicInteger threadIndex = new AtomicInteger(0);
                @Override                public Thread newThread(Runnable r) {                    return new Thread(r, "NettyClientWorkerThread_" + this.threadIndex.incrementAndGet());                }            });
        // 此处仅绑定一些连接选项及注册 handler, 真实使用是在 createChannel 时使用        Bootstrap handler = this.bootstrap.group(this.eventLoopGroupWorker).channel(NioSocketChannel.class)            .option(ChannelOption.TCP_NODELAY, true)            .option(ChannelOption.SO_KEEPALIVE, false)            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, nettyClientConfig.getConnectTimeoutMillis())            .option(ChannelOption.SO_SNDBUF, nettyClientConfig.getClientSocketSndBufSize())            .option(ChannelOption.SO_RCVBUF, nettyClientConfig.getClientSocketRcvBufSize())            .handler(new ChannelInitializer() {                @Override                public void initChannel(SocketChannel ch) throws Exception {                    ChannelPipeline pipeline = ch.pipeline();                    if (nettyClientConfig.isUseTLS()) {                        if (null != sslContext) {                            pipeline.addFirst(defaultEventExecutorGroup, "sslHandler", sslContext.newHandler(ch.alloc()));                            log.info("Prepend SSL handler");                        } else {                            log.warn("Connections are insecure as SSLContext is null!");                        }                    }                    pipeline.addLast(                        defaultEventExecutorGroup,                        new NettyEncoder(),                        new NettyDecoder(),                        new IdleStateHandler(0, 0, nettyClientConfig.getClientChannelMaxIdleTimeSeconds()),                        new NettyConnectManageHandler(),                        new NettyClientHandler());                }            });
        this.timer.scheduleAtFixedRate(new TimerTask() {            @Override            public void run() {                try {                    NettyRemotingClient.this.scanResponseTable();                } catch (Throwable e) {                    log.error("scanResponseTable exception", e);                }            }        }, 1000 * 3, 1000);
        if (this.channelEventListener != null) {            this.nettyEventExecutor.start();        }    }
    // 真正的远程连接会在进行发送消息时进行创建，且会使用一个 ConcurrentHashMap 进行缓存    // org.apache.rocketmq.remoting.netty.NettyRemotingClient#getAndCreateChannel    private Channel getAndCreateChannel(final String addr) throws InterruptedException {        if (null == addr) {            return getAndCreateNameserverChannel();        }
        ChannelWrapper cw = this.channelTables.get(addr);        if (cw != null && cw.isOK()) {            return cw.getChannel();        }
        return this.createChannel(addr);    }    private Channel createChannel(final String addr) throws InterruptedException {        ChannelWrapper cw = this.channelTables.get(addr);        if (cw != null && cw.isOK()) {            cw.getChannel().close();            channelTables.remove(addr);        }
        if (this.lockChannelTables.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) {            try {                boolean createNewConnection;                cw = this.channelTables.get(addr);                if (cw != null) {
                    if (cw.isOK()) {                        cw.getChannel().close();                        this.channelTables.remove(addr);                        createNewConnection = true;                    } else if (!cw.getChannelFuture().isDone()) {                        createNewConnection = false;                    } else {                        this.channelTables.remove(addr);                        createNewConnection = true;                    }                } else {                    createNewConnection = true;                }
                if (createNewConnection) {                    ChannelFuture channelFuture = this.bootstrap.connect(RemotingHelper.string2SocketAddress(addr));                    log.info("createChannel: begin to connect remote host[{}] asynchronously", addr);                    cw = new ChannelWrapper(channelFuture);                    this.channelTables.put(addr, cw);                }            } catch (Exception e) {                log.error("createChannel: create channel exception", e);            } finally {                this.lockChannelTables.unlock();            }        } else {            log.warn("createChannel: try to lock channel table, but timeout, {}ms", LOCK_TIMEOUT_MILLIS);        }
        if (cw != null) {            ChannelFuture channelFuture = cw.getChannelFuture();            if (channelFuture.awaitUninterruptibly(this.nettyClientConfig.getConnectTimeoutMillis())) {                if (cw.isOK()) {                    log.info("createChannel: connect remote host[{}] success, {}", addr, channelFuture.toString());                    return cw.getChannel();                } else {                    log.warn("createChannel: connect remote host[" + addr + "] failed, " + channelFuture.toString(), channelFuture.cause());                }            } else {                log.warn("createChannel: connect remote host[{}] timeout {}ms, {}", addr, this.nettyClientConfig.getConnectTimeoutMillis(),                    channelFuture.toString());            }        }
        return null;    }
    // 开启的线程服务还有很多种，我们来看一下    // org.apache.rocketmq.client.impl.factory.MQClientInstance#startScheduledTask    private void startScheduledTask() {        if (null == this.clientConfig.getNamesrvAddr()) {            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override                public void run() {                    try {                        MQClientInstance.this.mQClientAPIImpl.fetchNameServerAddr();                    } catch (Exception e) {                        log.error("ScheduledTask fetchNameServerAddr exception", e);                    }                }            }, 1000 * 10, 1000 * 60 * 2, TimeUnit.MILLISECONDS);        }
        // 刷新路由信息服务，默认30s 间隔        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override            public void run() {                try {                    MQClientInstance.this.updateTopicRouteInfoFromNameServer();                } catch (Exception e) {                    log.error("ScheduledTask updateTopicRouteInfoFromNameServer exception", e);                }            }        }, 10, this.clientConfig.getPollNameServerInterval(), TimeUnit.MILLISECONDS);
        // 心路线程，默认30s 间隔        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override            public void run() {                try {                    MQClientInstance.this.cleanOfflineBroker();                    MQClientInstance.this.sendHeartbeatToAllBrokerWithLock();                } catch (Exception e) {                    log.error("ScheduledTask sendHeartbeatToAllBroker exception", e);                }            }        }, 1000, this.clientConfig.getHeartbeatBrokerInterval(), TimeUnit.MILLISECONDS);        // 提交消费偏移信息，默认5s 间隔        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override            public void run() {                try {                    MQClientInstance.this.persistAllConsumerOffset();                } catch (Exception e) {                    log.error("ScheduledTask persistAllConsumerOffset exception", e);                }            }        }, 1000 * 10, this.clientConfig.getPersistConsumerOffsetInterval(), TimeUnit.MILLISECONDS);        // 没啥用，看本意是想动态调用线程池大小的，估计意义不大，也没有实现了        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override            public void run() {                try {                    MQClientInstance.this.adjustThreadPool();                } catch (Exception e) {                    log.error("ScheduledTask adjustThreadPool exception", e);                }            }        }, 1, 1, TimeUnit.MINUTES);    }    // org.apache.rocketmq.client.impl.factory.MQClientInstance#sendHeartbeatToAllBrokerWithLock    public void sendHeartbeatToAllBrokerWithLock() {        if (this.lockHeartbeat.tryLock()) {            try {                this.sendHeartbeatToAllBroker();                this.uploadFilterClassSource();            } catch (final Exception e) {                log.error("sendHeartbeatToAllBroker exception", e);            } finally {                this.lockHeartbeat.unlock();            }        } else {            log.warn("lock heartBeat, but failed.");        }    }    // 心跳机制的实现    private void sendHeartbeatToAllBroker() {        final HeartbeatData heartbeatData = this.prepareHeartbeatData();        final boolean producerEmpty = heartbeatData.getProducerDataSet().isEmpty();        final boolean consumerEmpty = heartbeatData.getConsumerDataSet().isEmpty();        if (producerEmpty && consumerEmpty) {            log.warn("sending heartbeat, but no consumer and no producer");            return;        }        // 迭代所有的 brokerAddrTable 中的 broker, 可惜的是，刚启动时, brokerAddrTable 可能为空        // 后续由心跳线程进行检查        if (!this.brokerAddrTable.isEmpty()) {            long times = this.sendHeartbeatTimesTotal.getAndIncrement();            Iterator>> it = this.brokerAddrTable.entrySet().iterator();            while (it.hasNext()) {                Entry> entry = it.next();                String brokerName = entry.getKey();                HashMap oneTable = entry.getValue();                if (oneTable != null) {                    for (Map.Entry entry1 : oneTable.entrySet()) {                        Long id = entry1.getKey();                        String addr = entry1.getValue();                        if (addr != null) {                            if (consumerEmpty) {                                if (id != MixAll.MASTER_ID)                                    continue;                            }
                            try {                                int version = this.mQClientAPIImpl.sendHearbeat(addr, heartbeatData, 3000);                                if (!this.brokerVersionTable.containsKey(brokerName)) {                                    this.brokerVersionTable.put(brokerName, new HashMap(4));                                }                                this.brokerVersionTable.get(brokerName).put(addr, version);                                if (times % 20 == 0) {                                    log.info("send heart beat to broker[{} {} {}] success", brokerName, id, addr);                                    log.info(heartbeatData.toString());                                }                            } catch (Exception e) {                                if (this.isBrokerInNameServer(addr)) {                                    log.info("send heart beat to broker[{} {} {}] failed", brokerName, id, addr, e);                                } else {                                    log.info("send heart beat to broker[{} {} {}] exception, because the broker not up, forget it", brokerName,                                        id, addr, e);                                }                            }                        }                    }                }            }        }    }