RocketMQ消息发送之查找Topic路由

前言

发送消息之前rocketMQ需要获取目的topic的路由信息，即需要将消息发送到哪个topic上

DefaultMQProducerImpl#tryToFindTopicPublishInfo

从缓存中获取topic路由信息，获取到有效路由直接返回，如果没获取到或者获取到的路由信息不可用，则向nameserver查询该topic的路由信息

    private TopicPublishInfo tryToFindTopicPublishInfo(final String topic) {
        // 从topicPublishInfoTable中获取指定主题的发布信息
        TopicPublishInfo topicPublishInfo = this.topicPublishInfoTable.get(topic);
        // 如果获取到的发布信息为空，或者发布信息不可用，则进行以下操作
        if (null == topicPublishInfo || !topicPublishInfo.ok()) {
            // 使用putIfAbsent方法向topicPublishInfoTable中添加一个新的主题发布信息对象
            this.topicPublishInfoTable.putIfAbsent(topic, new TopicPublishInfo());
            // 调用mQClientFactory.updateTopicRouteInfoFromNameServer方法从名称服务器更新主题的路由信息
            this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic);
            // 再次尝试从topicPublishInfoTable中获取指定主题的发布信息
            topicPublishInfo = this.topicPublishInfoTable.get(topic);
        }

        // 如果获取到的发布信息具有主题路由信息，或者发布信息可用，则直接返回获取到的发布信息
        if (topicPublishInfo.isHaveTopicRouterInfo() || topicPublishInfo.ok()) {
            return topicPublishInfo;
        } else {
            // 尝试用默认主题查询（topic = TBW102）
            this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic, true, this.defaultMQProducer);
            // 再次尝试从topicPublishInfoTable中获取指定主题的发布信息，并返回获取到的发布信息
            topicPublishInfo = this.topicPublishInfoTable.get(topic);
            return topicPublishInfo;
        }
    }

MQClientInstance#updateTopicRouteInfoFromNameServer

如果isDefault == true，则代表获取默认主题的路由信息，并根据配置更写读写队列的数量，因为defaultMQProducer.getDefaultTopicQueueNums()为4，所以这里结队列数量是4，再加上broker之间数据是各自独立的，所以这里容易出现负载不均衡的情况。（详见https://www.cnblogs.com/dingwpmz/p/11809404.html）

       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(clientConfig.getMqClientApiTimeout());
                        // 更新默认主题的读写队列数量
                        if (topicRouteData != null) {
                            for (QueueData data : topicRouteData.getQueueDatas()) {
                                // defaultMQProducer.getDefaultTopicQueueNums()= 4
                                int queueNums = Math.min(defaultMQProducer.getDefaultTopicQueueNums(), data.getReadQueueNums());
                                data.setReadQueueNums(queueNums);
                                data.setWriteQueueNums(queueNums);
                            }
                        }
                    } else {
                        // 否则，从名称服务器获取指定主题的路由信息
                        topicRouteData = this.mQClientAPIImpl.getTopicRouteInfoFromNameServer(topic, clientConfig.getMqClientApiTimeout());
                    }
                    // 如果成功获取到了主题的路由信息
                    if (topicRouteData != null) {
                        // 获取旧的主题路由信息
                        TopicRouteData old = this.topicRouteTable.get(topic);
                        // 判断新的主题路由信息是否与旧的不同
                        boolean changed = topicRouteData.topicRouteDataChanged(old);
                        // 如果路由信息发生了变化，或者需要更新主题路由信息
                        ///todo-tzx 22480 2024/4/14 19:19  当前只阅读了发送消息时查找topic路由信息的代码？而这个过程是缓存中不存在才会走到这里，所以这里一定是不同的，为什么还需要比较？或许是其他引用该方法的场景需要进行对比吗？
                        if (!changed) {
                            changed = this.isNeedUpdateTopicRouteInfo(topic);
                        } else {
                            log.info("the topic[{}] route info changed, old[{}] ,new[{}]", topic, old, topicRouteData);
                        }

                        if (changed) {
                            // 更新Broker地址表
                            for (BrokerData bd : topicRouteData.getBrokerDatas()) {
                                this.brokerAddrTable.put(bd.getBrokerName(), bd.getBrokerAddrs());
                            }

                            // 更新主题的端点映射
                            {
                                ConcurrentMap<MessageQueue, String> mqEndPoints = topicRouteData2EndpointsForStaticTopic(topic, topicRouteData);
                                if (!mqEndPoints.isEmpty()) {
                                    topicEndPointsTable.put(topic, mqEndPoints);
                                }
                            }

                            // 更新主题的发布信息
                            {
                                TopicPublishInfo publishInfo = topicRouteData2TopicPublishInfo(topic, topicRouteData);
                                publishInfo.setHaveTopicRouterInfo(true);
                                for (Entry<String, MQProducerInner> entry : this.producerTable.entrySet()) {
                                    MQProducerInner impl = entry.getValue();
                                    if (impl != null) {
                                        impl.updateTopicPublishInfo(topic, publishInfo);
                                    }
                                }
                            }

                            // 更新主题的订阅信息
                            if (!consumerTable.isEmpty()) {
                                Set<MessageQueue> subscribeInfo = topicRouteData2TopicSubscribeInfo(topic, topicRouteData);
                                for (Entry<String, MQConsumerInner> entry : this.consumerTable.entrySet()) {
                                    MQConsumerInner impl = entry.getValue();
                                    if (impl != null) {
                                        impl.updateTopicSubscribeInfo(topic, subscribeInfo);
                                    }
                                }
                            }
                            // 将新的主题路由信息加入到主题路由表中
                            TopicRouteData cloneTopicRouteData = new TopicRouteData(topicRouteData);
                            log.info("topicRouteTable.put. Topic = {}, TopicRouteData[{}]", topic, cloneTopicRouteData);
                            this.topicRouteTable.put(topic, cloneTopicRouteData);
                            return true;
                        }
                    } else {
                        log.warn("updateTopicRouteInfoFromNameServer, getTopicRouteInfoFromNameServer return null, Topic: {}. [{}]", topic, this.clientId);
                    }
                } catch (MQClientException e) {
                    if (!topic.startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX) && !topic.equals(TopicValidator.AUTO_CREATE_TOPIC_KEY_TOPIC)) {
                        log.warn("updateTopicRouteInfoFromNameServer Exception", e);
                    }
                } catch (RemotingException e) {
                    log.error("updateTopicRouteInfoFromNameServer Exception", e);
                    throw new IllegalStateException(e);
                } finally {
                    this.lockNamesrv.unlock();
                }
            } else {
                log.warn("updateTopicRouteInfoFromNameServer tryLock timeout {}ms. [{}]", LOCK_TIMEOUT_MILLIS, this.clientId);
            }
        } catch (InterruptedException e) {
            log.warn("updateTopicRouteInfoFromNameServer Exception", e);
        }

        return false;
    }