RocketMQ内容分享(二)：消息的实现、顺序消息&延迟消息&广播消息的实现、事务消息

最新推荐文章于 2024-04-10 22:38:30 发布
最新推荐文章于 2024-04-10 22:38:30 发布
阅读量914 收藏 22
点赞数 21
分类专栏： RocketMQ 内容分享 MQ（Message Queue）消息队列 内容分享 文章标签： java-rocketmq rocketmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45038038/article/details/134866620
版权

目录

消息示例-简单消息的实现

1. 前言

2. 同步消息（生产者）

2.1. 测试代码

3. 消费者

4. 异步消息

5. 单向消息

6. 总结

顺序消息&延迟消息&广播消息的实现

1. 前言

2. 局部顺序消息

2.1. 定义生产者

生产者运行结果（部分截图）

2.2.定义消费者

3. 碰到的问题

4. 全局顺序消息

5. 广播消息

6. 延迟消息

6.1. 延迟消息生产者

7.批量消息

8.过滤消息

使用tag过滤

8.1. 过滤消息生产者

8.2. 过滤消息的消费者

使用SQL过滤

语法

RocketMQ事务消息

1. 事务消息的定义

2.事务消息的实现流程

3. 事务消息的实现示例

3.1. 事务消息的消费者

3.2. 本地事务的实现

3.3. 事务消息的生产者

运行结果：

消息示例-简单消息的实现

1. 前言

上一篇文章我们介绍了RocketMQ集群的搭建，这篇文章将主要使用RocketMQ测试下简单消息。

2. 同步消息（生产者）

同步消息的话，消费者发布消息之后必须等集群返回成功之后才会发布下一条消息，消息的发布是同步进行的。

2.1. 测试代码

  1. 创建生产者

    	// 1.创建生产者对象
	DefaultMQProducer defaultMQProducer = new DefaultMQProducer("feige-producer-group");

  2. 指定nameserver

    // 2.指定nameServer
defaultMQProducer.setNamesrvAddr("172.31.184.89:9876");

    因为每个nameserver都有所有broker的路由信息，所以只需要指定一个nameserver。

  3. 启动生产者发布消息

    // 3.启动生产者
		defaultMQProducer.start();
		//4.创建消息
		for (int i = 0; i < 100; i++) {
			// 创建消息，指定topic,以及消息体
			Message message = new Message("base_topic", ("飞哥测试消息" + i).getBytes());
			//5.发送消息
			SendResult send = defaultMQProducer.send(message);
			System.out.println(send);
		}
		// 6.关闭生产者
		defaultMQProducer.shutdown();

创建一个名为 base_topic的topic，虽然集群中还没有这个topic，但是由于前面我们搭建集群的时候指定的可以自动创建topic autoCreateTopicEnable=true 。 然后消息体是：飞哥测试消息xxx。这里打印了集群的响应结果SendResult。

运行结果（部分结果）：

SendResult [sendStatus=SEND_OK, msgId=7F0000018D8014DAD5DC0C03E2250000, offsetMsgId=AC1FB85900002A9F00000000001F70B6, messageQueue=MessageQueue [topic=base_topic, brokerName=broker-b, queueId=0], queueOffset=125]
SendResult [sendStatus=SEND_OK, msgId=7F0000018D8014DAD5DC0C03E2410001, offsetMsgId=AC1FB85900002A9F00000000001F71A1, messageQueue=MessageQueue [topic=base_topic, brokerName=broker-b, queueId=1], queueOffset=125]
SendResult [sendStatus=SEND_OK, msgId=7F0000018D8014DAD5DC0C03E24D0002, offsetMsgId=AC1FB85900002A9F00000000001F728C, messageQueue=MessageQueue [topic=base_topic, brokerName=broker-b, queueId=2], queueOffset=125]
SendResult [sendStatus=SEND_OK, msgId=7F0000018D8014DAD5DC0C03E2570003, offsetMsgId=AC1FB85900002A9F00000000001F7377, messageQueue=MessageQueue [topic=base_topic, brokerName=broker-b, queueId=3], queueOffset=125]
SendResult [sendStatus=SEND_OK, msgId=7F0000018D8014DAD5DC0C03E2600004, offsetMsgId=AC1FB85900002A9F00000000001F7462, messageQueue=MessageQueue [topic=base_topic, brokerName=broker-b, queueId=0], queueOffset=126]
SendResult [sendStatus=SEND_OK, msgId=7F0000018D8014DAD5DC0C03E2830005, offsetMsgId=AC1FB85900002A9F00000000001F754D, messageQueue=MessageQueue [topic=base_topic, brokerName=broker-b, queueId=1], queueOffset=126]
SendResult [sendStatus=SEND_OK, msgId=7F0000018D8014DAD5DC0C03E28C0006, offsetMsgId=AC1FB85900002A9F00000000001F7638, messageQueue=MessageQueue [topic=base_topic, brokerName=broker-b, queueId=2], queueOffset=126]
SendResult [sendStatus=SEND_OK, msgId=7F0000018D8014DAD5DC0C03E2970007, offsetMsgId=AC1FB85900002A9F00000000001F7723, messageQueue=MessageQueue [topic=base_topic, brokerName=broker-b, queueId=3], queueOffset=126]

这里SendResult 返回结果有几个属性需要说明下：

  1. sendStatus： 发送状态
  2. msgId：消息ID，每个消息都是唯一的
  3. offsetMsgId：偏移消息ID，在队列里的消息唯一ID
  4. messageQueue：用于指定当前这条消息落到哪个队列中，在搭建集群的时候指定一个broker有4个messageQueue。
  5. topic：当前队列所属的主题
  6. brokerName：当前队列所属的broker
  7. queueId：当前队列在broker中序号
  8. queueOffset：当前消息在队列里的偏移量。

从打印的结果可以看出，目前这100条消息是轮流的发送到broker-b中的4个队列中的。关系如下图所示：

image-20230927223810119

3. 消费者

  1. 创建消费者&指定nameserver

    	// 1.创建消费者
		DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer_group");
		// 2.指定连接nameServer
		consumer.setNamesrvAddr("172.31.184.89:9876");

  2. 订阅一个或者多个topic，这里指定消费base_topic，不做过滤。

    // 3.订阅一个或者多个topic,这里指定消费base_topic，不做过滤
consumer.subscribe("base_topic", "*");

  3. 创建一个回调函数&处理消息

    		// 4.创建一个回调函数
	consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
			// 5.处理消息
			for (MessageExt msg : msgs) {
				System.out.println(msg);
				System.out.println("收到的消息内容：" + new String(msg.getBody()));
			}
			// 返回消费成功的对象
			return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
		});

    创建一个回调监听函数，它是一个长轮询，当有消息产生时，它会监听到并进行消费（ps: broker会把消息推送给消费者）。

  4. 启动消费者

    	// 6.启动消费者
		consumer.start();
		System.out.println("消费者已经启动");

    运行结果（部分截图）：

    image-20231003082615858

4. 异步消息

异步消息与同步消息的区别就是异步消息不需要等待集群返回发送成功的标识，即可发送下一条消息。主要是发送消息阶段有区别。其他的与同步消息相同。

// 异步消息发送失败重试次数
		defaultMQProducer.setRetryTimesWhenSendAsyncFailed(0);

		CountDownLatch2 countDownLatch2 = new CountDownLatch2(100);
		// 4.创建消息
		for (int i = 0; i < 100; i++) {
			// 创建消息，指定topic,以及消息体
			Message message = new Message("base_topic", "TagA", "feige", ("飞哥异步消息测试" + i).getBytes());
			// 5.发送消息
			int index = i;
			defaultMQProducer.send(message, new SendCallback() {
				@Override
				public void onSuccess(SendResult sendResult) {
					countDownLatch2.countDown();
					System.out.printf("%-10d ok,%s,%n", index,sendResult.getMsgId());
				}

				@Override
				public void onException(Throwable e) {
					countDownLatch2.countDown();
					System.out.printf("%-10d fail,%s,%n", index, e);
					e.printStackTrace();
				}
			});

		}
		System.out.println("=====================");
		countDownLatch2.await(10, TimeUnit.SECONDS);

异步消息在调用send方法的时候，需要实现SendCallback 接口。此函数有 onSuccess 方法和onException 方法。onSuccess 方法在消息发送成功的时候会被集群调用，而onException方法则是在消息发送失败的时候被调用。

5. 单向消息

单向消息只管发送不管接收。

//4.创建消息
		for (int i = 0; i < 100; i++) {
			// 创建消息，指定topic,以及消息体
			Message message = new Message("base_topic", ("飞哥同步消息测试：" + i).getBytes());
			//5.发送消息
		    defaultMQProducer.sendOneway(message);
		}

6. 总结

本文详细介绍了简单消息里的同步消息，异步消息和单向消息。他们的区别主要是生产者发布消息时的区别。另外，简单消息的消费是没有顺序的。

顺序消息&延迟消息&广播消息的实现

1. 前言

顺序消息指的是消费者在消费消息时，按照生产者发送消息的顺序进行消费。即先发送的先消费【FIFO】。

顺序消息分为 全局顺序消息和局部顺序消息。

全局顺序消息就是全局使用一个queue。

局部顺序消息就是 有顺序依赖的消息放在同一个queue中，多个queue并行消费。

2. 局部顺序消息

默认情况下RocketMQ会根据轮询的方式将消息发送到某个broker中的某个队列中，这样的话就不能保证消息是有序的。

比如在购物网站下单场景下：有 1. 创建订单---->2. 订单支付---->3. 订单发货---->4. 订单完成 四条消息。这四条消息逻辑上肯定是有序的。但是如果采用RocketMQ默认的消息投递方式，那么同一个订单，有可能创建订单被投递到了 MessageQueue1,订单支付的话被投递到了MessageQueue2。 由于消息在不同的MessageQueue中，消费者在消费的时候就可能会出现订单支付的消息先于创建订单的消息。

局部顺序消息就是要保证同一笔订单4条消息都放在同一个queue中，这样的话就不会出现订单支付的消息先于创建订单的消息被消费。就像下图所示：

局部顺序消息消费者在消费某个topic的某个队列中的消息的时候是顺序的。消费者使用MessageListenerOrderly类来进行消息监听。

2.1. 定义生产者

  1. 这里定义了名为part_order_topic_test的topic。运行程序之后该topic可以路由到broker-a 以及broker-b 两个broker。

    image-20231003154231683

public class OrderProducer {
	// 局部顺序消费,核心就是自己选择Queue，保证需要顺序保障的消息落到同一个队列中
	public static void main(String[] args) throws MQClientException, MQBrokerException, RemotingException, InterruptedException {
		DefaultMQProducer defaultMQProducer = new DefaultMQProducer("order_producer_group");
		defaultMQProducer.setNamesrvAddr("172.31.184.89:9876");
		defaultMQProducer.start();

		for (int i = 0; i < 10; i++) {
			int orderId = i;
			for (int j = 0; j < 5; j++) {
				// 构建消息体,tags和key 只是做一个简单区分
				Message partOrderMsg = new Message("part_order_topic_test", "order_" + orderId, "KEY_" + orderId, ("局部顺序消息处理_" + orderId + ";step_" + j).getBytes());
				SendResult send = defaultMQProducer.send(partOrderMsg, new MessageQueueSelector() {
					@Override
					//这里的arg参数就是外面的orderId
					public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
						Integer orderId = (Integer) arg;
						int index = orderId % mqs.size();
						return mqs.get(index);
					}
				}, orderId);

				System.out.printf("%s%n", send);
			}
		}
		defaultMQProducer.shutdown();
	}
}

  1. 在发送消息的时候实现MessageQueueSelector接口用于在发送消息的时候指定队列。其中， public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) 方法有三个参数：其中，mqs表示当前topic所路由的全部队列数，这里就是8个队列，broker-a有4个队列，broker-b有4个队列。msg就是传入的消息体，arg 就是传入的orderId。

  2. 这里根据orderId与队列数求模取余来获取消息应该发送到哪个队列中，这样就保证了相同的orderId的消息会落到同一个队列中

    Integer orderId = (Integer) arg;
int index = orderId % mqs.size();
return mqs.get(index);
生产者运行结果（部分截图）

image-20231003160039915

从运行结果可以看出相同orderId的消息被投递到了同一个MessageQueue中，而相同MessageQueue队列天然是有顺序的。

2.2.定义消费者

说完了生产者，接着来说说消费者。消费者的逻辑主要是在消费的时候需要实现 MessageListenerOrderly 类来进行消息监听。核心代码是：

	// 2.订阅消费消息
		defaultMQPushConsumer.registerMessageListener(new MessageListenerOrderly() {
			@Override
			public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
				for (MessageExt msg : msgs) {
					System.out.println("消费得到的消息是={}" + msg);
					System.out.println("消息体内容是={}" + new String(msg.getBody()));
				}
				return ConsumeOrderlyStatus.SUCCESS;
			}
		});

这里启动了三个消费者，不管消费者消费的顺序如何，相同的orderId下的5条消息都是被顺序消费的。

image-20231010125014684

image-20231010125043838

image-20231010125110337

3. 碰到的问题

在首次调试的时候出现了一个 broker is full 的错误。这是由于磁盘空间不足导致的，可以通过 df -h 命令查看当前磁盘空间的占用情况，当磁盘空间使用率超过90%的话则会报此错。

image-20231003131237358

4. 全局顺序消息

全局顺序消息是指消费者消费全部消息都是顺序的，只能让所有的消息都发送到同一个MessageQueue中来实现，在高并发场景下会非常影响效率。

5. 广播消息

广播消息是向主题（topic）的所有订阅者发送消息，订阅同一个topic的多个消费者，都能全量收到生产者发送的所有消息。

广播消息的生产者与普通同步消息的生产者实现是一致的，不同的是消费者的消息模式不同。这里给出消费者实现的不同之处。

	DefaultMQPushConsumer defaultMQPushConsumer = new DefaultMQPushConsumer("broadCastGroup");
		defaultMQPushConsumer.setNamesrvAddr("172.31.184.89:9876");
		// 设置消费者的模式是广播模式
		defaultMQPushConsumer.setMessageModel(MessageModel.BROADCASTING);

		//从第一位开始消费
		defaultMQPushConsumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

6. 延迟消息

延迟消息与普通消息的不同之处在于，它们要在指定的时间之后才会被传递。生产者并不会延迟发送消息，而是发送到topic里面，消费者延迟指定的时间进行消费。

6.1. 延迟消息生产者
DefaultMQProducer defaultMQProducer = new DefaultMQProducer("scheduled_group");
		defaultMQProducer.setNamesrvAddr("172.31.186.180:9876");
		defaultMQProducer.start();
		for (int i = 0; i < 100; i++) {
			Message message = new Message("Schedule_topic", ("延迟消息测试" + i).getBytes());
			//设置延迟级别，默认有18个延迟级别,这个消息将延迟10秒消费
			message.setDelayTimeLevel(3);
			defaultMQProducer.send(message);
		}
		System.out.println("所有延迟消息发送完成");
		defaultMQProducer.shutdown();

延迟消息生产者与普通消息生产者主要的区别是延迟消息需要调用 setDelayTimeLevel 方法设置延迟级别，这里设置级别是3，则是延迟10秒。RocketMQ提供了18种延迟级别。可以在 RocketMQ的仪表板中的集群中的broker配置中找到。

image-20231003200021490

延迟消息的消费者与普通消息的消费者相同的。RocketMQ内部通过名为SCHEDULE_TOPIC_XXXX 的topic来存放延迟消息。

image-20231003201410410

7.批量消息

批量发送消息提高了传递消息的性能。官方建议批量消息的总大小不应超过1M，实际不应超过4M。如果超过4M的批量消息需要进行分批处理。同时设置broker的配置参数为4M（在broker的配置文件中修改：maxMessageSize=4194304）。核心代码如下：

	//4.创建消息
		List<Message> messageList = new ArrayList<>();
		for (int i = 0; i < 100*100; i++) {
			// 创建消息，指定topic,以及消息体
			messageList.add(new Message("batch_topic", ("飞哥测试批量消息" + i).getBytes()));
		}
		//批量消息消息小于4M的处理
		SendResult send = defaultMQProducer.send(messageList);
		System.out.println(send);

8.过滤消息

使用tag过滤

在大多数情况下，标签是一种简单而有用的设计，可以用来选择你想要的消息。

首先是根据tag来过滤消息，生产者在发送消息的时候指定该消息的tag标签，消费者则可以根据tag来过滤消息。

8.1. 过滤消息生产者

这里定义了三个tag，分别是tagA，tagB以及tagC，生产者在生产消息的时候给每个消息指定不同的tag。

DefaultMQProducer defaultMQProducer = new DefaultMQProducer("TagProducer_group");
		defaultMQProducer.setNamesrvAddr("172.31.184.89:9876");
		defaultMQProducer.start();
		String[] tags = new String[]{"tagA", "tagB", "tagC"};
		for (int i = 0; i < 15; i++) {
			Message message = new Message("TagFilterTest", tags[i % tags.length], ("飞哥tag消息过滤" + tags[i % tags.length]).getBytes());
			SendResult send = defaultMQProducer.send(message);
			System.out.printf("%s%n", send);
		}
		defaultMQProducer.shutdown();
8.2. 过滤消息的消费者

消费者过滤出了标签带有tagA以及tagC的消息进行消费。这里其实是broker将consumer需要的消息推给消费者。

	DefaultMQPushConsumer defaultMQPushConsumer = new DefaultMQPushConsumer("tagConsumer");
		defaultMQPushConsumer.setNamesrvAddr("172.31.184.89:9876");
		defaultMQPushConsumer.subscribe("TagFilterTest", "tagA||tagC");
		defaultMQPushConsumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
			for (MessageExt msg : msgs) {
				System.out.println("接收到的消息=" + msg);
				System.out.println("接收到的消息体=" + new String(msg.getBody()));
			}
			return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
		});
		defaultMQPushConsumer.start();
		System.out.println("消费者已经启动");

image-20231003212919155

使用SQL过滤

SQL 功能可以通过发送消息时输入的属性进行一些计算，在RocketMQ定义的语法下，可以实现一些有趣的逻辑。

语法

RocketMQ只定义了一些基本的语法类支持这个特性。

1. 数值比较：如 `>`,`>=`,`<=`,`BETWEEN`,`=`;
2. 字符比较：如 `=`,'<>',`IN`;
3. `IS NULL` 或 `IS NOT NULL` ;
4. 逻辑`AND`,`OR`,`NOT`;

常量类型有：

1. 数字，如 123，
2. 字符，如 'abc',必须用单引号；
3. `NULL`,特殊常数；
4. 布尔值，`TRUE` 或 `FALSE`;

SQL过滤生产者

生产者主要设置属性过滤 message.putUserProperty("a", String.valueOf(i)); 表示第一条消息键值对是 a=0，第二条消息键值对是a=1。

	DefaultMQProducer defaultMQProducer = new DefaultMQProducer("TagProducer_group");
		defaultMQProducer.setNamesrvAddr("172.31.184.89:9876");
		defaultMQProducer.start();
		String[] tags = new String[]{"tagA", "tagB", "tagC"};
		for (int i = 0; i < 15; i++) {
			Message message = new Message("SQLFilterTest", tags[i % tags.length], ("飞哥sql消息过滤" + tags[i % tags.length]).getBytes());

			message.putUserProperty("a", String.valueOf(i));
			SendResult send = defaultMQProducer.send(message);
			System.out.printf("%s%n", send);
		}
		defaultMQProducer.shutdown();

SQL过滤消费者：

	DefaultMQPushConsumer defaultMQPushConsumer = new DefaultMQPushConsumer("tagConsumer");
		defaultMQPushConsumer.setNamesrvAddr("172.31.184.89:9876");
		defaultMQPushConsumer.subscribe("SQLFilterTest", MessageSelector.bySql("(TAGS is not null and TAGS in ('tagA','tagC'))"+" and (a is null and a between 0 and 3)"));
		defaultMQPushConsumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
			for (MessageExt msg : msgs) {
				System.out.println("接收到的消息=" + msg);
				System.out.println("接收到的消息体=" + new String(msg.getBody()));
			}
			return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
		});
		defaultMQPushConsumer.start();
		System.out.println("消费者已经启动");

如果运行报 The broker does not support consumer to filter message by SQL92

image-20231003221207618

则需要修改 broker.conf 文件，增加如下配置：

# 开启对 propertyfilter的支持
enablePropertyFilter = true 
filterSupportRetry = true

然后重启broker。

RocketMQ事务消息

1. 事务消息的定义

事务消息可以认为是一个两阶段的提交消息实现，以确保分布式事务的最终一致性。事务性消息确保本地事务的执行和消息的发送可以原子执行。

两阶段提交主要保证了分布式事务的原子性：即所有结点要么全做要么全不做，所谓的两个阶段是指：第一阶段：准备阶段；第二阶段：提交阶段。

事务消息有三种状态：

  1. TransactionStatus.CommitTransaction: 提交事务，表示允许消费者消费该消息。
  2. TransactionStatus.RollbackTransaction: 回滚事务，表示该消息将被删除，不允许消费。
  3. TransactionStatus.Unknow: 中间状态，表示需要MQ回查才能确定状态。

2.事务消息的实现流程

RocketMQ事务消息二阶段提交

  1. 生产者发送half消息，broker接收到half消息并回复half消息。
  2. 生产者调用 TransactionListener.executeTransaction() 方法执行本地事务。
  3. 生产者获得本地事务执行状态，提交给broker。如果状态是COMMIT_MESSAGE状态的话则broker会将消息推送给消费者。如果状态是ROLLBACK_MESSAGE状态的话则broker会丢弃此消息。如果状态是中间状态UNKNOW状态则broker会回查本地事务状态。
  4. 生产者调用 TransactionListener.checkLocalTransaction() 方法回查本地事务执行状态，并再次执行5,6,7三步骤，若回查次数超过15次则丢弃。

使用限制：

  1. 事务性消息没有调度和批处理支持。
  2. 为避免单条消息被检查次数过多，导致半队列消息堆积，我们默认单条消息的检查次数限制为15次，但用户可以通过更改 transactionCheckMax 来更改此限制，如果一条消息的检查次数超过 transactionCheckMax 次，broker默认会丢弃这条消息，同时打印错误日志。用户可以重写 AbstractTransactionCheckListener 类来改变这种行为。
  3. 事务消息将一定时间后检查，该时间由代理配置中的参数 transactionTimeout 确定。并且用户也可以在发送事务消息时通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，这个参数优先于 transactionMsgTimeout 参数。
  4. 一个事务性消息会被检查或消费不止一次。
  5. 事务性消息的生产者ID不能与其他类型消息的生产者ID共享，与其他类型的消息不同，事务性消息允许向后查询。MQ服务器通过其生产者ID查询客户端。
  6. 提交给用户目标主题的消息reput可能会失败，目前它取决于日志记录，高可用是由RocketMQ本身的高可用机制来保证的。如果要保证事务消息不丢失，保证事务完整性，推荐使用同步双写机制。

3. 事务消息的实现示例

3.1. 事务消息的消费者

事务消息的消费者与普通消息的消费者基本相同，也就是说事务消息是控制生产者端和broker端。

	DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("my_transaction_consumer");
		consumer.setNamesrvAddr("172.31.184.89:9876");
		consumer.subscribe("TransactionTopic", "*");
		// 4.创建一个回调函数
		consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
			// 5.处理消息
			for (MessageExt msg : msgs) {
				System.out.println(msg);
				System.out.println("收到的消息内容：" + new String(msg.getBody()));
			}
			// 返回消费成功的对象
			return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
		});
		// 6.启动消费者
		consumer.start();
		System.out.println("消费者已经启动");
3.2. 本地事务的实现

事务消息最关键的地方是生产者本地事务的实现，生产者本地事务实现 TransactionListener 接口，并实现该接口中的executeLocalTransaction方法和checkLocalTransaction方法。

其中，executeLocalTransaction 方法的作用是执行本地事务。它在生产者每次发送half消息的时候被调用，

  1. 如果调用此方法返回LocalTransactionState.COMMIT_MESSAGE状态，则此消息会被消费者消费到。
  2. 如果返回 LocalTransactionState.ROLLBACK_MESSAGE 状态，则此消息会被broker丢弃
  3. 如果返回 LocalTransactionState.UNKNOW 状态，即中间状态，则broker会调用checkLocalTransaction方法进行回查，最多回查15次。

checkLocalTransaction方法的作用是检查本地事务， 它是生产者发送完所有消息的时候调用，主要是针对的是中间状态的消息进行调用。

同样的如果调用此方法返回前面提到的三种状态，broker也会做出相同的处理。

public class TransactionListenerImpl implements TransactionListener {

	/**
	 * 执行本地事务
	 * 当事务half消息发送成功，这个方法将被执行
	 * 事务的half消息是发到 RMQ_SYS_TRANS_OP_HALF_TOPIC 的topic中
	 *
	 * @param msg 消息
	 * @param arg arg 自定义业务参数
	 * @return {@link LocalTransactionState}
	 */
	@Override
	public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
		String tags = msg.getTags();
		System.out.println("============执行executeLocalTransaction方法，;消息内容是="+new String(msg.getBody()));
		if (StringUtils.contains(tags, "tagA")) {
			return LocalTransactionState.COMMIT_MESSAGE;
		} else if (StringUtils.contains(tags, "tagB")) {
			return LocalTransactionState.ROLLBACK_MESSAGE;
		}
		return LocalTransactionState.UNKNOW;
	}

	/**
	 * 检查本地事务
	 * 回查本地事务状态，当half消息没响应时调用。
	 *
	 * @param msg 消息
	 * @return {@link LocalTransactionState}
	 */
	@Override
	public LocalTransactionState checkLocalTransaction(MessageExt msg) {
		String tags = msg.getTags();
		System.out.println("============执行checkLocalTransaction方法，;消息内容是="+new String(msg.getBody()));
		if (StringUtils.contains(tags, "tagC")) {
			return LocalTransactionState.COMMIT_MESSAGE;
		} else if (StringUtils.contains(tags, "tagD")) {
			return LocalTransactionState.ROLLBACK_MESSAGE;
		}
		return LocalTransactionState.UNKNOW;
	}
}
3.3. 事务消息的生产者

事务消息的生产者与普通消息的生产者最核心的区别是事务消息的生产者需要事务监听器，并且是调用sendMessageInTransaction 方法发送 half 消息。

         //1.定义事务监听器
		TransactionListener transactionListener = new TransactionListenerImpl();
		//2.定义生产者
		TransactionMQProducer producer = new TransactionMQProducer("transaction_produce_group");
		producer.setNamesrvAddr("172.31.184.89:9876");
		//3.定义线程池
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 5, 10, TimeUnit.SECONDS,
				new ArrayBlockingQueue<>(100), (runnable, executor) -> {
			BlockingQueue<Runnable> queue = executor.getQueue();
			try {
				queue.put(runnable);
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
		});
		//4.设置线程池
		producer.setExecutorService(threadPoolExecutor);
		//5.设置事务监听器
		producer.setTransactionListener(transactionListener);
		// 启动生产者
		producer.start();
		String[] tags = {"tagA", "tagB", "tagC", "tagD","tagE"};
		//发送10条half消息，消费者是收不到half消息的
		for (int i = 0; i < 10; i++) {
			Message message = new Message("TransactionTopic", tags[i % tags.length],
					"key" + i, ("飞哥测试事务消息" + tags[i % tags.length]+"_"+i).getBytes(StandardCharsets.UTF_8));
			TransactionSendResult transactionSendResult = producer.sendMessageInTransaction(message, null);
			System.out.println("本次发送的消息是=" + new String(message.getBody()));
			System.out.printf("%s%n", transactionSendResult);
			Thread.sleep(10);
		}
		System.out.println("==========所有消息发送完成======");
运行结果：

生产者：

image-20231005150155847

从运行结果可以看出中间状态的消息最多回查15次，就像图中的消息 执行checkLocalTransaction方法，;消息内容是=飞哥测试事务消息tagE_9 broker调用checkLocalTransaction 方法回查了15次。

image-20231005150245921

消费者：

我们可以看到最终消费者消费到的是消费的tags是tagA以及tagC的四条消息。

image-20231005150341147

那么，为啥生产者发送的half消息，消费者不会里面收到呢？这是因为half消息会被放到 RMQ_SYS_TRANS_OP_HALF_TOPIC 的topic中，直到本地事务返回 COMMIT_MESSAGE 状态时，消费者才能消费到此消息 。

之乎者也·
关注
专栏目录
RabbitMQ高级特性 - 事务消息
CYK_byte的博客
08-03 791
RabbitMQ 的 AMQP 协议实现了事务机制，允许开发者保证消息的发送和接收时原子性的，也就是说，要么消息全都发送成功，要么全都发送失败（只与发送方有关）.
Spring Boot集成RocketMQ实现普通、延时、事务消息发送接收、PULL消费模式及开启ACL | Spring Cloud 30
热门推荐
gmHappy
03-25 1万+
现在开始我们正式学习`Spring Boot`中集成`RocketMQ`使用,，在本章节主要进行对以下部分讲解说明： - 普通消息的发送接收 - 延时消息的发送接收 - 事务消息的发送接收 - 发送端和接收端开启`ACL` - `PULL`模式消费及`@ExtRocketMQConsumerConfiguration`使用
rocketmq总结(消息的顺序、重复、事务、消费模式)
weixin_30516243的博客
05-14 607
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系列五】消息示例-顺序消息&延迟消息&广播消息的实现
码农飞哥
10-21 1790
RocketMQ顺序消息是怎么实现的呢？啥是局部顺序消息，啥是全局顺序消息
（未完待续）浅谈微服务以及 常用中间件（ zookeeper redis rabbitmq）
舒婷(Zoe)
09-29 6376
传统的单体框架，已经不满足目前公司战略规划要求，近几年“微服务“ 这个字眼，出现的越来越频繁，虽然有过一年多微服务项目经验，也很难把微服务解释清楚，到底何为微服务？ 哈哈哈，好正经的开头，Martin Fowler曾在其blog上发表了”Microservices“的文章，正式提出了微服务架构，对于微服务的解释，他的定义为：微服务架构是一种架构模式，他 提倡将单一应用程序，划分为一个个独立的服务，服务之间相互协调，相互配合，为用户提供最终价值。 来一张图，感受一下微服务的魅力~ 将传统一个独...
RocketMQ-broker创建主题原理详解
龚厂长的博客
12-12 2939
本文基于RocketMQ 4.7.1版本 消息的发送和接收都要有对应的主题，所以使用rocketmq前需要完成主题的创建。rocketmq提供了两种创建主题的方式，一种是通过mqadmin工具创建，另一种是通过broker自动创建。下面分别介绍这两种方式以及背后的原理。 文章目录一、创建主题1、mqadmin 一、创建主题 1、mqadmin mqadmin工具是rocketmq提供的命令行管理工具，可以完成主题的创建修改删除，还有更新broker配置等操作，其位于rocketmq的bin目录下。本文只.
【RocketMQ 二十八】RocketMQ 消息查询
泯灭于众生，高歌于孤夜！
10-20 6668
3种消息查询⽅式：Message Key & Unique Key & Message Id3种消息查询⼯具：命令⾏、管理平台、客户端API，且⽀持将查询到让特定/所有消费者组重新消费屏蔽Unique Key & Message Id区别，很多地⽅⼆者可以通⽤Message Key & Unique Key 需要使⽤到哈希索引机制，有额外的索引维护成本Message Id由Broker和commit log offset组成，属于精确匹配，查询效率更好。
ROCKETMQ消息ID生成逻辑
weixin_34321753的博客
12-20 3650
2019独角兽企业重金招聘Python工程师标准>>> ...
RocketMQ高级特性总结(事务消息、顺序消息、延迟消息)
hosaos的博客
09-27 4125
文章目录事务消息场景分析基本思路及问题所在基本概念RocketMQ-事务消息设计思路两阶段提交事务状态定时回查延迟消息场景分析延迟消息Producer DemoRocketMQ延迟级别实现原理顺序消息全局顺序分区顺序Producer DemoConsumer Demo实现思路及原理 事务消息 场景分析 假设有两个用户，其银行账户不在一个银行中，服务不同，数据库也不同。现在要实现一个功能：用户A给B...
解析 RocketMQ 业务消息 - “顺序消息”
阿里云技术
08-25 906
作为金融级可靠的业务消息方案，RocketMQ 从创建之初就一直专注于业务集成领域的异步通信能力构建。本篇将继续业务消息集成的场景，从功能原理、应用案例、最佳实践以及实战等角度介绍 RocketMQ 的顺序消息功能。
springboot集成rocketmq，实现普通消息、顺序消息、延迟消息、事物消息
cputao的博客
09-03 334
把所有的消费者经过 Hash 计算分布到 Hash 环上，对所有的 MessageQueue 进行 Hash 计算，找到顺时针方向最近的消费者节点进行绑定。
RocketMQ高级原理：深入剖析消息系统的核心机制（超详细整理讲解，值得收藏）
03-17
RocketMQ支持分布式事务，通过半消息和回查机制实现事务一致性。Producer发送半消息，待本地事务执行完成后，根据结果提交或回滚消息。 五、消息存储与检索 Broker使用日志文件存储消息，通过文件分片和索引机制...
分布式消息队列RocketMQ(五)： RocketMQ工作原理
anndy_的专栏
09-10 1628
工作原理一、消息的生产1 消息的生产过程2 Queue选择算法轮询算法最小投递延迟算法二、消息的存储1 commitlog文件2 consumequeue3 对文件的读写4 与Kafka的对比三、indexFile1 索引条目结构2 indexFile的创建3 查询流程四、消息的消费1 获取消费类型：拉取式、推送式2 消费模式：广播消费、集群消费3 Rebalance机制4 Queue分配算法5 至少一次原则五、订阅关系的一致性1 正确订阅关系2 错误订阅关系六、offset管理1 offset本地管理模式
rocketmq 消息 自定义_RocketMQ的消息发送及消费
weixin_42496673的博客
12-23 1017
RocketMQ消息支持的模式：消息支持的模式分为三种：NormalProducer(普通同步)，消息异步发送，OneWay。消息同步发送：普通消息的发送和接收在前面已经演示过了，在前面的案例中是基于同步消息发送模式。也就是说消息发送出去后，producer会等到broker回应后才能继续发送下一个消息.消息异步发送：异步发送是指发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。...
rocketmq 消息id生成规则
chixingmang8023的博客
08-28 911
public staticString createMessageId(finalByteBuffer input,final ByteBuffer addr,final long offset) { input.flip(); in...
RocketMQ msgId与offsetMsgId释疑(实战篇)，2024年最新美团优选面试是电话面试吗
最新发布
m0_61067876的博客
04-10 743
文章中涉及到的知识点我都已经整理成了资料，录制了视频供大家下载学习，诚意满满，希望可以帮助在这个行业发展的朋友，在论坛博客等地方少花些时间找资料，把有限的时间，真正花在学习上，所以我把这些资料，分享出来。相信对于已经工作和遇到技术瓶颈的朋友们，在这份资料中一定都有你需要的内容。一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
RocketMQ（二）
Eriksen的博客
10-02 2170
RocketMQ
RocketMq之简介
weixin_42352733的博客
04-20 674
Producer 消息生产者，负责生产消息，一般由业务系统负责生产消息。一个消息生产者会把业务应用系统里产生的消息发送到Broker服务器。RocketMQ提供多种发送方式，同步发送、异步发送、顺序发送、单向发送。同步和异步方式均需要Broker返回确认信息，单向发送不需要。 Consumer 负责消费消息，一般是后台系统负责异步消费。一个消息消费者会从Broker服务器拉取消息、并将其提供给应用程序。从用户应用的角度而言提供了两种消费形式：拉取式消费、推动式消费。 NameS...
RabbitMQ怎么处理消息事务
yuanchengfu0910的博客
06-09 2528
注意：在生产者中，我们使用 channel.txCommit() 提交事务，而在消费者中，我们使用 channel.basicAck() 手动确认消息或 channel.basicReject() 手动拒绝消息并重新入队。通过将通道（Channel）设置为事务模式，所有发送到该通道的消息都将在提交事务之前被缓存，并且在提交事务后才会被投递到交换机中。在确认监听器中，可以处理确认（ack）和未确认（nack）消息的逻辑，确保消息发送的可靠性。当收到未确认消息时，表示消息发送失败，可以进行相应的处理。
RocketMQ 3.2.4开发详解：核心特性和问题解决方案
1. Publish/Subscribe（发布/订阅）模式：RocketMQ 支持发布者向主题发布消息，而多个订阅者可以订阅这些主题并接收消息，实现了广播和点对点通信模式。 2. MessagePriority（消息优先级）：RocketMQ 允许消息设置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

之乎者也·

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值