SpringBoot集成RocketMQ实现延时消费

前提：

运行项目需要具备RocketMQ环境，参考Docker搭建RocketMQ集群

一、pom依赖

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

二、配置yml文件

rocketmq:
  name-server: IP:9876  #IP为rocketmq访问的地址
  producer:
    group: first1-group  #事务消息才会用到

三、生产者

package com.tlxy.lhn.controller.rocketmq;

import com.tlxy.lhn.component.ProducerSchedule;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DelayController {

    @Autowired
    private ProducerSchedule producerSchedule;

    /**
     * 发送延时消息，模拟30分钟内未支付情况
     */
    @GetMapping("/pushMessageToDelayMQ")
    public void pushMessageToDelayMQ() {
        //消息主题和消息内容
        producerSchedule.send("MyTopic", "send delay message");

    }
}

package com.tlxy.lhn.component;

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Objects;

@Component
public class ProducerSchedule {
    private DefaultMQProducer producer;

    @Value("${rocketmq.producer.group}")
    private String producerGroup;

    @Value("${rocketmq.name-server}")
    private String nameServer;

    public ProducerSchedule() {
    }

    /**
     * 生产者构造
     *
     * @PostConstruct该注解被用来修饰一个非静态的void（）方法 Bean初始化的执行顺序：
     * Constructor(构造方法) -> @Autowired(依赖注入) -> @PostConstruct(注释的方法)
     */
    @PostConstruct
    public void DefaultMQProducer() {
        if (Objects.isNull(this.producer)) {
            this.producer = new DefaultMQProducer(this.producerGroup);
            this.producer.setNamesrvAddr(this.nameServer);
        }

        try {
            this.producer.start();
            System.out.println("Producer start");
        } catch (MQClientException e) {
            e.printStackTrace();
        }
    }


    public String send(String topic, String messageText) {
        Message message = new Message(topic, messageText.getBytes());

        /**
         * 延迟消息级别设置
         * messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
         */
        message.setDelayTimeLevel(4);

        SendResult result = null;
        try {
            // DefaultMQProducer.send() -> DefaultMQProducerImpl.send() -> DefaultMQProducerImpl.sendDefaultImpl()
            result = this.producer.send(message);
            System.out.println("MessageQueue: " + result.getMessageQueue());
            System.out.println("MsgId: " + result.getMsgId());
            System.out.println("SendStatus: " + result.getSendStatus());
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result.getMsgId();
    }
}

四、消费者（两种实现方式）

1、实现CommandLineRunner 接口

package com.tlxy.lhn.component;

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.message.Message;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * 普通消费
 */
@Component
public class PushConsumerSchedule implements CommandLineRunner {

    @Value("${rocketmq.consumer.group}")
    private String ConsumerGroup;

    @Value("${rocketmq.name-server}")
    private String nameServer;

    public void messageListener() throws MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(this.ConsumerGroup);
        consumer.setNamesrvAddr(this.nameServer);

        consumer.subscribe("MyTopic", "*");//订阅主题
        consumer.setConsumeMessageBatchMaxSize(1);//设置消费数量最大为1

        /**
         * 普通消费
         * 不追求时间顺序，只要把生产出来的消息全部消费完就可以。可以用并行的方式处理，效率高
         */
        consumer.registerMessageListener((MessageListenerConcurrently) (messages, context) -> {
            for (Message message : messages) {
                System.out.println("监听到消息: " + new String(message.getBody()));
            }
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });

        consumer.start();
    }

    @Override
    public void run(String... args) throws Exception {
        this.messageListener();
    }
}

测试结果：

2、消费者实现RocketMQListener、RocketMQPushConsumerLifecycleListener两个接口

package com.tlxy.lhn.component;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.apache.rocketmq.spring.core.RocketMQPushConsumerLifecycleListener;
import org.springframework.stereotype.Component;

import java.io.UnsupportedEncodingException;

@Component
@RocketMQMessageListener(topic = "MyTopic",
        selectorExpression = "*",
        consumerGroup = "consumer-group-test")
public class PushConsumerSchedule2 implements RocketMQListener<MessageExt>, RocketMQPushConsumerLifecycleListener {

    @Override
    public void onMessage(MessageExt message) {
        String msg = null;
        try {
            msg = new String(message.getBody(), "utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.err.println("注解方式接收到消息：MsgId:" + message.getMsgId() + "  QueueId:" + message.getQueueId() + " 消息[body]：" + msg);
        System.out.println("处理完成");
    }

    // 该方法重写消息监听器的属性
    @Override
    public void prepareStart(DefaultMQPushConsumer defaultMQPushConsumer) {
        // 每次拉取的间隔，单位为毫秒
        defaultMQPushConsumer.setPullInterval(2000);
        // 设置每次从队列中拉取的消息数为16
        defaultMQPushConsumer.setPullBatchSize(16);
    }
}

测试结果：

探索：

        1、RocketMq的四种消费类型（普通消费、顺序消费、事务消费、广播消费）使用场景？

        2、RocketMQ如何保证消息不丢失？

        3、RocketMQ如何存储消息？

        4、RocketMQ如何保证消息不被重复消费？