RocketMQ：发送消息与接收实例

最新推荐文章于 2024-07-31 21:26:52 发布

天空～之城

最新推荐文章于 2024-07-31 21:26:52 发布

阅读量418

点赞数

文章标签： rocketmq

本文链接：https://blog.csdn.net/weixin_42113716/article/details/132539012

版权

本文详细介绍了RocketMQ的四种消息发送方式：同步、异步、单向和顺序发送。同步发送适用于重要消息通知，异步发送适用于时间敏感场景，单向发送用于日志收集。顺序消息分为全局有序和分区有序，确保消息按照发送顺序消费。文中通过代码示例展示了如何实现这些功能。

摘要由CSDN通过智能技术生成

生产者发送消息的三种方式
1、同步发送
可靠同步发送
含义：同步发送是指消息发送方发出数据后，会在收到接收方发回响应之后才发下一个数据包的通讯方式
方式：调用DefaultMQProducer的send方法
应用场景：重要消息通知、短信通知等
2.异步发送
异步发送
含义：异步发送是指消息发送方发出数据后，不等待接收方响应，直接发送下一个数据包
方式：用户调用异步发送接口SendCallback
应用：时间敏感场景

3.单向发送
单向发送
含义：单向发送发送方只负责发送消息，不等待服务器回应，没有相应回调触发
发送消息时间短，通常为微妙级别
方式：sendOneway方法
应用：一定可靠性场景，如日志收集

4.顺序发送

创建项目，在生产者项目中添加test进行测试
在test目录下对应位置创建或修改已有测试类，添加自动注入生产者实例

@Autowired
DefaultMQProducer producer;

一、生产者

1）、pom.xml

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.0.2</version>
</dependency>

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.4.0</version>
</dependency>

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-common</artifactId>
    <version>4.3.0</version>
</dependency>

<!-- fastjson start -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

2)、配置文件 application.yml

rocketmq:
  name-server: 192.168.0.138:9876 #rocketMQ服务的地址(连接MQ服务器或MQ控制台使用)
  producer:
    group: provider-group # 生产者组
    #groupName: provider-group 
    namesrvAddr: 192.168.0.138:9876  # 文件中读取参数使用
    instanceName: rocketmq-consumer
    topic: order-topic01
    tag: "sms"
    # tag , "0||1||2"
    sendMsgTimeout: 10000
    maxMessageSize: 999999999
    compressOver: 40000

3)、MQ配置文件SpringConfig.java
在这里插入图片描述

package com.cloud.config;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfig {
    @Value("${rocketmq.producer.group}")
    private String groupName;
    @Value("${rocketmq.producer.namesrvAddr}")
    private String namesrvAddr;
    @Value("${rocketmq.producer.instanceName}")
    private String instanceName;
    @Value("${rocketmq.producer.sendMsgTimeout}")
    private int sendMsgTimeout;
    @Value("${rocketmq.producer.maxMessageSize}")
    private int maxMessageSize;
    @Value("${rocketmq.producer.compressOver}")
    private int compressOver;
    @Bean
    public DefaultMQProducer getRocketMQProducer() {
        DefaultMQProducer producer;
        producer = new DefaultMQProducer(this.groupName);
        producer.setNamesrvAddr(this.namesrvAddr);
        producer.setInstanceName(instanceName);
        producer.setSendMsgTimeout(this.sendMsgTimeout);
        producer.setCompressMsgBodyOverHowmuch(this.compressOver);
        producer.setMaxMessageSize(this.maxMessageSize);
        System.out.println("生产者已发送消息");
        /*RocketMq报错MQClientExceptionThe producer service state not OK, 
maybe started once, RUNNING*/
        /*https://blog.csdn.net/ibigboy/article/details/126436989*/
/*        try {
            System.out.println("Producer start...");
            producer.start();

        } catch (Exception e) {
            System.out.println(e);
        }*/
        return producer;
    }
}

二、消费者

1）、pom.xml

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.0.2</version>
</dependency>

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.4.0</version>
</dependency>

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-common</artifactId>
    <version>4.3.0</version>
</dependency>

<!-- fastjson start -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

2)、application.yml

rocketmq:
  name-server: 192.168.0.138:9876
  consumer:
    group: consumer-group
    namesrvAddr: 192.168.0.138:9876
    instanceName: rocketmq-consumer
  topic: order-topic01
  tag:  sms

3)、RocketConfig.java
在这里插入图片描述

package com.cloud.config;
import com.alibaba.fastjson.JSONException;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RocketConfig {
    @Value("${rocketmq.consumer.group}")
    String groupName;
    @Value("${rocketmq.consumer.namesrvAddr}")
    private String namesrvAddr;
    @Value("${rocketmq.consumer.instanceName}")
    private String instanceName;
    @Value("${rocketmq.topic}")
    private String topic;
    @Value("${rocketmq.tag}")
    private String tag;
    @Bean
    public DefaultMQPushConsumer getRocketMQConsumer() {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(this.groupName);
        consumer.setNamesrvAddr(this.namesrvAddr);
        consumer.setInstanceName(this.instanceName);
        consumer.setConsumeMessageBatchMaxSize(1);
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        /*consumer.setConsumeConcurrentlyMaxSpan(2000);  //单队列并行消费最大跨度，用于流控
        consumer.setPullThresholdForQueue(1000); // 一个queue最大消费的消息个数，用于流控
        //消息拉取时间间隔，默认为0，即拉完一次立马拉第二次，单位毫秒
consumer.setPullInterval(1000);
        consumer.setMessageModel(MessageModel.CLUSTERING);  //消费模式，集群消费*/
        try {
            consumer.subscribe(this.topic, tag);
            consumer.registerMessageListener((MessageListenerConcurrently) (msgList, consumeConcurrentlyContext) -> {
                try {
                    MessageExt msg = null;
                    for (MessageExt aMsgList : msgList) {
                        msg = aMsgList;
                        System.out.println("收到MQ消息："+new String(msg.getBody()));
                    }
                } catch (JSONException e) {
                    System.out.println(e);
                }
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            });
            consumer.start();
            System.out.println("已启动Conusmer【gruop:" + this.groupName + "，
instance:" + this.instanceName
                    + "】，监听TOPIC-{" + this.topic + "},tag-{" + this.tag + "}");
        } catch (MQClientException e) {
            System.out.println(e);
        }
        return consumer;
    }
}

三、在生产者项目中创建测试文件
在这里插入图片描述

SmsSend.java

package com.cloud;
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@SpringBootTest
public class SmsSend {
    @Autowired
    DefaultMQProducer producer;
    @Test
    void contextLoads() {
    }
    //RocketMQ学习二 【发送消息与接收实例】:https://blog.csdn.net/hey_lie/article/details/123180375
    /**
     * 1.同步发送
     * * 可靠同步发送
     * * 含义：同步发送是指消息发送方发出数据后，会在收到接收方发回响应之后才发下一个数据包的通讯方式
     * * 方式：调用DefaultMQProducer的send方法
     * * 应用场景： 重要消息通知、短信通知等
     * * 缺点：数据传输效率上稍慢
     */

    @Test
    void ReliableSynchronousT() throws MQBrokerException, RemotingException, InterruptedException, MQClientException 
        for (int i = 0; i < 10; i++) {
            final int index = i;
            /* Message body */
            Message msg = new Message("order-topic01" /* Topic */, "sms" /* Tag */, (" send hello rocketMq " +
                    index).getBytes(StandardCharsets.UTF_8));
            SendResult sendResult = producer.send(msg);
            System.out.println(sendResult.getSendStatus() + "  " + i);
        }
    }

    /**
     * 2.异步发送
     * /*
     *  * 异步发送
     *  * 含义：异步发送是指消息发送方发出数据后，不等待接收方响应，直接发送下一个数据包
     *  * 方式：用户调用异步发送接口SendCallback
     *  * 应用：时间敏感场景
     *  * 缺点：有消失丢失风险
     *  */

    @Test
    void AsyncT() throws RemotingException, InterruptedException, MQClientException {
        producer.setRetryTimesWhenSendAsyncFailed(0);
        CountDownLatch countDownLatch = new CountDownLatch(100);
        for (int i = 0; i < 10; i++){
            final  int index = i;
            Message msg = new Message("order-topic01"/*Topic*/,"sms"/*Tag*/, ("hello rocketMq by Async" +
                    index).getByte