3-rocketmq-支持的消息种类

最新推荐文章于 2024-08-05 09:15:00 发布

「已注销」

最新推荐文章于 2024-08-05 09:15:00 发布

阅读量197

点赞数

文章标签：队列 java kafka 分布式 rabbitmq

本文链接：https://blog.csdn.net/m0_53121042/article/details/112344327

版权

RocketMQ消息支持的模式

普通消息 NormalProducer

消息同步发送

producer.send(Message msg)
消息异步发送

producer.send(Message msg, SendCallback sendCallback)
单向发送OneWay

producer.sendOneWay(Message msg);

顺序消息 OrderProducer

简介

顺序消息(FIFO 消息)是 MQ 提供的一种严格按照顺序进行发布和消费的消息类型。顺序消息由两个部分组成：顺序发布和顺序消费。
顺序消息包含两种类型：

分区顺序：一个Partition内所有的消息按照先进先出的顺序进行发布和消费
全局顺序：一个Topic内所有的消息按照先进先出的顺序进行发布和消费

全局顺序其实是分区顺序的一个特例，即使Topic只有一个分区(以下不在讨论全局顺序，因为全局顺序将面临性能的问题，而且绝大多数场景都不需要全局顺序)

在MQ的模型中，顺序需要由3个阶段去保障：

消息被发送时保持顺序
消息被存储时保持和发送的顺序一致(依赖1)
消息被消费时保持和存储的顺序一致(依赖2)

顺序发送和顺序存储由rocketmq保证，顺序消费需要由消费者业务层保证

RocketMQ顺序消息原理

Producer保证顺序发送，Consumer消费时通过一个分区只能有一个线程消费的方式来保证消息顺序

实现

生产者producer

producer只需要确保消息发送到特定的分区，也就是MessageQueue。通过MessageQueueSelector来实现分区的选择(自定义消息发送规则)

public class Producer {
    public static void main(String[] args) {
        try {
            DefaultMQProducer producer = new DefaultMQProducer("producerGroup1");
            producer.setNamesrvAddr("10.211.55.4:9876");
            producer.setRetryTimesWhenSendFailed(3);
            producer.start();
            String[] tags = new String[]{"创建订单", "支付", "发货", "收货", "五星好评"};
            for (int i = 5; i < 25; i++) {
                int orderId = i / 5;
                Message msg = new Message("OrderTopic1", tags[i % tags.length], "uniqueId:" + i,
                        ("order_" + orderId + " " + tags[i % tags.length]).getBytes(RemotingHelper.DEFAULT_CHARSET));
                /**
                 * 实现MessageQueueSelector 保证顺序发送
                 * 实现MessageQueueSelector的三种实现：
                 * SelectMessageQueueByHash
                 * SelectMessageQueueByMachineRoom
                 * SelectMessageQueueByRandom
                 */
                SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
                    @Override
                    public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                        //此刻arg == orderId,可以保证是每个订单进入同一个队列
                        Integer id = (Integer) arg;
                        int index = id % mqs.size();
                        return mqs.get(index);
                    }
                }, orderId);
                System.out.printf("%s%n", sendResult);
            }
            producer.shutdown();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

消费者consumer

消费者端需要保证消息消费的顺序性，最简单的办法就是单线程消费。使用MessageListenerOrderly实现消费监听

疑问：一个broker能否被多个consumer同时消费？

public class Consumer {
    public static void main(String[] args) {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");
        consumer.setNamesrvAddr("10.211.55.4:9876");
        try {
            //设置Consumer从哪开始消费
            consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
            consumer.subscribe("OrderTopic1", "*");
            // 实现了MessageListenerOrderly表示一个队列只会被一个线程取到, 第二个线程无法访问这个队列,MessageListenerOrderly默认单线程
//            consumer.setConsumeThreadMin(3);
//            consumer.setConsumeThreadMax(6);
            consumer.registerMessageListener(new MessageListenerOrderly() {
                @Override
                public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                    try {
                        System.out.println("orderInfo: " + new String(msgs.get(0).getBody(), "utf-8"));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return ConsumeOrderlyStatus.SUCCESS;
                }
            });
            consumer.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("Consumer1 Started.");
    }

}