25.RocketMQ之生产者的启动流程

最新推荐文章于 2024-03-19 10:26:42 发布
最新推荐文章于 2024-03-19 10:26:42 发布
阅读量218 收藏
点赞数
文章标签： java-rocketmq rocketmq java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30635523/article/details/131513468
版权

highlight: arduino-light

生产者DefaultMQProducer启动

消息生产者的代码都在client模块中，相对于RocketMQ来讲，消息生产者既是客户端，也是消息的提供者。

image.png

下面来看下DefaultMQProducer相关的方法和属性。

DefaultMQProducer相关的方法

  • java //创建主题 void createTopic(final String key, final String newTopic, final int queueNum) throws MQClientException;
  • //根据时间戳从队列中查找消息偏移量 long searchOffset(final MessageQueue mq, final long timestamp)
  • //查找消息队列中最大的偏移量 long maxOffset(final MessageQueue mq) throws MQClientException;
  • //查找消息队列中最小的偏移量 long minOffset(final MessageQueue mq)
  • //根据messageId查找消息 MessageExt viewMessage(final String offsetMsgId) throws RemotingException, MQBrokerException,        InterruptedException, MQClientException;
  • //根据条件查找消息 QueryResult queryMessage(final String topic, final String key, final int maxNum, final long begin,        final long end) throws MQClientException, InterruptedException;
  • //根据消息ID和主题查找消息 MessageExt viewMessage(String topic,String msgId) throws RemotingException, MQBrokerException, InterruptedException, MQClientException;
  • //启动 void start() throws MQClientException;
  • //关闭 void shutdown();
  • //查找该主题下所有消息 List<MessageQueue> fetchPublishMessageQueues(final String topic) throws MQClientException;
  • //同步发送消息 SendResult send(final Message msg) throws MQClientException, RemotingException, MQBrokerException, InterruptedException;
  • //同步超时发送消息 SendResult send(final Message msg, final long timeout) throws MQClientException, RemotingException, MQBrokerException, InterruptedException;
  • //异步发送消息 void send(final Message msg, final SendCallback sendCallback) throws MQClientException, RemotingException, InterruptedException;
  • //异步超时发送消息 void send(final Message msg, final SendCallback sendCallback, final long timeout) throws MQClientException, RemotingException, InterruptedException;
  • //发送单向消息 void sendOneway(final Message msg) throws MQClientException, RemotingException, InterruptedException;
  • //选择指定队列同步发送消息 SendResult send(final Message msg, final MessageQueue mq) throws MQClientException, RemotingException, MQBrokerException, InterruptedException;
  • //选择指定队列异步发送消息 void send(final Message msg, final MessageQueue mq, final SendCallback sendCallback) throws MQClientException, RemotingException, InterruptedException;
  • //选择指定队列单项发送消息 void sendOneway(final Message msg, final MessageQueue mq) throws MQClientException, RemotingException, InterruptedException;
  • //批量发送消息 SendResult send(final Collection<Message> msgs) throws MQClientException, RemotingException, MQBrokerException,InterruptedException;

DefaultMQProducer相关的属性

producerGroup：生产者所属组 //AUTO_CREATE_TOPIC_KEY_TOPIC = "TBW102"; Will be created at broker when isAutoCreateTopicEnable createTopicKey：默认Topic //private volatile int defaultTopicQueueNums = 8; defaultTopicQueueNums：默认主题在每一个Broker队列数量8 sendMsgTimeout：发送消息默认超时时间，默认3s compressMsgBodyOverHowmuch：消息体超过该值则启用压缩，默认4k retryTimesWhenSendFailed：同步方式发送消息重试次数，默认为2，总共执行3次 retryTimesWhenSendAsyncFailed：异步方法发送消息重试次数，默认为2，总共执行3次 retryAnotherBrokerWhenNotStoreOK：消息重试时选择另外一个Broker时，是否不等待存储结果就返回，默认为false maxMessageSize：允许发送的最大消息长度，默认为4M

DefaultMQProducerImpl启动流程分析

消费者Consumer的启动和生产者Producer启动很类似，可以和Producer启动进行对比。

不同之处是消费端的PullMessageService、RebalanceService才有真正作用。

这2个定时任务对于producer是无用的，但是这两个定时任务是消费端的核心。

参考:https://segmentfault.com/a/1190000021613638

代码：DefaultMQProducerImpl#start

```java //检查生产者组是否满足要求 this.checkConfig();

//更改当前instanceName为进程ID if (!this.defaultMQProducer.getProducerGroup().equals(MixAll.CLIENTINNERPRODUCER_GROUP)) { this.defaultMQProducer.changeInstanceNameToPID(); } //获得MQ客户端实例 MQClientInstance this.mQClientFactory = MQClientManager.getInstance() .getAndCreateMQClientInstance (this.defaultMQProducer, rpcHook); ```

一个JVM中只存在一个MQClientManager实例，维护一个MQClientInstance缓存表。

同一个clientId只会创建一个MQClientInstance。

这也意味着同一台服务器,启动多个生产者、消费者也只有一个MQClientInstance。

ConcurrentMap<String/* clientId */, MQClientInstance> factoryTable = new ConcurrentHashMap<String,MQClientInstance>();

MQClientInstance封装了RocketMQ网络处理API，是消息生产者和消息消费者与NameServer、Broker打交道的网络通道

代码：DefaultMQProducerImpl#start

java 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); } //启动生产者 if (startFactory) { mQClientFactory.start(); }

``` DefaultMQPullConsumerImpl.start() (org.apache.rocketmq.client.impl.consumer) DefaultMQAdminExtImpl.start() (org.apache.rocketmq.tools.admin) DefaultMQPushConsumerImpl.start() (org.apache.rocketmq.client.impl.consumer) DefaultMQProducerImpl.start(boolean) (org.apache.rocketmq.client.impl.producer)

//上面的类都调用的该方法 所以这方法不是只有生产者调用 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 2分钟一次
                //更新NameServer地址，该地址要求返回结果为一个ip列表，以;隔开，
                //如果获取回来的地址跟现有的地址不一致则会更新缓存的NameServer地址列表。
                //解析出来的地址列表用于根据NettyRemotingClient内部持有的变量：
                this.startScheduledTask();
                // 启动拉取消息线程
                this.pullMessageService.start();
                // 该方法用于启动rebalance任务。
                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;
        }
    }
}

```

DefaultMQProducerImpl启动源码

DefaultMQProducerImpl#start()

java //启动producer public void start() throws MQClientException { //注意这里是个true 代表首先要启动mQClientFactory this.start(true); }

DefaultMQProducerImpl#start(boolean)

```java //第一次进来 startFactory = true public void start(final boolean startFactory) throws MQClientException { //初始默认是ServiceState.CREATE_JUST switch (this.serviceState) {

case CREATE_JUST:
            this.serviceState = ServiceState.START_FAILED;
            //检查生产者组命名规范 校验如下:
            //不能为空
            //最大长度不能超过255
            //不能叫 DEFAULT_PRODUCER
            //正则校验: ^[%|a-zA-Z0-9_-]+$
            this.checkConfig();

            //更改当前instanceName为进程ID
            //主要是通过UtilAll.getPid()
            //UtilAll.getPid() 则是调用
            //  ManagementFactory.getRuntimeMXBean().getName()
            //name的格式是 pid@hostname
            //提取  pid@hostname 中的 pid
            if(!this.defaultMQProducer.getProducerGroup().equals
                (MixAll.CLIENT_INNER_PRODUCER_GROUP)) {
                    this.defaultMQProducer.changeInstanceNameToPID();
            }

            //通过MQClientManager.getInstance()获得MQ客户端实例 MQClientInstance
            //MQClientManager.getInstance()返回的是MQClientManager
            //MQClientManager使用了单例模式

            //MQClientManager.getInstance()
            // 1.首先拼接 IP + @ + PID 如172.18.95.215@5444 作为clientId
            // 2.MQClientInstance instance = this.factoryTable.get(clientId);
            // 3.如果为空则创建MQClientInstance
            // 4.放入:this.factoryTable.putIfAbsent(clientId, instance);  
            //这样可以保证同一个JVM用一个MQClientInstance,比如启动生产者和消费者在1个main
            // 下次在启动MQClientInstance会判断状态是RUNNING,会直接break。跳出switch。
            this.mQClientFactory = MQClientManager.getInstance()
                .getAndCreateMQClientInstance(this.defaultMQProducer, rpcHook);

            //注册当前生产者到到MQClientInstance管理中,方便后续调用网路请求
            //如果存在同名的producer registerOK 返回false
            boolean registerOK 
                    = mQClientFactory
                        .registerProducer
                            (this.defaultMQProducer.getProducerGroup(), this);

            //如果存在同名的producer抛出异常
            if (!registerOK) {
                this.serviceState = ServiceState.CREATE_JUST;
                throw new MQClientException
                    ("The producer group has created use another name please");
            }

            //KEY = TBW102
            //VALUE = TopicPublishInfo
            this.topicPublishInfoTable
                .put(this.defaultMQProducer.getCreateTopicKey(), 
                     new TopicPublishInfo());

            if (startFactory) {
                //这里会调用
                //org.apache.rocketmq.client.impl.factory.MQClientInstance#start
                //启动很多服务
                //具体看
                //org.apache.rocketmq.client.impl.factory.MQClientInstance#start
                //当MQClientInstance启动完毕会调用
                //this.defaultMQProducer.getDefaultMQProducerImpl().start(false);
                //完成DefaultMQProducerImpl的启动
                mQClientFactory.start();
            }

            //修改启动状态
            //这样下次同一台机器的其他的producer启动时不需要在启动mQClientFactory
            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");
        default:
            break;
    }
    //发送心跳
    this.mQClientFactory.sendHeartbeatToAllBrokerWithLock();
}

```

检查生产者组命名规范

MQClientInstance#checkConfig

//检查生产者组命名规范 校验如下: //不能为空 //最大长度不能超过255 //不能叫 DEFAULT_PRODUCER //正则校验: ^[%|a-zA-Z0-9_-]+$ private void checkConfig() throws MQClientException { Validators.checkGroup(this.defaultMQProducer.getProducerGroup()); if (null == this.defaultMQProducer.getProducerGroup()) { throw new MQClientException("producerGroup is null", (Throwable)null); } else if (this.defaultMQProducer.getProducerGroup().equals("DEFAULT_PRODUCER")) { throw new MQClientException("producerGroup can not equal DEFAULT_PRODUCER, please specify another one.", (Throwable)null); } }

注册生产者,k:生产者名,v是生产者

MQClientInstance#registerProducer

```java //注册当前生产者到到MQClientInstance管理中,方便后续调用网路请求 //如果存在同名的producer registerOK 返回false public boolean registerProducer(final String group, final DefaultMQProducerImpl producer) { if (null == group || null == producer) { return false; }

MQProducerInner prev = this.producerTable.putIfAbsent(group, producer);
if (prev != null) {
    log.warn("the producer group[{}] exist already.", group);
    return false;
}

return true;

} ```

创建单例MQClientInstance

MQClientManager#getAndCreateMQClientInstance

MQClientInstance不是对外应用类，也就是说用户不需要自己实例化使用他。并且，MQClientInstance的实例化并不是直接new后使用，而是通过MQClientManager这个类型。

MQClientManager是个单例类，使用饿汉模式设计保证线程安全。他的作用是提供MQClientInstance实例，RocketMQ认为，MQClientInstance的实例是可以复用的实例，只要client相关特征参数相同，就会复用一个MQClientInstance实例，我们可以看看源码

原文链接：https://blog.csdn.net/tales522/article/details/88386738

java // private ConcurrentMap factoryTable =new ConcurrentHashMap(); public MQClientInstance getAndCreateMQClientInstance(final ClientConfig clientConfig, RPCHook rpcHook) { //构建客户端ID String clientId = clientConfig.buildMQClientId(); //根据客户端ID或者客户端实例 MQClientInstance instance = this.factoryTable.get(clientId); //实例如果为空就创建新的实例,并添加到实例表中 if (null == instance) { instance = new MQClientInstance(clientConfig.cloneClientConfig(), this.factoryIndexGenerator.getAndIncrement(), clientId, rpcHook); //添加到实例表中 //factoryTable 是1个 ConcurrentMap //通过容器的方式使用单例 new ConcurrentHashMap<String, MQClientInstance>(); 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; }

启动MQClientInstance

MQClientInstance#start

```java DefaultMQPullConsumerImpl.start() (org.apache.rocketmq.client.impl.consumer) DefaultMQAdminExtImpl.start() (org.apache.rocketmq.tools.admin) DefaultMQPushConsumerImpl.start() (org.apache.rocketmq.client.impl.consumer) DefaultMQProducerImpl.start(boolean) (org.apache.rocketmq.client.impl.producer)

//上面的类都调用的该方法 所以这方法不是只有生产者调用 //这也解释了为什么producer启动时为什么启动了那么多服务 //因为不管是消费者还是生产者都需要从nameServer拉取服务地址列表、发送心跳 //因此启动时不管先启动消费者还是先启动生产者 这些操作都是必不可少的。 //如果这样那么为什么不放到一起执行呢？ //启动的时机不一样吧 public void start() throws MQClientException {

synchronized (this) {
    //默认是  CREATE_JUST
    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();
            }

            //启动 NettyRemotingClient
            this.mQClientAPIImpl.start();
           // 有个判断null == this.clientConfig.getNamesrvAddr() 
           // 才会启动这个更新nameServer的地址的定时任务
           // 2分钟更新一次nameServer的地址，该地址要求返回结果为一个ip列表，以;隔开
           // 如果获取回来的地址跟现有的地址不一致则会更新缓存的NameServer地址列表。

           // 30秒更新一次topic的路由信息 如果不一致 会做全量更新
           // 30秒对Broker发送一次心跳检测，并将下线的broker删除
           // 5秒持久化一次consumer的offset
           // 1分钟调整一次线程池，这个定时任务其实什么都没有执行。
            this.startScheduledTask();
            // Start pull service  启动拉取消息线程
            this.pullMessageService.start();
            // 启动负载均衡服务 这里是一个Thread 所以看run方法
            this.rebalanceService.start();
            //注意这里是false
            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 objec has created before, and failed.");
        default:
            break;
    }
}

} ```

MQClientInstance#startScheduledTask
每30秒更新一次topic的路由信息

如果不一致做全量更新。都是map做的put操作。

  • MQClientInstance的updateTopicRouteInfoFromNameServer方法首先从consumerTable及producerTable获取topicList，然后遍历topicList执行updateTopicRouteInfoFromNameServer，最后执行的是updateTopicRouteInfoFromNameServer(topic, false, null)
  • 然后会执行mQClientAPIImpl.getTopicRouteInfoFromNameServer(topic, 1000 * 3)获取topicRouteData然后与topicRouteTable中的TopicRouteData进行对比，先通过topicRouteDataIsChange判断是否有变化，没有的话再通过isNeedUpdateTopicRouteInfo进一步判断
  • 若有变化则更新brokerAddrTable。
  • 遍历producerTable执行impl.updateTopicPublishInfo(topic, publishInfo)；
  • 遍历consumerTable执行impl.updateTopicSubscribeInfo(topic, subscribeInfo)
  • 最后将cloneTopicRouteData更新到topicRouteTable
每30秒对Broker发送一次心跳检测
每30秒更新本地路由删除下线broker
5秒持久化一次consumer的offset

```java private void startScheduledTask() {     // http://jmenv.tbsite.net:8080/rocketmq/nsaddr     // producer在初始化时通过向固定地址发送 httpGet请求，从而获得name server地址     // 一般都是提前配置好 不存在动态增减的情况.     // 因为是有个判断null == this.clientConfig.getNamesrvAddr() 才会启动这个定时任务     // 2分钟更新一次nameServer的地址，该地址要求返回结果为一个ip列表，以;隔开        // 如果获取回来的地址跟现有的地址不一致则会更新缓存的NameServer地址列表。              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);       }

     // 30秒从nameserver拉取一次topic的路由信息        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {            @Override            public void run() {                try {                    MQClientInstance.this.updateTopicRouteInfoFromNameServer();               } catch (Exception e) {                    log.error("ScheduledTask updateTopicRouteInfoFromNameServer", e);               }           }       }, 10, this.clientConfig.getPollNameServerInterval(), TimeUnit.MILLISECONDS);

   
    // this.clientConfig.getHeartbeatBrokerInterval()     // private int pollNameServerInterval = 1000 * 30;        // 30秒对Broker发送一次心跳检测，并将下线的broker删除,清理下线的broker     // 更新本地路由信息        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);    
    // this.clientConfig.getPersistConsumerOffsetInterval()     // private int persistConsumerOffsetInterval = 1000 * 5; // 5秒持久化一次consumer的offset是给消费者用的        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); ​    
    // 1分钟调整一次线程池，这个定时任务其实什么都没有执行。        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);   } ```

启动拉取消息线程

消息拉取与长轮询讲消费者的时候再专门分析

启动负载均衡服务

负载均衡服务讲消费者的时候再专门分析

生产者启动主要是创建单例MQClientInstance,然后启动MQClientInstance,启动MQClientInstance主要是启动下面几个重要的定时任务。

1.每30秒更新一次topic的路由信息

2.每30秒对Broker发送一次心跳检测

3.每30秒更新本地路由删除下线broker

4.5秒持久化一次consumer的offset

5.启动拉取消息定时任务

6.启动重新负载均衡定时任务

其中消息拉取与长轮询和负载均衡定时任务是消费者的核心定时任务,讲消费者的时候再讲。

然而,然而
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RocketMQ生产者消费者完整流程.vsd
06-11
配合看RocketMQ的生产者和消费者源码，里面有完整的启动流程和消费流程
rocketmq可视化控制台最新版 rocketmq-console-ng-2.x
04-05
3. **消息发送与消费监控**：监控生产者和消费者的行为，查看消息发送速率、消费进度、堆积情况等。 4. **消息追踪**：追踪消息在整个生命周期中的流转，定位消息丢失或延迟问题。 5. **实例监控**：展示各个Broker...
RocketMQ的生产者原理和最佳实践-学习笔记
chenyong6301567的博客
08-30 387
第2章 RocketMQ的生产者原理和最佳实践
RocketMQ生产者
clyu的博客
03-23 1172
前言 RocketMQ生产者顶级接口是MQProducer，他有2个子类DefaultMQProducer和TransactionMQProducer 一、MQProducer 1.1 开启和关闭Producer void start() throws MQClientException; void shutdown(); 1.2 单向发送消息 这种方式主要用在不特别关心发送结果的场景，例如日志发送 void sendOneway(final Message msg) throws ...; voi
RocketMQ之生产者（Producer）
最新发布
Lyhdreamer的博客
03-19 1264
RocketMQ生产者详解
RocketMq源码分析（六）--消息消费者启动流程
Shenkh的Java壁橱
05-02 934
如果是刚创建实例时（CREATE_JUST状态），则先将附实例状态更改为START_FAILED，然后进行一些列初始化并启动操作（检查配置、复制订阅信息、设置负载均衡实现、创建并加载消息进度offsetStore、创建并启动消息消费consumeMessageService服务、向消费者工厂注册自己），最后变更为RUNNING状态。//服务实例状态，有：CREATE_JUST、RUNNING、SHUTDOWN_ALREADY、START_FAILED，默认CREATE_JUST。接口定义，默认实现类为。
RocketMQ (八) 生产者-Producer
dmjxsy的博客
02-27 1501
RocketMQ(生产者)
Java进阶篇-SpringBoot集成RocketMQ
qq_33351639的博客
03-16 1486
注解来指定该消费者监听的RocketMQ主题和消费者组。同时实现了RocketMQListener。在application.properties/application.yml。接口，并指定消息类型为MessageExt。方法中处理接收到的RocketMQ消息。文件中添加RocketMQ的配置。发送消息，然后在控制台中查看。我们可以通过在测试类中使用。是否成功接收到了消息。
RocketMQ生产者和消费者Java代码示例.zip
12-26
1. **创建RocketMQ生产者** 在Java中，我们需要创建一个`DefaultMQProducer`实例，并设置生产者的组名。组名在RocketMQ中是一个重要的概念，同一组内的生产者会共享消息发送的责任，保证消息的幂等性。例如： ```...
RocketMQ-4.3.2启动服务包.zip
01-03
这个压缩包“RocketMQ-4.3.2启动服务包.zip”显然是针对Windows用户的，包含了快速启动RocketMQ服务的批处理文件，简化了安装和配置流程。 1. **RocketMQ基本概念** - **消息队列**: RocketMQ的核心是消息队列，它...
springboot1.5.10.RELEASE集成rocketmq4.3.1消息服务demo，多个消费者多监听
08-03
在SpringBoot的`application.properties`或`application.yml`中，指定NameServer地址、生产者和消费者的组名： ```properties # application.properties 示例 rocketmq.namesrv.addr=127.0.0.1:9876 rocketmq....
RocketMQ快速入门（5、名词解释之生产者Producer）
Doug Wang的博客
06-06 256
RocketMQ快速入门（5、名词解释之生产者Producer）
RocketMQ保姆级教程
weixin_45630885的博客
08-16 1206
不过这里我还建议再修改一处信息，因为Broker向NameServer进行注册的时候，带过去的ip如果不指定就会自动获取，但是自动获取的有个坑，就是有可能你的电脑无法访问到这个自动获取的ip，所以我建议手动指定你的电脑可以访问到的服务器ip。最后我再说一句，从文章整体也可以看出本文没有涉及太深入的一些机制和原理的讲解，比如消息是如何存储的，事务和延迟消息是如何实现的，主从是如何同步的等等，甚至压根就没提到队列这个词，主要是因为我打算后面再写一篇文章，来单独剖析这些机制和原理。...
【六】RocketMQ源码之-NameServer启动流程
程序猿
03-09 279
源码讲解,RocketMQ源码之-NameServer启动流程
RocketMQ：写一个生产者程序要注意些什么
Huangjiazhen711的博客
10-18 234
写一个生产者程序要注意基于业务场景，选择合适的发送消息的方式，其次是思考是否要使用消息 tag 和重试。
RocketMQ安装与启动
旷野历程
06-04 6084
官网：https://rocketmq.apache.org/ 1. 准备环境 系统：Centos7.3（无硬性要求） jdk：1.8 2. 环境部署 解压 rocketmq ，并进入 rocketmq 下的 bin 目录 #########调整启动内存####### # vim bin/runserver.sh　　#调整nameserver启动的内存（如果服务器内存比较大，可以不调整），如果内存较小，不调整此文件，可能导致无法启动 JAVA_OPT="${JAVA_OPT} -serve...
RocketMQ第三章：手把手教老婆实现：普通消息（同步，异步和单向）的生产者和消费者
热门推荐
小虚竹的专栏
04-10 2万+
第一节：项目准备 第二节：普通消息-生产者和消息者步骤说明 第三节：普通消息-同步消息 第四节：普通消息-异步消息 第五节：普通消息-单向消息 第六节：总结
rocketmq 启动多个生产者实例
feng的专栏
08-07 8043
最近在公司的项目中遇到一个坑，在一个应用里面启动多个实例的时候消息总是只能发送到其中一个实例对应的mq服务器上去，通过反射跟踪发现这2个实例的brokerAddrTable地址是一样的，开始还以为是配置设置的NamesrvAddr不对，后面打印出来发现NamesrvAddr是正常的，但是brokerAddrTable就是不对，始终指向第一个启动的brokerAddrTable地址。后面跟踪源代码发...
RocketMQ 的启动流程(windows)
qq_44805463的博客
09-14 920
配置环境变量 – 变量名：ROCKETMQ_HOME – 变量值：MQ解压路径 Cmd命令框执行进入至‘MQ文件夹\bin’下，然后执行‘start mqnamesrv.cmd’，启动NAMESERVER。成功后会弹出提示框，此框勿关闭。 Cmd命令框执行进入至‘MQ文件夹\bin’下，然后执行‘start mqbroker.cmd -n 127.0.0.1:9876 autoCreateTopicEnable=true’ ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值