一、三种消费 :1.普通消费 2. 顺序消费 3.事务消费
1.1 顺序消费:在网购的时候,我们需要下单,那么下单需要假如有三个顺序,第一、创建订单 ,第二:订单付款,第三:订单完成。也就是这个三个环节要有顺序,这个订单才有意义。RocketMQ可以保证顺序消费,他的实现是生产者(一个生产者可以对多个主题去发送消息)将这个三个消息放在topic(一个topic默认有4个队列)的一个队列里面,单机支持上万个持久化队列,消费端去消费的时候也是只能有一个Consumer去取得这个队列里面的数据,然后顺序消费。
单个节点(Producer端1个、Consumer端1个)
Producer端
- package order;
- import java.util.List;
- import com.alibaba.rocketmq.client.exception.MQBrokerException;
- import com.alibaba.rocketmq.client.exception.MQClientException;
- import com.alibaba.rocketmq.client.producer.DefaultMQProducer;
- import com.alibaba.rocketmq.client.producer.MessageQueueSelector;
- import com.alibaba.rocketmq.client.producer.SendResult;
- import com.alibaba.rocketmq.common.message.Message;
- import com.alibaba.rocketmq.common.message.MessageQueue;
- import com.alibaba.rocketmq.remoting.exception.RemotingException;
- /**
- * Producer,发送顺序消息
- */
- public class Producer {
- public static void main(String[] args) {
- try {
- DefaultMQProducer producer = new DefaultMQProducer("order_Producer");
- producer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");
- producer.start();
- // String[] tags = new String[] { "TagA", "TagB", "TagC", "TagD",
- // "TagE" };
- for (int i = 1; i <= 5; i++) {
- Message msg = new Message("TopicOrderTest", "order_1", "KEY" + i, ("order_1 " + i).getBytes());
- SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
- public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
- Integer id = (Integer) arg;
- int index = id % mqs.size();
- return mqs.get(index);
- }
- }, 0);
- System.out.println(sendResult);
- }
- producer.shutdown();
- } catch (MQClientException e) {
- e.printStackTrace();
- } catch (RemotingException e) {
- e.printStackTrace();
- } catch (MQBrokerException e) {
- e.printStackTrace();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
Consumer端代码
- package order;
- import java.util.List;
- import java.util.concurrent.TimeUnit;
- import java.util.concurrent.atomic.AtomicLong;
- import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer;
- import com.alibaba.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
- import com.alibaba.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
- import com.alibaba.rocketmq.client.consumer.listener.MessageListenerOrderly;
- import com.alibaba.rocketmq.client.exception.MQClientException;
- import com.alibaba.rocketmq.common.consumer.ConsumeFromWhere;
- import com.alibaba.rocketmq.common.message.MessageExt;
- /**
- * 顺序消息消费,带事务方式(应用可控制Offset什么时候提交)
- */
- public class Consumer1 {
- public static void main(String[] args) throws MQClientException {
- DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");
- consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");
- /**
- * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
- * 如果非第一次启动,那么按照上次消费的位置继续消费
- */
- consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
- consumer.subscribe("TopicOrderTest", "*");
- consumer.registerMessageListener(new MessageListenerOrderly() {
- AtomicLong consumeTimes = new AtomicLong(0);
- public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
- // 设置自动提交
- context.setAutoCommit(true);
- for (MessageExt msg : msgs) {
- System.out.println(msg + ",内容:" + new String(msg.getBody()));
- }
- try {
- TimeUnit.SECONDS.sleep(5L);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- ;
- return ConsumeOrderlyStatus.SUCCESS;
- }
- });
- consumer.start();
- System.out.println("Consumer1 Started.");
- }
- }
结果如下图所示:
这个五条数据被顺序消费了
多个节点(Producer端1个、Consumer端2个)
Producer端代码:
- package order;
- import java.util.List;
- import com.alibaba.rocketmq.client.exception.MQBrokerException;
- import com.alibaba.rocketmq.client.exception.MQClientException;
- import com.alibaba.rocketmq.client.producer.DefaultMQProducer;
- import com.alibaba.rocketmq.client.producer.MessageQueueSelector;
- import com.alibaba.rocketmq.client.producer.SendResult;
- import com.alibaba.rocketmq.common.message.Message;
- import com.alibaba.rocketmq.common.message.MessageQueue;
- import com.alibaba.rocketmq.remoting.exception.RemotingException;
- /**
- * Producer,发送顺序消息
- */
- public class Producer {
- public static void main(String[] args) {
- try {
- DefaultMQProducer producer = new DefaultMQProducer("order_Producer");
- producer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");
- producer.start();
- // String[] tags = new String[] { "TagA", "TagB", "TagC", "TagD",
- // "TagE" };
- for (int i = 1; i <= 5; i++) {
- Message msg = new Message("TopicOrderTest", "order_1", "KEY" + i, ("order_1 " + i).getBytes());
- SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
- public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
- Integer id = (Integer) arg;
- int index = id % mqs.size();
- return mqs.get(index);
- }
- }, 0);
- System.out.println(sendResult);
- }
- for (int i = 1; i <= 5; i++) {
- Message msg = new Message("TopicOrderTest", "order_2", "KEY" + i, ("order_2 " + i).getBytes());
- SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
- public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
- Integer id = (Integer) arg;
- int index = id % mqs.size();
- return mqs.get(index);
- }
- }, 1);
- System.out.println(sendResult);
- }
- for (int i = 1; i <= 5; i++) {
- Message msg = new Message("TopicOrderTest", "order_3", "KEY" + i, ("order_3 " + i).getBytes());
- SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
- public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
- Integer id = (Integer) arg;
- int index = id % mqs.size();
- return mqs.get(index);
- }
- }, 2);
- System.out.println(sendResult);
- }
- producer.shutdown();
- } catch (MQClientException e) {
- e.printStackTrace();
- } catch (RemotingException e) {
- e.printStackTrace();
- } catch (MQBrokerException e) {
- e.printStackTrace();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
Consumer1
- /**
- * 顺序消息消费,带事务方式(应用可控制Offset什么时候提交)
- */
- public class Consumer1 {
- public static void main(String[] args) throws MQClientException {
- DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");
- consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");
- /**
- * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
- * 如果非第一次启动,那么按照上次消费的位置继续消费
- */
- consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
- consumer.subscribe("TopicOrderTest", "*");
- /**
- * 实现了MessageListenerOrderly表示一个队列只会被一个线程取到
- *,第二个线程无法访问这个队列
- */
- consumer.registerMessageListener(new MessageListenerOrderly() {
- AtomicLong consumeTimes = new AtomicLong(0);
- public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
- // 设置自动提交
- context.setAutoCommit(true);
- for (MessageExt msg : msgs) {
- System.out.println(msg + ",内容:" + new String(msg.getBody()));
- }
- try {
- TimeUnit.SECONDS.sleep(5L);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- ;
- return ConsumeOrderlyStatus.SUCCESS;
- }
- });
- consumer.start();
- System.out.println("Consumer1 Started.");
- }
- }
Consumer2
- /**
- * 顺序消息消费,带事务方式(应用可控制Offset什么时候提交)
- */
- public class Consumer2 {
- public static void main(String[] args) throws MQClientException {
- DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("order_Consumer");
- consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");
- /**
- * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
- * 如果非第一次启动,那么按照上次消费的位置继续消费
- */
- consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
- consumer.subscribe("TopicOrderTest", "*");
- /**
- * 实现了MessageListenerOrderly表示一个队列只会被一个线程取到
- *,第二个线程无法访问这个队列
- */
- consumer.registerMessageListener(new MessageListenerOrderly() {
- AtomicLong consumeTimes = new AtomicLong(0);
- public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
- // 设置自动提交
- context.setAutoCommit(true);
- for (MessageExt msg : msgs) {
- System.out.println(msg + ",内容:" + new String(msg.getBody()));
- }
- try {
- TimeUnit.SECONDS.sleep(5L);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- ;
- return ConsumeOrderlyStatus.SUCCESS;
- }
- });
- consumer.start();
- System.out.println("Consumer2 Started.");
- }
- }
先启动Consumer1和Consumer2,然后启动Producer,Producer会发送15条消息
Consumer1消费情况如图,都按照顺序执行了
Consumer2消费情况如图,都按照顺序执行了
二、事务消费
这里说的主要是分布式事物。下面的例子的数据库分别安装在不同的节点上。
事物消费需要先说说什么是事物。比如说:我们跨行转账,从工商银行转到建设银行,也就是我从工商银行扣除1000元之后,我的建设银行也必须加1000元。这样才能保证数据的一致性。假如工商银行转1000元之后,建设银行的服务器突然宕机,那么我扣除了1000,但是并没有在建设银行给我加1000,就出现了数据的不一致。因此加1000和减1000才行,减1000和减1000必须一起成功,一起失败。
再比如,我们进行网购的时候,我们下单之后,订单提交成功,仓库商品的数量必须减一。但是订单可能是一个数据库,仓库数量可能又是在另个数据库里面。有可能订单提交成功之后,仓库数量服务器突然宕机。这样也出现了数据不一致的问题。
使用消息队列来解决分布式事物:
现在我们去外面饭店吃饭,很多时候都不会直接给了钱之后直接在付款的窗口递饭菜,而是付款之后他会给你一张小票,你拿着这个小票去出饭的窗口取饭。这里和我们的系统类似,提高了吞吐量。即使你到第二个窗口,师傅告诉你已经没饭了,你可以拿着这个凭证去退款,即使中途由于出了意外你无法到达窗口进行取饭,但是只要凭证还在,可以将钱退给你。这样就保证了数据的一致性。
如何保证凭证(消息)有2种方法:
1、在工商银行扣款的时候,余额表扣除1000,同时记录日志,而且这2个表是在同一个数据库实例中,可以使用本地事物解决。然后我们通知建设银行需要加1000给该用户,建设银行收到之后给我返回已经加了1000给用户的确认信息之后,我再标记日志表里面的日志为已经完成。
2、通过消息中间件
原文地址:http://www.jianshu.com/p/453c6e7ff81c
RocketMQ第一阶段发送Prepared消息时,会拿到消息的地址,第二阶段执行本地事物,第三阶段通过第一阶段拿到的地址去访问消息,并修改消息的状态。
细心的你可能又发现问题了,如果确认消息发送失败了怎么办?RocketMQ会定期扫描消息集群中的事物消息,如果发现了Prepared消息,它会向消息发送端(生产者)确认,Bob的钱到底是减了还是没减呢?如果减了是回滚还是继续发送确认消息呢?RocketMQ会根据发送端设置的策略来决定是回滚还是继续发送确认消息。这样就保证了消息发送与本地事务同时成功或同时失败。
例子:
Consumer 端
- package transaction;
- import java.util.List;
- import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer;
- import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
- import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
- import com.alibaba.rocketmq.client.consumer.listener.MessageListenerConcurrently;
- import com.alibaba.rocketmq.client.exception.MQClientException;
- import com.alibaba.rocketmq.common.consumer.ConsumeFromWhere;
- import com.alibaba.rocketmq.common.message.MessageExt;
- /**
- * Consumer,订阅消息
- */
- public class Consumer {
- public static void main(String[] args) throws InterruptedException, MQClientException {
- DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("transaction_Consumer");
- consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");
- consumer.setConsumeMessageBatchMaxSize(10);
- /**
- * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
- * 如果非第一次启动,那么按照上次消费的位置继续消费
- */
- consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
- consumer.subscribe("TopicTransactionTest", "*");
- consumer.registerMessageListener(new MessageListenerConcurrently() {
- public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
- try {
- for (MessageExt msg : msgs) {
- System.out.println(msg + ",内容:" + new String(msg.getBody()));
- }
- } catch (Exception e) {
- e.printStackTrace();
- return ConsumeConcurrentlyStatus.RECONSUME_LATER;// 重试
- }
- return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;// 成功
- }
- });
- consumer.start();
- System.out.println("transaction_Consumer Started.");
- }
- }
Producer端
- package transaction;
- import com.alibaba.rocketmq.client.exception.MQClientException;
- import com.alibaba.rocketmq.client.producer.SendResult;
- import com.alibaba.rocketmq.client.producer.TransactionCheckListener;
- import com.alibaba.rocketmq.client.producer.TransactionMQProducer;
- import com.alibaba.rocketmq.common.message.Message;
- /**
- * 发送事务消息例子
- *
- */
- public class Producer {
- public static void main(String[] args) throws MQClientException, InterruptedException {
- TransactionCheckListener transactionCheckListener = new TransactionCheckListenerImpl();
- TransactionMQProducer producer = new TransactionMQProducer("transaction_Producer");
- producer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876;192.168.100.149:9876;192.168.100.239:9876");
- // 事务回查最小并发数
- producer.setCheckThreadPoolMinSize(2);
- // 事务回查最大并发数
- producer.setCheckThreadPoolMaxSize(2);
- // 队列数
- producer.setCheckRequestHoldMax(2000);
- producer.setTransactionCheckListener(transactionCheckListener);
- producer.start();
- // String[] tags = new String[] { "TagA", "TagB", "TagC", "TagD", "TagE"
- // };
- TransactionExecuterImpl tranExecuter = new TransactionExecuterImpl();
- for (int i = 1; i <= 2; i++) {
- try {
- Message msg = new Message("TopicTransactionTest", "transaction" + i, "KEY" + i,
- ("Hello RocketMQ " + i).getBytes());
- SendResult sendResult = producer.sendMessageInTransaction(msg, tranExecuter, null);
- System.out.println(sendResult);
- Thread.sleep(10);
- } catch (MQClientException e) {
- e.printStackTrace();
- }
- }
- for (int i = 0; i < 100000; i++) {
- Thread.sleep(1000);
- }
- producer.shutdown();
- }
- }
TransactionExecuterImpl --执行本地事务
- package transaction;
- import com.alibaba.rocketmq.client.producer.LocalTransactionExecuter;
- import com.alibaba.rocketmq.client.producer.LocalTransactionState;
- import com.alibaba.rocketmq.common.message.Message;
- /**
- * 执行本地事务
- */
- public class TransactionExecuterImpl implements LocalTransactionExecuter {
- // private AtomicInteger transactionIndex = new AtomicInteger(1);
- public LocalTransactionState executeLocalTransactionBranch(final Message msg, final Object arg) {
- System.out.println("执行本地事务msg = " + new String(msg.getBody()));
- System.out.println("执行本地事务arg = " + arg);
- String tags = msg.getTags();
- if (tags.equals("transaction2")) {
- System.out.println("======我的操作============,失败了 -进行ROLLBACK");
- return LocalTransactionState.ROLLBACK_MESSAGE;
- }
- return LocalTransactionState.COMMIT_MESSAGE;
- // return LocalTransactionState.UNKNOW;
- }
- }
TransactionCheckListenerImpl--未决事务,服务器回查客户端(目前已经被阉割啦)
- package transaction;
- import com.alibaba.rocketmq.client.producer.LocalTransactionState;
- import com.alibaba.rocketmq.client.producer.TransactionCheckListener;
- import com.alibaba.rocketmq.common.message.MessageExt;
- /**
- * 未决事务,服务器回查客户端
- */
- public class TransactionCheckListenerImpl implements TransactionCheckListener {
- // private AtomicInteger transactionIndex = new AtomicInteger(0);
- //在这里,我们可以根据由MQ回传的key去数据库查询,这条数据到底是成功了还是失败了。
- public LocalTransactionState checkLocalTransactionState(MessageExt msg) {
- System.out.println("未决事务,服务器回查客户端msg =" + new String(msg.getBody().toString()));
- // return LocalTransactionState.ROLLBACK_MESSAGE;
- return LocalTransactionState.COMMIT_MESSAGE;
- // return LocalTransactionState.UNKNOW;
- }
- }
producer端:发送数据到MQ,并且处理本地事物。这里模拟了一个成功一个失败。Consumer只会接收到本地事物成功的数据。第二个数据失败了,不会被消费。
Consumer只会接收到一个,第二个数据不会被接收到
http://blog.csdn.net/u010634288/article/details/57158374
相关推荐
除了基本使用和事务消息,RocketMQ还有其他高级功能,如消息回溯、延迟消息、顺序消息、消息过滤等。消息回溯可以在不影响正常消息消费的情况下,追溯历史消息。延迟消息可以设定消息在未来的某个时间点才被消费。...
3. **消息队列特性**:利用消息队列系统本身的特性支持顺序消费,如RabbitMQ、RocketMQ等提供的顺序消费功能。 ### 三、分布式事务 #### 定义 分布式事务是指跨越多个数据库或者服务的事务操作,它涉及到多个资源...
整合SpringBoot与RocketMQ的主要目的是在SpringBoot应用中利用RocketMQ的功能,如发布/订阅消息、顺序消息、事务消息等。这使得应用可以轻松地处理高并发和大量数据的传输问题,提高系统的稳定性和可扩展性。 **二...
RocketMQ支持顺序消费,每个topic下的四个队列可用于实现顺序消息处理。此外,它还解决了分布式事务的问题,例如在银行转账场景中保证数据一致性。通过预处理消息、提交本地事务,然后发送确认消息来确保事务一致性...
RocketMQ还提供了多种特性,如消息顺序性、消息重试、延迟消息、死信队列、事务消息等。消息顺序性适用于对消息顺序有严格要求的场景,如金融交易。消息重试机制确保消息不丢失,延迟消息可以在指定时间后才被消费。...
其中,AT级别确保消息至少被消费一次,MT则保证消息在单个消费者内按照发送顺序消费。 RocketMQ的设计中还包括了消息回溯、延迟消息和事务消息等高级特性。消息回溯允许消费者从历史消息中读取,而延迟消息则可以...
8. **顺序消息**:RocketMQ支持全局顺序和局部顺序消息,保证消息按照特定顺序消费,这对于某些业务场景(如日志记录、库存更新)至关重要。 9. **高可用与容灾**:RocketMQ通过主备切换、镜像复制等方式保证服务的...
5. **分布式事务**:RocketMQ支持分布式事务,通过半消息和全局顺序消息实现事务一致性。 6. **流量控制**:为了防止消费者或生产者因处理速度过慢而导致消息积压,RocketMQ提供了流量控制策略。 7. **消息过滤**...
4. **分布式事务协调**:RocketMQ 使用 GroupOffset 和 BrokeOffset 实现消费者组的事务协调,确保消息的正确消费。 5. **云原生设计**:RocketMQ 针对云环境进行了优化,支持大规模集群管理和监控。 6. **多语言...
011-011_RocketMQ_Producer_顺序消费机制详解 012-012_RocketMQ_Producer_事务消息机制详解 013-013_RocketMQ_Consumer_Push和Pull模式及使用详解 014-014_RocketMQ_Consumer_配置参数详解 015-015_RocketMQ_...
5. **消息顺序**:RocketMQ提供严格的消息顺序保证,通过指定消息的队列和发送策略,可以确保消息按照特定的顺序被消费。 6. **消息分发策略**:RocketMQ支持广播(Broadcasting)和集群(Clustering)两种消费模式...
RocketMQ源码分析,分为存储篇、NameServer篇、Broker篇、Producer篇、Consumer篇五大部分进行源码级的讲解。...5、讲解Consumer端的启动、PUSH模式的消息消费、PULL模式的消息消费、顺序消费/并发消费等功能;
全局顺序消息是在一个Topic下所有消息都按照发送顺序消费,而分区顺序消息则是每个队列内的消息顺序。 6. **事务消息**:RocketMQ提供了分布式事务支持,实现了分布式环境下的二阶段提交协议,保证了消息的最终一致...
2. **顺序消息**:RocketMQ支持顺序消息发送和消费,这意味着消息按照特定的顺序(如生产者发送的顺序)被消费者接收,这对于需要保证消息处理顺序的业务场景非常关键。 3. **批量消息**:批量发送和接收消息是提高...
3. **事务消息**:RocketMQ支持事务消息,可以确保消息在数据库事务提交后才发送,如果事务失败,消息不会发出,从而避免了数据不一致导致的消息丢失。 4. **持久化存储**:RocketMQ将消息存储在磁盘上,即使在系统...
- 消费策略:支持顺序消费、广播消费、集群消费等多种消费策略。 5. **RocketMQ部署与配置**:安装RocketMQ涉及NameServer、Broker、Producer和Consumer的配置,包括启动脚本、配置文件修改、环境变量设置等步骤。...
5. 高效的刷盘策略:RocketMQ采用异步刷盘和顺序写磁盘技术,保证了高吞吐量和低延迟。 三、RocketMQ的实现机制 1. 消息确认:Pull Consumer在拉取消息后需要向Broker发送确认,而Push Consumer则由Broker在消息...
11. **Java API**:RocketMQ 3.2.6 版本提供了 Java 开发接口,开发者可以方便地在 Java 应用中集成 RocketMQ,实现消息的发送和消费。 学习RocketMQ 3.2.6,你需要理解以上核心概念,并通过实践操作加深理解。同时...
13. **消息顺序性**:RocketMQ通过设置消息队列的分配策略,可以保证在同一队列内的消息顺序消费,适用于需要消息顺序性的场景。 通过"rocketmq-all-5.1.3-bin-release"这个压缩包,你可以得到完整的RocketMQ运行...
6. 消息顺序:对于需要顺序处理的场景,RocketMQ提供有序消息服务,确保消息的顺序消费。 7. 灵活的调度策略:支持多种调度策略,如定时消息、延时消息和死信队列,满足不同业务需求。 三、RocketMQ的应用场景 1....