rocketMQ 4.8.0 各种消息模式测试，普通，多TAG，顺序，事务，发送并响应生产消息模式测试demo

最新推荐文章于 2022-09-05 01:00:35 发布
最新推荐文章于 2022-09-05 01:00:35 发布
阅读量2k 收藏 2
点赞数 1
分类专栏： java 文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuexi_deng/article/details/121704118
版权

1.前言

由于公司项目中目前正在淘汰RabbitMQ全面使用RocketMQ,所以抽空整理了一些Rocket的常用的用法，写成了一个Demo，RocketMQ相比RabbitMQ的优势，个人认为就是在堆积处理方面非常的优秀，以及在顺序处理消息方面的写法特别的简单。
深入了解可以在gitlab上阅读相关的中文文档 
https://github.com/apache/rocketmq/tree/master/docs/cn

2.DEMO

本次的Demo主要是根据RocketMQ 4.8.0 ,rocket-spring-boot-stater 2.2.0进行的测各种消息模式测试，主要是普通，多TAG，顺序，事务，发送并相应生产消息模式

2.1常量定义

public class TestMQConstant {
    //格式
    public static final String FORMAT = "%s:%s";
    //格式
    public static final String SYMBOL = "||";
    //topic
    public static final String TOPIC = "testTopic";
    //正常消息的 tag
    public static final String TAG_NORMAL = "normal";
    //正常消息的 消费者组tag
    public static final String CONSUMER_NORMAL = "consumerNormal";
    //顺序消息的 tag
    public static final String TAG_ORDERLY = "orderly";
    //顺序消息的 的消费者组
    public static final String CONSUMER_ORDERLY = "consumerOrderly";
    //消息者接收多个 tag
    public static final String TAG_MULTI_FIRST = "multiFirst";
    public static final String TAG_MULTI_SECOND = "multiSecond";
    public static final String TAG_MULTI = TAG_MULTI_FIRST + SYMBOL + TAG_MULTI_SECOND;
    //消息者接收多个的 的消费者组
    public static final String CONSUMER_MULTI = "consumerMulti";
    //发送并等待回复 tag
    public static final String TAG_SEND_AND_RECEIVE = "sendAndReceive";
    //发送并等待回复 的 消费者组
    public static final String CONSUMER_SEND_AND_RECEIVE = "consumerSendAndReceive";
    //事务 tag
    public static final String TAG_TRANSACTION = "transaction";
    //事务的 消费者组
    public static final String CONSUMER_TRANSACTION = "consumerTransaction";
    //顺序消息的share_key
    public static final String SHARER_KEY_QUEUE_FIRST = "queueFirst";
    //顺序消息的share_key
    public static final String SHARER_KEY_QUEUE_SECOND = "queueSecond";

    private TestMQConstant() {
    }
}

2.2 消息实体类定义

/**
 * 测试消息体
 *
 * @author dengmeiluan
 * @date 2021/12/3 16:07
 */
public class TestMessage {

    private String field1;
    private String field2;
    private Boolean flag;
    private String shareKey;

    public String getShareKey() {
        return shareKey;
    }

    public void setShareKey(String shareKey) {
        this.shareKey = shareKey;
    }

    public String getField1() {
        return field1;
    }

    public void setField1(String field1) {
        this.field1 = field1;
    }

    public String getField2() {
        return field2;
    }

    public void setField2(String field2) {
        this.field2 = field2;
    }

    public Boolean getFlag() {
        return flag;
    }

    public void setFlag(Boolean flag) {
        this.flag = flag;
    }

    @Override
    public String toString() {
        return "TestMessage{" +
                "field1='" + field1 + '\'' +
                ", field2='" + field2 + '\'' +
                ", flag=" + flag +
                ", shareKey='" + shareKey + '\'' +
                '}';
    }
}

/**
 * 自定义回复消息实体
 *
 * @author dengmeiluan
 * @date 2021/12/3 16:45
 */
public class TestReplyMessage {

    private String message;
    private int code;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    @Override
    public String toString() {
        return "TestReplyMessage{" +
                "message='" + message + '\'' +
                ", code=" + code +
                '}';
    }
}

2.3 配置文件配置

2.3.1生产者

rocketmq.name-server=127.0.0.1:9876
rocketmq.producer.group=test-producer-group
rocketmq.producer.access-key=
rocketmq.producer.secret-key=

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.7</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>TestRocketMQProducer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>TestRocketMQProducer</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.restdocs</groupId>
            <artifactId>spring-restdocs-mockmvc</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.asciidoctor</groupId>
                <artifactId>asciidoctor-maven-plugin</artifactId>
                <version>1.5.8</version>
                <executions>
                    <execution>
                        <id>generate-docs</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>process-asciidoc</goal>
                        </goals>
                        <configuration>
                            <backend>html</backend>
                            <doctype>book</doctype>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.2.5.RELEASE</version>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2.3.2消费者

# rocketmq
rocketmq.name-server=127.0.0.1:9876
rocketmq.producer.access-key=
rocketmq.producer.secret-key=

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>TestRocketMQConsumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>TestRocketMQConsumer</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.restdocs</groupId>
            <artifactId>spring-restdocs-mockmvc</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.asciidoctor</groupId>
                <artifactId>asciidoctor-maven-plugin</artifactId>
                <version>1.5.8</version>
                <executions>
                    <execution>
                        <id>generate-docs</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>process-asciidoc</goal>
                        </goals>
                        <configuration>
                            <backend>html</backend>
                            <doctype>book</doctype>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3测试各类消费模式

3.1普通消费模式

3.1.1 生产者

    @Resource
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送普通消息
     *
     * @return void
     * @author dengmeiluan
     * @date 2021/12/3 15:38
     */
    @Test
    void sendNormalMessage() {
        List<TestMessage> dataList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            TestMessage testQueue1TestMessage1 = new TestMessage();
            testQueue1TestMessage1.setField1(i + "");
            dataList.add(testQueue1TestMessage1);
        }
        String destination = formatDestinationByTag(TAG_NORMAL);
        for (TestMessage testMessage : dataList) {
            rocketMQTemplate.syncSend(destination, testMessage);
        }
    }

3.1.2 消费者

/**
 * 正常消费消息消费者
 *
 * @author dengmeiluan
 * @date 2021/12/3 16:45
 */
@Service
@RocketMQMessageListener(
        topic = TestMQConstant.TOPIC,
        consumerGroup = TestMQConstant.CONSUMER_NORMAL,
        selectorExpression = TestMQConstant.TAG_NORMAL,
        consumeMode = ConsumeMode.CONCURRENTLY)
@Slf4j
public class TesNormalConsumer implements RocketMQListener<TestMessage> {

    @Override
    public void onMessage(TestMessage testMessage) {
        log.info("进入了【普通消费者】:{}", testMessage);
    }
}

3.2 有序的消费模式

3.2.1 生产者

    /**
     * 发送有序的消息,根据tag + share_key
     *
     * @return void
     * @author dengmeiluan
     * @date 2021/12/3 15:38
     */
    @Test
    void sendOrderlyMessage() throws InterruptedException {
        List<TestMessage> queue1 = new ArrayList<>();
        List<TestMessage> queue2 = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            //queue1
            TestMessage testQueue1TestMessage1 = new TestMessage();
            testQueue1TestMessage1.setField1(String.valueOf(i));
            testQueue1TestMessage1.setShareKey(SHARER_KEY_QUEUE_FIRST);
            queue1.add(testQueue1TestMessage1);
            //queue2
            TestMessage testQueue1TestMessage2 = new TestMessage();
            testQueue1TestMessage2.setField2(String.valueOf(i));
            testQueue1TestMessage2.setShareKey(SHARER_KEY_QUEUE_SECOND);
            queue2.add(testQueue1TestMessage2);
        }
        String destination = formatDestinationByTag(TAG_ORDERLY);
        Thread thread1 = new Thread(() -> {
            for (TestMessage testMessage : queue1) {
                rocketMQTemplate.syncSendOrderly(destination, testMessage, testMessage.getShareKey());
            }
        });
        Thread thread2 = new Thread(() -> {
            for (TestMessage testMessage : queue2) {
                rocketMQTemplate.syncSendOrderly(destination, testMessage, testMessage.getShareKey());
            }
        });
        //模拟多线程发送
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }

3.2.2 消费者

/**
 * 每个shareKey对应的队列按FIFO的顺序消费,顺序消费者
 *
 * @author dengmeiluan
 * @date 2021/12/3 16:45
 */
@Service
@RocketMQMessageListener(
        topic = TestMQConstant.TOPIC,
        consumerGroup = TestMQConstant.CONSUMER_ORDERLY,
        selectorExpression = TestMQConstant.TAG_ORDERLY,
        consumeMode = ConsumeMode.ORDERLY)
@Slf4j
public class TestOrderlyConsumer implements RocketMQListener<TestMessage> {

    private static final Random random = new Random();

    @SneakyThrows
    @Override
    public void onMessage(TestMessage testMessage) {
        log.info("进入了【顺序消费者】:{}", testMessage);
        String shareKey = testMessage.getShareKey();
        if (TestMQConstant.SHARER_KEY_QUEUE_FIRST.equals(shareKey) || TestMQConstant.SHARER_KEY_QUEUE_SECOND.equals(shareKey)) {
            int randomInt = random.nextInt(100) + 1000;
            log.info("随机睡眠:{}", randomInt);
            Thread.sleep(randomInt);
        }
        log.info("睡眠结束:{}", testMessage);
    }
}

3.3 多个Tag消费者模式

3.3.1 生产者

    /**
     * 发送多个tag到达同一个消费者
     *
     * @return void
     * @author dengmeiluan
     * @date 2021/12/3 15:55
     */
    @Test
    void sendMultiTagToSameConsumerMessage() {
        //tag1
        TestMessage testQueue1TestMessage1 = new TestMessage();
        testQueue1TestMessage1.setField1(TAG_MULTI_FIRST);
        //tag2
        TestMessage testQueue1TestMessage2 = new TestMessage();
        testQueue1TestMessage2.setField1(TAG_MULTI_SECOND);
        String destination1 = formatDestinationByTag(TAG_MULTI_FIRST);
        String destination2 = formatDestinationByTag(TAG_MULTI_SECOND);
        rocketMQTemplate.syncSend(destination1, testQueue1TestMessage1);
        rocketMQTemplate.syncSend(destination2, testQueue1TestMessage2);
    }

3.3.2 消费者

/**
 * 可以接受多个tag消费消息消费者
 *
 * @author dengmeiluan
 * @date 2021/12/3 16:45
 */
@Service
@RocketMQMessageListener(
        topic = TestMQConstant.TOPIC,
        consumerGroup = TestMQConstant.CONSUMER_MULTI,
        selectorExpression = TestMQConstant.TAG_MULTI,
        consumeMode = ConsumeMode.CONCURRENTLY)
@Slf4j
public class TesMultiNormalConsumer implements RocketMQListener<TestMessage> {

    @Override
    public void onMessage(TestMessage testMessage) {
        log.info("进入了【多个Tag的消费者】:tag{}", testMessage.getField1());
    }
}

3.4 事务消费者模式

3.4.1生产者

    /**
     * 发送事务消息
     *
     * @return void
     * @author dengmeiluan
     * @date 2021/12/3 16:05
     */
    @Test
    void senTransactionMessage() throws InterruptedException {
        TestMessage success = new TestMessage();
        success.setField1(TAG_TRANSACTION);
        success.setFlag(true);
        senTransactionMessage(success);

        TestMessage fail = new TestMessage();
        fail.setField1(TAG_TRANSACTION);
        fail.setFlag(false);
        senTransactionMessage(fail);

        TestMessage unknown = new TestMessage();
        success.setField1(TAG_TRANSACTION);
        success.setFlag(null);
        senTransactionMessage(unknown);

        Thread.sleep(30000);
    }

    private void senTransactionMessage(TestMessage success) {
        String destination = formatDestinationByTag(TAG_TRANSACTION);
        Message<TestMessage> build = MessageBuilder.withPayload(success).build();
        TransactionSendResult transactionSendResult = rocketMQTemplate.sendMessageInTransaction(destination, build, success.getFlag());
        System.out.println(transactionSendResult.toString());
    }

3.4.2 消费者

/**
 * 事务消息消费者（事实上就是普通的消息消费者,事务消费是对生产者的,对消费者无感）
 *
 * @author dengmeiluan
 * @date 2021/12/3 16:45
 */
@Service
@RocketMQMessageListener(
        topic = TestMQConstant.TOPIC,
        consumerGroup = TestMQConstant.CONSUMER_TRANSACTION,
        selectorExpression = TestMQConstant.TAG_TRANSACTION,
        consumeMode = ConsumeMode.CONCURRENTLY)
@Slf4j
public class TesTransactionConsumer implements RocketMQListener<TestMessage> {

    @Override
    public void onMessage(TestMessage message) {
        //事务消息本身对消费者是无感的,主要是对生产者本地事务+消息的持久化的
        log.info("进入了【事务消费者】:{}", message);
    }
}

3.5 发送并相应模式

3.5.1 生产者

    /**
     * 发送并等待回复,默认3s
     *
     * @return void
     * @author dengmeiluan
     * @date 2021/12/3 16:05
     */
    @Test
    void sendAndReceiver() {
        TestMessage testEntityTestMessage = new TestMessage();
        testEntityTestMessage.setField1(TAG_SEND_AND_RECEIVE);
        String destination = formatDestinationByTag(TAG_SEND_AND_RECEIVE);
        TestReplyMessage testReplyMessage = rocketMQTemplate.sendAndReceive(destination, testEntityTestMessage, TestReplyMessage.class, 6000);
        System.out.println(testReplyMessage);
    }

3.5.2 消费者

/**
 * 发送消息并且回复消费者,需要实现RocketMQReplyListener
 *
 * @author dengmeiluan
 * @date 2021/12/3 16:45
 */
@Service
@RocketMQMessageListener(
        topic = TestMQConstant.TOPIC,
        consumerGroup = TestMQConstant.CONSUMER_SEND_AND_RECEIVE,
        selectorExpression = TestMQConstant.TAG_SEND_AND_RECEIVE,
        consumeMode = ConsumeMode.CONCURRENTLY)
@Slf4j
public class TesSendAndReceiverConsumer implements RocketMQReplyListener<TestMessage, TestReplyMessage> {

    @SneakyThrows
    @Override
    public TestReplyMessage onMessage(TestMessage message) {
        log.info("进入了【发送并且响应的消费者】:{}", message);
        log.info("正在消费...loading...");
        //睡眠之后再响应
        Thread.sleep(3000);
        TestReplyMessage testReplyMessage = new TestReplyMessage();
        testReplyMessage.setMessage("消费成功");
        testReplyMessage.setCode(0);
        return testReplyMessage;
    }
}

4 完整Maven代码下载路径

https://download.csdn.net/download/xuexi_deng/54839349
xuexi_deng
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Rocketmq使用手册第一篇(springboot整合rocketmq)
m0_54883970的博客
08-02 3945
rocketmq默认消息发送16次后数据会自动进入死信队列,每次重试的偏移量会在重试队列记录,修改重试的时间间隔以及自定义是否直接进入死信队列这些配置再springboot中暂时没有提供可用的接口,官方建议使用默认的方式,如果有此业务需求,可以通过支持原生Listener的使用方式自己控制ConsumeConcurrentlyStatus实现,具体实现代码如下/***RocketMQPush模式消费*/@Service@RocketMQMessageListener(topic=“...
【消息队列】RocketMQ 消息的 topic 和 tag 区别以及使用方式
最新发布
代码的魅力，根本走不出来
01-18 2250
在 RocketMQ 中，消息的 Topic 和 Tag 是用于标识和分类消息的两个关键属性。它们有不同的作用和使用方式。
RocketMQ 4.8.0版本
04-20
直接使用即可,点击bin目录下aMqStartup.bat,abMqStartup.bat即可,记得必须搭配1.8以上jdk使用,如果需要MQ项目请留言
RocketMq--key和tag的作用及容易踩坑的点
wodiaonihai的博客
01-12 1万+
Producer 实例 Producer 的一个对象实例，不同的 Producer 实例可以运行在不同进程内或者不同机器上。Producer 实例线程安全，可在同一进程内多线程之间共 享。 Message Key Key 一般用于消息在业务层面的唯一标识。对发送的消息设置好 Key，以后可以根据这个 Key 来查找消息。比如消息异常，消息丢失，进行查找会很 方便。RocketMQ 会创建专门的索引文件，用来存储 Key 与消息的映射，由于是 Hash 索引，应尽量使 Key 唯一，避免潜在的哈希冲突。 Ta
RocketMQ-05 消费者和生产者
mail_liuxing的专栏
07-17 930
一、消费者 （一）消费者类型 消费者可以分为两种类型： DefaultMQPushConsumer：由操作系统控制读取操作，收到消息后自动调用传入的处理方法来处理； DefaultMQPullConsumer：读取操作中的大部分功能需要用户自主控制。 （二）DefaultMQPushConsumer 使用解释 使用DefaultMQPushConsumer主要设置好各种参数和传入处理消息的函...
RocketMQTemplate基本使用
技术交流
05-22 1万+
文章目录1、环境准备2、生产者普通消息同步消息异步消息3、消费者（1）基础示例（2）顺序消费（2）消费模式a.集群模式b.广播模式（3）重复消费4、accessKey和secretKey 1、环境准备 pom引入依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter&l
rocketmq一个topic对用多个tag时tag的定义方式
m0_46608027的博客
05-27 8015
在使用rocketmq时，发现消费者只能受到部分消息（消费者tag里定义的tag），查看监控器总是显示消息被过滤，解决方式（注意private String tag = "tag1";） private String consumerGroup = "consumerTopic"; private String namesrvAddr = "127.0.0.1:9876"; private String topic = "supplyTopic"; private St
RocketMq发送消息Producer配置
weixin_42038771的博客
05-01 2043
在使用阿里的rocketmq发送数据时,大数据量，多线程情况下,会产生并非网络原因的发送失败.故使用以下发送方式,方法是采用内部静态类型的单例模式. @Component public class ProducerBeanSingleTon { @Value("${openservices.ons.producerBean.producerId}") private String ...
RocketMQ代码实战(二)：RocketMQ发送带Tag的消息
小英雄
04-28 6730
在代码实战：使用rocketmq-spring-boot-starter发送和消费消息 讲解了使用rocketmq-spring-boot-starter快速搭建生产者消费者服务，本次继续讲解 发送带Tag的消息 Tag（标签）可以看作子主题，它是消息的第二级类型。同一业务模块不同目的的消息就可以用相同 Topic 而不同的 Tag来标识。比如交易消息又可以分为：交易创建消息、交易完成消息等，一条消息可以没有 Tag。 1.发送消息 @RestController public class Rock
RocketMQ中msg&tag的生命周期
CBeann的博客
09-05 1422
RocketMQ中msg&tag的生命周期
rocketmq-all-4.8.0-bin-release
06-28
安装 RocketMQ 1. 下载 rocketmq 二进制文件 wget --no-check-certificate https://dlcdn.apache.org/rocketmq/4.9.2/rocketmq-all-4.9.2-bin-release.zip 2. 解压缩 rocketmq 将 rocketmq 解压到 /usr/local/ 目录 ...
rocketmq-all-4.8.0-bin-release.zip
12-22
rocketmq-all-4.8.0-bin-release.zip apache rocketmq 4.8.0 消息中间件 Apache RocketMQ™ is a unified messaging engine, lightweight data processing platform.
rocketmq-all-4.8.0-source-release.zip
12-22
rocketmq-all-4.8.0-source-release.zip apache rocketmq 4.8.0 消息中间件 Apache RocketMQ™ is a unified messaging engine, lightweight data processing platform.
最新版 rocketmq-all-4.8.0-bin-release.zip
01-04
最新版 rocketmq-all-4.8.0-bin-release.zip最新版 rocketmq-all-4.8.0-bin-release.zip
RocketMQ 中Topic、Tag、GroupName基本概念介绍
热门推荐
LoveSummer
07-08 1万+
本文主要介绍RocketMQ中Topic、Tag、GroupName的概念、设计初衷以及使用方法。 一.Topic 首先看看官方的定义： Topic是生产者在发送消息和消费者在拉取消息的类别。Topic与生产者和消费者之间的关系非常松散。具体来说，一个Topic可能有0个，一个或多个生产者向它发送消息；相反，一个生产者可以发送不同类型Topic的消息。类似的，消费者组可以订阅一个或多个主题，只要该组的实例保持其订阅一致即可。 Topic在Google翻译中解释为话题。我们可以理解为第一级消息类型，类比于
RocketMQ Topic/Group/Tags介绍
xzh_blog
07-20 8465
Topic是RocketMQ里对消息的一级归类。RocketMQ支持发布和订阅模型，通过Topic完成消息的发布和订阅。消息生产者将消息发送到Topic中，而消息消费者则通过订阅该Topic来消费消息。
源码分析RocketMQ同一个消费组设置不同tag，消息订阅失败问题
weixin_34112208的博客
06-14 7562
背景介绍 项目组使用阿里RocketMQ，对同一个消费组设置不同的tag订阅关系，出现消息丢失的问题，本文从rocketmq源码研究消息发布与订阅原理，并分析导致该问题的原因。 官方说明 告诉使用者：同一个消费组，必须保持订阅关系一致 为什么？它没有说！只能从源码找答案 问题复现 启动消费者1，消费组为group1，订阅topicA的消息，tag设置为tag1 || tag2 启动消费者2...
RocketMQ4.8(jdk11)部署+springboot2.x实战
frank_0807的博客
02-17 4087
springboot2.X整合RocketMQ4.X(jdk11) 一.简介 二.Centos7.x骨架搭建 1.安装jdk11.0.10 下载地址 导入linux进行安装配置 解压：tar -zxvf jdk-11.0.10_linux-x64_bin.tar.gz 重命名：mv xxx jdk11 vim /etc/profile 加入 export JAVA_HOME=/usr/local/software/jdk11 export PATH=$JAVA_HOME/bin:$PATH export C
RocketMQ：剖析ACL权限控制原理、实现和应用
Ramboy's Blogs
05-29 2576
前言         RocketMQ 作为一款优秀的中间件，应用领域非常广泛，金融、电商、电信、医疗、社科、安保等不同的领域都有其大规模的应用，无疑安全性很受质疑，因为内部没有安全相关的业务模块，消息的发送和消费得不到很好的安全管控需要业务方自己去封装安全模块，无形中增加了使用成本。         在 RocketMQ 4.4.0 版本升级中加入
rocketmq发送消息
07-27
关于 RocketMQ 的消息发送，您可以按照以下步骤进行操作： 1. 首先，您需要引入 RocketMQ 的客户端依赖。您可以在项目的构建文件中添加以下 Maven 依赖： ```xml <groupId>org.apache.rocketmq <artifactId>...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值