RocketMQ 4.7.1 环境搭建、集群、SpringBoot整合MQ

导读

  之前学过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

双主双从集群搭建

点我直达

 

posted @ 2020-10-26 00:21  陈彦斌  阅读(5465)  评论(4编辑  收藏  举报