Rocketmq

S Y H

已于 2023-04-23 14:25:06 修改

阅读量6.4k

点赞数 34

分类专栏：微服务组件文章标签： java

于 2021-11-29 12:43:52 首次发布

本文链接：https://blog.csdn.net/asddasddeedd/article/details/121607092

版权

微服务组件专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、Linux安装Rocketmq

1、linux安装jdk

由于Rocketmq使用java写的，所以运行环境需要jdk

第一步：将文件jdk-8u212-linux-x64.tar.gz（jdk）上传到 /root 目录

第二步：执行解压命令

# 将jdk解压到 /usr/local/ 目录
tar -xf jdk-8u212-linux-x64.tar.gz -C /usr/local/

# 切换到 /usr/local/ 目录, 显示列表, 查看解压缩的jdk目录
cd /usr/local
ll

第三步：配置环境变量

修改 /etc/profile 配置文件, 配置环境变量

vim /etc/profile

# 在文件末尾添加以下内容:

export JAVA_HOME=/usr/local/jdk1.8.0_212
export PATH=$JAVA_HOME/bin:$PATH

修改完后, 让环境变量立即生效

source /etc/profile

第四步：验证

java -version

----------------------------------------------------------------
java version "1.8.0_212"
Java(TM) SE Runtime Environment (build 1.8.0_212-b10)
Java HotSpot(TM) 64-Bit Server VM (build 25.212-b10, mixed mode)


javac -version

---------------
javac 1.8.0_212

2、linux安装Rocketmq

第一步：下载 rocketmq 二进制文件
wget https://mirror.bit.edu.cn/apache/rocketmq/4.7.0/rocketmq-all-4.7.0-bin-release.zip 

第二步：解压缩 rocketmq

将 rocketmq 解压到 /usr/local/ 目录

unzip rocketmq-all-4.7.0-bin-release.zip -d /usr/local/

# 修改一下文件夹名，改成 rocketmq 方便使用
mv /usr/local/rocketmq-all-4.7.0-bin-release /usr/local/rocketmq

第三步：配置环境变量 ROCKETMQ_HOME 和 PATH

为了后续操作方便可以配置环境变量，之后在任意位置都可以执行rocketmq的操作命令。
vim /etc/profile
# 在文件末尾添加以下内容:
export ROCKETMQ_HOME=/usr/local/rocketmq
export PATH=$ROCKETMQ_HOME/bin:$PATH
修改完后, 让环境变量立即生效
source /etc/profile

第四步：减小 rocketmq 使用的内存
rocketmq需要启动两个服务: name server 和 broker, name server 默认配置JVM使用的内存是4g, broker默认配置JVM使用的内存是8g.

开发环境中如果内存不足, 服务可能会无法启动, 可以通过降低两个服务的内存, 使服务可以正常启动, 也可以节省内存.

修改 name server 内存改为 256m
cd /usr/local/rocketmq/

# 编辑 bin/runserver.sh
vim bin/runserver.sh

# 找到文件中下面这一行:
JAVA_OPT="${JAVA_OPT} -server -Xms4g -Xmx4g -Xmn2g -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"

# 将 -Xms4g -Xmx4g -Xmn2g 修改为 -Xms256m -Xmx256m -Xmn128m
JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"
修改 broker 内存改为 256m
# 编辑 bin/runbroker.sh
vim bin/runbroker.sh

# 找到文件中下面这一行:
JAVA_OPT="${JAVA_OPT} -server -Xms8g -Xmx8g -Xmn4g"

# 将 -Xms8g -Xmx8g -Xmn4g 修改为 -Xms256m -Xmx256m -Xmn128m
JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m"

第五步，启动 rocketmq

先启动 name server

# 进入 rocketmq 目录
cd /usr/local/rocketmq/

# 启动 name server
nohup sh bin/mqnamesrv &

# 查看运行日志, 看到"The Name Server boot success."表示启动成功
tail -f ~/logs/rocketmqlogs/namesrv.log

再启动 broker

# 启动 broker, 连接name server: localhost:9876
nohup sh bin/mqbroker -n localhost:9876 &

# 查看运行日志, 看到"The broker[......:10911] boot success."表示启动成功
tail -f ~/logs/rocketmqlogs/broker.log

第六步. 关闭防火墙

rocketmq的通信会用到多个端口, 为了方便测试我们关闭防火墙
# 关闭防火墙
systemctl stop firewalld.service

# 禁止防火墙开机启动
systemctl disable firewalld.service

第七步：测试

运行测试, 启动生产者发送消息, 启动消费者接收消息

# 通过环境变量, 告诉客户端程序name server的地址
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

3、RocketMQ 的关闭命令

关闭 broker

mqshutdown broker

关闭 nameserver

mqshutdown namesrv

4、收发消息出现超时问题

cd /usr/local/rocketmq/

vim conf/broker.conf

末尾添加
brokerIP1=192.168.64.141

关闭 broker 服务
mqshutdown broker

重新使用 broker.conf 配置启动 broker
nohup sh bin/mqbroker -n localhost:9876 -c conf/broker.conf &

二、Linux安装Rocketmq的管理界面

(57条消息) RocketMQ (一) 安装_扎瓦江石的博客-CSDN博客

1、下载地址

在开源项目 rocketmq-dashboard 中提供了rocketmq 的管理界面: 地址为: https://github.com/apache/rocketmq-dashboard

github 在国内访问缓慢, 也可以使用码云的镜像项目, 地址为: https://gitee.com/mirrors_apache/rocketmq-dashboard

2、运行启动管理界面

打包的 jar 文件在 target 目录, 进入目录执行jar文件

# 进入 target 目录
cd target

# 运行管理界面
nohup java -jar rocketmq-console-ng-1.0.1.jar --server.port=8080 --rocketmq.config.namesrvAddr=localhost:9876 &

3、运行启动管理界面

http://192.168.64.141:8080

rocketmq

三、双主双从同步复制集群方案

RocketMQ (二) 双主双从同步复制集群方案_wanght笔记-CSDN博客

四、基本原理

在管理界面中新建主题Topic1，这里把写队列和读队列的数量都设置成3。

topic1

Topic1 主题，并创建了3写3读队列

perm 参数的含义

perm 参数是设置队列的读写权限，下面表格列出了可配置的值及其含义：

取值	含义
6	同时开启读写
4	禁写
2	禁读

Topic 收发消息原理

topic

生产者的负载均衡

producer

生产者以轮询的方式向所有写队列发送消息，这些队列可能会分布在多个broker实例上。

消费者的负载均衡

一个 group 中的多个消费者，可以以负载均衡的方式来接收消息。

读取队列被均匀分配给这些消费者，它们从指定的队列来接收消息。队列的分配可以采用不同的策略，这里简略介绍以下三种策略：

1、AllocateMessageQueueAveragely 平均分配

这是默认策略，它是这样分配队列的：

topic

2、 AllocateMessageQueueAveragelyByCircle 环形分配

如果使用环形分配，在消费者的代码中需要设置分配策略，代码如下：

consumer.setAllocateMessageQueueStrategy(new AllocateMessageQueueAveragelyByCircle());

topic

3、AllocateMessageQueueConsistentHash 一致性哈希

如果使用一致性哈希算法进行分配，在消费者的代码中需要设置分配策略，代码如下：

consumer.setAllocateMessageQueueStrategy(new AllocateMessageQueueConsistentHash());

这种算法依靠一致性哈希算法，看当前消费者可以落到哪个虚拟节点，该虚拟节点对应哪个队列。

五、使用RocketMQ原生API收发消息代码样例

添加依赖

    <dependencies>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
            <version>4.7.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-store</artifactId>
            <version>4.7.1</version>
        </dependency>

    </dependencies>

1、同步消息

同步消息发送要保证强一致性，发到master的消息向slave复制后，才会向生产者发送反馈信息。

这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。

同步消息代码

生产者代码

import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.Scanner;

//同步消息
public class Producer {

    public static void main(String[] args) throws MQBrokerException, RemotingException, InterruptedException, MQClientException {
        //1、新建生产者实例
        DefaultMQProducer p = new DefaultMQProducer("p1"); //参数为生产者组名字，无所谓，都可以

        //2、设置name server（注册中心）的地址
        p.setNamesrvAddr("192.168.64.141:9876");

        //3、启动（连接服务器）
        p.start();

        //4、发送消息
        while (true){
            System.out.println("请输入消息");
            String s = new Scanner(System.in).nextLine();

            //4.1、将要发送的消息封装到Message对象   import org.apache.rocketmq.common.message.Message;
            //参数一为注册名字，相当于一级标签，参数二（可加可不加）为二级标签,参数三为需要发送的消息，格式为byte数组
            Message msg = new Message("Topic1","Tap1",s.getBytes());

            //4.2、会得到一个反馈信息：发送到哪里，是否成功，等等）
            SendResult r =  p.send(msg);

            //打印反馈信息
            System.out.println(r);
        }
    }
}

消费者代码


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.message.MessageExt;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {

        //1、新建消费者实例
        DefaultMQPushConsumer c = new DefaultMQPushConsumer("c1");//参数为消费者组名字，无所谓，都可以

        //2、设置name server（注册中心）的地址
        c.setNamesrvAddr("192.168.64.141:9876");

        //3、订阅消息（指定在哪接收消息）
        // *                        - 所有标签
        // Tag1 || Tag2 || Tag3     - 多种标签
        // Tag1                     - 一种标签
        c.subscribe("Topic1","Tap1");

        //4、设置处理消息的监听器
        c.setMessageListener(new MessageListenerConcurrently() {  //多个线程并发接收处理消息（同时接收处理多条消息）
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : msgs) {
                    String s = new String(msg.getBody());
                    System.out.println("收到消息：" + s);
                }

                //表示消息处理成功
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;

                //有异常使用这个返回，告诉服务器重新发送，共计18次。并且请求间隔越来越长，最长间隔2小时。如果18次都处理失败，消息会进入死信队列。
                //return ConsumeConcurrentlyStatus.RECONSUME_LATER;
            }
        });

        //5、启动（连接服务器）
        c.start();
    }
}

2、延时消息

消息发送到 Rocketmq 服务器后，延迟一定时间再向消费者进行投递。

延时消息的使用场景：

比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存。

延时消息和同步消息唯一的区别就是添加了一段延时代码

msg.setDelayTimeLevel(3);

延时对应关系表

级别	延时时长
1	1s
2	5s
3	10s
4	30s
5	1m
6	2m
7	3m
8	4m
9	5m
10	6m
11	7m
12	8m
13	9m
14	10m
15	20m
16	30m
17	1h
18	2h

延时代码

生产者代码


import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;
import java.util.Scanner;

//延迟消息
public class Producer {

    public static void main(String[] args) throws MQBrokerException, RemotingException, InterruptedException, MQClientException {
        //1、新建生产者实例
        DefaultMQProducer p = new DefaultMQProducer("p1"); //参数为生产者组名字，无所谓，都可以

        //2、设置name server（注册中心）的地址
        p.setNamesrvAddr("192.168.64.141:9876");

        //3、启动（连接服务器）
        p.start();

        //4、发送消息
        while (true){
            System.out.println("请输入消息");
            String s = new Scanner(System.in).nextLine();

            //4.1、将要发送的消息封装到Message对象   import org.apache.rocketmq.common.message.Message;
            //参数一为注册名字，相当于一级标签，参数二（可加可不加）为二级标签,参数三为需要发送的消息，格式为byte数组
            Message msg = new Message("Topic1","Tap1",s.getBytes());

            //4.2、设置延迟级别
            msg.setDelayTimeLevel(3);

            //4.3、会得到一个反馈信息：发送到哪里，是否成功，等等）
            SendResult r =  p.send(msg);
            
            //打印反馈信息
            System.out.println(r);

        }
    }
}

消费者代码


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.message.MessageExt;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {

        //1、新建消费者实例
        DefaultMQPushConsumer c = new DefaultMQPushConsumer("c1");//参数为消费者组名字，无所谓，都可以

        //2、设置name server（注册中心）的地址
        c.setNamesrvAddr("192.168.64.141:9876");

        //3、订阅消息（指定在哪接收消息）
        // *                        - 所有标签
        // Tag1 || Tag2 || Tag3     - 多种标签
        // Tag1                     - 一种标签
        c.subscribe("Topic1","Tap1");

        //4、设置处理消息的监听器
        c.setMessageListener(new MessageListenerConcurrently() {  //多个线程并发接收处理消息（同时接收处理多条消息）
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : msgs) {
                    String s = new String(msg.getBody());
                    System.out.println("收到消息：" + s);
                }

                //表示消息处理成功
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;

                //有异常使用这个返回，告诉服务器重新发送，共计18次。并且请求间隔越来越长，最长间隔2小时。如果18次都处理失败，消息会进入死信队列。
                //return ConsumeConcurrentlyStatus.RECONSUME_LATER;
            }
        });

        //5、启动（连接服务器）
        c.start();
    }
}

3、顺序消息

上图演示了 Rocketmq 顺序消息的基本原理：

同一组有序的消息序列，会被发送到同一个队列，按照 FIFO 的方式进行处理
一个队列只允许一个消费者线程接收消息，这样就保证消息按顺序被接收

生产者发送消息

import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.List;
import java.util.Scanner;

//顺序消息
public class Producer {

    static String[] msgs = {
            "15103111039,创建",
            "15103111065,创建",
            "15103111039,付款",
            "15103117235,创建",
            "15103111065,付款",
            "15103117235,付款",
            "15103111065,完成",
            "15103111039,推送",
            "15103117235,完成",
            "15103111039,完成"
    };

    public static void main(String[] args) throws MQBrokerException, RemotingException, InterruptedException, MQClientException {

        //1、新建生产者实例
        DefaultMQProducer p = new DefaultMQProducer("p1"); //参数为生产者组名字，无所谓，都可以

        //2、设置name server（注册中心）的地址
        p.setNamesrvAddr("192.168.64.141:9876");

        //3、启动（连接服务器）
        p.start();

        //4、遍历数组发送消息
        for (String s : msgs){

            //4.1获取数组每个元素的id
            Long orderId =  Long.valueOf(s.split(",")[0]);

            //4.2、将要发送的消息封装到Message对象   import org.apache.rocketmq.common.message.Message;
            //参数一为注册名字，相当于一级标签，参数二（可加可不加）为二级标签,参数三为需要发送的消息，格式为byte数组
            Message msg = new Message("Topic2",s.getBytes());//服务器上没有Topic2，服务器上可以设置，默认可以自动创建

            //4.3、会得到一个反馈信息 参数一为要发送的消息，参数二为队列选择器，参数三为选择依据）
            SendResult r =  p.send(msg,
                    new MessageQueueSelector() {
                        @Override                          //参数一：队列信息，参数二：发送的消息对象，参数三：选择依据
                        public MessageQueue select(List<MessageQueue> list, Message message, Object o) {

                            Long orderId = (Long) o;
                            int index =(int) (orderId % list.size());
                            return list.get(index);
                         }
                     }, orderId);

            System.out.println(r);

        }
    }
}

消费者接收消息

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.message.MessageExt;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {

        //1、新建消费者实例
        DefaultMQPushConsumer c = new DefaultMQPushConsumer("c2");//参数为消费者组名字，无所谓，都可以

        //2、设置name server（注册中心）的地址
        c.setNamesrvAddr("192.168.64.141:9876");

        //3、订阅消息（指定在哪接收消息）       //消费者没有设置标签，这里使用*号表示接收所有
        c.subscribe("Topic2","*");

        //4、设置处理消息的监听器,MessageListenerOrderly监听器可以按顺序处理消息
        c.setMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {

                for (MessageExt msg : list){
                    String s = new String(msg.getBody());
                    System.out.println("收到:" + s);
                }
                return ConsumeOrderlyStatus.SUCCESS ;
            }
        });

        //5、启动
        c.start();
    }
}

4、事务消息

RocketMQ 提供了可靠性消息，也叫事务消息。下面分析一下其原理。

事务消息的原理

下面来看 RocketMQ 的事务消息是如何来发送“可靠消息”的，只需要以下三步：

发送半消息（半消息不会发送给消费者）
执行本地事务
提交消息

完成事务消息发送后，消费者就可以以正常的方式来消费数据。

RocketMQ 的自动重发机制在绝大多数情况下，都可以保证消息被正确消费。

假如消息最终消费失败了，还可以由人工处理进行托底。

上面分析的是正常情况下的执行流程。下面再来看两种错误情况：

事务执行失败时回滚消息
服务器无法得知消息状态时，需要主动回查消息状态

回滚：

消息回查：

生产者发送消息

import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.*;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.remoting.exception.RemotingException;

import java.util.Scanner;

//事务消息
public class Producer {


    public static void main(String[] args) throws MQBrokerException, RemotingException, InterruptedException, MQClientException {

        //1、新建生产者实例
        TransactionMQProducer p = new TransactionMQProducer("p3"); //参数为生产者组名字，无所谓，都可以

        //2、设置name server（注册中心）的地址
        p.setNamesrvAddr("192.168.64.141:9876");

        //3、创建事务监听器
        p.setTransactionListener(new TransactionListener() {
            //3.1、执行本地事务
            @Override                                        //参数一为消息，参数二为业务数据参数
            public LocalTransactionState executeLocalTransaction(Message message, Object o) {

                System.out.println("半消息发送后，执行本地事务 ；业务数据参数为：" + o);

                if (true){  //测试未知状态
                    return LocalTransactionState.UNKNOW;
                }

                //返回状态,要么成功要么失败
                if (Math.random() < 0.5){
                    System.out.println("本地事务执行成功，提交消息");
                    //成功
                    return LocalTransactionState.COMMIT_MESSAGE;
                }else {
                    System.out.println("本地事务执行失败，回滚消息");
                    //失败
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                }
                //表示是未知状态（实际业务中不可能出现这么模糊状态）
                //return LocalTransactionState.UNKNOW;
            }

            //3.2、处理Rocketmq服务器的事务回查操作
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
                //可能原因
                //1、由于网络中断，上面事务无法通知服务器
                //2、上面的本地事务执行缓慢，超过一分钟

                System.out.println("Rocketmq服务器正在回查事务状态");

                //模拟网络中断，无法得到事务状态
                return LocalTransactionState.ROLLBACK_MESSAGE;
            }
        });

        //4、启动（连接服务器）
        p.start();

        //5、发送事务消息（先发送半消息），会触发一个监听器执行本地事务
        while (true){
            System.out.println("输入消息：");
            String s = new Scanner(System.in).nextLine();
            Message msg = new Message("Topic3",s.getBytes());
            //参数二为传递给监听器的业务数据参数
            p.sendMessageInTransaction(msg,"传递业务数据参数");
        }

    }
}

消费者接收消息

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.message.MessageExt;

import java.util.List;

public class Consumer {

    public static void main(String[] args) throws MQClientException {

        //1、新建消费者实例
        DefaultMQPushConsumer c = new DefaultMQPushConsumer("c1");//参数为消费者组名字，无所谓，都可以

        //2、设置name server（注册中心）的地址
        c.setNamesrvAddr("192.168.64.141:9876");

        //3、订阅消息（指定在哪接收消息）
        c.subscribe("Topic3","Tap1");

        //4、设置处理消息的监听器
        c.setMessageListener(new MessageListenerConcurrently() {  //多个线程并发接收处理消息（同时接收处理多条消息）
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : msgs) {
                    String s = new String(msg.getBody());
                    System.out.println("收到消息：" + s);
                }

                //表示消息处理成功
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;

                //有异常使用这个返回，告诉服务器重新发送，共计18次。并且请求间隔越来越长，最长间隔2小时。如果18次都处理失败，消息会进入死信队列。
                //return ConsumeConcurrentlyStatus.RECONSUME_LATER;
            }
        });

        //5、启动（连接服务器）
        c.start();
    }
}

5、异步消息

master 收到消息后立即向生产者进行反馈。之后再以异步方式向 slave 复制消息。

异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。

S Y H

关注

34
点赞
踩
36

收藏

觉得还不错? 一键收藏
打赏
0
评论
Rocketmq

由于Rocketmq使用java写的，所以运行环境需要jdk将文件上传到 /root 目录执行解压命令配置环境变量修改 /etc/profile 配置文件, 配置环境变量修改完后, 让环境变量立即生效验证。
复制链接

扫一扫