RocketMQ学习（三）：消息类型——发送方式，接收方式，顺序消息

最新推荐文章于 2024-01-18 10:15:03 发布

IcyDate

最新推荐文章于 2024-01-18 10:15:03 发布

阅读量1.3k

点赞数 1

分类专栏：消息中间件 # RocketMQ 文章标签： RocketMQ 顺序消息

本文链接：https://blog.csdn.net/IcyDate/article/details/103255745

版权

消息中间件同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

RocketMQ

6 篇文章 1 订阅

订阅专栏

准备工作

所需的MQ客户端依赖

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.4.0</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.29</version>
</dependency>

基本属性解释

GroupName（组名）：代表具有相同角色的生产者组合或消费者组合，称为生产者组或消费者组。作用是在集群HA的情况下，一个生产者宕机，本地事务回滚后，可以继续联系该组下的另外一个生产者实例，不至于导致业务走不下去。

Topic（主题）：可理解为消息的一级目录，目的是能够把同一业务的消息归类。

Tag（标签）：可理解为消息的二级目录，能够对同一业务模块下的不同目的的消息再次分类。

发送方式

生产者步骤

创建消息生产者producer，并制定生产者组名
指定Nameserver地址
启动producer
创建消息对象，指定主题Topic、Tag和消息体
发送消息
关闭生产者producer

1）同步消息

同步消息指，消息发送后会等待broker响应，接收到响应结果后再发送下一条，一般用于对消息可靠性要求较高的场景，例如短信通知。

public class SyncProducer {
    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        // 2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.1.1:9876;192.168.1.2:9876");
        // 3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            // 4.创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("base", "tag1", ("Sync msg-" + i).getBytes());
            // 5.发送同步消息
            SendResult result = producer.send(msg);
            System.out.println("发送状态：" + result);
            System.out.println("消息ID：" + result.getMsgId());
            System.out.println("队列ID：" + result.getMessageQueue().getQueueId());
        }
        // 6.关闭生产者producer
        producer.shutdown();
    }
}

运行结果

2）异步消息

异步消息，消息发送后不会等待broker响应，而是在其回调函数中接收。用于发送端不能容忍长时间等待broker响应的场景。

public class AsyncProducer {
    public static void main(String[] args) throws Exception {
        // 1.创建消息生产者producer，并制定生产者组名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        // 2.指定Nameserver地址
        producer.setNamesrvAddr("192.168.1.1:9876;192.168.1.2:9876");
        // 3.启动producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            // 4.创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("base", "tag2", ("Async msg-" + i).getBytes());
            // 5.发送异步消息,并传递一个回调的匿名对象
            producer.send(msg, new SendCallback() {

                // 消息发送成功的回调
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.println("发送状态：" + sendResult.getSendStatus());
                    System.out.println("消息ID：" + sendResult.getMsgId());
                    System.out.println("队列ID：" + sendResult.getMessageQueue().getQueueId());
                }

                // 消息发送失败的回调
                @Override
                public void onException(Throwable throwable) {
                    System.out.println(throwable);
                }
            });
        }

        // 由于是异步，防止消息未发送完生产者就关闭了
        Thread.sleep(5000);
        producer.shutdown();
    }
}

值得注意的是，让主线程睡眠是为了防止生产者提前关闭，否则可能会抛出"The producer service state not OK, SHUTDOWN_ALREADY"，"No route info of this topic, xxx"

3）单向消息

一般用于不关心发送结果的场景，例如日志发送

public class OnewayProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        producer.setNamesrvAddr("192.168.1.1:9876;192.168.1.2:9876");
        producer.start();

        for (int i = 0; i < 10; i++) {
            // 4.创建消息对象，指定主题Topic、Tag和消息体
            Message msg = new Message("base", "tag3", ("Oneway msg" + i).getBytes());
            // 5.发送单向消息
            producer.sendOneway(msg);
        }
        // 6.关闭生产者producer
        producer.shutdown();
    }
}

接收方式

消费者步骤

创建消费者Consumer，制定消费者组名
指定Nameserver地址
订阅主题Topic和Tag
设置回调函数，处理消息
启动消费者consumer

1）负载均衡

负载均衡模式是消息消费的默认模式，多个消费者消费队列消息，每个消费者处理的消息不同

public class Comsumer {
    public static void main(String[] args) throws Exception {
        // 创建消费者Consumer，制定消费者组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        // 指定Nameserver地址
        consumer.setNamesrvAddr("192.168.1.1:9876;192.168.1.2:9876");
        // 订阅主题Topic和Tag
        consumer.subscribe("base", "tag1");

        // 设置消费模式负载均衡（不设置也是默认）
        consumer.setMessageModel(MessageModel.CLUSTERING);

        // 设置匿名内部类，处理消息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                list.forEach(item -> {
                    System.out.println(new String(item.getBody()));
                });
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 启动消费者consumer
        consumer.start();
    }
}

结果可以看到不同消费者消费的消息

2）广播模式

广播模式与负载均衡相反，每个消费者消费到的消息是相同的，只需要设置消费者的模式为

consumer.setMessageModel(MessageModel.BROADCASTING);

顺序消息

消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。

有读者可能会问，消息队列本身就是FIFO（先进先出），为何还要保证顺序。是因为，消费者将消息发送至broker中后，会采用Round Robin 轮询的方式，把消息存储到不同的消息队列中。而消费者会同时从多个消息队列拉取消息。这时如果多个消息具有连续性，例如订单的（创建→付款→推送→完成）这四个消息的顺序就不能保证一致。

要解决这个问题，就必须让同一订单的消息发送至同一个队列，消费者也只消费这一个队列（单线程）即可。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。

订单类

下面的例子以订单流程为基础，一个完整订单有四个消息（创建→付款→推送→完成），订单号相同的消息被先后发送至同一个队列。

public class Order {
    private int orderId; // 订单号
    private String desc; // 内容

    // 省略get/set，构造方法

    @Override
    public String toString() {
        return "Order{" +
                "orderId=" + orderId +
                ", desc='" + desc + '\'' +
                '}';
    }

    public List<Order> buildOrders() {
        List<Order> orderList = new ArrayList<Order>();

        Order orderDemo = new Order(1, "创建");
        orderList.add(orderDemo);

        orderDemo = new Order(2, "创建");
        orderList.add(orderDemo);

        orderDemo = new Order(1,"付款");
        orderList.add(orderDemo);

        orderDemo = new Order(3, "创建");
        orderList.add(orderDemo);

        orderDemo = new Order(2, "付款");
        orderList.add(orderDemo);

        orderDemo = new Order(3, "付款");
        orderList.add(orderDemo);

        orderDemo = new Order(2, "完成");
        orderList.add(orderDemo);

        orderDemo = new Order(1, "推送");
        orderList.add(orderDemo);

        orderDemo = new Order(3, "完成");
        orderList.add(orderDemo);

        orderDemo = new Order(1, "完成");
        orderList.add(orderDemo);

        return orderList;
    }
}

生产者

生产者要做的事通过订单id的不同，为消息指定送往的消息队列

public class OrderProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        producer.setNamesrvAddr("192.168.1.1:9876");
        producer.start();

        // 构建出消息集合
        List<Order> orderList = new Order().buildOrders();

        for (Order order : orderList) {
            Message msg = new Message("orderTopic", "order", order.toString().getBytes());

            /**
             * 参数一：消息对象
             * 参数二：消息队列选择器
             * 参数三：选择队列的业务标识
             */
            SendResult result = producer.send(msg, new MessageQueueSelector() {

                /**
                 *
                 * @param list 消息队列集合
                 * @param message 消息
                 * @param o 业务标识(send方法传递的标识，会在这个方法接收到)
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                    int orderId = (int) o;
                    int index = 0;
                    // 根据id选择不同的索引用于消息队列集合
                    switch (orderId) {
                        case 1:
                            index = 0;
                            break;
                        case 2:
                            index = 1;
                            break;
                        case 3:
                            index = 2;
                            break;
                    }
                    
                    // 返回的结果是要选择的消息队列
                    return list.get(index);
                }
            }, order.getOrderId()); // 这里是send方法第三个参数
        }

        producer.shutdown();
    }
}

消费者

消费者需要将消费消息的匿名内部类由MessageListenerConcurrently改为MessageListenerOrderly。

public class OrderConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        consumer.setNamesrvAddr("192.168.1.1:9876");
        consumer.subscribe("orderTopic", "order");

        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
                list.forEach(msg -> {
                    // 可以看到一个consume线程只消费一个queue, 订单对每个queue(分区)有序
                    System.out.println("【" + Thread.currentThread().getName() + "】从消息队列id为" + msg.getQueueId() + "消费了：" + new String(msg.getBody()));
                });

                return ConsumeOrderlyStatus.SUCCESS;
            }
        });

        consumer.start();
        System.out.println("消费者启动");
    }
}

从结果可以看出，每个订单的流程顺序是正确的，达到了分区有序。且一个线程只会消费一个队列里的消息。

IcyDate

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
RocketMQ学习（三）：消息类型——发送方式，接收方式，顺序消息

目录准备工作基本属性解释发送方式1）同步消息2）异步消息3）单向消息接收方式1）负载均衡2）广播模式顺序消息订单类生产者消费者准备工作所需的MQ客户端依赖<dependency> <groupId>org.apache.rocketmq</groupId> <artifact...
复制链接

扫一扫

专栏目录