rocketmq template确认消息 rocketmq 消息顺序

转载

mob6454cc63081f 2024-04-11 22:25:47

文章标签 rocketmq 顺序消息 List apache java 文章分类 机器学习人工智能

核心知识之RocketMQ顺序消息讲解

简介：讲解RocketMQ顺序消息的使用和讲解
生产端保证发送消息有序，且发送到同一个Topic的同个queue里面，RocketMQ的确是能保证FIFO的

例子：订单的顺序流程是：创建、付款、物流、完成，订单号相同的消息会被先后发送到同一个队列中，
根据MessageQueueSelector里面自定义策略，根据同个业务id放置到同个queue里面，如订单号取模运算再放到selector中，同一个模的值都会投递到同一条queue

public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
		//如果是订单号是字符串，则进行hash,得到一个hash值
	  Long id = (Long) arg;
      long index = id % mqs.size();
      return mqs.get((int)index);
    }

消费端要在保证消费同个topic里的同个队列，不应该用MessageListenerConcurrently，

= 应该使用MessageListenerOrderly，自带单线程消费消息，不能再Consumer端再使用多线程去消费，消费端分配到的queue数量是固定的，集群消会锁住当前正在消费的队列集合的消息，所以会保证顺序消费。

官方例子 https://rocketmq.apache.org/docs/order-example/

案例实战之RocketMQ顺序消息消息者消费实战

简介：讲解使用代码编写案例，进行RocketMQ顺序消息消费实战

MessageListenerConcurrently

MessageListenerOrderly

Consumer会平均分配queue的数量

并不是简单禁止并发处理，而是为每个Consumer Quene加个锁，消费每个

消息前，需要获得这个消息所在的Queue的锁，这样同个时间，同个Queue的

消息不被并发消费，但是不同Queue的消息可以并发处理

扩展思维：为什么高并发情况下ConcurrentHashMap比HashTable和HashMap更高效且线程安全？

提示：分段锁Segment

示例代码

controller代码

@RequestMapping("/api/v1/pay_cb")
    public Object callback() throws Exception {
//      将消息发送到指定的队列
        DefaultMQProducer producer = payProducer.getProducer();
        List<ProductOrder> productList = ProductOrder.getProductList();
        for (int i = 0; i < productList.size(); i++) {
            Message msg = new Message(JmsConfig.TOPIC,"",productList.get(i).getOrderId() + "",productList.get(i).toString().getBytes());
            producer.send(msg, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                    long id = (long) o;
                    long l = id % list.size();
                    return list.get((int) l);
                }
            }, productList.get(i).getOrderId(), new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {

                }

                @Override
                public void onException(Throwable throwable) {

                }
            });
        }
        return new HashMap<>();
    }

生产消息

package net.lhw.lhwmq.jms;

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.springframework.stereotype.Component;

@Component
public class PayProducer {

    private DefaultMQProducer producer;
    private String producerGroup = "pay_group_producer";
    public PayProducer(){
        producer = new DefaultMQProducer(producerGroup);
        producer.setVipChannelEnabled(false);
        //指定NameServer地址，多个地址以 ; 隔开
        //如 producer.setNamesrvAddr("192.168.100.141:9876;192.168.100.142:9876;192.168.100.149:9876");
        producer.setNamesrvAddr(JmsConfig.NAME_SERVER);
        start();
    }


    public DefaultMQProducer getProducer(){
        return this.producer;
    }

    /**
     * 对象在使用之前必须要调用一次，只能初始化一次
     */
    public void start(){
        try {
            this.producer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
    }

    /**
     * 一般在应用上下文，使用上下文监听器，进行关闭
     */
    public void shutdown(){
        this.producer.shutdown();
    }
}

消费消息

package net.lhw.lhwmq.jms;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.*;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.springframework.stereotype.Component;

import java.io.UnsupportedEncodingException;
import java.util.List;

@Component
public class PayConsumer {

    private DefaultMQPushConsumer consumer;

    private String consumerGroup = "pay_consumer_group";

    public PayConsumer() throws MQClientException {
        consumer = new DefaultMQPushConsumer(consumerGroup);
        consumer.setNamesrvAddr(JmsConfig.NAME_SERVER);
        // 设置从最后一个开始消费
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);

        consumer.subscribe(JmsConfig.TOPIC, "*");
        /*
         * 方法一
         * */
        consumer.registerMessageListener(new MessageListenerOrderly() {

            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
                Message msg = list.get(0);
                try {
                    String topic = msg.getTopic();
                    String body = new String(msg.getBody(), "utf-8");
                    String tags = msg.getTags();
                    String keys = msg.getKeys();
                    System.out.println("topic=" + topic + ", tags=" + tags + ", keys=" + keys + ", msg=" + body);

                    return ConsumeOrderlyStatus.SUCCESS;

                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                    return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                }
            }
        });

        consumer.start();
        System.out.println("consumer start ...");

    }
}

实体类

package net.lhw.lhwmq.domain;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class ProductOrder implements Serializable {
    private long orderId;

    private String orderType;

    public ProductOrder(){}

    public ProductOrder(long orderId, String orderType){
        this.orderId = orderId;
        this.orderType = orderType;
    }

    public long getOrderId() {
        return orderId;
    }

    public void setOrderId(long orderId) {
        this.orderId = orderId;
    }

    public String getOrderType() {
        return orderType;
    }

    public void setOrderType(String orderType) {
        this.orderType = orderType;
    }

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

    public static List<ProductOrder> getProductList(){
        List<ProductOrder> list = new ArrayList<>();
        list.add(new ProductOrder(111l, "创建订单"));
        list.add(new ProductOrder(222l, "创建订单"));
        list.add(new ProductOrder(333l, "创建订单"));
        list.add(new ProductOrder(111l, "支付订单"));
        list.add(new ProductOrder(222l, "支付订单"));
        list.add(new ProductOrder(333l, "支付订单"));
        list.add(new ProductOrder(111l, "完成订单"));
        list.add(new ProductOrder(222l, "完成订单"));
        list.add(new ProductOrder(333l, "完成订单"));

        return list;
    }
}

代码运行结果

运行两个消费者终端
消费和生产结果
生产消息

producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D00009, offsetMsgId=2F68950D00002A9F00000000000108D5, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=3], queueOffset=93]
producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D0000A, offsetMsgId=2F68950D00002A9F00000000000109AF, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=2], queueOffset=93]
producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D0000B, offsetMsgId=2F68950D00002A9F0000000000010A89, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=1], queueOffset=93]
producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D0000C, offsetMsgId=2F68950D00002A9F0000000000010B63, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=3], queueOffset=94]
producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D0000D, offsetMsgId=2F68950D00002A9F0000000000010C3D, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=2], queueOffset=94]
producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D0000E, offsetMsgId=2F68950D00002A9F0000000000010D17, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=1], queueOffset=94]
producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D0000F, offsetMsgId=2F68950D00002A9F0000000000010DF1, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=2], queueOffset=95]
producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D00011, offsetMsgId=2F68950D00002A9F0000000000010FA5, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=3], queueOffset=95]
producer: SendResult [sendStatus=SEND_OK, msgId=A9FE7E08062F18B4AAC208A4C6D00010, offsetMsgId=2F68950D00002A9F0000000000010ECB, messageQueue=MessageQueue [topic=pay_prder_topic, brokerName=broker-a, queueId=1], queueOffset=95]

两个客户端的消费记录
客户端一

consumer ：  topic=pay_prder_topic, tags=null, keys=333, msg=ProductOrder{orderId=333, orderType='创建订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=333, msg=ProductOrder{orderId=333, orderType='支付订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=333, msg=ProductOrder{orderId=333, orderType='完成订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=333, msg=ProductOrder{orderId=333, orderType='创建订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=333, msg=ProductOrder{orderId=333, orderType='支付订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=333, msg=ProductOrder{orderId=333, orderType='完成订单'}

客户端二

consumer ：  topic=pay_prder_topic, tags=null, keys=111, msg=ProductOrder{orderId=111, orderType='创建订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=222, msg=ProductOrder{orderId=222, orderType='创建订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=111, msg=ProductOrder{orderId=111, orderType='支付订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=111, msg=ProductOrder{orderId=111, orderType='完成订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=222, msg=ProductOrder{orderId=222, orderType='支付订单'}
consumer ：  topic=pay_prder_topic, tags=null, keys=222, msg=ProductOrder{orderId=222, orderType='完成订单'}

我们看到，生产还是消费消息，都是按顺序进行的。