RocketMQ 03 常用api

最新推荐文章于 2023-07-28 16:09:47 发布
最新推荐文章于 2023-07-28 16:09:47 发布
阅读量309 收藏
点赞数
分类专栏： # RockeMQ 文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshengwei230612/article/details/109151458
版权

RocketMQ 03

pom 依赖

		<dependency>
			<groupId>org.apache.rocketmq</groupId>
			<artifactId>rocketmq-client</artifactId>
			<version>4.6.1</version>
		</dependency>

消息

消息消费模式

消息消费模式由消费者来决定，可以由消费者设置MessageModel来决定消息模式。

消息模式默认为集群消费模式

 consumer.setMessageModel(MessageModel.BROADCASTING);
 consumer.setMessageModel(MessageModel.CLUSTERING);
集群消息

在这里插入图片描述

集群消息是指集群化部署消费者

当使用集群消费模式时，MQ 认为任意一条消息只需要被集群内的任意一个消费者处理即可。

特点

  • 每条消息只需要被处理一次，broker只会把消息发送给消费集群中的一个消费者
  • 在消息重投时，不能保证路由到同一台机器上
  • 消费状态由broker维护
广播消息

在这里插入图片描述

当使用广播消费模式时，MQ 会将每条消息推送给集群内所有注册过的客户端，保证消息至少被每台机器消费一次。

特点

  • 消费进度由consumer维护

  • 保证每个消费者消费一次消息

  • 消费失败的消息不会重投

发送方式

同步消息

消息发送中进入同步等待状态，可以保证消息投递一定到达

异步消息

想要快速发送消息，又不想丢失的时候可以使用异步消息

         producer.send(message,new SendCallback() {
			
			public void onSuccess(SendResult sendResult) {
				// TODO Auto-generated method stub
				System.out.println("ok");
			}
			
			public void onException(Throwable e) {
				// TODO Auto-generated method stub
				e.printStackTrace();
				System.out.println("err");
			}
		});
单向消息

只发送消息，不等待服务器响应，只发送请求不等待应答。此方式发送消息的过程耗时非常短，一般在微秒级别。

 producer.sendOneway(message);

批量消息发送

可以多条消息打包一起发送，减少网络传输次数提高效率。

producer.send(Collection c)方法可以接受一个集合 实现批量发送

 public SendResult send(
        Collection<Message> msgs) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        return this.defaultMQProducerImpl.send(batch(msgs));
    }
  • 批量消息要求必要具有同一topic、相同消息配置
  • 不支持延时消息
  • 建议一个批量消息最好不要超过1MB大小
  • 如果不确定是否超过限制，可以手动计算大小分批发送

TAG

可以使用tag来过滤消费

在Producer中使用Tag：

Message msg = new Message("TopicTest","TagA" ,("Hello RocketMQ " ).getBytes(RemotingHelper.DEFAULT_CHARSET));

在Consumer中订阅Tag：

consumer.subscribe("TopicTest", "TagA||TagB");// * 代表订阅Topic下的所有消息

SQL表达式过滤

消费者将收到包含TAGA或TAGB或TAGB的消息. 但限制是一条消息只能有一个标签，而这对于复杂的情况可能无效。 在这种情况下，您可以使用SQL表达式筛选出消息.

配置

在broker.conf中添加配置

enablePropertyFilter=true

启动broker 加载指定配置文件

../bin/mqbroker -n 192.168.150.113:9876 -c broker.conf

随后在集群配置中可以看到

在这里插入图片描述

实例
        MessageSelector selector = MessageSelector.bySql("order > 5");
        consumer.subscribe("xxoo3", selector);
语法

RocketMQ只定义了一些基本的语法来支持这个功能。 你也可以很容易地扩展它.

  1. 数字比较, 像 >, >=, <, <=, BETWEEN, =;
  2. 字符比较, 像 =, <>, IN;
  3. IS NULL 或者 IS NOT NULL;
  4. 逻辑运算AND, OR, NOT;

常量类型是:

  1. 数字, 像123, 3.1415;
  2. 字符串, 像‘abc’,必须使用单引号;
  3. NULL, 特殊常数;
  4. 布尔常量, TRUE 或FALSE;

延迟消息

RocketMQ使用messageDelayLevel可以设置延迟投递

默认配置为

messageDelayLevel	1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
配置

在broker.conf中添加配置

messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h

这个配置项配置了从1级开始，各级延时的时间，可以修改这个指定级别的延时时间；

时间单位支持：s、m、h、d，分别表示秒、分、时、天；

使用

发送消息时设置

message.setDelayTimeLevel(1);

顺序消费

队列先天支持FIFO模型，单一生产和消费者下只要保证使用MessageListenerOrderly监听器即可

顺序消费表示消息消费的顺序同生产者为每个消息队列发送的顺序一致，所以如果正在处理全局顺序是强制性的场景，需要确保使用的主题只有一个消息队列。

并行消费不再保证消息顺序，消费的最大并行数量受每个消费者客户端指定的线程池限制。

那么只要顺序的发送，再保证一个线程只去消费一个队列上的消息，那么他就是有序的。

跟普通消息相比，顺序消息的使用需要在producer的send()方法中添加MessageQueueSelector接口的实现类，并重写select选择使用的队列，因为顺序消息局部顺序，需要将所有消息指定发送到同一队列中。

queue相等于kafka分区，每个topic有多个queue

在这里插入图片描述

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
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.client.producer.TransactionSendResult;
import org.apache.rocketmq.client.producer.selector.SelectMessageQueueByHash;
import org.apache.rocketmq.client.producer.selector.SelectMessageQueueByRandom;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.message.MessageQueue;

/**
 * 消息发送者
 *
 */
public class Producer4 {

	public static void main(String[] args)throws Exception {
		
		DefaultMQProducer producer = new DefaultMQProducer("pgp01");
		
		producer.setNamesrvAddr("192.168.150.113:9876");
		
		
		producer.start();
		
		
		for (int i = 0; i < 20; i++) {
				
			Message message = new Message("xxoo007", ("hi!" + i).getBytes());
			
			producer.send(
					// 要发的那条消息
					message,
					// queue 选择器 ，向 topic中的哪个queue去写消息
					new MessageQueueSelector() {
						// 手动 选择一个queue
						public MessageQueue select(
								// 当前topic 里面包含的所有queue
								List<MessageQueue> mqs
								, 
								// 具体要发的那条消息
								Message msg
								
								// 对应到 send（） 里的 args
								, Object arg) {
							// TODO Auto-generated method stub
							
							// 向固定的一个queue里写消息
							MessageQueue queue = mqs.get(0);
							// 选好的queue
							return queue;
						}
					},
					// 自定义参数
					0, 2000);
		}
		
	//	producer.shutdown();
		System.out.println("已经停机");
		
	}
}

import java.util.List;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;

public class Consumer3 {

	public static void main(String[] args)throws Exception {
		
		DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("g02");
		
		consumer.setNamesrvAddr("192.168.150.113:9876");
		
		consumer.subscribe("xxoo007", "*");
		
		
		
		/**
		 * 
		 * 
		 * 
		 * 
		 * MessageListenerConcurrently   并发消费 / 开多个线程  对一个queue 也是对应开启多个线程
		 * 
		 * 
		 */
//		consumer.registerMessageListener(new MessageListenerConcurrently() {
//			
//			public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
//
//				for (MessageExt msg : msgs) {
//					
//					System.out.println(new String(msg.getBody()));;
//				}
//				return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
//			}
//		});

		
		/*
		 * 
		 * MessageListenerOrderly 顺序消费 ,对一个queue 开启一个线程，多个queue 开多个线程 
		 * 
		 * 
		 */
		
		
		// 
		// 最大开启消费线程数
	//	consumer.setConsumeThreadMax(consumeThreadMax);
		//  最小线程数
	//	consumer.setConsumeThreadMin(consumeThreadMin);
		consumer.registerMessageListener(new MessageListenerOrderly() {
			
			public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
				for (MessageExt msg : msgs) {
				
				System.out.println(new String(msg.getBody()) + " Thread:" + Thread.currentThread().getName());;
			}
			return ConsumeOrderlyStatus.SUCCESS;
			}
		});
		
		consumer.start();
		System.out.println("Consumer g02 start...");
	}
}

保证有序参与因素

  • FIFO
  • 队列内保证有序
  • 消费线程

重试机制

producer

默认超时时间

默认发送超时时间3000ms

    /**
     * Timeout for sending messages.
     */
    private int sendMsgTimeout = 3000;

	// 异步发送时 重试次数，默认 2
	producer.setRetryTimesWhenSendAsyncFailed(1);
	// 同步发送时 重试次数，默认 2
	producer.setRetryTimesWhenSendFailed(1);	
	
	// 是否向其他broker发送请求 默认false
	producer.setRetryAnotherBrokerWhenNotStoreOK(true);

在这里插入图片描述

Consumer

消费超时，单位分钟

consumer.setConsumeTimeout()

发送ack，消费失败

RECONSUME_LATER

broker投递

只有在消息模式为MessageModel.CLUSTERING集群模式时，Broker才会自动进行重试，广播消息不重试

重投使用messageDelayLevel

默认值

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

事务消息

分布式系统中的事务可以使用TCC（Try、Confirm、Cancel）、2pc来解决分布式系统中的消息原子性

RocketMQ 4.3+提供分布事务功能，通过 RocketMQ 事务消息能达到分布式事务的最终一致

RocketMQ实现方式

在这里插入图片描述

**Half Message：**预处理消息，当broker收到此类消息后，会存储到RMQ_SYS_TRANS_HALF_TOPIC的消息消费队列中

**检查事务状态：**Broker会开启一个定时任务，消费RMQ_SYS_TRANS_HALF_TOPIC队列中的消息，每次执行任务会向消息发送者确认事务执行状态（提交、回滚、未知），如果是未知，等待下一次回调。

**超时：**如果超过回查次数，默认回滚消息

TransactionListener的两个方法
executeLocalTransaction

半消息发送成功触发此方法来执行本地事务

checkLocalTransaction

broker将发送检查消息来检查事务状态，并将调用此方法来获取本地事务状态

本地事务执行状态

LocalTransactionState.COMMIT_MESSAGE

执行事务成功，确认提交

LocalTransactionState.ROLLBACK_MESSAGE

回滚消息，broker端会删除半消息

LocalTransactionState.UNKNOW

暂时为未知状态，等待broker回查

import org.apache.rocketmq.client.producer.LocalTransactionState;
import org.apache.rocketmq.client.producer.TransactionListener;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.client.producer.TransactionSendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
public class ProducerTransaction {
    public static void main(String[] args)throws Exception {
        TransactionMQProducer producer = new TransactionMQProducer("xoxogp1");
        producer.setNamesrvAddr("10.139.12.15:9876");

        producer.setTransactionListener(new TransactionListener() {
            public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
                // 执行 本地事务
                System.out.println("=====executeLocalTransaction");
                System.out.println("msg:" + new String(msg.getBody()));
                System.out.println("msg:" + msg.getTransactionId());

                /**
                 *
                 * 事务方法 写这里
                 *
                 * 同步执行
                 * -----a----
                 * a 提交注册信息()  ;
                 * b 写入数据库();
                 * c 新用户() -> 发消息;
                 *
                 * 事务消息的应用场景是不是适合发送多个消息要保证同时成功或失败？
                 *
                 * ----b----
                 *
                 * 读取消息
                 * 拿到新用户的信息 发短信
                 *
                 *
                 * 那如果最后一个commit发送失败，
                 * 业务的事务 异常， 然后broker等超时回调检查 发现失败，就扔掉数据是吗？
                 *
                 *
                 * 下订单，发半消息 尝试扣款，
                 如果订单成功，就真正扣款 ，如果订单失败，则不扣款，  如果半消息扣款失败 则回滚订单   是这样的吗

                 mysql 的事务

                 */
                try {

                    // 业务
                } catch (Exception e) {
                    //
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                }
                // 真正发出去的数据 可用
                return LocalTransactionState.COMMIT_MESSAGE;
            }

            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
                // Broker 端 回调 ，检查事务

                System.out.println("=====checkLocalTransaction");
                System.out.println("msg:" + new String(msg.getBody()));
                System.out.println("msg:" + msg.getTransactionId());

                // 事务执行成功
                return LocalTransactionState.COMMIT_MESSAGE;
                // 等会儿
                //		return LocalTransactionState.UNKNOW;
                // 回滚消息
                //		return LocalTransactionState.ROLLBACK_MESSAGE;
            }
        });


        producer.start();


        TransactionSendResult sendResult = producer.sendMessageInTransaction(new Message("topic1025", "测试！这是事务消息".getBytes()), null);

        System.out.println("sendResult:" + sendResult);

        //	producer.shutdown();
        System.out.println("已经停机");
    }
}
紫金小飞侠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RocketMQ源码 — 九、 RocketMQ延时消息
weixin_34060741的博客
05-10 298
上一节消息重试里面提到了重试的消息可以被延时消费，其实除此之外，用户发送的消息也可以指定延时时间（更准确的说是延时等级），然后在指定延时时间之后投递消息，然后被consumer消费。阿里云的ons还支持定时消息，而且延时消息是直接指定延时时间，其实阿里云的延时消息也是定时消息的另一种表述方式，都是通过设置消息被投递的时间来实现的，但是Apache RocketMQ在版本4.2.0中尚不支持指定时间...
RocketMQ基础API使用以及基本原理探究
蒋大钊的博客
06-15 1638
总结RocketMQ中基本API的使用以及一些基础性原理的探究
工具篇7--RocketMq消息模型介绍
拽着尾巴的鱼儿的博客
06-27 1508
作为一个国产的消息中间件，阿里参考Kafka 开发了RocketMq 进行消息通信，它具有分布式，高可用、高吞吐、可伸缩的特性，本文对于其模型进行探究；模型图中已经展示了RocketMq的几个重要组件，与kafka 不同的是这里多出了一个叫NameServer的组件；对broker 进行维护，并对消息消息进行路由；
RocketMQTemplate 实现消息发送
HGW的博客
02-22 6046
springboot整合RocketMQ，发送普通消息、过滤消息、同步消息、延时消息、批量消息、异步消息、单向消息、顺序消息、事务消息样例并分析源码。
RocketMQ发送消息
qq_62767608的博客
06-21 3614
MQ的消费模式可以大致分为两种，一种是，一种是。服务端 (MQ) 主动推送消息给客户端，优点是及时性较好流控客户端 需要主动到 服务端 (MQ) 取数据，优点是客户端可以依据自己的消费能力进行消费，Push模式也是基于Pull模式的，所以不管是Push模式还是Pull模式，都是Pull模式。一般情况下，优先选择Pull模式。
rocketMq可视化界面
05-20
RocketMQ提供了丰富的API，支持多种语言，包括Java、Python、Go等。在实际应用中，为了更好地管理和监控RocketMQ的运行状态，一个可视化的管理界面是必不可少的。本项目"rocketMq可视化界面"就是为了解决这个问题，...
RocketMq + Spring 示例
11-04
Spring 框架是Java开发中最常用的框架之一，用于简化企业级应用的开发。将 RocketMQ 集成到 Spring 应用中，可以充分利用其消息传递的能力，提高系统的解耦度和可维护性。 本示例旨在展示如何在 Spring 应用中集成 ...
rocketmq-4.7.1Java 项目完整jar集合
12-04
2. **RocketMQ的客户端API**：这个集合中的jar文件包含了RocketMQ的Java客户端API，开发者可以通过这些API轻松地在应用中集成RocketMQ，进行消息的发送和接收。这些API封装了与服务器的交互细节，使得开发者能更专注...
rocketmq-spring.rar
09-06
8. **监控与管理**：可以利用RocketMQ提供的控制台或API进行消息队列的监控，查看消息发送、消费的状态，以便于问题排查和性能调优。 9. **异常处理**：考虑异常情况，例如消息发送失败、消费异常等，应有适当的重...
rocketMq-broadcast.zip
01-27
Java作为最常用的企业级编程语言，其在RocketMQ中的应用非常广泛。使用Java来实现RocketMQ的广播模式，主要涉及到以下几个关键知识点： 1. ** RocketMQ 安装与配置**：首先，你需要在本地或者服务器上安装并配置...
2、RocketMQ的消息模型
最新发布
初秋和的博客
07-28 1146
在通过 producer.sendMessageInTransaction发送事务消息后，如果消息发送成功，就会调用到这里的executeLocalTransaction方法，来执行本地事务。如果是返回未知状态，RocketMQ Broker服务器会以1分钟的间隔时间不断回查，直至达到事务回查最大检测数，如果超过这个数字还未查询到事务状态，则回滚此消息。值得注意的是，如果发送事务消息，在这里我们的创建的实例必须是 TransactionMQProducer。上面的代码中，主要就是创建事务消息的发送者。
RocketMq使用（5.0）
我的技术博客
12-09 3948
这一部分我们可以结合一下管理控制台，先来理解下RocketMQ的一些重要的基础概念：官方文档-消息发送领域模型：https://rocketmq.apache.org/zh/docs/domainModel/01main整个消息流程（大致，错了勿怪）1、部署时Broker会根据配置的nameserver地址，将自身的名称，地址等信息注册到nameserver上，每个nameserver上都具备了全量的broker信息。一般只要一台nameserver和一台broker master 节点正常，整个集群就可以
RocketMQ个人笔记
wei494199967的博客
05-17 636
RocketMQ
简述RocketMQ消息拉取过程
Java技术攻略的博客
03-17 1699
相信每一个使用RocketMQ的开发工程师都想了解一下消息是如何被拉到消费端的，消费者在消息拉取过程中都做了什么操作？这些疑问将在接下来的这篇文章中给大家一一解开；
RocketMQ原生API使用 & 6种模式消息实战demo
沮丧的南瓜
08-15 666
一、RocketMQ原生API使用 使用RocketMQ的原生API开发是最简单也是目前看来最牢靠的方式。这里我们用SpringBoot来搭建一系列消息生产者和消息消费者，来访问我们之前搭建的RocketMQ集群。 1、测试环境搭建 ​首先创建一个基于Maven的SpringBoot工程，引入如下依赖： <dependencies> <dependency> <groupId>org.apache.rocketmq</gro
SpringCloud集成RocketMQ实现事务消息方案
热门推荐
传智燕青
09-01 3万+
前边的话 当前SpringCloud作为微服务开发的首选开源方案提供了完善的微服务开发技术套件，不过针对分布式领域的难题–分布式事务控制并没有成熟的方案，本篇将介绍作为柔性事务控制的优秀方案RocketMQ的使用原理和方法。 通过本案例的学习，掌握SpringCloud集成RocketMQ事务分布式事务控制的方法。 RocketMQ事务消息方案 RocketMQ 是一个来自阿里巴巴的分布式消息中间...
RocketMQ学习笔记（12）----RocketMQ的Consumer API简介
Teddies10081008的博客
11-14 222
由于消息的消费方式有两种，所以两种方式也有不同的API： 1. PushConsumer的配置 　　1.consumerGroup： 默认值为DEFAULT_CONSUMER，Consumer组名，多个Consumer如果属于一个应用，订阅同样的消息，且消费逻辑一致，则应该将它们归为同一组 　　2.messageModel： 消息模型，默认值为CLUSTERING，支持集群消费...
rocketMQ 消息查询（id,key） 运维命令以及java API的用法
花裤衩
08-18 2万+
MQ相关介绍：http://blog.csdn.net/luckyzhoustar/article/details/51286554 RocketMq是一个纯Java、分布式、队列模型的的开源的消息中间件，但是目前相关的资料较少，所以出现了问题很难找到解决方案。 1、MQ 消息生产：http://blog.csdn.net/luckyzhoustar/article/detai
【RocketMQ】消息重试、重试次数设置、死信队列
m0_45406092的博客
09-28 1万+
文章目录1. 死信队列1.1 死信特性1.2 查看死信消息参考 1. 死信队列 上一篇《RocketMQ：消息重试》中我们提到当一条消息消费失败时，RocketMQ会进行一定次数的重试。重试的结果也很简单，无非就是在第N次重试时，被成功消费。或者就是经过M次重试后，仍然没有被消息。这通常是由于消费者在正常情况下无法正确地消费该消息。此时，RocketMQ不会立即将消息丢弃，而是将其发送到该消费者对应的特殊队列中去。 在RocketMQ中，这种正常情况下无法被消费的消息被称为死信消息（Dead-Lette
rocketmq集成springboot
07-20
Spring Boot 集成 RocketMQ 的方法有很多，下面是一种常用的方法： 1. 在项目中添加 RocketMQ 的依赖，可以在 pom.xml 文件中添加如下内容： ``` <groupId>org.apache.rocketmq <artifactId>rocketmq-client ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值