RocketMQ

最新推荐文章于 2024-08-04 11:07:52 发布

DarzenWong

最新推荐文章于 2024-08-04 11:07:52 发布

阅读量2.8k

点赞数 2

文章标签： java 分布式 kafka

本文链接：https://blog.csdn.net/DarzenWong/article/details/122485404

版权

01. 初识 RocketMQ

1.1 简介

RocketMQ （MQ 即Message Queue）是阿里云的一款低延迟、高并发、高可用、高可靠的分布式消息中间件。该产品最初由阿里巴巴自研并捐赠给 Apache 基金会，服务于阿里集团 13 年，覆盖全集团所有业务。作为双十一交易核心链路的官方指定产品，支撑千万级并发、万亿级数据洪峰，历年刷新全球最大的交易消息流转记录，它具有以下特点：

能够保证严格的消息顺序
提供丰富的消息拉取模式
高效的订阅者水平扩展能力
实时的消息订阅机制
亿级消息堆积能力

RocketMQ单机可以支持亿级的消息堆积能力。单机1个Broker写入QPS约7万条/秒，单机部署3个Broker，可以跑到最高12万条/秒（消息大小10个字节）

1.2 应用场景

1）异步处理

在这里插入图片描述

将耗时较长的业务逻辑，进行异步处理，比如注册之后短信、邮箱的发送。

不使用异步处理，执行流程如下：

1、用户系统：用户注册，插入一条用户信息到数据库（耗时1s）

2、用户系统：调用邮件系统接口，发送邮件（3s）

3、用户系统：返回结果给用户（共耗费4s）

在这里插入图片描述

使用异步处理，执行流程如下：

1、用户系统：用户注册，插入一条用户信息到数据库（耗时1s）

2、用户系统：推送一条发送邮件的消息给MQ，耗费（耗时1s）

3、用户系统：返回结果给用户（共耗费2s）

4、邮件系统：从MQ获取发送邮件的消息，进行处理。

2）应用解耦

在这里插入图片描述

执行流程如下：

1、订单系统：用户下单后，订单系统完成持久化处理，将消息写入消息队列，返回用户订单下单成功。
2、库存系统：订阅下单的消息，采用拉/推的方式，获取下单信息，库存系统根据下单信息，进行库存操作。

假如在下单时库存系统不能正常使用，也不影响正常下单，因为订单系统写入消息队列后就不再关心其他的后续操作了。实现订单系统与库存系统的应用解耦。

3）流量削峰
应用场景：秒杀活动，一般会因为流量过大，导致流量暴增，应用挂掉。（试想：一个数据库能处理的最大连接数是有限制的，抢购的商品数也是有限制，比方说一共10万个用户来抢某个商品，商品数只有100，如果所有的请求都直接涌入数据库，对数据库的压力非常大）为解决这个问题，一般需要在应用上游加入消息队列。

在这里插入图片描述

执行流程如下（10万个用户抢100个商品）：

1、用户下单：假设有10个用户同时下单，即10万个请求同时进来。
2、请求处理服务：收到的请求数保存在redis当中（假设是N，初始值为0），每次收到新的请求，都会把N + 1，并且判断是否大于 100，如果大于100，则直接返回用户秒杀失败。否则把用户请求推送到MQ当中。

3、订单处理服务：从MQ中消费消息，把100个请求依次进行处理。

4）消息通讯

消息通讯是指，消息队列一般都内置了高效的通信机制，因此也可以用于消息通讯。比如实现点对点消息队列，或者聊天室等。

1.3 相关概念

在这里插入图片描述

Broker：存放消息的服务实例；
Queue（队列）：Broker中具体存放数据的数据结构；
NameServer（命名服务）：记录Broker的地址信息；
Producer（生产者）：生产并推送消息到Broker中；
Consumer（消费者）：从Broker中拉取到消息，并处理；
Broker、NameServer、Producer、Consumer都可以做集群；

在这里插入图片描述

1.4 小结

在这里插入图片描述

02. 安装 RocketMQ

2.1 安装JDK

1）上传jdk安装包并解压

# 进入/usr/local目录
cd /usr/local 
tar -zxvf jdk-8u171-linux-x64.tar.gz

2）设置环境变量

vi /etc/profile

JAVA_HOME=/usr/local/jdk1.8.0_171
PATH=$JAVA_HOME/bin:$PATH
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export JAVA_HOME
export PATH
export CLASSPATH

3）使得环境变量生效

source /etc/profile

4）验证

java -version

2.2 安装RocketMQ

下载地址：http://rocketmq.apache.org/dowloading/releases/

将 rocketmq-all-4.5.0-bin-release.zip 上传到Linux系统 /usr/local目录下；然后解压即可

# 安装unzip命名
yum install unzip -y

# 解压rocketmq-all-4.5.0-bin-release.zip
cd /usr/local
unzip rocketmq-all-4.5.0-bin-release.zip

2.3 启动

1）Name Server

# 修改默认jvm内存大小
cd /usr/local/rocketmq-all-4.5.0-bin-release/bin

vi runserver.sh
# 找文件的第39行，这是修改前的
# JAVA_OPT="${JAVA_OPT} -server -Xms4g -Xmx4g -Xmn2g -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"  
# 这是修改后的
# JAVA_OPT="${JAVA_OPT} -server -Xms512m -Xmx512m -Xmn256m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=128m"  

# 启动Name Server, 1>/dev/null代表标准输出不输出到文件, 2>&1代表标准错误输出不输出到文件, &代表后台启动
nohup ./mqnamesrv 1>/dev/null 2>&1  &

# jps查看是否启动
jps

2）Broker

# 1.修改默认jvm内存大小
cd /usr/local/rocketmq-all-4.5.0-bin-release/bin
vi runbroker.sh 
# 找文件的第39行，将所有的 8 都修改为 1 ；修改效果如下
# JAVA_OPT="${JAVA_OPT} -server -Xms8g -Xmx8g -Xmn4g"  这行是原来的
# JAVA_OPT="${JAVA_OPT} -server -Xms512m -Xmx512m -Xmn256m"  这是修改后的

# 2.修改broker配置文件
cd /usr/local/rocketmq-all-4.5.0-bin-release
vi conf/broker.conf
# 在这个文件的最后添加如下两行，ip地址记得要修改为自己的虚拟机IP
# 指定nameServer的地址
namesrvAddr = 192.168.253.128:9876
# 指定broker的地址
brokerIP1 = 192.168.253.128

# 3.启动Broker的时候加上配置文件
cd /usr/local/rocketmq-all-4.5.0-bin-release/bin
# autoCreateTopicEnable=true代表自动创建主题，-c指定配置文件
nohup ./mqbroker autoCreateTopicEnable=true -c ../conf/broker.conf 1>/dev/null 2>&1 &

2.4 停止

cd /usr/local/rocketmq-all-4.5.0-bin-release/bin

# 停止 Broker
./mqshutdown broker

# 停止 name server
./mqshutdown namesrv

# 执行停止命令后，稍等一会使用jps查看是否已经关闭，或者使用ps -ef| grep java
jps

03. RocketMQ-Console管理控制台

RocketMQ-Console是RocketMQ项目的扩展插件，是一个图形化管理控制台，提供Broker集群状态查看、Topic管理、Producer、Consumer状态展示、消息查询等常用功能，这个功能在安装好RocketMQ后需要额外单独安装、运行。它是一款使用spring boot开发的应用，在任意一台安装了java的机器运行该jar包即可。

将 rocketmq-console-ng-1.0.1.jar 上传到系统/usr/local下，然后启动（在windows上也可以运行）

# 启动 rocketmq-console管理控制台
cd /usr/local

nohup java -jar -Drocketmq.config.namesrvAddr=localhost:9876 rocketmq-console-ng-1.0.1.jar 1>/dev/null 2>&1 &

启动后在浏览器访问：http://虚拟机ip:8080

在这里插入图片描述

注意：要访问RocketMQ的各个组件需要开放端口，或者直接关闭防火墙；命令如下

systemctl stop firewalld

04. 快速入门

4.1 生产者

4.1.1 创建工程

在这里插入图片描述

4.1.2 添加依赖

将工程中的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 http://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.1.6.RELEASE</version>
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>rocketmq-spring-boot-producer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.0.2</version>
        </dependency>
    </dependencies>

</project>

4.1.3 配置文件

创建 application.yml 配置文件如下：

rocketmq:
  name-server: 192.168.253.128:9876
  producer:
    group: rocket-producer
server:
  port: 9090

4.1.4 启动类

创建 com.itheima.ProducerApplication 类；代码如下：

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProducerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class);
    }
}

4.1.5 编写控制器

创建 com.itheima.controller.RocketMqController ，用于发送消息

package com.itheima.controller;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/mq")
@RestController
public class RocketMqController {
    
    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @GetMapping("/hi")
    public String sayHello(){
        /**
         * 参数1：主题:标签，如果没有标签则直接写主题名称即可
         * 参数2：要发送的消息内存
         */
        rocketMQTemplate.convertAndSend("news:spring", "你好！火箭。");
        return "success";
    }
}

启动生产者，访问：http://localhost:9090/mq/hi

在这里插入图片描述

4.2 消费者

4.2.1 创建工程

在这里插入图片描述

4.2.2 添加依赖

将工程中的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 http://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.1.6.RELEASE</version>
    </parent>

    <groupId>com.itheima</groupId>
    <artifactId>rocketmq-spring-boot-consumer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.0.2</version>
        </dependency>
        
    </dependencies>

</project>

4.2.3 配置文件

创建 application.yml 配置文件如下：

rocketmq:
  name-server: 192.168.253.128:9876

4.2.4 启动类

创建 com.itheima.ConsumerApplication 类；代码如下：

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class);
    }
}

4.2.5 创建监听器

创建 com.itheima.listener.MyMessageListener 用于接收来自MQ的消息监听器；

package com.itheima.listener;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(
        // 主题
        topic = "news",
        // 标签表达式
        selectorExpression = "spring",
        // 消费者组名称
        consumerGroup = "rocketmq-consumer"
)
public class MyMessageListener implements RocketMQListener<String> {
    @Override
    public void onMessage(String message) {
        // 如果方法报错，MQ会重发消息
        System.out.println("接收到消息：" + message);
    }
}

启动消费者，控制台会输出：

在这里插入图片描述

RocketMQ是基于发布与订阅模式，可以在订阅了主题并符合过滤标签的消费者都可以接收到消息。但是若在同一个消费者组中，则消费者之间是竞争关系。

4.3 小结

生产者
- 添加启动器依赖
- 添加yml配置：1、指定命名服务地址；2、指定生产者组
- 注入RocketMQTemplate，调用convertAndSend方法，指定主题:标签，消息内容
消费者
- 添加启动器依赖
- 添加yml配置：1、指定命名服务地址
- 创建消息监听器：
  - 实现RocketMQListener
  - 添加@Component
  - 添加@RocketMQMessageListener，指定消费者组、订阅的主题及标签

05. RocketMQ模式-简单模式

RocketMQ支持好几种消息模式，分别有：简单模式（同步发送消息、异步发送消息、单向发送消息）、有序消息模式、广播模式、事务性消息模式、延时、过滤、批量发送等模式。

5.1 同步发送消息

5.1.1 介绍

同步发送消息指的是生产者发送消息后会等待MQ返回结果之后才能继续其它操作。例如：多个人排队在一个电话亭打电话。

在这里插入图片描述

**应用场景：**重要通知邮件、报名短信通知、营销短信系统（SMS通知，SMS营销系统等广泛的场景中使用可靠的同步传输）

5.1.2 相关API

// 转换并发送，等价于简单模式-同步发送消息
// 参数1-主题:标签，参数2-消息内容（可以是一个普通对象，它会自动转成message对象）
rocketMQTemplate.convertAndSend("news:spring", "你好！火箭");

// 简单模式-同步发送消息，参数1-主题:标签，参数2-构建得到一个message对象
rocketMQTemplate.syncSend("news:spring", MessageBuilder.withPayload("你好！火箭").build());
rocketMQTemplate.send("news:spring", MessageBuilder.withPayload("你好！火箭").build());

快速入门的代码就是同步发送，不再编写。

5.2 异步发送消息

5.2.1 介绍

特点：异步发送消息指的是生产者发送消息后不会等待MQ返回结果，可以马上进行下一条消息发送或者其它操作。发送出去即刻返回，利用回调做后续处理。例如：核酸检测完了后，不是直接告诉你结果，而是通过你留下的电话告知你结果。

在这里插入图片描述

应用场景： 常用于响应时间敏感的业务场景。通俗说就是想快点完成，做其他事。

5.2.2 代码实现

在生产者控制器中，添加新方法如下：

/**
 * 异步发送
 */
@GetMapping("/async")
public String async() {

    for (int i = 0; i < 5; i++) {
        final int index = i;
        String msgStr = "littlebaby " + i;
        System.out.println("发送消息：" + msgStr);

        // 参数1-主题:标签，参数2-消息对象
        template.asyncSend("news:spring", MessageBuilder.withPayload(msgStr).build(), new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println("发送成功，下标：" + index + "，结果：" + sendResult);
            }

            @Override
            public void onException(Throwable throwable) {
                System.out.println("发送失败，下标：" + index + "，异常消息：" + throwable.getMessage());
            }
        });
    }
    return "async";
}

5.2.3 测试

1）重启生产者，访问http://localhost:9090/mq/async，控制台输出：

在这里插入图片描述

为什么发送的顺序和收到发送结果的顺序不一致？

举个例子：很多人排队做核酸检测时，采咽拭子可能是按照顺序来的，但是递交上去之后，做检验并不一定按照顺序来的，最后通知结果的顺序也当然就可能不一样了。同理，发送完消息后，MQ要把消息放到磁盘上这个动作是多线程完成的，可能有些线程做的快，有些线程做的慢，做的快的就先返回结果。

2）消费者控制台输出：

在这里插入图片描述

为什么收到的顺序也如此混乱？

消费者内部处理这些消息也是通过多线程完成的。

5.3 单向发送消息

5.3.1 介绍

**特点：**单向（Oneway）发送特点为只负责发送消息，不等待服务器回应且没有回调函数触发，即只发送请求不等待应答。此方式发送消息的过程耗时非常短，一般在微秒级别。

**应用场景：**适用于某些耗时非常短，但对可靠性要求并不高的场景，例如分布式日志管理系统中的日志收集。

5.3.2 代码实现

在生产者控制器中，添加新方法如下：

/**
 * 单向发送
 */
@GetMapping("/oneway")
public String oneway() {
    template.sendOneWay("news:spring", MessageBuilder.withPayload("单向消息").build());
    return "oneway";
}

5.2.3 测试

1）重启生产者，访问http://localhost:9090/mq/oneway

2）消费者控制台输出：

在这里插入图片描述

5.4 小结

方式	速度	返回结果	可靠性
同步	较快	有	不丢失消息
异步	快	有	不丢失消息
单向	最快	无	可能丢失消息

06. RocketMQ模式-有序消息模式

6.1 介绍

**特点：**顺序消息（FIFO 消息）是 MQ 提供的一种严格按照顺序进行发布和消费的消息类型。顺序消息由两个部分组成：顺序发布和顺序消费。

**应用场景：**如网上购物的时候；需要发送 ①创建订单，②订单付款，③订单完成3类消息的时候，使用有序消息可以让3类消息顺序发送、顺序消费。

6.2 实现原理

6.2.1 顺序发布

是同一个topic下的消息，只要是放到同一个队列中，肯定是按照顺序进行存放的，如下图所示：

在这里插入图片描述

6.2.2 顺序消费

在这里插入图片描述

6.3 代码实现

6.3.1 生产者代码

/**
 * 顺序消息
 */
@GetMapping("/order")
public String order() {
    for (int i = 0; i < 3; i++){
        String msgStr = "消息 - " + i;
        System.out.println("发送消息：" + msgStr);
        // 参数3-hash值，相同hash值的消息会发给同一个队列，实际项目可以使用订单编号等唯一标识
        template.syncSendOrderly("news:spring", MessageBuilder.withPayload(msgStr).build(), "00001");
    }
    return "order";
}

6.3.2 消费者代码

package com.itheima.rocketmq.listener;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(
        // 主题
        topic = "news",
        // 标签表达式
        selectorExpression = "spring",
        // 消费者组名称
        consumerGroup = "rocketmq-consumer",
        // 设置单线程消费
        consumeMode = ConsumeMode.ORDERLY  
)
public class MyMessageListener implements RocketMQListener<String> {
    @Override
    public void onMessage(String message) {
        System.out.println("接收到消息：" + message);
    }
}

6.4 测试

1）重启消费者ConsumerApplication

2）重启生产者，访问http://localhost:9090/mq/order，控制台输出：

在这里插入图片描述

3）消费者控制台输出：

在这里插入图片描述

07. RocketMQ模式-广播模式

7.1 介绍

**特点：**广播模式是生产者发送一条消息，消费者组内的所有节点都可以消费到消息。（默认是竞争关系）

**应用场景：**适用于集群服务更新缓存或配置等场景。

在这里插入图片描述

7.2 代码实现

生产者代码无需改动，修改消费者监听器中消费模式即可

package com.itheima.rocketmq.listener;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(
        // 主题
        topic = "news",
        // 标签表达式
        selectorExpression = "spring",
        // 消费者组名称
        consumerGroup = "rocketmq-consumer",
        // 设置广播消费
        messageModel = MessageModel.BROADCASTING
)
public class MyMessageListener implements RocketMQListener<String> {
    @Override
    public void onMessage(String message) {
        System.out.println("接收到消息：" + message);
    }
}

说明：广播模式和单线程消费不能共存，需要去掉consumeMode配置

7.3 测试

7.3.1 修改配置

在这里插入图片描述

7.3.2 启动两个消费者

在这里插入图片描述

7.3.3 发送消息

访问生产者http://localhost:9090/mq/hi，两个消费者控制台输出如下：

在这里插入图片描述

08. RocketMQ模式-延迟消息模式

8.1 介绍

**特点：**Producer 将消息发送到RocketMQ 后，并不期望这条消息立马投递，而是推迟一段时间后在投递到 Consumer 进行消费。

应用场景：

延迟任务：例如淘宝商城超时未支付就关闭订单的场景，在订单创建时会发送一条延时消息。这条消息将会在 30 分钟以后投递给消费者，消费者收到此消息后需要判断对应的订单是否已完成支付，如支付未完成，则关闭订单；如已完成支付则忽略。

8.2 代码实现

在生产者控制器中，添加新方法如下：

/**
 * 延迟消息
 */
@GetMapping("/delay")
public String delay() {
    // 参数3-超时时间，超过多久没发送成功就抛出异常(包括连接MQ超时，或MQ超过多久没返回结果)
    // 参数4-延迟的级别，下面代表第三个级别，也就是延迟10秒
    template.syncSend("news:spring", MessageBuilder.withPayload("延迟消息").build(),
            2000, 3);
    return "delay";
}

级别包含以下几个：

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

8.3 测试

1）重启生产者，访问http://localhost:9090/mq/delay

2）观察消费者控制台10s后才输出内容：

在这里插入图片描述

09. RocketMQ模式-事务消息模式

9.1 分布式事务

它是一种分布式事务的解决方案。
当一个业务操作涉及到分布式系统中不同子系统之间时；如：网上购物下单的时候，需要先在商品管理系统扣减商品库存（事务A），然后在订单系统生成订单（事务B）。

在这里插入图片描述

分布式事务：即应该保证上述的两个操作的原子性，只有所有操作成功才算是下单成功，若有一个失败则都应该回滚。

以上流程中的A事务和B事务分属于不同的系统，这个我们就称之为分布式事务。分布式系统中都会存在分布式事务，解决分布式的方案有很多种，有两阶段提交（2PC）、可靠消息最终一致性、TCC、最大努力通知等。事务性消息模式就是属于可靠消息最终一次性方案。

9.2 RocketMQ事务性消息

在这里插入图片描述

9.3 代码实现

1）生产者控制器添加方法如下：

/**
 * 事务消息
 */
@GetMapping("/transaction")
public String transaction() {
    // 参数1-事务组名，参数4-自定义参数
    template.sendMessageInTransaction("tx_group", "news:spring",
            MessageBuilder.withPayload("事务消息").build(), "");
    return "transaction";
}

2）生产者添加本地事务监听器com.itheima.listeners.MyTxProducerListener

package com.itheima.listeners;

import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.springframework.messaging.Message;

/**
 * 事务回调监听器
 */
@RocketMQTransactionListener(txProducerGroup = "tx_group") // 生产者事务组
public class MyTxProducerListener implements RocketMQLocalTransactionListener {

    /**
     * 本地事务方法
     * @param msg 消息对象
     * @param arg 发送消息传递的自定义参数
     * @return 返回值为事务状态，COMMIT-提交，ROLLBACK-回滚，UNKNOWN-未知
     */
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        try {
            // 实际项目中对数据库表进行操作，如果没问题，返回COMMIT状态
            // 可以模拟出错如下
            // int i = 1/0;
            return RocketMQLocalTransactionState.COMMIT;

        } catch (Exception e) {
            // 如果发生异常，返回ROLLBACK状态
            return RocketMQLocalTransactionState.ROLLBACK;
        }

    }

    /**
     * 检查事务状态方法
     * @param msg 消息对象
     * @return
     */
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        // 实际项目中根据Msg查询数据库表检查事务状态
        // 例如：如果本地事务本应该删除某条数据，就查询数据是否已被删除
        // 若没删除，代表本地事务执行失败，就返回ROLLBACK
        // 若删除就返回COMMIT
        // 若检查时又发生异常，可以返回UNKNOW，让MQ下次继续回查状态
        return RocketMQLocalTransactionState.COMMIT;
    }
}

9.4 测试

重启生产者，访问http://localhost:9090/mq/transaction，消费者控制台输出如下：

在这里插入图片描述

9.4 案例分析

假设上例中的生产者是商品管理系统，消费者是订单系统。

第一步：商品管理系统处理业务同时也是消息生产者，向RocketMQ发送半消息；

第二步：商品管理系统执行扣减库存的事务，调用 TransactionListenerImpl 中的 executeLocalTransaction方法；

扣减库存成功，本地事务提交，则向 MQ 发送 COMMIT_MESSAGE，消息由半消息转换为 COMMIT 状态；
扣减库存失败，本地事务回滚，则向 MQ 发送 ROLLBACK_MESSAGE，MQ 会在3天后删除半消息
若发送 UNKNOW，接下来MQ会定时回调 checkLocalTransaction 方法（最多5次），该方法同样可以返回状态，处理方式同 executeLocalTransaction 方法。

第三步：订单系统作为消费者只接收COMMIT状态下修改的半消息；如果消息接收成功则执行订单生成，如果消息接收失败RocketMQ会重发消息。（默认16次）

9.5 方案严谨性分析

发送半消息失败那么在商品管理系统就会产生异常，也就没有接下来其他任何操作了；
若执行本地事务失败，即扣减库存失败则回滚，MQ 将消息删除了，消费者也不会收到消息；
若执行本地事务成功，但是发送commit状态到MQ失败，那么 MQ 会定时回查半消息的事务状态；
订单系统接收消息失败，MQ 有记录并也会重发消息；
重复消费的问题，订单系统记录消费过的消息来达到去重（幂等判断）；
订单系统生成订单失败，那么可以在订单系统记录失败情况，RocketMQ官方推荐此时由人工处理，但也可以让MQ重发消息。

DarzenWong

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
RocketMQ

01. 初识 RocketMQ1.1 简介RocketMQ （MQ 即Message Queue）是阿里云的一款低延迟、高并发、高可用、高可靠的分布式消息中间件。该产品最初由阿里巴巴自研并捐赠给 Apache 基金会，服务于阿里集团 13 年，覆盖全集团所有业务。作为双十一交易核心链路的官方指定产品，支撑千万级并发、万亿级数据洪峰，历年刷新全球最大的交易消息流转记录，它具有以下特点：能够保证严格的消息顺序提供丰富的消息拉取模式高效的订阅者水平扩展能力实时的消息订阅机制亿级消息堆积能力Ro
复制链接

扫一扫