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

陳彥斌發表於2020-10-26

導讀

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

部署

官網

點我直達

前置條件

  1. 推薦使用64位作業系統,建議使用Linux / Unix / Mac;
  2. 64位JDK 1.8+;
  3. Maven 3.2.x;
  4. Git;
  5. 適用於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

安裝依賴項

  1. jdk:點我直達
  2. maven:點我直達
  3. 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當機,磁碟損壞情況,會丟失你少量訊息

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

優點

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

缺點

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

推薦

  1. 主從(非同步、同步雙寫)
  2. 雙主雙從,多主多從模式(非同步複製)
  3. 雙主雙從,多主多從模式(同步雙寫)

主從叢集搭建

準備工作

  準備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 &

注意事項

  1. namesrvAddr:相同
  2. brokerClusterName:相同
  3. brokerName:相同
  4. brokerId:不同,0是主節點
  5. deleteWhen:相同
  6. fileReservedTime:相同
  7. brokerRole:不同,分ASYNC_MASTER、SLAVE
  8. 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下面全部訊息都要有序(很少用)

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

區域性順序

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

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

順序釋出

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

順序消費

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

注意事項

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

官方例子

點我直達

改造生產者程式碼

建立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

  1. CONSUME_FORM_FIRST_OFFSET:初次從訊息佇列頭部開始消費,即歷史訊息(還儲存在broker的)全部消費一遍,後續在啟動接著上次消費的進度開始消費
  2. CONSUME_FROM_LAST_OFFSET:預設策略,初次從該佇列尾開始消費,即跳過歷史小心,後續在啟動接著上次消費的進度開始消費
  3. 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

常見面試題

為什麼訊息佇列?

優點

  1. 非同步:例如秒殺,可以使用,點我直達
  2. 解耦
  3. 削峰:秒殺情況下,一個個入隊,一個個出隊,有序進行

缺點

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

如何避免重複消費?

  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端

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

broker端

  1. 雙主雙從架構,NameServer需要多節點
  2. 同步雙寫,非同步刷盤

consumer端

  1. 訊息消費儲存日誌檔案中

大量堆積到broker裡面,如何處理?

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

RocketMQ高效能的原因?

MQ架構配置

  1. 順序寫
  2. 隨機讀
  3. 零拷貝

傳送端高可用

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

消費高可用

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

提升訊息的消費能力

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

專案原始碼

案例原始碼

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

Linux下RocketMQ安裝包

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

尾聲

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

相關文章