RocketMQ 4.7.1 環境搭建、叢集、MQ整合SpringBoot

陳彥斌發表於2020-10-26

MQSpring Boot

導讀

　　之前學過ActiveMQ但是併發量不是很大點我直達，所以又學阿里開源的RocketMQ，據說佇列可以堆積億級別。下面是網上找的訊息佇列對比圖，僅供參考

部署

官網

點我直達

前置條件

推薦使用64位作業系統，建議使用Linux / Unix / Mac；
64位JDK 1.8+;
Maven 3.2.x;
Git;
適用於Broker伺服器的記憶體4G +可用磁碟

下載

地址：https://downloads.apache.org/rocketmq/4.7.1/rocketmq-all-4.7.1-source-release.zip

百度雲盤：

連結: https://pan.baidu.com/s/1luq_MwxSn8k_bugrnQSJWg  密碼: varj

安裝依賴項

jdk：點我直達
maven：點我直達
git安裝：yum install -y git

export JAVA_HOME=/opt/soft/jdk1.8.0_202
export PATH=$JAVA_HOME/bin:$PATH
export CLASPATH=.:$JAVA_home/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export JAVA_HOME PATH CLASSPATH
export MAVEN_HOME=/opt/soft/apache-maven-3.6.3
export PATH=$PATH:$MAVEN_HOME/bin

mq上傳至linux

解壓

maven編譯

啟動NameServer

後臺啟動方式

nohup sh bin/mqnamesrv &

NameServer啟動時記憶體不足(問題解決)

找到runserver.sh 修改JAVA_OPT

vim /bin/runserver.sh配置

啟動Broker

nohup sh bin/mqbroker -n localhost:9876 &

語法：nohup sh bin/mqbroker -n NameServer服務ip地址

Broker記憶體不足（問題解決）

找到runbroker.sh 修改JAVA_OPT

vim /bin/runbroker.sh配置

服務都啟動成功

模擬消費

export NAMESRV_ADDR=localhost:9876

sh bin/tools.sh org.apache.rocketmq.example.quickstart.Producer

sh bin/tools.sh org.apache.rocketmq.example.quickstart.Consumer

開2個控制檯，連線通一臺linux

注意

　　NameServer預設埠號：9876；broker預設埠號：10911

視覺化控制檯

官網地址

點我直達

百度雲盤

連結: https://pan.baidu.com/s/1mdEGkq-JBTy1wtNmFPkmDg  密碼: v6bq

解壓

安裝編譯

進入：/opt/soft/rocketmq-externals-master/rocketmq-console
編譯： mvn clean package -Dmaven.test.skip=true

修改appliccation.properties的rocketmq.config.namesrvAddr

編譯打包

啟動

　　進入target目錄，啟動java -jar

守護程式啟動： nohup java -jar rocketmq-console-ng-2.0.0.jar &

SpringBoot整合RocketMQ(生產者)

建立SpringBoot專案

點我直達

專案結構

加入依賴

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ybchen</groupId>
    <artifactId>ybchen-mq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>ybchen-mq</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--注意： 這裡的版本,要和部署在伺服器上的版本號一致-->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.7.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-common</artifactId>
            <version>4.7.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

PayProducer.java

package com.ybchen.ybchenmq.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 String producerGroup = "pay_group";
    /**
     * MQ的地址，注意需開放埠號或者關閉防火牆
     */
    private String nameServerAddr = "192.168.199.100:9876";
    private DefaultMQProducer producer;

    public PayProducer() {
        producer = new DefaultMQProducer(producerGroup);
        //指定NameServer地址，多個地址以;隔開
        //如 producer.setNamesrvAddr("192.168.199.100:9876;192.168.199.101:9876;192.168.199.102:9876")
        producer.setNamesrvAddr(nameServerAddr);
        start();
    }

    /**
     * 獲取生產者
     * @return
     */
    public DefaultMQProducer getProducer() {
        return this.producer;
    }

    /**
     * 開啟，物件在使用之前必須要呼叫一次，只能初始化一次
     */
    public void start() {
        try {
            this.producer.start();
        } catch (MQClientException e) {
            e.printStackTrace();
        }
    }

    /**
     * 關閉，一般在應用上下文，使用上下文監聽器，進行關閉
     */
    public void shutdown() {
        this.producer.shutdown();
    }
}

PayController.java

package com.ybchen.ybchenmq.controller;

import com.ybchen.ybchenmq.jms.PayProducer;
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName：PayController
 * @Description：支付
 * @Author：chenyb
 * @Date：2020/10/18 2:47 下午
 * @Versiion：1.0
 */
@RestController
@RequestMapping("/api/v1")
public class PayController {
    @Autowired
    private PayProducer payProducer;

    private static final String TOPIC = "ybchen_pay_topic";

    /**
     * 支付回撥
     *
     * @param text
     * @return
     */
    @RequestMapping("pay_cb")
    public Object callback(String text) {
        /**
         * String topic：話題
         * String tags：二級分類
         * byte[] body：body訊息位元組陣列
         */
        Message message = new Message(TOPIC,"tag_a",("hello ybchen ==>"+text).getBytes());
        try {
            SendResult send = payProducer.getProducer().send(message);
            System.out.println("send------>"+send);
        } catch (MQClientException e) {
            e.printStackTrace();
        } catch (RemotingException e) {
            e.printStackTrace();
        } catch (MQBrokerException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "ok";
    }
}

測試

常見錯誤

錯誤一

org.apache.rocketmq.remoting.exception.RemotingTooMuchRequestException:
sendDefaultImpl call timeout

原因：阿里雲存在多網路卡，rocketmq會根據當前網路卡選擇一個IP使用，當你的機器有多塊網路卡時，很可能會有問題，比如，機器上有兩個ip，一個公網ip，一個私網ip，因此需要配置broker.conf指定當前公網的ip，然後重啟broker


修改配置：/opt/soft/rocketmq-all-4.7.1-source-release/distribution/target/rocketmq-4.7.1/rocketmq-4.7.1/conf/broker.conf
新增這個配置：brokerIP1=xxx.xxx.xxx.xxx

啟動命令：nohup sh bin/mqbroker -n localhost:9876 -c ./conf/broker.conf &

錯誤2

MQClientException: No route info of this topic, TopicTest1

原因：Broker 緊追自動建立Topic，且使用者沒有通過手工方式建立此Topic，或者broker和Nameserver網路不通

解決：
    通過sh bin/mqbroker -m 檢視配置
    autoCreateTopicEnable=true 則自動建立Topic

Centos 7 關閉防火牆：systemctl stop firewalld

錯誤3

控制檯檢視不了資料，提示連線10909錯誤

原因：Rocket預設開啟了VIP通道，VPI通道埠號為10911-2=10909

解決：阿里雲安全組新增一個埠：10909

錯誤4

　　無法自動建立topic：客戶端版本要和服務端版本保持一致

伺服器上裝的是4.7.1

引入依賴項時
        <!--注意： 這裡的版本,要和部署在伺服器上的版本號一致-->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.7.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-common</artifactId>
            <version>4.7.1</version>
        </dependency>

檢索訊息傳送

SpringBoot整合RocketMQ(消費者)

建立SpringBoot專案

專案結構

加入依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ybchen</groupId>
    <artifactId>ybchen-mq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>ybchen-mq</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--注意： 這裡的版本,要和部署在伺服器上的版本號一致-->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.7.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-common</artifactId>
            <version>4.7.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

PayConsumer.java

package com.ybchen.ybchenmqconsumer.jms;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
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.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;

/**
 * @ClassName：PayConsumer
 * @Description：消費者
 * @Author：chenyb
 * @Date：2020/10/18 4:13 下午
 * @Versiion：1.0
 */
@Component
public class PayConsumer {
    /**
     * 生產者所屬的組
     */
    private String producerGroup = "pay_consumer_group";
    /**
     * MQ的地址，注意需開放埠號或者關閉防火牆
     */
    private String nameServerAddr = "192.168.199.100:9876";
    /**
     * 訂閱主題
     */
    private String topic = "ybchen_pay_topic";
    private DefaultMQPushConsumer consumer;

    public PayConsumer() throws MQClientException {
        consumer = new DefaultMQPushConsumer(producerGroup);
        //指定NameServer地址，多個地址以;隔開
        //如 producer.setNamesrvAddr("192.168.199.100:9876;192.168.199.101:9876;192.168.199.102:9876")
        consumer.setNamesrvAddr(nameServerAddr);
        //設定消費地點，從最後一個開始消費
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        //訂閱主題，監聽主題下的那些標籤
        consumer.subscribe(topic, "*");
        //註解一個監聽器
        //lambda方式
//        consumer.registerMessageListener((MessageListenerConcurrently) (msg, context) -> {
//            try {
//                Message message = msg.get(0);
//                System.out.printf("%s Receive New Messages: %s %n",
//                        Thread.currentThread().getName(), new String(msg.get(0).getBody()));
//                //主題
//                String topic = message.getTopic();
//                //訊息內容
//                String body = null;
//                body = new String(message.getBody(), "utf-8");
//                //二級分類
//                String tags = message.getTags();
//                //鍵
//                String keys = message.getKeys();
//                System.out.println("topic=" + topic + ", tags=" + tags + ", keys=" + keys + ", msg=" + body);
//                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
//            } catch (UnsupportedEncodingException e) {
//                e.printStackTrace();
//                return ConsumeConcurrentlyStatus.RECONSUME_LATER;
//            }
//        });

        //一般方式
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                try {
                    Message message = list.get(0);
                    System.out.printf("%s Receive New Messages: %s %n",
                            Thread.currentThread().getName(), new String(list.get(0).getBody(),"utf-8"));
                    //主題
                    String topic = message.getTopic();
                    //訊息內容
                    String body = null;
                    body = new String(message.getBody(), "utf-8");
                    //二級分類
                    String tags = message.getTags();
                    //鍵
                    String keys = message.getKeys();
                    System.out.println("topic=" + topic + ", tags=" + tags + ", keys=" + keys + ", msg=" + body);
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                    return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                }
            }
        });
        consumer.start();
        System.out.println("consumer start ..........");
    }
}

application.properties

server.port=8081

測試生產者消費者

MQ叢集架構模式分析

單節點

優點

　　本地開發測試，配置簡單，同步刷盤訊息一條都不會丟

缺點

　　不可靠，如果當機，會導致服務不可用

主從(非同步、同步雙寫)

優點

　　同步雙寫訊息不丟失，非同步複製存在少量丟失你，主節點當機，從節點可以對外提供訊息的消費，但是不支援寫入

缺點

　　主備有短暫訊息延遲，毫秒級，目前不支援自動切換，需要指令碼或者其他程式進行檢測然後停止broker，重啟讓從節點成為主節點

雙主

優點

　　配置簡單，可以靠配置RAID磁碟陣列保證訊息可靠，非同步刷盤丟失少量訊息

缺點

　　master當機期間，未被消費的訊息在機器恢復之前不可訊息，實時性會受到影響

雙主雙從，多主多從模式(非同步複製)

優點

　　磁碟損壞，訊息丟失的非常小，訊息實時性不會受影響，Master當機後，消費者仍然可以從Slave消費

缺點

　　主備有短暫訊息延遲，毫秒級，如果Master當機，磁碟損壞情況，會丟失你少量訊息

雙主雙從，多主多從模式(同步雙寫)

優點

　　同步雙寫方式，主備都寫成功，才嚮應用返回成功，服務可用性與資料可用性非常高

缺點

　　效能比非同步複製模式略低，主當機後，備機不能自動切換為主機

主從叢集搭建

準備工作

　　準備2臺機器，ip地址分別為：192.168.199.100；192.168.199.101；

　　環境：RocketMQ4.7.1+jdk8+Maven+Centos 7

啟動兩臺nameserver

　　啟動兩個機器的nameserver

路徑：/opt/soft/rocketmq-all-4.7.1-source-release/distribution/target/rocketmq-4.7.1/rocketmq-4.7.1

啟動：nohup sh bin/mqnamesrc &

編輯並啟動roccketmq

主節點

進入：/opt/soft/rocketmq-all-4.7.1-source-release/distribution/target/rocketmq-4.7.1/rocketmq-4.7.1/conf/2m-2s-async


編輯並修改如下：vim broker-a.properties 
namesrvAddr=192.168.199.100:9876;192.168.199.101:9876
brokerClusterName=YbChenCluster
brokerName=broker-a
brokerId=0
deleteWhen=04
fileReservedTime=48
brokerRole=ASYNC_MASTER
flushDiskType=ASYNC_FLUSH


啟動：nohup sh bin/mqbroker -c conf/2m-2s-async/broker/broker-a.properties &

從節點

進入：/opt/soft/rocketmq-all-4.7.1-source-release/distribution/target/rocketmq-4.7.1/rocketmq-4.7.1/conf/2m-2s-async


編輯並修改如下：vim broker-a-s.properties 
namesrvAddr=192.168.199.100:9876;192.168.199.101:9876
brokerClusterName=YbChenCluster
brokerName=broker-a
brokerId=1
deleteWhen=04
fileReservedTime=48
brokerRole=SLAVE
flushDiskType=ASYNC_FLUSH


啟動：nohup sh bin/mqbroker -c conf/2m-2s-async/broker/broker-a-s.properties &

注意事項

namesrvAddr：相同
brokerClusterName：相同
brokerName：相同
brokerId：不同，0是主節點
deleteWhen：相同
fileReservedTime：相同
brokerRole：不同，分ASYNC_MASTER、SLAVE
flushDiskType：相同

啟動broker

使用管控臺

　　使用192.168.199.100這臺伺服器，修改配置

192.168.199.100這臺伺服器

進入：/opt/soft/rocketmq-externals-master/rocketmq-console/src/main/resources


修改配置檔案：vim application.properties

rocketmq.config.namesrvAddr=192.168.199.100:9876;192.168.199.101:9876


編譯

切換到：/opt/soft/rocketmq-externals-master/rocketmq-console
打包：
mvn clean
mvn install -Dmaven.test.skip=true


啟動

進入：/opt/soft/rocketmq-externals-master/rocketmq-console/target
守護程式方式啟動：nohup java -jar rocketmq-console-ng-2.0.0.jar &

叢集測試

故障演練

　　模擬主掛了，但是從還可以被消費，此時不能寫入，等主重啟後，可以繼續寫入(資料不會被重複消費)，以下內容是連續的

總結

　　好了，到目前為止，主從已經搭建完成了。

　　Broker分為Master和Slave，一個Master可以對應多個Slave，但一個Slave只能對應一個Master，Master與Slave通過相同的Broker Name來匹配，不同的Broker id來定義時Master還是Slave

　　　　Broker向所有的NameServer節點建立長連線，定時註冊Topic和傳送後設資料資訊

　　　　NameServer定時掃描(預設2分鐘)所有存活Broker的連線，如果超過時間沒響應，則斷開連線(心跳檢測)，但是Consumer客戶端不能感知，Consumer定時(30秒)從NameServer獲取topic的最新資訊，所以broker不可用時，Consumer最多需要30秒才能發現

　　只有Master才能進行寫入操作，Slave不允許寫入只能同步，同步策略取決於Master配置

　　客戶端消費可以從Master和Slave消費，預設消費者都從Master消費，如果在Master掛了之後，客戶端從NameServer中感知Broker當機，就會從Slave消費，感知非實時，存在一定的滯後性，Slave不能保證Master的100%都同步過來，會有少量的訊息丟失。一旦Master恢復，未同步過去的訊息會被最終消費掉。

　　如果Consumer例項的數量比Message Queue的總數量還多的話，多出來的Consumer例項將無法分到Queue，也就無法消費到訊息，也就無法起到分攤負載的作用，所以需要控制讓Queue的總數量大於Consumer的數量。

場景模擬

生產和消費重試及處理

生產者重試

訊息重試(保證資料的高可靠性)，本身內部支援重試，預設次數是2
如果網路情況較差，或者跨叢集則建議多改幾次

生產者設定重試次數，並設定唯一的key(一般唯一識別符號)

消費者重試

原因：訊息處理異常，broker端到consumer端各種問題，如網路原因閃斷，消費處理失敗，ACK返回失敗等
注意
- 重試間隔時間配置，預設每條訊息最多重試16次
- 超過重試次數人工補償
- 消費端去重
- 一條訊息無論重試多少次，這些重試訊息的Message ID，key不會改變
- 消費重試只針對叢集消費方式生效；廣播方式不提供失敗重試特性，即消費失敗後，失敗訊息不再重試，繼續消費新的訊息

設定廣播方式

模擬訊息重發

非同步傳送訊息和回撥實戰

應用場景

　　比如12306付完錢?後，非同步出票，對效能要求高，可以支援更高的併發，回撥成功後觸發相應的業務(onSuccess)

官方例子

點我直達

改造生產者

演示

onSuccess：因為是非同步方式，這裡可以記錄日誌啥的
onException：補償機制，根據實際情況使用，看是否進行重試

OneWay(無需等待)

應用場景

　　主要做日誌收集，適用於對效能要求高，但可靠性並不高的場景。

延遲訊息實戰

什麼是延遲訊息

Producer將訊息傳送到訊息佇列RocketMQ服務端，但並不期望這條訊息立馬投遞，而是推遲在當前時間點之後的某一個時間投遞到Consumer進行消費，該訊息即定時訊息，目前支援固定精度的訊息
延遲訊息級別，1....18

1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h

應用場景

通過訊息觸發一些定時任務，比如在某一固定時間點向使用者傳送提醒訊息
訊息生產和消費有時間視窗要求：比如在天貓電商交易中超時未支付關閉訂單的場景，在訂單建立時會傳送一條延遲訊息。這條訊息將會在30分鐘以後投遞給消費者，消費者收到此訊息後需要判斷對應的訂單是否已完成支付。如支付未完成，則關閉訂單。如已完成支付則忽略。

改生產者

生產者MessageQueueSelector實戰

簡介

　　生產訊息使用MessageQueueSelector投遞到Topic下指定的Queue

應用場景

順序訊息
分攤負載

預設topic下的queue數量是4，可以配置

支援同步，非同步傳送指定的MessageQueue

選擇的queue數量必須小於配置的，否則會出錯

好處

　　如果佇列中某個產品，流量暴增，隨機分配的話，會導致整個Topic都不能使用，指定到佇列的話，如果這個佇列壞了，其他佇列不影響使用。

改造生產者

同步傳送

傳送結果=SEND_OK，msg=SendResult [sendStatus=SEND_OK, msgId=AC1068013E3F18B4AAC276723EAC0000, offsetMsgId=C0A8C76400002A9F000000000009B536, messageQueue=MessageQueue [topic=ybchen_pay_topic, brokerName=broker-a, queueId=0], queueOffset=1]
傳送結果=SEND_OK，msg=SendResult [sendStatus=SEND_OK, msgId=AC1068013E3F18B4AAC27672BCD50001, offsetMsgId=C0A8C76400002A9F000000000009B602, messageQueue=MessageQueue [topic=ybchen_pay_topic, brokerName=broker-a, queueId=0], queueOffset=2]
傳送結果=SEND_OK，msg=SendResult [sendStatus=SEND_OK, msgId=AC1068013E3F18B4AAC27672CAA20002, offsetMsgId=C0A8C76400002A9F000000000009B6CF, messageQueue=MessageQueue [topic=ybchen_pay_topic, brokerName=broker-a, queueId=0], queueOffset=3]

　　可以看到列印出來的，queueId=0

非同步傳送

生產者端程式碼修改

    @Autowired
    private PayProducer payProducer;

    private static final String TOPIC = "ybchen_pay_topic";

    /**
     * 支付回撥
     *
     * @param text
     * @return
     */
    @RequestMapping("pay_cb")
    public Object callback(String text) {
        /**
         * String topic：話題
         * String tags：二級分類
         * byte[] body：body訊息位元組陣列
         */
        Message message = new Message(TOPIC, "tag_a", text.getBytes());
        //生產者使用MessageQueueSelector投遞到Topic下指定的Queue，arg只能小於等於4
//        try {
//            SendResult sendResult = payProducer.getProducer().send(message, new MessageQueueSelector() {
//                @Override
//                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
//                    int queueNum=Integer.parseInt(o.toString());
//                    return list.get(queueNum);
//                }
//            }, 0);
//            System.out.printf("傳送結果=%s，msg=%s",sendResult.getSendStatus(),sendResult);
//        } catch (MQClientException e) {
//            e.printStackTrace();
//        } catch (RemotingException e) {
//            e.printStackTrace();
//        } catch (MQBrokerException e) {
//            e.printStackTrace();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        //非同步傳送到指定的queue
        try {
            payProducer.getProducer().send(message, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                    int queueNum = Integer.parseInt(o.toString());
                    return list.get(queueNum);
                }
            }, 3, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.printf("傳送結果=%s，msg=%s", sendResult.getSendStatus(), sendResult);
                }

                @Override
                public void onException(Throwable e) {
                    e.printStackTrace();
                }
            });
        } catch (MQClientException e) {
            e.printStackTrace();
        } catch (RemotingException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
        //message.setDelayTimeLevel(2);
//        try {
//            SendResult send = payProducer.getProducer().send(message);
//            System.out.println("send------>"+send);
//        } catch (MQClientException e) {
//            e.printStackTrace();
//        } catch (RemotingException e) {
//            e.printStackTrace();
//        } catch (MQBrokerException e) {
//            e.printStackTrace();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        //非同步傳送
//        try {
//            payProducer.getProducer().send(message, new SendCallback() {
//                @Override
//                public void onSuccess(SendResult sendResult) {
//                    System.out.printf("傳送結果=%s，msg=%s",sendResult.getSendStatus(),sendResult);
//                }
//
//                @Override
//                public void onException(Throwable e) {
//                    e.printStackTrace();
//                    //補償機制，根據實際情況使用，看是否進行重試
//                }
//            });
//        } catch (MQClientException e) {
//            e.printStackTrace();
//        } catch (RemotingException e) {
//            e.printStackTrace();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        return "ok";
    }

順序訊息的應用場景

簡介

　　順序訊息可以應用到電商和證券系統，訂單系統。

什麼是順序系統？

　　訊息的生產和消費順序一致

全域性順序

　　topic下面全部訊息都要有序(很少用)

效能要求不高，所有的訊息嚴格按照FIFO(先進先出)原則進行訊息釋出和消費的場景，並行度成為訊息系統的瓶頸，吞吐量不夠
在證券處理中，以人民幣兌換美元為例，在價格相同的情況下，先出價者優先處理，則可以通過全域性順序的方式進行釋出和消費

區域性順序

　　只要保證一組訊息被順序消費即可(RocketMQ中使用)

效能要求高
電商的訂單建立，同一訂單相關的建立訂單訊息、訂單支付訊息、訂單退款訊息、訂單物流訊息、訂單交易成功訊息都會按照先後順序來發布和消費

順序釋出

　　對於指定的一個Topic，客戶端按照一定的先後順序傳送訊息

順序消費

　　對於指定的一個Topic，按照一定的先後順序接收訊息，即先傳送的訊息一定先會被客戶端接收到

注意事項

順序訊息不支援非同步傳送，否則將無法保證順序消費
順序訊息暫不支援廣播模式

官方例子

點我直達

改造生產者程式碼

建立ProductOrder.java

package com.ybchen.ybchenmq.entity;

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

/**
 * @ClassName：ProductOrder
 * @Description：訂單
 * @Author：chenyb
 * @Date：2020/10/25 12:56 下午
 * @Versiion：1.0
 */
public class ProductOrder implements Serializable {
    /**
     * 訂單id
     */
    private long orderIdl;
    /**
     * 訂單操作型別
     */
    private String type;

    public long getOrderIdl() {
        return orderIdl;
    }

    public void setOrderIdl(long orderIdl) {
        this.orderIdl = orderIdl;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public ProductOrder() {

    }

    public ProductOrder(long orderIdl, String type) {
        this.orderIdl = orderIdl;
        this.type = type;
    }

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

    /**
     * 模擬批量建立實體類
     * @return
     */
    public static List<ProductOrder> getOrderList(){
        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(111L,"完成訂單"));
        list.add(new ProductOrder(222L,"完成訂單"));
        list.add(new ProductOrder(333L,"支付訂單"));
        list.add(new ProductOrder(333L,"完成訂單"));
        return list;
    }
}

控制層：PayController.java

    @Autowired
    private PayProducer payProducer;

    private static final String TOPIC = "ybchen_pay_topic";
    private static final String TOPIC_ORDER = "ybchen_pay_order_topic";

    @RequestMapping("pay_order")
    public Object payOrder() throws Exception{
        //獲取訂單號
        List<ProductOrder> list=ProductOrder.getOrderList();
        for (int i = 0; i < list.size(); i++) {
            ProductOrder order=list.get(i);
            Message message=new Message(TOPIC_ORDER,
                    "",
                    order.getOrderIdl()+"",
                    order.toString().getBytes());
            //傳送，同一個訂單id進入同一個佇列中
           SendResult sendResult =payProducer.getProducer().send(message, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message message, Object arg) {
                    Long id=(Long)arg;
                    long index=id%mqs.size();
                    return mqs.get((int) index);
                }
            },order.getOrderIdl());
           //列印輸出結果
            System.out.printf("傳送結果=%s，sendResult=%s，orderId=%s，type=%s\n",
                    sendResult.getSendStatus(),
                    sendResult.toString(),
                    order.getOrderIdl(),
                    order.getType());

        }
        return "ok";
    }

改造消費者

package com.ybchen.ybchenmqconsumer.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.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @ClassName：PayOrderConsumer
 * @Description：消費者-訂單
 * @Author：chenyb
 * @Date：2020/10/18 4:13 下午
 * @Versiion：1.0
 */
@Component
public class PayOrderConsumer {
    /**
     * 生產者所屬的組
     */
    private String producerGroup = "pay_order_consumer_group";
    /**
     * MQ的地址，注意需開放埠號或者關閉防火牆
     */
    private String nameServerAddr = "192.168.199.100:9876;192.168.199.101:9876";
    /**
     * 訂閱主題，訂單
     */
    private static final String TOPIC_ORDER = "ybchen_pay_order_topic";
    private DefaultMQPushConsumer consumer;

    public PayOrderConsumer() throws MQClientException {
        consumer = new DefaultMQPushConsumer(producerGroup);
        //指定NameServer地址，多個地址以;隔開
        //如 producer.setNamesrvAddr("192.168.199.100:9876;192.168.199.101:9876;192.168.199.102:9876")
        consumer.setNamesrvAddr(nameServerAddr);
        //設定消費地點，從最後一個開始消費
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        //訂閱主題，監聽主題下的那些標籤
        consumer.subscribe(TOPIC_ORDER, "*");
        //預設是叢集方式，廣播方式不支援重試
        consumer.setMessageModel(MessageModel.CLUSTERING);
        //註解一個監聽器
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list,
                                                       ConsumeOrderlyContext consumeOrderlyContext) {
                MessageExt msg=list.get(0);
                System.out.printf("%s Receive New Messages: %s %n",Thread.currentThread().getName(),
                        new String(msg.getBody()));
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        consumer.start();
        System.out.println("consumer order start ..........");
    }
}

測試順序訊息

一個生產者一個消費者

　　可以看到消費的時候，有點慢，因為我本地安裝了2個虛擬機器做一主一從，消費的順序是正確的，都是按照：建立訂單、支付訂單、完成訂單

2020-10-25 13:52:31.822  INFO 1473 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2020-10-25 13:52:31.822  INFO 1473 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2020-10-25 13:52:31.825  INFO 1473 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 3 ms
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D46F0000, offsetMsgId=C0A8C76400002A9F000000000009C8B2, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=3], queueOffset=6]，orderId=111，type=建立訂單
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D4930001, offsetMsgId=C0A8C76400002A9F000000000009C9A5, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=2], queueOffset=6]，orderId=222，type=建立訂單
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D4A90002, offsetMsgId=C0A8C76400002A9F000000000009CA98, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=1], queueOffset=6]，orderId=333，type=建立訂單
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D4C00003, offsetMsgId=C0A8C76400002A9F000000000009CB8B, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=3], queueOffset=7]，orderId=111，type=支付訂單
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D4CC0004, offsetMsgId=C0A8C76400002A9F000000000009CC7E, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=2], queueOffset=7]，orderId=222，type=支付訂單
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D4D00005, offsetMsgId=C0A8C76400002A9F000000000009CD71, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=3], queueOffset=8]，orderId=111，type=完成訂單
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D4D30006, offsetMsgId=C0A8C76400002A9F000000000009CE64, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=2], queueOffset=8]，orderId=222，type=完成訂單
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D4DE0007, offsetMsgId=C0A8C76400002A9F000000000009CF57, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=1], queueOffset=7]，orderId=333，type=支付訂單
傳送結果=SEND_OK，sendResult=SendResult [sendStatus=SEND_OK, msgId=AC10680105C118B4AAC27E92D4F80008, offsetMsgId=C0A8C76400002A9F000000000009D04A, messageQueue=MessageQueue [topic=ybchen_pay_order_topic, brokerName=broker-a, queueId=1], queueOffset=8]，orderId=333，type=完成訂單

ConsumeMessageThread_1 Receive New Messages: ProductOrder{orderIdl=333, type='建立訂單'} 
ConsumeMessageThread_1 Receive New Messages: ProductOrder{orderIdl=333, type='支付訂單'} 
ConsumeMessageThread_1 Receive New Messages: ProductOrder{orderIdl=333, type='完成訂單'} 
ConsumeMessageThread_2 Receive New Messages: ProductOrder{orderIdl=222, type='建立訂單'} 
ConsumeMessageThread_2 Receive New Messages: ProductOrder{orderIdl=222, type='支付訂單'} 
ConsumeMessageThread_2 Receive New Messages: ProductOrder{orderIdl=222, type='完成訂單'} 
ConsumeMessageThread_3 Receive New Messages: ProductOrder{orderIdl=111, type='建立訂單'} 
ConsumeMessageThread_3 Receive New Messages: ProductOrder{orderIdl=111, type='支付訂單'} 
ConsumeMessageThread_3 Receive New Messages: ProductOrder{orderIdl=111, type='完成訂單'}

一個生產者3個消費者

　　消費者會平均分配queue的數量，消費者數量小於等於4！！！

　　本地線上模擬，一個生產者、3個消費者場景，看看消費的順序，內容較長，被分割3塊

消費者核心配置

setConsumeFromWhere

CONSUME_FORM_FIRST_OFFSET：初次從訊息佇列頭部開始消費，即歷史訊息(還儲存在broker的)全部消費一遍，後續在啟動接著上次消費的進度開始消費
CONSUME_FROM_LAST_OFFSET：預設策略，初次從該佇列尾開始消費，即跳過歷史小心，後續在啟動接著上次消費的進度開始消費
CCONSUME_FROM_TIMESTAMP：從某個時間點開始消費，預設是半小時以前，後續在啟動接著上次消費的進度開始消費

setAllocateMessageQueueStrategy

負載均衡策略演算法，即消費者分配到queue的演算法，預設值AllocateMessageQueueAveragely即取模平均分配

setOffsetStore

訊息消費進度儲存器，2個策略
- LocalFileOffsetStore(廣播模式預設使用)
- RemoteBrokerOffsetStore(叢集模式預設使用)

setConsumeThreadMin

最小消費執行緒池數量

setConsumeThreadMax

最大消費執行緒池數量

setPullBatchSize

消費者去broker拉取訊息時，一次次拉取多少條

setConsumeMessageBatchMaxSize

單次消費時一次性消費多少條訊息

setMessageModel

消費者消費模式
- CLUSTERING：預設是叢集模式
- BROADCASTING：廣播模式

Topic下佇列的奇偶數會影響Customer個數裡面的消費數量

如果是4個佇列(預設佇列為4)，8個訊息，4個節點則各會消費2條，如果不對等，則負載均衡會分配不均勻
如果consumer例項數量比message queue的總數量還多的話，多出來的consumer例項將無法分到queue，也就無法消費達到訊息，也就無法起到分攤負載的作用，所以需要控制讓queue的總數量大於consumer的數量

叢集模式(預設)

Consumer例項平均分攤消費生產者傳送的訊息
例如：訂單訊息，只能被消費一次

廣播模式

廣播模式下消費訊息，投遞到Broker的訊息會被每個Consumer進行消費，一條訊息被多個Consumer消費，廣播消費中ConsumerGroup暫時無用
例如：QQ群，群主發一條訊息，所有人都可以看到

訊息儲存

ConsumeQueue

　　邏輯佇列，預設儲存位置：/root/store/consumequeue

CommitLog

　　真正儲存訊息檔案的，預設儲存位置：/root/store/commitlog

常見面試題

為什麼訊息佇列？

優點

非同步：例如秒殺，可以使用，點我直達
解耦
削峰：秒殺情況下，一個個入隊，一個個出隊，有序進行

缺點

系統可用性越低：外部依賴越多，依賴越多，出問題風險越大
系統複雜性提高：需要考慮多種場景，比如訊息重複消費、訊息丟失
需要更多的機器和人力：訊息佇列一般叢集部署，需要運維和監控

如何避免重複消費？

　　RocketMQ不保證訊息不重複，如果業務保證嚴格的不能重複消費，需要自己去業務端去重

資料庫表去重

　　指定某個欄位唯一值

setNX

　　利用Redis的特性分散式鎖，下面是我之前的程式碼，待改造

package com.cyb.redis.utils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class jedisUtils {
    private static String ip = "192.168.31.200";
    private static int port = 6379;
    private static JedisPool pool;
    static {
        pool = new JedisPool(ip, port);
    }
    public static Jedis getJedis() {
        return pool.getResource();
    }
    public static boolean getLock(String lockKey, String requestId, int timeout) {
        //獲取jedis物件，負責和遠端redis伺服器進行連線
        Jedis je=getJedis();
        //引數3：NX和XX
        //引數4：EX和PX
        String result = je.set(lockKey, requestId, "NX", "EX", timeout);
        if (result=="ok") {
            return true;
        }
        return false;
    }

    public static synchronized boolean getLock2(String lockKey, String requestId, int timeout) {
        //獲取jedis物件，負責和遠端redis伺服器進行連線
        Jedis je=getJedis();
        //引數3：NX和XX
        //引數4：EX和PX
        Long result = je.setnx(lockKey, requestId);
        if (result==1) {
            je.expire(lockKey, timeout); //設定有效期
            return true;
        }
        return false;
    }
}

Redis原子遞增

　　利用Redis的incr特性，如果大於0說明消費過了(需要設定過期時間)

如何保證訊息的可靠性傳輸？

producer端

不採用oneway傳送，使用同步或者一部方式傳送，做好重試，但是重試的Message key必須唯一
投遞的日誌需要儲存，關鍵欄位、投遞時間、投遞狀態、重試次數、請求體、響應體等

broker端

雙主雙從架構，NameServer需要多節點
同步雙寫，非同步刷盤

consumer端

訊息消費儲存日誌檔案中

大量堆積到broker裡面，如何處理？

臨時topic佇列擴容，提高消費者能力
編寫臨時處理分發程式，從舊topic快速讀取到臨時新topic中，新topic的queue數量擴容多倍，然後再啟動更多consumer進行臨時新的topic消費

RocketMQ高效能的原因？

MQ架構配置

順序寫
隨機讀
零拷貝

傳送端高可用

雙主雙從架構：建立Topic的時候，MessageQueue建立在多個Broker上，即相同的Broker名稱，不同brokerid；當一個Master不可用時，組內其他的Master仍然可用

消費高可用

主從架構：Broker角色，Master提供讀寫，Slave只支援讀
Consumer不用配置，當Master不可用或者繁忙的時候，Consumer會自動切換到Slave節點進行讀取

提升訊息的消費能力

增加多個消費者
修改消費者的執行緒池最小/大數量

專案原始碼

案例原始碼

連結: https://pan.baidu.com/s/1Q8iL0lH-bdFEycYGq61hQg  密碼: rww2

Linux下RocketMQ安裝包

連結: https://pan.baidu.com/s/1dkE7sAs9E4TjwDQ38Pv4_A  密碼: mkjm

尾聲

　　過幾天搭建RocketMQ雙主雙從叢集，今天先到這兒~

【環境搭建】RocketMQ叢集搭建
2022-12-24
MQ
RocketMQ4.7.1雙主雙從叢集搭建
2020-10-30
MQ
深入理解Redis系列之叢集環境SpringBoot整合
2018-11-26
RedisSpring Boot
Zookeeper 叢集環境搭建
2018-07-25
es 5.5.3叢集環境搭建
2018-07-14
Redis叢集環境搭建實踐
2020-10-27
Redis
12. Redis叢集環境搭建
2020-10-07
Redis
rocketMq叢集master模式搭建
2022-01-26
MQAST模式
rocketMq之叢集搭建（三）
2020-12-07
MQ
Redis 結合 Docker 搭建叢集，並整合SpringBoot
2024-06-04
RedisDockerSpring Boot
k8s——搭建叢集環境
2024-05-06
K8S
高可用叢集環境搭建-留檔
2019-08-22
Mac 環境下 Redis 叢集的搭建
2021-09-09
MacRedis
ZooKeeper 系列（二）—— Zookeeper單機環境和叢集環境搭建
2019-07-01
RocketMQ系列（二）環境搭建
2020-06-05
MQ
Hadoop叢集之 ZooKeeper和Hbase環境搭建
2018-05-28
Hadoop
Windows 10環境簡單搭建ELK叢集
2019-03-20
Windows
RocketMQ雙主雙從叢集搭建
2020-09-24
MQ
Linux 環境下搭建Hadoop叢集(全分佈)
2018-09-20
LinuxHadoop
Ubuntu上搭建Hadoop叢集環境的步驟
2023-11-03
UbuntuHadoop
Hadoop框架：叢集模式下分散式環境搭建
2020-09-27
Hadoop框架模式分散式
搭建eureka叢集環境以及客戶端配置
2024-12-03
客戶端
Elasticsearch叢集搭建教程及生產環境配置
2021-09-01
Elasticsearch
在Docker中搭建rabbit MQ叢集（Mac + OrbStack）
2024-07-05
DockerMQMacORB
RocketMQ整合SpringBoot
2024-04-16
MQSpring Boot
SpringBoot(17）---SpringBoot整合RocketMQ
2019-06-30
Spring BootMQ
4 種高可用 RocketMQ 叢集搭建方案！
2020-11-29
MQ
hadoop之旅9-centerOS7 : hbase叢集環境搭建
2018-11-12
HadoopROS
基於docker環境下搭建redis主從叢集
2020-06-22
DockerRedis
Linux環境搭建Nginx+Tomcat負載均衡叢集
2018-12-23
LinuxNginxTomcat負載
SSM整合之CRUD環境搭建整合
2020-11-26
SSM
大資料叢集搭建 – 1. CDH叢集安裝 – 環境準備
2018-07-18
大資料
Apache SeaTunnel 2.3.5 Zeta-Server叢集環境搭建與使用
2024-08-13
ApacheServer
如何基於Jupyter notebook搭建Spark叢集開發環境
2021-10-12
Spark開發環境
Docker環境下秒建Redis叢集，連SpringBoot也整上了！
2020-03-31
DockerRedisSpring Boot
RocketMQ(1)---架構原理及環境搭建
2020-06-21
MQ架構
Redis 4.0叢集環境部署
2018-06-11
Redis
Linux環境快速搭建elasticsearch6.5.4叢集和Head外掛
2022-07-28
LinuxElasticsearch

RocketMQ 4.7.1 環境搭建、叢集、MQ整合SpringBoot

導讀

部署

官網

前置條件

下載

安裝依賴項

mq上傳至linux

解壓

maven編譯

啟動NameServer

後臺啟動方式

NameServer啟動時記憶體不足(問題解決)

啟動Broker

Broker記憶體不足（問題解決）

服務都啟動成功

模擬消費

注意

視覺化控制檯

官網地址

解壓

安裝編譯

啟動

SpringBoot整合RocketMQ(生產者)

建立SpringBoot專案

專案結構

加入依賴

PayProducer.java

PayController.java

測試

常見錯誤

錯誤一

錯誤2

錯誤3

錯誤4

檢索訊息傳送

SpringBoot整合RocketMQ(消費者)

建立SpringBoot專案

專案結構

加入依賴

PayConsumer.java

application.properties

測試生產者消費者

MQ叢集架構模式分析

單節點

優點

缺點

主從(非同步、同步雙寫)

優點

缺點

雙主

優點

缺點

雙主雙從，多主多從模式(非同步複製)

優點

缺點

雙主雙從，多主多從模式(同步雙寫)

優點

缺點

推薦

主從叢集搭建

準備工作

啟動兩臺nameserver

編輯並啟動roccketmq

注意事項

啟動broker

使用管控臺

叢集測試

故障演練

總結

場景模擬

生產和消費重試及處理

生產者重試

消費者重試

模擬訊息重發

非同步傳送訊息和回撥實戰

應用場景

官方例子

改造生產者

演示