一、软件版本
- jdk 1.8
- RocketMQ 4.4.0
- SpringBoot 2.3.2.RELEASE
二、步骤分析
2.1 消息发送者步骤分析
1.创建消息生产者producer，并制定生产者组名
2.指定Nameserver地址
3.启动producer
4.创建消息对象，指定主题Topic、Tag和消息体
5.发送消息
6.关闭生产者producer
2.2 消息消费者步骤分析
1.创建消费者Consumer，制定消费者组名
2.指定Nameserver地址
3.订阅主题Topic和Tag
4.设置回调函数，处理消息
5.启动消费者consumer
三、导入MQ客户端依赖
我们在Pom文件中导入对应的依赖
<!-- rocketmq -->
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>4.4.0</version>
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
四、消息发送示例
4.1 基本样例
4.1.1 消息发送
发送同步消息
这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。
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.common.RemotingHelper;
/**
* 发送同步消息
*/
public class SyncProducer {
public static void main(String[] args) throws Exception {
// 1.创建消息生产者producer，并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");
// 2.设置NameServer的地址
producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.128:9876");
// 3.启动Producer实例
producer.start();
for (int i = 0; i < 10; i++) {
// 4.创建消息，并指定Topic，Tag和消息体
Message msg = new Message("testTopic" /* Topic */,
"OneTag" /* Tag */,
("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
);
// 5.发送消息到一个Broker
SendResult sendResult = producer.send(msg);
// 通过sendResult返回消息是否成功送达
System.out.printf("%s%n", sendResult);
}
// 6.如果不再发送消息，关闭Producer实例。
producer.shutdown();
}
}
发送成功截图如下
发送异步消息
异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;
public class AsyncProducer {
public static void main(String[] args) throws Exception {
// 实例化消息生产者Producer
DefaultMQProducer producer = new DefaultMQProducer("group1");
// 设置NameServer的地址
producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 启动Producer实例
producer.start();
//producer.setRetryTimesWhenSendAsyncFailed(0);
for (int i = 0; i < 10; i++) {
// 创建消息，并指定Topic，Tag和消息体
Message msg = new Message("testTopic1",
"Tag2 ",
"OrderId888",
"Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
// SendCallback接收异步返回结果的回调
producer.send(msg, new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
System.out.println("发送结果"+sendResult);
}
@Override
public void onException(Throwable e) {
e.printStackTrace();
}
});
}
//暂停一秒钟 防止出现Producer被提前关闭
Thread.sleep(1000);
// 如果不再发送消息，关闭Producer实例。
producer.shutdown();
}
}
发送成功截图如下
单向发送消息
这种方式主要用在不特别关心发送结果的场景，例如日志发送。
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;
public class OnewayProducer {
public static void main(String[] args) throws Exception{
// 实例化消息生产者Producer
DefaultMQProducer producer = new DefaultMQProducer("group1");
// 设置NameServer的地址
producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 启动Producer实例
producer.start();
for (int i = 0; i < 10; i++) {
// 创建消息，并指定Topic，Tag和消息体
Message msg = new Message("testTopic2" /* Topic */,
"Tag1" /* Tag */,
("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */
);
// 发送单向消息，没有任何返回结果
producer.sendOneway(msg);
}
// 如果不再发送消息，关闭Producer实例。
producer.shutdown();
}
}
发送成功截图如下
4.1.2 消费消息
RocketMQ的默认消费模式是负载均衡模式
负载均衡模式
负载均衡模式就是会自动的帮你选择消费者处理消息
public static void main(String[] args) throws Exception {
// 实例化消息生产者,指定组名
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
// 指定Namesrv地址信息.
consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 订阅Topic 第一个参数是topic名称 第二个参数是tag，可以用*代表全部
consumer.subscribe("testTopic", "Tag1");
//负载均衡模式消费
consumer.setMessageModel(MessageModel.CLUSTERING);
// 注册回调函数，处理消息
consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
msgs.forEach(temp -> {
System.out.println("接收到新的消息,内容为="+new String(temp.getBody()));
});
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
});
//启动消息者
consumer.start();
System.out.printf("消费端已启动---%n");
}
启动两个客户端，消费成功截图如下
-
客户端一
-
客户端二
广播模式
广播模式就是所有的消费者都会收到一样的消息
public static void main(String[] args) throws Exception {
// 实例化消息生产者,指定组名
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
// 指定Namesrv地址信息.
consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 订阅Topic 第一个参数是topic名称 第二个参数是tag，可以用*代表全部
consumer.subscribe("testTopic", "Tag1");
//广播模式消费
consumer.setMessageModel(MessageModel.BROADCASTING);
// 注册回调函数，处理消息
consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
msgs.forEach(temp -> {
System.out.println("接收到新的消息,内容为="+new String(temp.getBody()));
});
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
});
//启动消息者
consumer.start();
System.out.printf("消费端已启动---%n");
}
再次启动两个客户端，消费成功截图如下
- 客户端一
- 客户端二
4.2 顺序消息
消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。
顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。
下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。
4.2.1 顺序消费生产
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 java.util.List;
public class OrderProducer {
public static void main(String[] args) throws Exception {
// 1.创建消息生产者producer，并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("group1");
// 2.设置NameServer的地址
producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 3.启动Producer实例
producer.start();
//构建消息集合
List<OrderStep> orderStepList = OrderStep.buildOrders();
for (int i = 0; i < orderStepList.size(); i++) {
String body = orderStepList.get(i) + "";
Message msg = new Message("orderTopic", "Order", "i" + i, body.getBytes());
/**
* 参数一：消息对象
* 参数二：消息队列的选择器
* 参数三：选择队列的业务标识（订单id）
*/
SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
/**
*
* @param list 队列集合
* @param message 消息对象
* @param o 业务标识参数
* @return
*/
@Override
public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
long orderId = (long)o;
long index = orderId % list.size();
return list.get((int)index);
}
}, orderStepList.get(i).getOrderId());
System.out.println(String.format("返回状态为:%s, 队列id为:%d, body数据为:%s",
sendResult.getSendStatus(),
sendResult.getMessageQueue().getQueueId(),
body));
}
// 6.如果不再发送消息，关闭Producer实例。
producer.shutdown();
}
}
4.2.2 顺序消费消费
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.message.MessageExt;
/**
* 顺序消息消费，带事务方式（应用可控制Offset什么时候提交）
*/
public class ConsumerInOrder {
public static void main(String[] args) throws Exception {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
consumer.subscribe("orderTopic", "*");
consumer.registerMessageListener((MessageListenerOrderly) (msgs, context) -> {
for (MessageExt msg : msgs) {
// 可以看到每个queue有唯一的consume线程来消费, 订单对每个queue(分区)有序
System.out.println("线程名称=" + Thread.currentThread().getName() + "队列id=" + msg.getQueueId() + ", 消息内容:" + new String(msg.getBody()));
}
return ConsumeOrderlyStatus.SUCCESS;
});
consumer.start();
System.out.println("消费者启动 ");
}
}
4.2.3 测试
我们启动 OrderProducer 和 ConsumerInOrder
OrderProducer
ConsumerInOrder
4.3 延迟消息
比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存
4.3.1 使用限制
现在RocketMq并不支持任意时间的延时，需要设置几个固定的延时等级，从1s到2h分别对应着等级1到18
private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
4.3.2 消息消费者
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
public class ScheduledMessageConsumer {
public static void main(String[] args) throws Exception {
// 实例化消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ScheduledGroup1");
consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 订阅Topics
consumer.subscribe("TestTopic", "*");
// 注册消息监听者
consumer.registerMessageListener((MessageListenerConcurrently) (messages, context) -> {
for (MessageExt message : messages) {
// 打印延迟时间
System.out.println("接收到消息[msgId=" + message.getMsgId() + "] " + (System.currentTimeMillis() - message.getStoreTimestamp()) + "ms 延迟");
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
});
// 启动消费者
consumer.start();
System.out.println("延迟消息消费者启动");
}
}
4.3.3 消息发送者
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
public class ScheduledMessageProducer {
public static void main(String[] args) throws Exception {
// 实例化一个生产者来产生延时消息
DefaultMQProducer producer = new DefaultMQProducer("ScheduledGroup1");
producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 启动生产者
producer.start();
int totalMessagesToSend = 10;
for (int i = 0; i < totalMessagesToSend; i++) {
Message message = new Message("TestTopic", ("成功发送延迟消息 " + i).getBytes());
// 设置延时等级3,这个消息将在10s之后发送(现在只支持固定的几个时间,详看delayTimeLevel)
message.setDelayTimeLevel(3);
// 发送消息
producer.send(message);
}
// 关闭生产者
producer.shutdown();
}
}
4.3.4 测试
4.4 批量消息
批量发送消息能显著提高传递小消息的性能。限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOK，而且不能是延时消息。此外，这一批消息的总大小不应超过4MB。
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import java.util.ArrayList;
import java.util.List;
public class BatchProducer {
public static void main(String[] args) throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("BatchGroup");
producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
producer.start();
List<Message> messages = new ArrayList<>();
messages.add(new Message("batchTopic", "Tag1", "OrderID001", "Hello world 0".getBytes()));
messages.add(new Message("batchTopic", "Tag1", "OrderID002", "Hello world 1".getBytes()));
messages.add(new Message("batchTopic", "Tag1", "OrderID003", "Hello world 2".getBytes()));
producer.send(messages);
producer.shutdown();
}
}
4.5 过滤消息
在大多数情况下，TAG是一个简单而有用的设计，其可以来选择您想要的消息。例如：
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("CID_EXAMPLE");
consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");
消费者将接收包含TAGA或TAGB或TAGC的消息。但是限制是一个消息只能有一个标签，这对于复杂的场景可能不起作用。
在这种情况下，可以使用SQL表达式筛选消息。SQL特性可以通过发送消息时的属性来进行计算。在RocketMQ定义的语法下，可以实现一些简单的逻辑。下面是一个例子：
------------
| message |
|----------| a > 5 AND b = 'abc'
| a = 10 | --------------------> 找到
| b = 'abc'|
| c = true |
------------
------------
| message |
|----------| a > 5 AND b = 'abc'
| a = 1 | --------------------> 未找到
| b = 'abc'|
| c = true |
------------
4.5.1 消息消费者
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.MessageSelector;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
public class FilterConsumer {
public static void main(String[] args) throws Exception {
// 实例化消息生产者,指定组名
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("FilterGroup");
// 指定Namesrv地址信息.
consumer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 订阅Topic 第一个参数是topic名称 第二个参数是tag，可以用*代表全部
consumer.subscribe("testTopic", MessageSelector.bySql("i > 5"));
//负载均衡模式消费
// consumer.setMessageModel(MessageModel.BROADCASTING);
// 注册回调函数，处理消息
consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
msgs.forEach(temp -> {
System.out.println("接收到新的消息,内容为="+new String(temp.getBody()));
});
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
});
//启动消息者
consumer.start();
System.out.printf("消费端已启动%n");
}
}
4.5.2 消息生产者
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.common.RemotingHelper;
public class FilterProducer {
public static void main(String[] args) throws Exception {
// 1.创建消息生产者producer，并制定生产者组名
DefaultMQProducer producer = new DefaultMQProducer("FilterGroup");
// 2.设置NameServer的地址
producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
// 3.启动Producer实例
producer.start();
for (int i = 0; i < 10; i++) {
Message msg = new Message("testTopic",
"Tag1" ,
("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET)
);
// 设置一些属性
msg.putUserProperty("i", String.valueOf(i));
// 5.发送消息到一个Broker
SendResult sendResult = producer.send(msg);
// 通过sendResult返回消息是否成功送达
System.out.printf("%s%n", sendResult);
}
// 6.如果不再发送消息，关闭Producer实例。
producer.shutdown();
}
}
4.5.3 测试
消费者端只能接收到i>5的消息
4.6 事务消息
4.6.1流程分析
上图说明了事务消息的大致方案，其中分为两个流程：正常事务消息的发送及提交、事务消息的补偿流程。
事务消息发送及提交
(1) 发送消息（half消息）。
(2) 服务端响应消息写入结果。
(3) 根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）。
(4) 根据本地事务状态执行Commit或者Rollback（Commit操作生成消息索引，消息对消费者可见）
事务补偿
(1) 对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一次“回查”
(2) Producer收到回查消息，检查回查消息对应的本地事务的状态
(3) 根据本地事务状态，重新Commit或者Rollback
其中，补偿阶段用于解决消息Commit或者Rollback发生超时或者失败的情况。
事务消息状态
事务消息共有三种状态，提交状态、回滚状态、中间状态：
(1) TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。
(2) TransactionStatus.RollbackTransaction: 回滚事务，它代表该消息将被删除，不允许被消费。
(3) TransactionStatus.Unknown: 中间状态，它代表需要检查消息队列来确定状态。
4.6.2 发送事务消息
事务监听接口
当发送半消息成功时，我们使用 executeLocalTransaction 方法来执行本地事务。它返回前一节中提到的三个事务状态之一。checkLocalTranscation 方法用于检查本地事务状态，并回应消息队列的检查请求。它也是返回前一节中提到的三个事务状态之一。
public class TransactionListenerImpl implements TransactionListener {
@Override
public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
System.out.println("执行本地事务");
if (StringUtils.equals("TagA", msg.getTags())) {
return LocalTransactionState.COMMIT_MESSAGE;
} else if (StringUtils.equals("TagB", msg.getTags())) {
return LocalTransactionState.ROLLBACK_MESSAGE;
} else {
return LocalTransactionState.UNKNOW;
}
}
@Override
public LocalTransactionState checkLocalTransaction(MessageExt msg) {
System.out.println("MQ检查消息Tag【"+msg.getTags()+"】的本地事务执行结果");
return LocalTransactionState.COMMIT_MESSAGE;
}
}
事务性生产者
使用 TransactionMQProducer类创建生产者，并指定唯一的 ProducerGroup，就可以设置自定义线程池来处理这些检查请求。执行本地事务后、需要根据执行结果对消息队列进行回复。回传的事务状态在请参考前一节。
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.TransactionListener;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;
import java.io.UnsupportedEncodingException;
import java.util.concurrent.TimeUnit;
public class Producer {
public static void main(String[] args) throws MQClientException, InterruptedException {
//创建事务监听器
TransactionListener transactionListener = new TransactionListenerImpl();
//创建消息生产者
TransactionMQProducer producer = new TransactionMQProducer("TransactionGroup");
producer.setNamesrvAddr("192.168.186.128:9876;192.168.186.129:9876");
//生产者这是监听器
producer.setTransactionListener(transactionListener);
//启动消息生产者
producer.start();
String[] tags = new String[]{"TagA", "TagB", "TagC"};
for (int i = 0; i < 3; i++) {
try {
Message msg = new Message("TransactionTopic", tags[i % tags.length], "KEY" + i,
("Transaction RocketMQ Message" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
SendResult sendResult = producer.sendMessageInTransaction(msg, null);
System.out.printf("%s%n", sendResult);
TimeUnit.SECONDS.sleep(1);
} catch (MQClientException | UnsupportedEncodingException e) {
e.printStackTrace();
}
}
System.out.println("生产者端已启动");
//producer.shutdown();
}
}
测试
4.6.3 使用限制
- 事务消息不支持延时消息和批量消息。
- 为了避免单个消息被检查太多次而导致半队列消息累积，我们默认将单个消息的检查次数限制为 15 次，但是用户可以通过 Broker 配置文件的
transactionCheckMax参数来修改此限制。如果已经检查某条消息超过 N 次的话（ N =transactionCheckMax） 则 Broker 将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写AbstractTransactionCheckListener类来修改这个行为。 - 事务消息将在 Broker 配置文件中的参数 transactionMsgTimeout 这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，该参数优先于
transactionMsgTimeout参数。 - 事务性消息可能不止一次被检查或消费。
- 提交给用户的目标主题消息可能会失败，目前这依日志的记录而定。它的高可用性通过 RocketMQ 本身的高可用性机制来保证，如果希望确保事务消息不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
- 事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。
扫一扫
8106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
