RocketMQ笔记（五）SpringBoot整合RocketMQ批量发送消息

最新推荐文章于 2024-09-25 10:01:51 发布
最新推荐文章于 2024-09-25 10:01:51 发布
阅读量1.8k 收藏 13
点赞数 27
分类专栏： RocketMQ笔记 文章标签： rocketmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alian_1223/article/details/136641867
版权

目录

一、简介

  在之前的文章中，我讲过了，同步发送单条消息，异步发送单条消息，发送单向消息，发送顺序消息，今天我们讲讲如何批量发送消息，主要还是使用方法RocketMQTemplate的syncSend方法。

1.1、特点

  批量发送和单条发送消息的主要区别有以下几点：

  • 网络开销 发送单条消息时，每个消息都需要单独建立网络连接、发送数据包、等待响应等，网络开销较大。批量发送可以将多条消息打包在一起发送，减少网络连接建立的次数，降低网络开销
  • 吞吐量 由于批量发送减少了网络开销，所以可以在单位时间内发送更多的消息，提高了吞吐量。在高并发高流量场景下，批量发送能够发挥更好的性能
  • 消息顺序 单条发送消息的顺序是有序的，后发送的在队列中排在前发送的后面。而对于批量发送，一个批次内的消息顺序是固定的，但不同批次之间的消息顺序是无序的，会按照到达顺序存储在队列中。如果需要严格消息顺序，单条发送更合适
  • 消息重试 如果批量发送的一个批次中有部分消息发送失败，需重发整个批次，没有选择重发其中部分消息的功能（涉及幂等性问题）。单条发送失败时只需重发该单条消息
  • 编程复杂度 批量发送需要构造MessageBatch或Message列表对象，编程略微复杂些。单条发送只需构造单个Message对象

二、Maven依赖

pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>rocketmq</artifactId>
        <groupId>com.alian</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>06-send-batched-message</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.alian</groupId>
            <artifactId>common-rocketmq-dto</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

  父工程已经在我上一篇文章里，通用公共包也在我上一篇文章里有说明，包括消费者。具体参考：RocketMQ笔记（一）SpringBoot整合RocketMQ发送同步消息

三、application配置

application.properties

server.port=8005

# rocketmq地址
rocketmq.name-server=192.168.0.234:9876
# 默认的生产者组
rocketmq.producer.group=batched_group
# 发送同步消息超时时间
rocketmq.producer.send-message-timeout=3000
# 用于设置在消息发送失败后，生产者是否尝试切换到下一个服务器。设置为 true 表示启用，在发送失败时尝试切换到下一个服务器
rocketmq.producer.retry-next-server=true
# 用于指定消息发送失败时的重试次数
rocketmq.producer.retry-times-when-send-failed=3
# 设置消息压缩的阈值,为0表示禁用消息体的压缩
rocketmq.producer.compress-message-body-threshold=0

四、批量发送

  在 RocketMQ 中，RocketMQTemplate的syncSend方法，它允许你批量发送同步消息，主要参数：

  • topic：（普通消息都发送到topic=string_message_topic）
  • Collection<T>：消息集合

测试类都引入依赖

	@Autowired
    private RocketMQTemplate rocketMQTemplate;

4.1、同步消息

    @Test
    public void syncSendBatchStringMessagesWithBuilder() {
        String topic = "string_message_topic";
        String message = "超级喜欢Golang语言：";
        List<Message<String>> messageList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Message<String> rocketMessage = MessageBuilder.withPayload(message + i)
                    // 设置消息类型
                    .setHeader(MessageHeaders.CONTENT_TYPE, "text/plain")
                    .build();
            // 加入到列表
            messageList.add(rocketMessage);
        }
        // 使用syncSend发送批量消息
        SendResult sendResult = rocketMQTemplate.syncSend(topic, messageList);
        log.info("同步批量发送普通消息结果：{}",sendResult);
    }

运行结果：

[_GROUP_STRING_1] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：0
[_GROUP_STRING_2] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：1
[_GROUP_STRING_4] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：3
[_GROUP_STRING_5] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：4
[_GROUP_STRING_3] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：2
[_GROUP_STRING_6] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：5
[_GROUP_STRING_7] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：6
[_GROUP_STRING_8] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：7
[_GROUP_STRING_9] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：8
[GROUP_STRING_10] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 同步批量发送普通消息：9

4.2、异步消息

    @Test
    public void asyncSendBatchStringMessageWithBuilder() {
        String topic = "string_message_topic";
        String message = "Alian超级喜欢Golang语言：";
        List<Message<String>> messageList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Message<String> rocketMessage = MessageBuilder.withPayload(message + i)
                    // 设置消息类型
                    .setHeader(MessageHeaders.CONTENT_TYPE, "text/plain")
                    .build();
            // 加入到列表
            messageList.add(rocketMessage);
        }
        // 使用asyncSend发送批量消息
        rocketMQTemplate.asyncSend(topic, messageList, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                // 异步发送成功的回调逻辑
                log.info("异步批量发送普通消息成功: " + sendResult);
            }

            @Override
            public void onException(Throwable e) {
                // 异步发送失败的回调逻辑
                log.info("异步批量发送普通消息失败: " + e.getMessage());
            }
        });
    }

运行结果：

[_GROUP_STRING_1] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：0
[_GROUP_STRING_8] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：1
[_GROUP_STRING_3] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：7
[_GROUP_STRING_6] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：4
[_GROUP_STRING_9] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：2
[_GROUP_STRING_5] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：6
[GROUP_STRING_10] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：3
[_GROUP_STRING_2] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：8
[_GROUP_STRING_4] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：9
[_GROUP_STRING_7] c.a.concurrent.StringMessageConsumer     : 字符串消费者接收到的消息: 异步批量发送普通消息：5

4.3、顺序消息

  在 RocketMQ 中，RocketMQTemplate的syncSendOrderly方法，它允许你批量发送同步消息，主要参数：

  • topic：（和之前有区别，普通消息都发送到topic=ordered_string_message_topic）
  • Collection<T>：消息集合
  • hashKey：通过hashKey发送到同一个队列
    @Test
    public void syncSendBatchOrderlyStringMessagesWithBuilder() {
        String topic = "ordered_string_message_topic";
        String message = "同步批量发送顺序消息，超级喜欢Go语言：";
        List<Message<String>> messageList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Message<String> rocketMessage = MessageBuilder.withPayload(message + i)
                    // 设置消息类型
                    .setHeader(MessageHeaders.CONTENT_TYPE, "text/plain")
                    .build();
            // 加入到列表
            messageList.add(rocketMessage);
        }
        // 使用syncSendOrderly发送批量顺序消息，消费者线程设置为1
        SendResult sendResult = rocketMQTemplate.syncSendOrderly(topic, messageList, "alian_sync_ordered");
        log.info("批量发送顺序消息发送结果：{}",sendResult);
    }

运行结果：

[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：0
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：1
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：2
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：3
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：4
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：5
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：6
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：7
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：8
[GROUP_STRING_10] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: 同步批量发送顺序消息，超级喜欢Go语言：9

  所以我之前说批量发送消息的topic不一样，因为

@Slf4j
@Service
@RocketMQMessageListener(topic = "ordered_string_message_topic", 
						consumerGroup = "ORDERED_GROUP_STRING", 
						consumeMode = ConsumeMode.ORDERLY)
public class StringMessageConsumer implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("字符串消费者接收到的消息: {}", message);
        // 处理消息的业务逻辑
    }
}

  顺序消息要顺序消费，也就是每次是一个线程去消费，相当于单线程，也就有序了。关键就是配置了：consumeMode = ConsumeMode.ORDERLY

  当然，我们也可以把消费者线程数设置为 consumeThreadNumber = 1，也就是单线程消费了，从而确保了消息的顺序消费（指单实例）：

@RocketMQMessageListener(topic = "ordered_string_message_topic", 
						consumerGroup = "CONCURRENT_GROUP_STRING",
						consumeThreadNumber = 1)
public class StringMessageConsumer implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("字符串消费者接收到的消息: {}", message);
        // 处理消息的业务逻辑
    }
}

4.4、关于异步批量发送

  有可能你会写下面的异步批量发送顺序消息

	@Test
    public void asyncSendBatchOrderlyStringMessageWithBuilder2() {
        String topic = "ordered_string_message_topic";
        String message = "Alian超级喜欢Golang语言：";
        List<String> messageList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            // 加入到列表
            messageList.add(message + i);
        }
        // 使用 asyncSendOrderly 发送批量消息
        rocketMQTemplate.asyncSendOrderly(topic, messageList, "alian_async_ordered", new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                // 异步发送成功的回调逻辑
                log.info("异步消息发送字符串消息成功: " + sendResult);
            }

            @Override
            public void onException(Throwable e) {
                // 异步发送失败的回调逻辑
                log.info("异步消息发送字符串消息失败: " + e.getMessage());
            }
        });
    }

  其实这个是不对的，最终的结果是一个把你这里的messageList，当做了一个消息列表接收了，如下结果：

[GROUP_STRING_18] com.alian.ordered.StringMessageConsumer  : 字符串消费者接收到的消息: ["Alian超级喜欢Golang语言：0","Alian超级喜欢Golang语言：1","Alian超级喜欢Golang语言：2","Alian超级喜欢Golang语言：3","Alian超级喜欢Golang语言：4","Alian超级喜欢Golang语言：5","Alian超级喜欢Golang语言：6","Alian超级喜欢Golang语言：7","Alian超级喜欢Golang语言：8","Alian超级喜欢Golang语言：9"]

  RocketMQ对于单条消息和批量消息在队列中是如何被处理的？

  • 对于单条发送的消息，RocketMQ会按照队列中的顺序，将每条消息分发给一个消费者线程。因此，即使有多个消费者线程，由于每条消息都被单独处理，消费的顺序仍然会与发送的顺序一致。

  • 对于批量发送的消息，情况就有所不同。批量消息是作为一个整体发送的，因此在队列中，它们被视为一个单独的实体。当RocketMQ从队列中取出批量消息时，它会将整个批量消息作为一个整体分发给一个消费者线程。如果有多个消费者线程，由于操作系统的线程调度策略，处理批量消息的线程可能会在处理消息的过程中被调度出去，从而允许其他线程处理后面的消息。这样就可能导致消费的顺序与发送的顺序不一致。

4.5、结论

为此我测试了多次，得到结论：

  • 单条发送消息到同一个队列，使用多个消费线程消费该队列，由于消息本身是有序的，所以消费顺序也是有序的
  • 单批次批量发送消息到同一个队列，使用单个消费线程消费该队列，由于消费线程是单一的，所以消费顺序也是有序的
  • 单批次批量发送消息到同一个队列，使用多个消费线程消费时，消费顺序就不是有序的了

五、其他

  既然知道批量消息是作为一个整体的，那么肯定就会对消息大小有限制，在 Apache RocketMQ 中，批量消息的大小默认限制是4MB。这意味着，你不能发送总大小超过4MB的批量消息。

如果你想修改这个限制，你需要修改RocketMQ的配置。具体的修改方法如下：

  1. 找到RocketMQ的配置文件broker.conf，这个文件通常位于RocketMQ安装目录的conf目录下。
  2. 在broker.conf文件中，找到maxMessageSize这个配置项。这个配置项决定了批量消息的最大大小。
  3. 修改maxMessageSize的值为你想要的大小。注意，这个值是以字节为单位的，所以如果你想设置批量消息的最大大小为8MB，你应该设置maxMessageSize=8388608。
  4. 保存并关闭broker.conf文件。
  5. 重启RocketMQ的Broker服务，以使新的配置生效。

  虽然你可以通过修改配置来增加批量消息的最大大小，但是你应该谨慎地考虑这个决定。增加批量消息的最大大小可能会增加Broker的内存使用量，并可能影响到消息的发送和接收性能。因此，在修改这个配置之前，你应该先考虑你的应用的需求和Broker的性能。

  因为优先的是@RocketMQMessageListener 注解中设置 consumerGroup 和messageModel 参数。

嘉禾嘉宁papa
关注
专栏目录
RocketMQ批量消息发送
qq_57756904的博客
09-02 1553
批量消息发送能够提高发送效率，提升系统吞吐量。同一批批量消息的topic、waitStoreMsgOK属性必须保持一致，批量消息不支持延迟消息。批量消息发送一次最多可以发送 4MiB 的消息，但是如果需要发送更大的消息，建议将较大的消息分成多个不超过 1MiB 的小消息。
SpringBoot整合阿里RocketMQ
RickSunLee的博客
01-16 3345
什么是RocketMQ 阿里消息队列 RocketMQ版既可为分布式应用系统提供异步解耦和削峰填谷的能力，同时也具备互联网应用所需的海量消息堆积、高吞吐、可靠重试等特性，同时是收费的产品。 应用场景 削峰填谷 诸如秒杀、抢红包、企业开门红等大型活动时皆会带来较高的流量脉冲，或因没做相应的保护而导致系统超负荷甚至崩溃，或因限制太过导致请求大量失败而影响用户体验，消息队列 RocketMQ 版可提供削...
消息队列 RocketMQ：（七）批量消息
weixin_46812727的博客
08-11 3143
文章目录 消息队列 RocketMQ：（一）概述 消息队列 RocketMQ：（二）系统架构 消息队列 RocketMQ：（三）发送普通消息（三种方式） 消息队列 RocketMQ：（四）顺序消息 消息队列 RocketMQ：（五）延时消息 前提 创建一个 Maven 的 Java 工程。 引入 RocketMQ 的 Client 依赖，版本需要和服务端一致。 <dependency> <groupId>org.apache.rocketmq</groupId&g
Springboot&RocketMQ生产者发送消息
guojing99的博客
09-14 941
Springboot&RocketMQ生产者发送消息。RocketMQ中消息发送的三种方式（同步、异步、sendOneway）。同步发送（Sync Send）。发送一个简单的对象消息(同步发送)。异步发送（Async Send）。单向发送（Send Oneway）。发送消息带上tag、key关键信息。发送顺序消息 syncSendOrderly。
Rocketmq消息批量发送&消息批量消费
拽着尾巴的鱼儿的博客
05-30 8849
Pull是客户端需要主动到服务端取数据，优点是客户端可以依据自己的消费能力进行消费，但拉取的频率也需要用户自己控制，拉取频繁容易造成服务端和客户端的压力，拉取间隔长又容易造成消费不及时。批量消费消息是一种提高 RocketMQ 消费者性能和吞吐量的好方法，但需要注意消息列表大小、消息顺序和事务性质等问题，以确保消费者的可靠性和稳定性。前言：批量发送和消费消息在一定程度上可以提高吞吐量，减少带宽，那么Rocketmq 中的消息怎么进行批量的发送和批量的消费呢；计算消息的大小并进行压缩。
RocketMQ 发送批量消息、过滤消息和事务消息
Wayfreem的博客
04-17 801
使用 RocketMQ 发送批量消息、事务消息，以及如何过滤发送的消息
springboot整合rocketMq、rocketMq批量发送、消费、rocketMq手动发送和监听
m0_46861007的博客
01-06 6095
RocketMQ 是一款高性能、高吞吐量、低延迟的消息中间件。由阿里出品，后来捐赠给开源组织Apache。一般用于流量削峰填谷、异步通信、系统之间异步解耦、顺序消息、定时消息、事务消息等场景。RocketMQ5.0还支持类使用kafka的流处理。
RocketMQ学习笔记
Spring_East的博客
12-23 1040
优点：异步、解耦、削峰 缺点：系统可用性降低、复杂性提高、系统的一致性(若A系统成功，B、C系统失败) 适用于上下游关系，上游作为生产者，下游作为消费者 Producer 生产者 Producer Group 生产者组，发送同一类消息的生产者 Consumer 消息消费者 Consumer Group 消费者组，消费同一类消息的多个 consumer 实例组成一个消费者组 Name Server 为producer和cunsumer提供路由信息 Broker Broker 接收来自生产者.
基于RocketMQ实现服务异步通信SpringCloudAlibaba
m0_58008803的博客
12-28 416
首先咱们先来认识什么是消息队列 MQ 呢？ 消息队列与 RocketMQ 消息队列 MQ 消息队列（Message Queue）简称 MQ，是一种跨进程的通信机制，通常用于应用程序间进行数据的异步传输，MQ 产品在架构中通常也被叫作“消息中间件”。它的最主要职责就是保证服务间进行可靠的数据传输，同时实现服务间的解耦。 这么说太过学术，我们看一个项目的实际案例，假设市级税务系统向省级税务系统上报本年度税务汇总数据，按以往的设计市级税务系统作为数据的生产者需要了解省级税务系统的 IP、端口、接口等诸多细
SpringCloudAlibaba之基于RocketMQ实现服务异步通信
plpldog的博客
06-11 361
首先咱们先来认识什么是消息队列 MQ 呢？ 消息队列与 RocketMQ 消息队列 MQ 消息队列（Message Queue）简称 MQ，是一种跨进程的通信机制，通常用于应用程序间进行数据的异步传输，MQ 产品在架构中通常也被叫作“消息中间件”。它的最主要职责就是保证服务间进行可靠的数据传输，同时实现服务间的解耦。 这么说太过学术，我们看一个项目的实际案例，假设市级税务系统向省级税务系统上报本年度税务汇总数据，按以往的设计市级税务系统作为数据的生产者需要了解省级税务系统的 IP、端口、接口等诸多细
RocketMQ：批量消息
yanyf的博客
12-31 1154
* 批量发送消息能显著提高传递小消息的性能。限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOk， * 而且不能是延时消息。此外，这一批消息的总大小不应超过4MB * 如果超过4MB，这时候最好把消息进行分割 <dependency> <groupId>org.apache.rocketmq</groupId> ...
六.RocketMQ极简入门-RocketMQ消息批量发送
墨家巨子@俏如来
10-08 3357
使用场景 如果消息过多，每次发送消息都和MQ建立连接，无疑是一种性能开销，批量消息可以把消息打包批量发送，批量发送消息能显著提高传递小消息的性能。 批量消息概述 批量发送消息能显著提高传递小消息的性能。限制是这些批量消息应该有相同的topic，而且不能是延时消息。此外，这一批消息的总大小不应超过4MB，如果超过可以有2种处理方案： 1.将消息进行切割成多个小于4M的内容进行发送 2.修改4M的限制改成更大 可以设置Producer的maxMessageSize属性 修改配置文件中的maxMessageSi
rocketmq批量消息投递
chenghanlan5902的博客
08-02 225
批量发送消息可提高传递小消息的性能。同时也需要满足以下特征 批量消息要求必要具有同一topic、相同消息配置 不支持延时消息 建议一个批量消息最好不要超过1MB大小 示例 小于1MB String topic = "BatchTest"; List<Message&g...
SpringBoot集成RocketMQ实现三种消息发送方式
热门推荐
m0_37999219的博客
06-08 1万+
以上输出：发送者向MQ 执行发送消息API 时，指定消息发送成功后的回调函数，然后调用消息发送API 后，立即返回，消息发送者线程不阻塞，直到运行结束，消息发送成功或失败的回调任务在一个新的线程中返回。以上输出：消息发送者向MQ 执行发送消息API 时，直接返回，不等待消息服务器的结果，也不注册回调函数，只管发，不管是否成功存储在消息服务器上。以上输出可以看到：同步消息发送后，消息发送到broker后就返回结果了，消费端还未处理完，两者互互不影响。运行项目需要具备RocketMQ环境，参考。
RocketMQ笔记（七）SpringBoot整合RocketMQ发送事务消息
嘉禾嘉宁papa
04-07 2339
在之前的文章中，我讲过了，同步发送单条消息，异步发送单条消息，发送单向消息，发送顺序消息，以及批量发送消息，延迟消息。今天说下发送事务消息。事务消息交互流程如下图所示。生产者将消息发送至Apache RocketMQ服务端Apache RocketMQ服务端将消息持久化成功之后，向生产者返回Ack确认消息已经发送成功，此时消息被标记为"暂不能投递"，这种状态下的消息即为半事务消息生产者开始执行本地事务逻辑生产者根据本地事务执行结果向服务端提交二次确认结果（Commit或是Rollback。
【 RocketMQ —— 06 批量消息】
m0_72328778的博客
07-06 337
在RocketMQ中，批量消息（Batch Message）是一种高效的消息发送方式，适用于需要同时发送多条消息的场景。通过批量消息，生产者可以在一次网络请求中发送多条消息，从而提高吞吐量。下面是如何在Spring Boot项目中使用RocketMQ实现批量消息的示例。
RocketMQ快速入门：集成springboot实现各类消息发送｜异步、同步、顺序、单向、延迟、事务消息（六）附带源码
55555的博客
06-18 1262
上一节针对spring或其他框架集成rocketmq实现消息发送进行了讲解，而作为当前更加流行的springboot框架，实现rocketmq的集成则更加简单，本节我们就重点针对springboot集成rocketmq，实现异步、同步、单向、顺序、延迟、事务消息发送进行讲解，文末附上源码。
RocketMQ中如何实现消息的批量发送和消费？
最新发布
qq_33240556的博客
09-25 430
在 RocketMQ 中，批量发送和消费消息可以提高系统的吞吐量并减少网络开销。
RocketMQ批量消息的实现原理
yqqの博客
06-20 517
在高并发场景中，批量发送消息能显著提高传递消息发送时的性能（减少网络连接及IO的开销）。使用批量消息时的限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOK（集群时会细讲），且不能是延时消息。在发送批量消息时先构建一个消息对象集合，然后调用send(Collection msg)系列的方法即可。由于批量消息的4MB限制，所以一般情况下在集合中添加消息需要先计算当前集合中消息对象的大小是否超过限制，如果超过限制也可以使用分割消息的方式进行多次批量发送。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值