RocketMQ學習（三）：消息類型——發送方式，接收方式，順序消息

準備工作

所需的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("消費者啓動");
    }
}

從結果可以看出，每個訂單的流程順序是正確的，達到了分區有序。且一個線程只會消費一個隊列裏的消息。

RocketMQ學習（三）：消息類型——發送方式，接收方式，順序消息

準備工作

基本屬性解釋

發送方式

1）同步消息

2）異步消息

3）單向消息

接收方式

1）負載均衡

2）廣播模式

順序消息

訂單類

生產者

消費者

RocketMQ學習（四）：消息類型——延時消息，批量消息，過濾消息，事務消息

RocketMQ學習（一）：入門

JAVA網絡編程（二）：UDP編程

RocketMQ學習（二）：集羣

JAVA網絡編程（一）：IP，端口，URL

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結