RocketMQ-CSDN博客

本文链接：https://blog.csdn.net/2301_76797112/article/details/131968082

文章介绍了RocketMQ的基本使用，包括生产者和消费者的创建与消息发送。在SpringBoot环境中，展示了同步、异步和单向发送消息的方法，以及配置文件中的相关设置。此外，提到了MQ在限流削峰、异步解耦等场景的应用。

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

RocketMQ入门案例

1.1先导入依赖

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

写一个生产者

步骤分析

1.创建producer组

2.设置NameServer地址

3.start启动生产者

4.发送消息

topic：主题

tags：标签

代码展示：

public class Producer {
    public static void main(String[] args) throws Exception {
        //创建producer组
        DefaultMQProducer producer = new DefaultMQProducer("producer-hello");
        //设置NameServer地址
        producer.setNamesrvAddr("127.0.0.1:9876");
        //startr生产者
        producer.start();
        //发送消息获取结果
        //String topic, String tags, byte[] body
        Message message = new Message("topic-order","tags-order-flow","物流信息".getBytes("utf-8"));
        SendResult result = producer.send(message);
        System.out.println(result);
        //结束producer
    }
}

代码解释：

DefaultMQProducer ： MQ生产者，可以指定组名 producerGroupName
producer.setNamesrvAddr ：指定Name Server地址，用作Brocker发现。注意IP和启动name server服务时指定的IP保持一致。
producer.start() ：启动生产者
new Message("topic_log","tags_error",("我是消息"+i).getBytes()) ：消息，参数为：topic，tags,内容
producer.send(message) : 发送消息

消费者：

1.创建consumer组

2.设置NameServer地址

3.订阅

4.设置消息回调处理监听->处理消息

5.Start consumer

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1. 创建consumer组
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer-hello");
        //2. 设置Name Server地址
        consumer.setNamesrvAddr("localhost:9876");
        //3. 订阅
        consumer.subscribe("topic-order","tags-order-flow");
        //4. 设置消息回调处理监听 -> 处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                list.forEach(messageExt -> {
                    byte[] body = messageExt.getBody();
                    String msg = new String(body, StandardCharsets.UTF_8);
                    System.out.println(msg);
                });
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5. Start consumer
        consumer.start();
    }

}

RocketMQ的使用

1.环境搭建

1.1导入依赖

<parent>
    <groupId> org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-spring-boot-starter</artifactId>
       <!-- <version>2.0.4</version> -->
         <version>2.2.1</version>
    </dependency>
 
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

1.2配置文件yml

rocketmq:
  name-server: 127.0.0.1:9876
  #生产者配置
  producer:
    #生产者组名字
    group: "service-producer"
    # 消息最大长度 默认 1024 * 1024 * 4 (4M)
    max-message-size: 4194304
    # 发送消息超时时间，默认 3000
    send-message-timeout: 3000
    # 发送消息失败重试次数，默认2
    retry-times-when-send-failed: 2
    # 异步消息发送失败重试次数
    retry-times-when-send-async-failed: 2
    #达到 4096 ，进行消息压缩
    compress-message-body-threshold: 4096
  consumer:
    #消费者名字
    group: "service-consumer"
    #批量拉取消息数量
    pull-batch-size: 10
    message-model: CLUSTERING
    selector-expression: "*"
server:
  port: 1111

1.3同步发送：

//同步发送
    @RequestMapping("/send/{message}")
    public String sendMessage(@PathVariable("message")String message){
        Message<String> build = MessageBuilder.withPayload(message).build();
        rocketMQTemplate.send("topic-orders:tags-order-flow",build);
        return "同步发送成功";
    }

1.4异步发送

//异步发送
    @RequestMapping("/callback/{message}")
    public String sendCallback(@PathVariable("message")String message){
        Message<String> build = MessageBuilder.withPayload(message).build();
        rocketMQTemplate.asyncSend("topic-orders:tags-order-flow",build,new SendCallback() {

            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println(sendResult);
            }

            @Override
            public void onException(Throwable e) {
                System.out.println("发送失败");
            }
        });
        return "异步发送成功";
    }

1.5单向发送

//单向发送
    @RequestMapping("/alone/{message}")
    public String sendAloneMessage(@PathVariable("message")String message){
        Message<String> build = MessageBuilder.withPayload(message).build();
        rocketMQTemplate.sendOneWay("topic-orders:tags-order-flow",build);
        return "单向发送成功";
    }

2.消费者

@Component
@RocketMQMessageListener(
        //消费者的名字
        consumerGroup = "consumer",
        //主题
        topic = "topic-orders",
        //tags
        selectorExpression = "tags-order-flow",
        //消息消费模式：默认是CLUSTERING集群，还支持BROADCASTING广播
        messageModel = MessageModel.CLUSTERING)
public class Consumer implements RocketMQListener<MessageExt> {

    @Override
    public void onMessage(MessageExt messageExt) {
        if (messageExt.getBody()==null || messageExt.getBody().length == 0)
                return;
            String msg = new String(messageExt.getBody(), StandardCharsets.UTF_8);
             System.out.println(msg);
    }
}

延迟消息实战

SendResult sendResult = mqTemplate.syncSend("topic-test:tags-test", message, 2000, 3);//延迟消息
        log.info("发送延迟消息{}",sendResult);

MQ的含义：

MQ全称为Message Queue，即消息队列，是一种提供消息队列服务的中间件，也称为消息中间件，是一套提供了消息生产、存储、消费全过程的软件系统，遵循FIFO原则。

MQ的使用场景(重要)

1.限流削峰

2.异步&解耦

3.数据收集

4.大数据处理