RocketMQ 自动注入消费者

Java利用配置文件自动生成RocketMQ消费者
原创 于 2024-11-07 21:58:29 发布 · 952 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rocketmq #java

目录

前言

之前接到一个需求，我们项目的技术负责人希望通过配置的形式，在项目启动的时候自动根据配置生成对应的消费者

觉得还有点意思，随即记录一下~

一、情景介绍

比如我这里有一个消费者 MessageConsumer：

@Slf4j
@Service
@RocketMQMessageListener(
        consumerGroup = "mike-group",
        topic = "mike-message",
        selectorExpression = "TAG_MESSAGE_CONSUMER",
        consumeThreadMax = 6,
        consumeTimeout = 60L)
public class MessageConsumer implements RocketMQListener<NotifyMessage> {

    @Override
    public void onMessage(NotifyMessage notifyMessage) {
        System.err.println("我收到啦~~");
        System.err.println("message = " + notifyMessage);
    }
}

在项目启动的时候会根据 @RocketMQMessageListener 注解上的配置生成一个消费者

假如我还需要一个 MessageConsumer 消费者，其 selectorExpression 的配置为 TAG_MESSAGE_CONSUMER_01，consumeThreadMax 要设置为 8

通常情况下我们会再复制一个 MessageConsumer 命名为 MessageConsumer_01，然后在新的消费者上改对应的配置，例如：

@Slf4j
@Service
@RocketMQMessageListener(
        consumerGroup = "mike-group-01",
        topic = "mike-message",
        selectorExpression = "TAG_MESSAGE_CONSUMER_01",
        consumeThreadMax = 8,
        consumeTimeout = 60L)
public class MessageConsumer_01 implements RocketMQListener<NotifyMessage> {

    @Override
    public void onMessage(NotifyMessage notifyMessage) {
        System.err.println("我收到啦~~");
        System.err.println("message = " + notifyMessage);
    }
}

这样做虽然没啥问题，只是这两个类除了配置不一样，其它的代码都是一摸一样的，倘若之后还要有一个 selectorExpression = TAG_MESSAGE_CONSUMER_02 的消费者，那我又得再复制一个 MessageConsumer，这样就造成了大量的代码冗余

所以就希望通过读取配置文件生成对应配置的消费者

二、问题分析

要如何实现这个功能，可以去看下 RocketMQ 的源码，看 Spring 是如何创建 RocketMQ 的消费者的

源码如下：

org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer#initRocketMQPushConsumer

在这里插入图片描述

在该方法中可以看到 Spring 是如何初始化消费者，参照这个方法，只需要在项目启动完成后，将初始化从注解上获取消费者配置的地方换成从配置文件上获取就可以了

通过实现 ApplicationListener<ApplicationReadyEvent> 可以监听项目是否启动完成

三、代码实现

因为消费者是需要通过配置文件的配置来自动生成，那么可以将需要自动生成的消费者（比如 MessageConsumer）其 @RocketMQMessageListener 的配置注释掉

@Slf4j
@Service
//@RocketMQMessageListener(
//        consumerGroup = "mike-group",
//        topic = "mike-message",
//        selectorExpression = "TAG_MESSAGE_CONSUMER",
//        consumeThreadMax = 6,
//        consumeTimeout = 60L)
public class MessageConsumer implements RocketMQListener<NotifyMessage> {

    @Override
    public void onMessage(NotifyMessage notifyMessage) {
        System.err.println("我收到啦~~");
        System.err.println("message = " + notifyMessage);
    }
}

配置文件上自动注入消费者的配置最好和 @RocketMQMessageListener 的属性相同，并且可以配置多个自动注入的消费者，那么对应的映射文件可以这么写

AutoConsumerProperties.java

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;

import java.util.List;

@Data
@RefreshScope
@Configuration
@ConfigurationProperties(prefix = "auto-consumer")
public class AutoConsumerProperties {

    private List<AutoConsumer> messageConsumer;
}

AutoConsumer.java

import lombok.Data;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.SelectorType;

@Data
public class AutoConsumer {

    private String consumerGroup;

    private String topic;

    private SelectorType selectorType = SelectorType.TAG;

    private String selectorExpression = "*";

    private ConsumeMode consumeMode = ConsumeMode.CONCURRENTLY;

    private MessageModel messageModel = MessageModel.CLUSTERING;

    private int consumeThreadMin = 64;

    private int consumeThreadMax = 64;

    private long consumeTimeout = 15L;

    private String accessKey;

    private String secretKey;

    private boolean enableMsgTrace;

    private String customizedTraceTopic;

    private String nameServer;

    private String accessChannel;
}

核心代码：

ConsumerStarted.java

import cn.hutool.core.collection.CollUtil;
import com.mike.common.core.utils.JacksonUtil;
import com.mike.server.message.config.properties.AutoConsumer;
import com.mike.server.message.config.properties.AutoConsumerProperties;
import com.mike.server.message.consumer.MessageConsumer;
import com.mike.server.message.domain.entity.NotifyMessage;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.rocketmq.client.AccessChannel;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.MessageSelector;
import org.apache.rocketmq.client.consumer.listener.*;
import org.apache.rocketmq.client.consumer.rebalance.AllocateMessageQueueAveragely;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.apache.rocketmq.remoting.RPCHook;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.apache.rocketmq.spring.support.RocketMQUtil;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Objects;

@Slf4j
@Component
public class ConsumerStarted implements ApplicationContextAware, ApplicationListener<ApplicationReadyEvent> /* , InitializingBean, SmartLifecycle */ {

    @Value("${rocketmq.name-server:}")
    private String nameServer;
    @Value("${rocketmq.consumer.topic:}")
    private String topic;
    @Value("${rocketmq.consumer.access-key:}")
    private String accessKey;
    @Value("${rocketmq.consumer.secret-key:}")
    private String secretKey;

    @Resource
    private AutoConsumerProperties autoConsumerProperties;

    @Resource
    private MessageConsumer messageConsumer;

    private ApplicationContext applicationContext;

    private final static boolean enableMsgTrace = true;
    private final static String customizedTraceTopic = null;

    @Override
    @SuppressWarnings("all")
    public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
        // 需要等到程序启动完全之后再去启动
        initConsumer();
    }

    public void initConsumer() {
        List<AutoConsumer> messageConsumers = autoConsumerProperties.getMessageConsumer();
        if (CollUtil.isEmpty(messageConsumers)) return;
        final RocketMQListener<NotifyMessage> messageConsumerListener = messageConsumer;
        this.autoGenerateConsumer(messageConsumers, messageConsumerListener, NotifyMessage.class);
    }

    @SuppressWarnings("all")
    private <R> void autoGenerateConsumer(List<AutoConsumer> autoConsumers, RocketMQListener<R> rocketMQListener, Class<R> objClass) {
        // 根据 tag 自动生成对应的消费者
        for (AutoConsumer autoConsumer : autoConsumers) {
            String consumerGroup = autoConsumer.getConsumerGroup();

            String nameServer = getValueOrDefault(autoConsumer.getNameServer(), this.nameServer);
            String topic = getValueOrDefault(autoConsumer.getTopic(), this.topic);
            String accessKey = getValueOrDefault(autoConsumer.getAccessKey(), this.accessKey);
            String secretKey = getValueOrDefault(autoConsumer.getSecretKey(), this.secretKey);

            try {
                Assert.notNull(consumerGroup, "Property 'consumerGroup' is required");
                Assert.notNull(nameServer, "Property 'nameServer' is required");
                Assert.notNull(topic, "Property 'topic' is required");

                DefaultMQPushConsumer consumer;

                RPCHook rpcHook = RocketMQUtil.getRPCHookByAkSk(this.applicationContext.getEnvironment(), accessKey, secretKey);
                if (Objects.nonNull(rpcHook)) {
                    consumer = new DefaultMQPushConsumer(consumerGroup, rpcHook, new AllocateMessageQueueAveragely(), enableMsgTrace, customizedTraceTopic);
                    consumer.setVipChannelEnabled(false);
                } else {
                    consumer = new DefaultMQPushConsumer(consumerGroup, enableMsgTrace, customizedTraceTopic);
                }
                consumer.setInstanceName(RocketMQUtil.getInstanceName(this.nameServer));
                consumer.setNamesrvAddr(this.nameServer);
                consumer.setAccessChannel(AccessChannel.LOCAL);
                consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
                consumer.setConsumeThreadMin(autoConsumer.getConsumeThreadMin());
                consumer.setConsumeThreadMax(autoConsumer.getConsumeThreadMax());
                if (consumer.getConsumeThreadMax() < consumer.getConsumeThreadMin()) {
                    consumer.setConsumeThreadMin(consumer.getConsumeThreadMax());
                }

                switch (autoConsumer.getMessageModel()) {
                    case BROADCASTING:
                        consumer.setMessageModel(MessageModel.BROADCASTING);
                        break;
                    case CLUSTERING:
                        consumer.setMessageModel(MessageModel.CLUSTERING);
                        break;
                    default:
                        throw new IllegalArgumentException("Property 'messageModel' was wrong.");
                }

                switch (autoConsumer.getSelectorType()) {
                    case TAG:
                        consumer.subscribe(topic, autoConsumer.getSelectorExpression());
                        break;
                    case SQL92:
                        consumer.subscribe(topic, MessageSelector.bySql(autoConsumer.getSelectorExpression()));
                        break;
                    default:
                        throw new IllegalArgumentException("Property 'selectorType' was wrong.");
                }

                switch (autoConsumer.getConsumeMode()) {
                    case ORDERLY:
                        consumer.setMessageListener(new DefaultMessageListenerOrderly(autoConsumer, rocketMQListener, objClass));
                        break;
                    case CONCURRENTLY:
                        consumer.setMessageListener(new DefaultMessageListenerConcurrently(autoConsumer, rocketMQListener, objClass));
                        break;
                    default:
                        throw new IllegalArgumentException("Property 'consumeMode' was wrong.");
                }

                consumer.start();

                log.info("Consumer Start Success: {}:{}", topic, autoConsumer.getSelectorExpression());
            } catch (MQClientException e) {
                e.printStackTrace();
                log.info("Consumer Start Failed: {}:{}", topic, autoConsumer.getSelectorExpression());
            }
        }
    }

    private String getValueOrDefault(String value, String defaultValue) {
        return StringUtils.isNotBlank(value)? value: defaultValue;
    }

    @Override
    @SuppressWarnings("all")
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public class DefaultMessageListenerOrderly<T> implements MessageListenerOrderly {

        private final AutoConsumer autoConsumer;
        private final RocketMQListener<T> rocketMQListener;
        private final Class<T> objClass;

        public DefaultMessageListenerOrderly(AutoConsumer autoConsumer, RocketMQListener<T> rocketMQListener, Class<T> objClass) {
            this.autoConsumer = autoConsumer;
            this.rocketMQListener = rocketMQListener;
            this.objClass = objClass;
        }

        public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgList, ConsumeOrderlyContext context) {

            for (MessageExt messageExt : msgList) {
                log.info("group[{}]-tag[{}] consume start ->>>", autoConsumer.getConsumerGroup(), autoConsumer.getSelectorExpression());
                log.debug("received msg: {}", messageExt);
                try {
                    long now = System.currentTimeMillis();
                    this.rocketMQListener.onMessage(doConvertMessage(messageExt, this.objClass));
                    long costTime = System.currentTimeMillis() - now;
                    log.debug("consume {} cost: {} ms", messageExt.getMsgId(), costTime);
                } catch (Exception var9) {
                    log.warn("consume message failed. messageId:{}, topic:{}, reconsumeTimes:{}", messageExt.getMsgId(), messageExt.getTopic(), messageExt.getReconsumeTimes(), var9);
                    final long suspendCurrentQueueTimeMillis = 1000L;
                    context.setSuspendCurrentQueueTimeMillis(suspendCurrentQueueTimeMillis);
                    return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                }
            }

            return ConsumeOrderlyStatus.SUCCESS;
        }
    }

    public class DefaultMessageListenerConcurrently <T> implements MessageListenerConcurrently {

        private final AutoConsumer autoConsumer;
        private final RocketMQListener<T> rocketMQListener;
        private final Class<T> objClass;

        public DefaultMessageListenerConcurrently(AutoConsumer autoConsumer, RocketMQListener<T> rocketMQListener, Class<T> objClass) {
            this.autoConsumer = autoConsumer;
            this.rocketMQListener = rocketMQListener;
            this.objClass = objClass;
        }

        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgList, ConsumeConcurrentlyContext context) {

            for (MessageExt messageExt : msgList) {
                log.info("group[{}]-tag[{}] consume start ->>>", autoConsumer.getConsumerGroup(), autoConsumer.getSelectorExpression());
                log.debug("received msg: {}", messageExt);
                try {
                    long now = System.currentTimeMillis();
                    this.rocketMQListener.onMessage(doConvertMessage(messageExt, objClass));
                    long costTime = System.currentTimeMillis() - now;
                    log.debug("consume {} cost: {} ms", messageExt.getMsgId(), costTime);
                } catch (Exception var9) {
                    log.warn("consume message failed. messageId:{}, topic:{}, reconsumeTimes:{}", messageExt.getMsgId(), messageExt.getTopic(), messageExt.getReconsumeTimes(), var9);
                    final int delayLevelWhenNextConsume = 0;
                    context.setDelayLevelWhenNextConsume(delayLevelWhenNextConsume);
                    return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                }
            }
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    }

    @SuppressWarnings("unchecked")
    private <T> T doConvertMessage(MessageExt messageExt, Class<T> objClass) {
        if (Objects.equals(objClass, MessageExt.class)) {
            return (T)messageExt;
        } else {
            String str = new String(messageExt.getBody(), StandardCharsets.UTF_8);
            if (Objects.equals(objClass, String.class)) {
                return (T)str;
            } else {
                if (objClass != null) {
                    return JacksonUtil.fromJson(str, objClass);
                } else {
                    log.info("convert failed. str:{}, msgType:{}", str, null);
                    throw new RuntimeException("cannot convert message to " + null);
                }
            }
        }
    }
}

配置文件 yml 新增自动注入消费者的配置

auto-consumer:
  message-consumer:
    - consumer-group: mico-group
      topic: mike-message
      selector-expression: TAG_MESSAGE_CONSUMER
      consume-thread-max: 6

    - consumer-group: mike-group-01
      topic: mike-message
      selector-expression: TAG_MESSAGE_CONSUMER_01
      consume-thread-max: 8

    - consumer-group: mike-group-02
      topic: mike-message
      selector-expression: TAG_MESSAGE_CONSUMER_02
      consume-thread-max: 10

如果是配置在 properties 文件中，配置如下：

auto-consumer.message-consumer[0].consumer-group = mico-group
auto-consumer.message-consumer[0].topic = mike-message
auto-consumer.message-consumer[0].selector-expression = TAG_MESSAGE_CONSUMER
auto-consumer.message-consumer[0].consume-thread-max = 6

auto-consumer.message-consumer[1].consumer-group = mico-group-01
auto-consumer.message-consumer[1].topic = mike-message
auto-consumer.message-consumer[1].selector-expression = TAG_MESSAGE_CONSUMER_01
auto-consumer.message-consumer[1].consume-thread-max = 8

auto-consumer.message-consumer[2].consumer-group = mico-group-02
auto-consumer.message-consumer[2].topic = mike-message
auto-consumer.message-consumer[2].selector-expression = TAG_MESSAGE_CONSUMER_02
auto-consumer.message-consumer[2].consume-thread-max = 10

启动项目进行验证，观察是否有三个消费者被创建

在这里插入图片描述

从日志上看确实根据配置文件自动创建了三个不同的消费者

springcloudalibaba架构(26):RocketMQMessageLisntener
不积跬步，无以至千里
08-15 1589
RocketMQ两种消息模式。
如何禁用@RocketMQMessageListener监听器?
搬山境KL攻城狮的修炼手册
12-12 322
如何禁用@RocketMQMessageListener监听器?
SpringBoot集成RocketMQ消费者@RocketMQMessageListener注解参数介绍（内含5.x新参数介绍-rocketmq-spring-boot-starter 2.2.3）
热门推荐
kerwin的博客
04-01 1万+
SpringBoot集成RocketMQ消费者@RocketMQMessageListener注解参数介绍内含5.x新参数介绍-rocketmq-spring-boot-starter 2.2.3
RocketMQ学习笔记四之【DefaultMQPullConsumer使用与流程简单分析】
路漫漫，水迢迢
01-05 6433
我们首先看下DefaultMQPullConsumer使用例子： package com.swk.springboot.rocketmq; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.rocketmq.client...
rockerMq实现消费者动态上下线
qq_34468174的博客
08-21 2770
需求： 1.通过接口方式动态控制消费者的上线和下线，通过配置的方式，实现对接不同rocketmq系统的不同消息队列的消费； 2.从消息队列中读取到消息后，将对映值映射到实现配置好的数据模板中，转换为模板格式的数据； 直切主题，实现动态上下线的两个主要类： 1.配置类，存储消费者连接对象，可以扩展为redis <dependency> <groupId>org.apache.rocketmq</groupId> <ar...
RocketMQ (十一) 消费者-Consumer
dmjxsy的博客
03-09 2519
RocketMQ(消费者)
rocketmq-spring-boot-starter导致的多消费者实例重复消费问题
qq_35008624的博客
03-09 4776
rocketM多消费者重复问题问题描述背景知识本地代码消息积压并重复消息原因分析 问题描述 在使用rocketMQ集群模式消费的时候（通过springboot整合的依赖操作），发现在一台服务器启动多个消费者实例后，消息进行了重复消费，但是在不同的服务器部署消费者实例后，消息能正常消费。 背景知识 rocketMQ的消费模式有两种： 负载均衡模式 消费者采用负载均衡方式消费消息，多个消费者（服务启动多个，本地多个springboot加载类启动）共同消费队列消息，每个消费者处理的消息不同 广播模式 消
SpringBoot接入最新版RocketMq-Spring2.2.0,消费者指定返回消息处理状态
技术初创者陈乐的博客
03-16 1398
SpringBoot接入最新版RocketMq-Spring2.2.0,消费者指定返回消息处理状态 因为用的是RocketMq4.8.0,因此接入最新的rocketmq-spring 首先引入依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifactId> <versi
RocketMQ保姆级教程
m0_68850571的博客
08-22 3165
RocketMQ是阿里巴巴旗下一款开源的MQ框架，经历过双十一考验、Java编程语言实现，有非常好完整生态系统。RocketMQ作为一款纯java、分布式、队列模型的开源消息中间件，支持事务消息、顺序消息、批量消息、定时消息、消息回溯等，总之就是葛大爷的一句话整篇文章可以大致分为三个部分，第一部分属于一些核心概念和工作流程的讲解；第二部分就是纯手动搭建了一套环境；第三部分是基于环境进行测试和集成到SpringBoot，因为整个过程讲的比较细，所以我称之为“保姆级教程”。好了，废话补多少，直接进入主题。
消息队列监听器无法注入bean的问题解决
04-24
在Spring中，我们通常使用`ApplicationContext`来获取bean，或者在有`@Autowired`注解的字段和方法上进行自动注入。如果`BeanUtil`没有正确地处理bean的获取，也可能导致问题的发生。 `system.properties`是系统...
RocketMQ 生产者源码分析：DefaultMQProducer、DefaultMQProducerImpl
vnjohn 博主 > 主线分享后端领域业务设计知识、源码思想、架构设计
01-02 2865
该篇博文主要介绍生产者侧相关的类：MQProducer 能力定义者、DefaultMQProducer 能力抽象者、DefaultMQProducerImpl 能力实现者、ClientConfig RocketMQ 客户端公共的配置类，主要围绕它们内部的参数配置以及属性先初步开展介绍了一下，后续主要在启动 Producer 以及通过 Producer 发送消息时，在生产者这一侧处理的工作
rocketMQ生产者和消费者
ankora的博客
10-24 8649
简单写一个MQ的生产者和消费者。生产者生产4个topic。消费者订阅消费，多线程启动4个线程，每个线程新建一个消费者来消费一个topic的数据。rocketMQ本身就是多线程的，设置每个消费者的线程数为5个。例子如下： 生产者代码如下： import javax.annotation.PreDestroy; import com.alibaba.rocketmq.cli
【NET6】集成RocketMQ，Linux Docker + Windows 多环境 安装RocketMQ
技术分享博客，工作经验，技能学习分享（多做一些不会的，会有意向不到的收获，IT高手不可能永远只做会的）
04-30 2197
【NET6】集成RocketMQ，Linux Docker + Windows 多环境 安装RocketMQ
RocketMQ消息队列-@RocketMQMessageListener实现原理
Apandam的博客
09-02 1万+
相当于定义一个消费者，定义了消费者的一些属性实现接口来处理具体消费逻辑每个消费者初始化了一个对象，该对象中包含消费实例和消费者的属性服务启动的时候开启一个线程轮训队列中的消息，如果没有就一直阻塞，拿到消息后，最终会调用自己实现的onMessage方法。
RocketMQ
javasimawanyi的博客
09-01 1017
消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见的角色大致也就有Producer（生产者）、Consumer（消费者）例如：寄快递。
springboot集成rocketmq消费者
Leon_Jinhai_Sun的博客
06-16 1037
消息消费者 1）添加依赖 同消息生产者 2）配置文件 同消息生产者 3）启动类 @SpringBootApplication public class MQConsumerApplication { public static void main(String[] args) { SpringApplication.run(MQSpringBootApplication.class); } } 4）消息监听器 @Slf4j @Component @Rock
RocketMQ如何配置简单的生产者和消费者
最新发布
weixin_71901717的博客
07-15 1989
rocketmq的消息队列简单使用笔记
Spring Rocketmq 事务消息 @RocketMQMessageListener注解的使用
weixin_51442090的博客
01-12 1万+
RocketMQMessageListener事务消息监听器。
RocketMQ总结
weixin_47628141的博客
08-02 3304
rocketMQ消息队列就是让java工程之间可以传递消息，不同与微服务， 微服务是找到注册服务的接口，然后拿到服务路径去请求，服务请求服务， 消息队列是工程给工程发消息，不一定得有web工程 微服务和消息队列都有注册中心，微服务是从注册中心拉取到其他服务信息去请求， 消息队列是拉取到broker（broker在创建的时候就注册到注册中心了’）给broker消息，想拿消息的工程就和收听广播一样，订阅消息主题，只要这个主题一有信息，broker就会让该工程拉取到该主题的消息 rocketMQ使用 1，注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值