RocketMQ的顺序消费和事务消费

最新推荐文章于 2024-07-22 10:36:23 发布
最新推荐文章于 2024-07-22 10:36:23 发布
阅读量1.1w 收藏 19
点赞数 1
分类专栏： RocketMQ 文章标签： RocketMQ 中间件 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010634288/article/details/57158374
版权

一、三种消费 ：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只会接收到一个，第二个数据不会被接收到







Mr_蜗牛
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
重复消费、顺序消费、分布式事务.pdf
10-26
3. **消息队列特性**：利用消息队列系统本身的特性支持顺序消费，如RabbitMQ、RocketMQ等提供的顺序消费功能。 ### 三、分布式事务 #### 定义 分布式事务是指跨越多个数据库或者服务的事务操作，它涉及到多个资源...
RocketMQ在平安银行的实践和应用
01-27
RocketMQ满足了这些要求，同时具备强大的堆积能力、顺序能力、事务性、重试和延迟消息功能以及消息回溯能力，使其在银行的业务场景中得到广泛应用。 在平安银行的具体应用中，RocketMQ主要涉及以下三个关键场景： ...
rocketmq 顺序消费
loveme888的专栏
11-11 1423
<dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifactId> <version>2.0.3</...
RocketMQ事务消费和顺序消费详解
客人
07-12 860
一、RocketMq有3中消息类型 1.普通消费 2. 顺序消费 3.事务消费 顺序消费场景 在网购的时候，我们需要下单，那么下单需要假如有三个顺序，第一、创建订单 ，第二：订单付款，第三：订单完成。也就是这个三个环节要有顺序，这个订单才有意义。RocketMQ可以保证顺序消费。 rocketMq实现顺序消费的原理 produce在发送消息的时候，把消息发到同一个队列（queue）中,消费者注册消息监听器为MessageListenerOrderly，这样就可以保证消费端只有一个线程去消费消息 .
RocketMQ顺序消费
Lin_Miao_09的博客
07-22 983
RocketMQ 支持两种类型的顺序消息消费：分区顺序消息（Partition Ordered Messages）和全局顺序消息（Global Ordered Messages）。这两种方式都能确保消息的顺序消费，但它们的工作机制有所不同。
RocketMQ顺序消息和事务消息
Lailai Monkey的博客
02-02 810
RocketMq有3种消息类型 普通消息 顺序消息 事务消息 普通消息 正常发送消费消息即可。 生产者 //发送同步消息 rocketMQTemplate.syncSend("topicSend", "Hello World!"); //发送同步消息 rocketMQTemplate.syncSend("topic名称:tags名称", "消息内容"); User user = new User(); use
RocketMQ笔记（四）SpringBoot整合RocketMQ发送顺序消息
嘉禾嘉宁papa
03-31 1766
RocketMQ提供了一种发送顺序消息的方法，顺序消息是指消息发送和消费的顺序是有序的，即消息按照特定的顺序发送到 Broker，然后按照相同的顺序消费。这个方法就是的。
rocketmq使用.zip
02-21
除了基本使用和事务消息，RocketMQ还有其他高级功能，如消息回溯、延迟消息、顺序消息、消息过滤等。消息回溯可以在不影响正常消息消费的情况下，追溯历史消息。延迟消息可以设定消息在未来的某个时间点才被消费。...
RocketMQ实践：确保消息不丢失与顺序性的高效策略
03-17
3. **事务消息**：RocketMQ支持事务消息，可以确保消息在数据库事务提交后才发送，如果事务失败，消息不会发出，从而避免了数据不一致导致的消息丢失。 4. **持久化存储**：RocketMQ将消息存储在磁盘上，即使在系统...
RocketMQ消息优先级
zhao_god的专栏
11-15 734
TypeC处于第三优先级。如果业务需要AA类型的消息被及时处理，可以把这三种相似类型的消息分拆到两个Topic里，比如AA类型的消息在一个单独的Topic，AB、AC类型的消息在另外一个Topic。第一种是比较简单的情况，如果当前Topic里有多种相似类型的消息，比如类型AA、AB、AC，当AB、AC的消息量很大，但是处理速度比较慢的时候，队列里会有很多AB、AC类型的消息在等候处理，这个时候如果有少量AA类型的消息加入，就会排在AB、AC类型消息后面，需要等候很长时间才能被处理。
RocketMQ之顺序消息
qq_41665452的博客
09-27 1835
前言 在项目中使用MQ消息队列时，某些业务场景可能需要保证消息的顺序消费执行。 比如在订单流程场景中：创建订单、支付订单、订单完成这三个订单状态需要保证顺序执行，不能先支付订单，再创建订单。也不能订单完成，再去支付订单。 在项目中如果使用默认的普通消息，那么就算生产者按照顺序发布消息后，消费端也有可能会不会按照顺序进行消费消息。 RocketMQ RocketMQ在其官方文档中指出，除了支持无序消息以外，还支持顺序消息。 无序消息：普通消息，事务消息，延迟消息和定时消息 顺序消息：全局顺序消息，
RocketMQ的顺序消息（顺序消费）
热门推荐
终生学习践行者
10-29 4万+
简单介绍了消息有序性的概念，以及RocketMQ如何实现消息的顺序消费。
rocketmq总结(消息的顺序、重复、事务、消费模式)
weixin_30516243的博客
05-14 557
rocketmq总结(消息的顺序、重复、事务、消费模式) 参考： http://www.cnblogs.com/wxd0108/p/6038543.html https://www.cnblogs.com/520playboy/p/6750023.html https://blog.csdn.net/chunlongyu/article/details/53977819 https...
RocketMq——顺序消费和事务
beyond_zl的博客
07-29 3009
RocketMQ不遵循JMS规范，自己有一套自定义的机制，使用订阅主题的方式发送和接收任务，支持广播和集群两种消费模式。集群模式：设置消费端对象属性：MessageModel.CLUSTERING,这种方式就可以达到ActiveMQ水平扩展负载均衡消费消息的实现。比较特殊的是这种行为可以支持先发送数据（生产端先发送到MQ），消费端订阅主题发生在生产端之后也可以收到数据，比较灵活。广播模式：设置消费端
rocketMQ架构(集群)流程，及顺序消费等问题
祁_z
05-20 3921
RocketMQ架构图 RocketMQ 四种集群部署方式 单个Master节点， 缺点就是如果宕机之后可能整个服务不可用； 多个Master节点，分摊存放我们的消息，缺点：没有Slave节点，主的Master节点宕机之后消息数据可能会丢失的； 多个Master和Slave节点，之间数据同步采用异步形式，效率非常高，数据可能短暂产生延迟（毫秒级别的） 多个Master和Slave节点，采用同步形式，效率比较低、数据不会产生延迟。 broker如果配置集群： 多个broker(master).
RocketMQ之消费者顺序消费源码解析
我神级欧文的博客
12-24 1951
RocketMQ对于消费者端顺序消费来说只能保证局部顺序，并不能保证全局顺序消费，局部顺序的意思就是只能对于一个mq的消息达到顺序消费，所以若是想要达到全局顺序消费的效果，对于一个topic来说可以值设置一个mq。 RocketMQ实现顺序消费的原理：因为要保证一个mq的消息能够被顺序消费，第一首先这个mq的消息必须要保证不能被一个以上的消费者所消费（并发消费时如果发生mq的负载均衡就可能会产生一个mq的消息被重复消费了，并且还是乱序消费的），那么其实问题就在于消费者之间是不同的系统而产生的，按照正常的.
RocketMQ的顺序消费实现（分区有序、全局有序）
yqqの博客
06-20 3155
全局有序比较简单，主要控制在于创建Topic指定只有一个队列，同步确保生产者与消费者都只有一个实例进行即可。
RocketMQ-初体验RocketMQ(07)-使用API操作RocketMQ_顺序消息 ordermessage
小工匠
11-10 1万+
文章目录顺序消息的概念顺序消费的原理消费状态演示ProducerConsumer 顺序消息的概念 消息有序指的是可以按照消息的发送顺序来消费(FIFO)。 RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。 顺序消费的原理 在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)； 而消费消息的时候从多个queue上拉取消息，这种...
rocketmq重复消费
最新发布
08-07
4. **顺序消费**：对于需要严格按序处理的消息，RocketMQ允许配置为顺序消费，确保同一消息只被一个消费者消费。 然而，尽管如此，由于分布式系统的复杂性，仍然存在极小概率的重复消费情况。开发者应该在应用层面...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值