RocketMQ_001_消息发送流程

最新推荐文章于 2024-07-31 21:26:52 发布
原创 最新推荐文章于 2024-07-31 21:26:52 发布 · 2.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rocketmq

本文详细分析了RocketMQ中Producer启动及发送消息的流程，包括启动时如何从NameServer获取topic路由信息，以及NameServer如何处理Producer的请求。在启动时，Producer会向NameServer注册并获取topic配置，然后尝试找到topic路由信息。如果找不到，会更新本地路由信息。整个过程涉及了NameServer的通信机制和路由信息的更新策略。

前提条件

1、NameServer已启动。各个NameServer无状态，无通信。
2、broker已启动。
在这里插入图片描述
3、broker启动时，加载$HOME/store/config/topics.json里的信息，定时注册到3个NameServer里。

{
	"dataVersion":{
		"counter":3,
		"timestamp":1647074381689
	},
	"topicConfigTable":{
		"SCHEDULE_TOPIC_XXXX":{
			"order":false,
			"perm":6,
			"readQueueNums":18,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"SCHEDULE_TOPIC_XXXX",
			"topicSysFlag":0,
			"writeQueueNums":18
		},
		"SELF_TEST_TOPIC":{
			"order":false,
			"perm":6,
			"readQueueNums":1,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"SELF_TEST_TOPIC",
			"topicSysFlag":0,
			"writeQueueNums":1
		},
		"%RETRY%testGroupName":{
			"order":false,
			"perm":6,
			"readQueueNums":1,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"%RETRY%testGroupName",
			"topicSysFlag":0,
			"writeQueueNums":1
		},
		"DefaultCluster":{
			"order":false,
			"perm":7,
			"readQueueNums":16,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"DefaultCluster",
			"topicSysFlag":0,
			"writeQueueNums":16
		},
		"DefaultCluster_REPLY_TOPIC":{
			"order":false,
			"perm":6,
			"readQueueNums":1,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"DefaultCluster_REPLY_TOPIC",
			"topicSysFlag":0,
			"writeQueueNums":1
		},
		"RMQ_SYS_TRANS_HALF_TOPIC":{
			"order":false,
			"perm":6,
			"readQueueNums":1,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"RMQ_SYS_TRANS_HALF_TOPIC",
			"topicSysFlag":0,
			"writeQueueNums":1
		},
		"TBW102":{
			"order":false,
			"perm":7,
			"readQueueNums":8,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"TBW102",
			"topicSysFlag":0,
			"writeQueueNums":8
		},
		"BenchmarkTest":{
			"order":false,
			"perm":6,
			"readQueueNums":1024,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"BenchmarkTest",
			"topicSysFlag":0,
			"writeQueueNums":1024
		},
		"OFFSET_MOVED_EVENT":{
			"order":false,
			"perm":6,
			"readQueueNums":1,
			"topicFilterType":"SINGLE_TAG",
			"topicName":"OFFSET_MOVED_EVENT",
			"topicSysFlag":0,
			"writeQueueNums":1
		}
	}
}

4、由于所有NameServer节点里的路由信息都一致，所以producer选择任一一个NameServer与之通信，获得topic路由信息。

Producer发送消息源码分析

DefaultMQProducer producer = new DefaultMQProducer(Constants.TEST_GROUP_NAME);
        producer.setNamesrvAddr(Constants.NAME_SERVER);
        producer.start();
Message msg = new Message(Constants.TEST_TOPIC_NAME,
	Constants.TEST_TAG, "key" + i,(Constants.HELLO_ROCKETMQ + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
producer.sendOneway(msg);

producer启动主要流程

在这里插入图片描述

sendOneWay

start()方法初始化, sendOneWay拼装、发送消息。

调用tryToFindTopicPublishInfo方法，从topicPublishInfoTable中寻找topic路由信息。

Producer启动的时候，先向NameServer发起请求，询问topic路由信息。
如果找不到，调用updateTopicRouteInfoFromNameServer从NameServer获取topic路由信息。
如果找到了，调用updateTopicRouteInfoFromNameServer更新本地的topic路由信息。

   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 {
           this.mQClientFactory.updateTopicRouteInfoFromNameServer(topic, true, this.defaultMQProducer);
           topicPublishInfo = this.topicPublishInfoTable.get(topic);
           return topicPublishInfo;
       }
   }

topicPublishInfoTable是什么结构？

private final ConcurrentMap<String/* topic */, TopicPublishInfo> topicPublishInfoTable =
        new ConcurrentHashMap<String, TopicPublishInfo>();

不同于broker的topic信息，client启动的时候，默认只有一个TBW102的topic。
在这里插入图片描述

updateTopicRouteInfoFromNameServer做了什么？

通过getDefaultTopicRouteInfoFromNameServer从NameServer获取topic信息T1，将T和和本地topicRouteTable中的topic(T2)比较，看是否需要更新。
T1结构一览：
在这里插入图片描述

  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(),
                          clientConfig.getMqClientApiTimeout());
                      if (topicRouteData != null) {
                          for (QueueData data : topicRouteData.getQueueDatas()) {
                              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 = 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());
                          }
						…………
                          log.info("topicRouteTable.put. Topic = {}, TopicRouteData[{}]", topic, cloneTopicRouteData);
                          this.topicRouteTable.put(topic, cloneTopicRouteData);
                          return true;
                      }
  }

getTopicRouteInfoFromNameServer做了什么？

封装了一个RequestCode.GET_ROUTEINFO_BY_TOPIC的Netty command。

public TopicRouteData getTopicRouteInfoFromNameServer(final String topic, final long timeoutMillis,
      boolean allowTopicNotExist) throws MQClientException, InterruptedException, RemotingTimeoutException, RemotingSendRequestException, RemotingConnectException {
      GetRouteInfoRequestHeader requestHeader = new GetRouteInfoRequestHeader();
      requestHeader.setTopic(topic);
	  //******************look at me plz********************************************
      RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.GET_ROUTEINFO_BY_TOPIC, requestHeader);

      RemotingCommand response = this.remotingClient.invokeSync(null, request, timeoutMillis);
      assert response != null;
      switch (response.getCode()) {
          case ResponseCode.TOPIC_NOT_EXIST: {
              if (allowTopicNotExist) {
                  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());
  }

Netty封装通用调用方法

public RemotingCommand invokeSync(String addr, final RemotingCommand request, long timeoutMillis)
    throws InterruptedException, RemotingConnectException, RemotingSendRequestException, RemotingTimeoutException {
    long beginStartTime = System.currentTimeMillis();
    //******************look at me plz********************************************
    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 the addr[" + addr + "] 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);
    }
}

这2个方法，就是从NameServer的list中获取1个NameServer，如果超时，轮询下一个。

private Channel getAndCreateChannel(final String addr) throws RemotingConnectException, 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 getAndCreateNameserverChannel() throws RemotingConnectException, InterruptedException {
      String addr = this.namesrvAddrChoosed.get();
      if (addr != null) {
          ChannelWrapper cw = this.channelTables.get(addr);
          if (cw != null && cw.isOK()) {
              return cw.getChannel();
          }
      }

      final List<String> addrList = this.namesrvAddrList.get();
      if (this.namesrvChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) {
          try {
              addr = this.namesrvAddrChoosed.get();
              if (addr != null) {
                  ChannelWrapper cw = this.channelTables.get(addr);
                  if (cw != null && cw.isOK()) {
                      return cw.getChannel();
                  }
              }
    		//******************look at me plz********************************************
              if (addrList != null && !addrList.isEmpty()) {
                  for (int i = 0; i < addrList.size(); i++) {
                      int index = this.namesrvIndex.incrementAndGet();
                      index = Math.abs(index);
                      index = index % addrList.size();
                      String newAddr = addrList.get(index);

                      this.namesrvAddrChoosed.set(newAddr);
                      log.info("new name server is chosen. OLD: {} , NEW: {}. namesrvIndex = {}", addr, newAddr, namesrvIndex);
                      Channel channelNew = this.createChannel(newAddr);
                      if (channelNew != null) {
                          return channelNew;
                      }
                  }
                  throw new RemotingConnectException(addrList.toString());
              }
          } finally {
              this.namesrvChannelLock.unlock();
          }
      } else {
          log.warn("getAndCreateNameserverChannel: try to lock name server, but timeout, {}ms", LOCK_TIMEOUT_MILLIS);
      }

      return null;
  }
RocketMQ消息发送
qq_27061805的博客
04-08 4606
RocketMQ消息发送 RocketMQ 支持3 种消息发送方式： 同步 （sync）、异步（async）、单向（oneway）。 同步：发送者向 MQ 执行发送消息API 时，同步等待，直到消息服务器返回发送结果。 异步：发送者向MQ 执行发送消息API 时，指定消息发送成功后的回调函数，然后调用消息发送API 后，立即返回，消息发送者线程不阻塞，直到运行结束，消息发送成功或失败的回调任务在一个新的线程中返回。 单向：消息发送者向MQ 执行发送消息API 时，直接返回，不等待消息服务器的结果
RocketMq发送消息
wanli4717的博客
02-28 5700
发送类型 Rocketmq提供三种方式可以发送普通消息：同步、异步、和单向发送。 同步：发送方发送消息后，收到服务端响应后才发送下一条消息 异步：发送一条消息后，不等服务端返回就可以继续发送消息或者后续任务处理。发送方通过回调接口接收服务端响应，并处理响应结果。 OneWay：发送方发送消息，不等待服务端返回响应且没有回调函数触发，即只发送请求不需要应答。 发送方式对比：发送吞吐量,单向>异步>同步。但单向发送可靠性差存在丢失消息可能，选型根据实际需求确定。 Demo演示 ..
RocketMQ发送消息
qq_62767608的博客
06-21 5136
MQ的消费模式可以大致分为两种，一种是，一种是。服务端 (MQ) 主动推送消息给客户端，优点是及时性较好流控客户端 需要主动到 服务端 (MQ) 取数据，优点是客户端可以依据自己的消费能力进行消费，Push模式也是基于Pull模式的，所以不管是Push模式还是Pull模式，都是Pull模式。一般情况下，优先选择Pull模式。
RocketMQ 发送消息
贝克街的流浪猫
03-31 400
引言 前面我们已经简单地介绍了 RocketMQ 的整体设计思路，本文着重其中消息发送部分的实现细节。 消息发送 RocketMQ支持3种消息发送方式:同步(sync)、异步(async)、单向(oneway)。 同步:发送者向MQ执行发送消息API时，同步等待，直到消息服务器返回发送结果。 异步:发送者向MQ执行发送消息API时，指定消息发送成功后的回调函数，然后调用消息发送API后，立即返回，消息发送者线程不阻塞，直到运行结束，消息发送成功或失败的回调任务在一个新的线程中执行。 单向:消息发送者向MQ
RocketMQ_design.zip
08-23
在RocketMQ_design.pdf文档中，可能会详细阐述RocketMQ的架构设计、核心组件的工作原理、消息传递流程、以及如何配置和使用RocketMQ等内容。这将帮助读者深入理解RocketMQ如何实现高效的分布式消息处理，并提供实践...
RocketMQ 消息发送流程
黎明就要到来
06-26 995
该文所涉及的 RocketMQ 源码版本为 4.9.3。
RocketMq事务消息发送代码流程详解
08-18
RocketMq事务消息发送代码流程详解 RocketMq是一种流行的开源消息队列系统，事务消息是其核心功能之一。事务消息发送代码流程详解是指在RocketMq中实现事务消息发送的整个过程。下面我们将详细介绍RocketMq事务消息...
消息中间件—RocketMQ消息发送
01-27
本文来自于jianshu，文章介绍了RocketMQ网络架构图以及RocketMQ发送普通消息的全流程解读等相关内容。摘要：使用客户端发送一条消息很Easy，在这背后RocketMQ完成了怎么样的操作呢？大道至简，消息队列可以简单概括...
rocketmq_4.2.0 最新编译版
11-02
9. **监控与管理**：RocketMQ提供了一套管理控制台，可以对RocketMQ集群进行监控和管理，包括查看集群状态、消息发送与消费情况、异常排查等。 10. **性能优化**：RocketMQ 4.2.0版本可能包含了性能优化，例如更快...
rocketMq发送事务消息
热门推荐
congge
10-07 1万+
事务消费 我们经常支付宝转账余额宝，这是日常生活的一件普通小事，但是我们思考支付宝扣除转账的钱之后，如果系统挂掉怎么办，这时余额宝账户并没有增加相应的金额，数据就会出现不一致状况了。 上述场景在各个类型的系统中都能找到相似影子，比如在电商系统中，当有用户下单后，除了在订单表插入一条记录外，对应商品表的这个商品数量必须减1吧，怎么保证？！在搜索广告系统中，当用户点击某广告后，除了在点击事件表中增加一...
RocketMQ消息发送篇
吃四碗饭的嘤嘤怪的博客
03-03 2384
RocketMQ支持3种消息发送方式：同步（sync）、异步（async）、单向（oneway）。 同步：发送者向MQ执行发送消息API时，同步等待，直到消息服务器返回发送结果。 异步：发送者向MQ执行发送消息API时，指定消息发送成功后的回调函数，然后调用消息发送API后，立即返回，消息发送者线程不阻塞，直到运行结束，消息发送成功或失败的回调任务在一个新的线程中执行。 单向：消息发送者向MQ执行发送消息API时，直接返回，不等待消息服务器的结果，也不注册回调函数，简单地说，就是只管发，不在乎消息是否
RocketMQ的消息发送方式
凡是过往，皆为序章
10-17 7646
目录 同步发送 异步发送 单向发送 总结 同步发送 简单来说，同步发送就是指 producer 发送消息后，会在接收到 broker 响应后才继续发下一条消息的通信方式。 由于这种同步发送的方式确保了消息的可靠性，同时也能及时得到消息发送的结果，故而适合一些发送比较重要的消息场景，比如说重要的通知邮件、营销短信等等。在实际应用中，这种同步发送的方式还是用得比较多的。 异步...
RocketMQ 消息发送、消息类别
小钟不想敲代码
05-21 6737
RocketMQ 消息发送、消息类别
RocketMQ：消息发送与消费
上海一九四三
07-02 4412
在此之前，我们已经介绍过《RocketMQ：快速入门》和《RocketMQ：搭建集群》。现在我们已经准备好RocketMQ的环境了，接下来就是通过实战去演示RocketMQ中各种消息类型的生产和消费了。 1. 开发环境 （1）引入RocketMQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId&
RocketMQ(四)——常用Example(转)
学会改变自己——才能突破
03-18 1675
最近看了看RocketMQ的官方文档，感觉不错，一直在用，每看一次，深刻一次。接下几篇主要是整理转载一下！ 官方地址：http://rocketmq.apache.org/docs/motivation/ github地址：https://github.com/apache/rocketmq 当然需要我们根据实际情况，做我们想要的抽象封装! 1 基本样例 在基本样例中我们提供如下的功能场景： ...
三.RocketMQ极简入门-RocketMQ普通消息发送
墨家巨子@俏如来
09-12 1601
前言 RocketMQ已经写了两章了，一章是RocketMQ认识和安装，一章是RocketMQ的工作流程和核心概念，本章我们开始使用RocketMQ来发送和接收消息。RocketMQ的消息种类非常多，比如：普通消息，顺序消息，延迟消息，批量发送，消息过滤等等。本篇文章来探讨一下 普通消息的发送 文章目录前言普通消息发送同步发送异步发送单向发送消费者案例总结 普通消息发送 普通消息这里介绍三种发送方式，同步发送，异步发送，单向发送。我们先导入需要的依赖，版本尽量和RocketMQ的安装版本一致。 <d
RocketMQ消息发送基本示例(推送消费者)
最新发布
tiantiantbtb的博客
07-31 981
3.单向发送:只负责发送,不管消息是否发送成功 单向发送不保证消息的送达，仅适用于对可靠性要求不高的场景。2.异步发送:不等待消息返回直接进入后续流程.broker将结果返回后调用callback函数,并使用。1.同步发送:等待消息返回后再继续进行下面的操作 同步发送保证了消息的可靠性，适用于关键业务场景。推模式:消费者等待Broker把消息推送过来。拉模式:消费者主动去Broker上拉取消息。CountDownLatch计数。事实上:尽管存在“推送消费者”（消息生产者通过三种方式发送消息。
RocketMQ消息发送详解：从发送流程到网络架构
RocketMQ是一款分布式消息中间件，本文...RocketMQ的消息发送流程是一个分布式系统中的复杂交互过程，涉及多个组件之间的协作，保证了消息的可靠传递和高可用性。这对于初学者来说是一个很好的研究和学习MQ技术的起点。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值