8. RocketMQ快速入门
RocketMQ提供了发送多种发送消息的模式，例如同步消息，异步消息，顺序消息，延迟消息，事务消息等，我们一一学习
8.1 消息发送和监听的流程
我们先搞清楚消息发送和监听的流程，然后我们在开始敲代码
8.1.1 消息生产者
| 1.创建消息生产者producer，并制定生产者组名
2.指定Nameserver地址
3.启动producer
4.创建消息对象，指定主题Topic、Tag和消息体等
5.发送消息
| 6.关闭生产者producer |
|---|
8.1.2 消息消费者
| 1.创建消费者consumer，制定消费者组名
2.指定Nameserver地址
3.创建监听订阅主题Topic和Tag等
4.处理消息
| 5.启动消费者consumer |
|---|
8.2 搭建Rocketmq-demo
8.2.1 加入依赖
|
org.apache.rocketmq
rocketmq-client
4.9.2
8.2.2 编写生产者
| /** * 测试生产者 * * @throws Exception */
@Testpublic void testProducer() throws Exception {
_// 创建默认的生产者 _
DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _
producer.setNamesrvAddr(“localhost:9876”);
_// 启动实例 _
producer.start();
for (int i = 0; i < 10; i++) {
_// 创建消息 _
_// 第一个参数：主题的名字 _
_// 第二个参数：消息内容 _
Message msg = new Message(“TopicTest”, ("Hello RocketMQ " + i).getBytes());
SendResult send = producer.send(msg);
System.out.println(send);
}
_// 关闭实例 _producer.shutdown();
| } |
|---|
8.2.3 编写消费者
| _/** * 测试消费者 * * @throws Exception */ _
@Test public void testConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
_// 设置nameServer地址 _
consumer.setNamesrvAddr(“localhost:9876”);
_// 订阅一个主题来消费 表示没有过滤参数 表示这个主题的任何消息 _consumer.subscribe(“TopicTest”, "");
_// 注册一个消费监听 _
_MessageListenerConcurrently 是多线程消费，默认20个线程，可以参看consumer.setConsumeThreadMax() _
consumer.registerMessageListener(new MessageListenerConcurrently() { @Override
public ConsumeConcurrentlyStatus consumeMessage(List msgs,
ConsumeConcurrentlyContext context) {
System.out.println(Thread.currentThread().getName() + “----” + msgs);
_// 返回消费的状态 如果是CONSUME_SUCCESS 则成功，若为RECONSUME_LATER则该条消息会被重回队列，重新被投递 _
_// 重试的时间为messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h _
// 也就是第一次1s 第二次5s 第三次10s … 如果重试了18次 那么这个消息就会被终止发送给消费者
_// _
_return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; _
return ConsumeConcurrentlyStatus.RECONSUME_LATER;
} });
_// 这个start一定要写在registerMessageListener下面 _
consumer.start();
System.in.read();
| } |
|---|
8.2.4 测试
启动生产者和消费者进行测试
9. 消费模式
MQ的消费模式可以大致分为两种，一种是推Push，一种是拉Pull。
Push是服务端【MQ】主动推送消息给客户端，优点是及时性较好，但如果客户端没有做好流控，一旦服务端推送大量消息到客户端时，就会导致客户端消息堆积甚至崩溃。
Pull是客户端需要主动到服务端取数据，优点是客户端可以依据自己的消费能力进行消费，但拉取的频率也需要用户自己控制，拉取频繁容易造成服务端和客户端的压力，拉取间隔长又容易造成消费不及时。
Push模式也是基于pull模式的，只能客户端内部封装了api，一般场景下，上游消息生产量小或者均速的时候，选择push模式。在特殊场景下，例如电商大促，抢优惠券等场景可以选择pull模式
10. RocketMQ发送同步消息
上面的快速入门就是发送同步消息，发送过后会有一个返回值，也就是mq服务器接收到消息后返回的一个确认，这种方式非常安全，但是性能上并没有这么高，而且在mq集群中，也是要等到所有的从机都复制了消息以后才会返回，所以针对重要的消息可以选择这种方式
11. RocketMQ发送异步消息
异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。发送完以后会有一个异步消息通知
11.1 异步消息生产者
| @Testpublic void testAsyncProducer() throws Exception {
_// 创建默认的生产者 _
DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _
producer.setNamesrvAddr(“localhost:9876”);
_// 启动实例 _producer.start();
Message msg = new Message(“TopicTest”, (“异步消息”).getBytes());** **
**producer.send(msg, new SendCallback() { **
**@Override **
**public void onSuccess(SendResult sendResult) { **
**System.out.println(“发送成功”); **
**} **
**@Override **
**public void onException(Throwable e) { **
System.out.println(“发送失败”); **
** } });
System.out.println(“看看谁先执行”);
_// 挂起jvm 因为回调是异步的不然测试不出来 _
System.in.read();
_// 关闭实例 _
producer.shutdown();
| } |
|---|
11.2 异步消息消费者
| @Testpublic void testAsyncConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
_// 设置nameServer地址 _consumer.setNamesrvAddr(“localhost:9876”);
_// 订阅一个主题来消费 表示没有过滤参数 表示这个主题的任何消息 _
consumer.subscribe(“TopicTest”, "");
_// 注册一个消费监听 MessageListenerConcurrently是并发消费 _
_// 默认是20个线程一起消费，可以参看 consumer.setConsumeThreadMax() _consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List msgs,
ConsumeConcurrentlyContext context) {
_// 这里执行消费的代码 默认是多线程消费 _
System.out.println(Thread.currentThread().getName() + “----” + msgs);
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
} });
consumer.start();
System.in.read();
| } |
|---|
12. RocketMQ发送单向消息
这种方式主要用在不关心发送结果的场景，这种方式吞吐量很大，但是存在消息丢失的风险，例如日志信息的发送
12.1 单向消息生产者
| @Testpublic void testOnewayProducer() throws Exception {
_// 创建默认的生产者 _
DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _
producer.setNamesrvAddr(“localhost:9876”);
// 启动实例 _
producer.start();
Message msg = new Message(“TopicTest”, (“单向消息”).getBytes());
// 发送单向消息** _producer.sendOneway(msg);**
_// 关闭实例 _
producer.shutdown();
| } |
|---|
12.2 单向消息消费者
消费者和上面一样
13. RocketMQ发送延迟消息
消息放入mq后，过一段时间，才会被监听到，然后消费
比如下订单业务，提交了一个订单就可以发送一个延时消息，30min后去检查这个订单的状态，如果还是未付款就取消订单释放库存。
13.1 延迟消息生产者
| @Testpublic void testDelayProducer() throws Exception {
_// 创建默认的生产者 _
DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _
producer.setNamesrvAddr(“localhost:9876”);
// 启动实例 _
producer.start();
Message msg = new Message(“TopicTest”, (“延迟消息”).getBytes());
// 给这个消息设定一个延迟等级 _
_ // messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h** _**
msg.setDelayTimeLevel(3);
_// 发送单向消息 _
producer.send(msg);
_// 打印时间 _
System.out.println(new Date());
_// 关闭实例 _
producer.shutdown();
| } |
|---|
13.2 延迟消息消费者
消费者和上面一样
这里注意的是RocketMQ不支持任意时间的延时
只支持以下几个固定的延时等级，等级1就对应1s，以此类推，最高支持2h延迟
private String messageDelayLevel = “1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h”;
14. RocketMQ发送顺序消息
消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为：分区有序或者全局有序。
可能大家会有疑问，mq不就是FIFO吗？
rocketMq的broker的机制，导致了rocketMq会有这个问题
因为一个broker中对应了四个queue
顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。
下面用订单进行分区有序的示例。一个订单的顺序流程是：下订单、发短信通知、物流、签收。订单顺序号相同的消息会被先后发送到同一个队列中，消费时，同一个顺序获取到的肯定是同一个队列。
14.1 场景分析
模拟一个订单的发送流程，创建两个订单，发送的消息分别是
订单号111 消息流程 下订单->物流->签收
订单号112 消息流程 下订单->物流->拒收
14.2 创建一个订单对象
| @Data@AllArgsConstructor@NoArgsConstructorpublic class Order {
_/** * 订单id / _
private Integer orderId;
_/* * 订单编号 / _
private Integer orderNumber;
_/* * 订单价格 / _
private Double price;
_/* * 订单号创建时间 / _
private Date createTime;
_/* * 订单描述 */ _
private String desc;
| } |
|---|
14.3 顺序消息生产者
| @Testpublic void testOrderlyProducer() throws Exception {
_// 创建默认的生产者 _
DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _
producer.setNamesrvAddr(“localhost:9876”);
_// 启动实例 _
producer.start();
List orderList = Arrays.asList(
new Order(1, 111, 59D, new Date(), “下订单”),
new Order(2, 111, 59D, new Date(), “物流”),
new Order(3, 111, 59D, new Date(), “签收”),
new Order(4, 112, 89D, new Date(), “下订单”),
new Order(5, 112, 89D, new Date(), “物流”),
new Order(6, 112, 89D, new Date(), “拒收”) );
_// 循环集合开始发送 orderList.forEach(order -> {
Message message = new Message(“TopicTest”, order.toString().getBytes());
try {** **
**// 发送的时候 相同的订单号选择同一个队列 **
**producer.send(message, new MessageQueueSelector() { **
**@Override **
**public MessageQueue select(List mqs, Message msg, Object arg) { **
**// 当前主题有多少个队列 **
**int queueNumber = mqs.size(); **
**// 这个arg就是后面传入的 order.getOrderNumber() **
**Integer i = (Integer) arg; **
**// 用这个值去%队列的个数得到一个队列 **
**int index = i % queueNumber; **
**// 返回选择的这个队列即可 ，那么相同的订单号 就会被放在相同的队列里 实现FIFO了 _**
**return mqs.get(index); **
} }, order.getOrderNumber());
} catch (Exception e) {
System.out.println(“发送异常”);
} });
_// 关闭实例 _
producer.shutdown();
| } |
|---|
14.4 顺序消息消费者，测试时等一会即可有延迟
| @Testpublic void testOrderlyConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
_// 设置nameServer地址 _
consumer.setNamesrvAddr(“localhost:9876”);
_// 订阅一个主题来消费 表示没有过滤参数 表示这个主题的任何消息 _
consumer.subscribe(“TopicTest”, "");
_// 注册一个消费监听 MessageListenerOrderly 是顺序消费 单线程消费 _
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List msgs, ConsumeOrderlyContext context) {
MessageExt messageExt = msgs.get(0);
System.out.println(new String(messageExt.getBody()));
return ConsumeOrderlyStatus.SUCCESS;
} });
consumer.start();
System.in.read();
| } |
|---|
15. RocketMQ发送批量消息
Rocketmq可以一次性发送一组消息，那么这一组消息会被当做一个消息消费
15.1 批量消息生产者
| @Testpublic void testBatchProducer() throws Exception {
_// 创建默认的生产者 _
_ _DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _
producer.setNamesrvAddr(“localhost:9876”);
_// 启动实例 _
producer.start(); List msgs = Arrays.asList(
new Message(“TopicTest”, “我是一组消息的A消息”.getBytes()),
new Message(“TopicTest”, “我是一组消息的B消息”.getBytes()),
new Message(“TopicTest”, “我是一组消息的C消息”.getBytes()) );
SendResult send = producer.send(msgs);
System.out.println(send);
_// 关闭实例 _
producer.shutdown();
| } |
|---|
15.2 批量消息消费者
| @Testpublic void testBatchConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
_// 设置nameServer地址 _
consumer.setNamesrvAddr(“localhost:9876”);
_// 订阅一个主题来消费 表达式，默认是* _
consumer.subscribe(“TopicTest”, “*”);
_// 注册一个消费监听 MessageListenerConcurrently是并发消费 _
_// 默认是20个线程一起消费，可以参看 consumer.setConsumeThreadMax() _
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override public ConsumeConcurrentlyStatus
consumeMessage(List msgs,
ConsumeConcurrentlyContext context) {
_// 这里执行消费的代码 默认是多线程消费 _System.out.println(Thread.currentThread().getName() + “----” + new String(msgs.get(0).getBody()));
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
} });
consumer.start();
System.in.read();
| } |
|---|
16. RocketMQ发送事务消息
16.1 事务消息的发送流程
它可以被认为是一个两阶段的提交消息实现，以确保分布式系统的最终一致性。事务性消息确保本地事务的执行和消息的发送可以原子地执行。
上图说明了事务消息的大致方案，其中分为两个流程：正常事务消息的发送及提交、事务消息的补偿流程。
事务消息发送及提交
1. 发送消息（half消息）。
2. 服务端响应消息写入结果。
3. 根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）。
4. 根据本地事务状态执行Commit或Rollback（Commit操作生成消息索引，消息对消费者可见）
事务补偿
1. 对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一次“回查”
2. Producer收到回查消息，检查回查消息对应的本地事务的状态
3. 根据本地事务状态，重新Commit或者Rollback
其中，补偿阶段用于解决消息UNKNOW或者Rollback发生超时或者失败的情况。
事务消息状态
事务消息共有三种状态，提交状态、回滚状态、中间状态：
l TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。
l TransactionStatus.RollbackTransaction: 回滚事务，它代表该消息将被删除，不允许被消费。
l TransactionStatus.Unknown: 中间状态，它代表需要检查消息队列来确定状态。
16.2 事务消息生产者
| /** * TransactionalMessageCheckService的检测频率默认1分钟，可通过在broker.conf文件中设置transactionCheckInterval的值来改变默认值，单位为毫秒。 * 从broker配置文件中获取transactionTimeOut参数值。 * 从broker配置文件中获取transactionCheckMax参数值，表示事务的最大检测次数，如果超过检测次数，消息会默认为丢弃，即回滚消息。 * * @throws Exception */
@Testpublic void testTransactionProducer() throws Exception {
_// 创建一个事务消息生产者 _
TransactionMQProducer producer = new TransactionMQProducer(“test-group”); producer.setNamesrvAddr(“localhost:9876”);
_// 设置事务消息监听器 _
producer.setTransactionListener(new TransactionListener() {
_// 这个是执行本地业务方法 _
@Override public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
System.out.println(new Date());
System.out.println(new String(msg.getBody()));
_// 这个可以使用try catch对业务代码进行性包裹 _
_ // COMMIT_MESSAGE 表示允许消费者消费该消息 _
_ // ROLLBACK_MESSAGE 表示该消息将被删除，不允许消费 _
_// UNKNOW表示需要MQ回查才能确定状态 那么过一会 代码会走下面的checkLocalTransaction(msg)方法 _
return LocalTransactionState.UNKNOW;
}
_// 这里是回查方法 回查不是再次执行业务操作，而是确认上面的操作是否有结果 _
_// 默认是1min回查 默认回查15次 超过次数则丢弃打印日志 可以通过参数设置 _
_// transactionTimeOut 超时时间 _
_ // transactionCheckMax 最大回查次数 _
_// transactionCheckInterval 回查间隔时间单位毫秒 _
_ // 触发条件 _
_// 1.当上面执行本地事务返回结果UNKNOW时,或者下面的回查方法也返回UNKNOW时 会触发回查 _
_// 2.当上面操作超过20s没有做出一个结果，也就是超时或者卡主了，也会进行回查 _
_ _@Override
public LocalTransactionState checkLocalTransaction(MessageExt msg) {
System.err.println(new Date());
System.err.println(new String(msg.getBody()));
_// 这里 _
return LocalTransactionState.UNKNOW;
}
});
producer.start();
Message message = new Message(“TopicTest2”, “我是一个事务消息”.getBytes());
_// 发送消息 _
producer.sendMessageInTransaction(message, null);
System.out.println(new Date());
System.in.read();
| } |
|---|
16.3 事务消息消费者
| @Testpublic void testTransactionConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
_// 设置nameServer地址 _
consumer.setNamesrvAddr(“localhost:9876”);
// 订阅一个主题来消费 *表示没有过滤参数 表示这个主题的任何消息
_ _consumer.subscribe(“TopicTest2”, “*”);
_// 注册一个消费监听 MessageListenerConcurrently是并发消费 _
_ // 默认是20个线程一起消费，可以参看 consumer.setConsumeThreadMax() _
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override public ConsumeConcurrentlyStatus
consumeMessage(List msgs,
ConsumeConcurrentlyContext context) {
_// 这里执行消费的代码 默认是多线程消费 _
System.out.println(Thread.currentThread().getName() + “----” + new String(msgs.get(0).getBody()));
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.in.read();
| } |
|---|
16.4 测试结果
17. RocketMQ发送带标签的消息，消息过滤
Rocketmq提供消息过滤功能，通过tag或者key进行区分
我们往一个主题里面发送消息的时候，根据业务逻辑，可能需要区分，比如带有tagA标签的被A消费，带有tagB标签的被B消费，还有在事务监听的类里面，只要是事务消息都要走同一个监听，我们也需要通过过滤才区别对待
17.1 标签消息生产者
| @Testpublic void testTagProducer() throws Exception {
_// 创建默认的生产者 _
DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _
producer.setNamesrvAddr(“localhost:9876”);
_// 启动实例 _
producer.start();
Message msg = new Message(“TopicTest”,“tagA”, “我是一个带标记的消息”.getBytes());
SendResult send = producer.send(msg);
System.out.println(send);
_// 关闭实例 _
producer.shutdown();
}
|
| — |
17.2 标签消息消费者
| @Testpublic void testTagConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
// 设置nameServer地址 _
consumer.setNamesrvAddr(“localhost:9876”);** **
**// 订阅一个主题来消费 表达式，默认是*,支持"tagA || tagB || tagC" 这样或者的写法 只要是符合任何一个标签都可以消费 _**
consumer.subscribe(“TopicTest”, “tagA || tagB || tagC”);
_// 注册一个消费监听 MessageListenerConcurrently是并发消费 // 默认是20个线程一起消费，可以参看 consumer.setConsumeThreadMax() _
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override public ConsumeConcurrentlyStatus
consumeMessage(List msgs,
ConsumeConcurrentlyContext context) {
_// 这里执行消费的代码 默认是多线程消费 _
_ _System.out.println(Thread.currentThread().getName() + “----” + new String(msgs.get(0).getBody()));
System.out.println(msgs.get(0).getTags());
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.in.read();
}
|
| — |
17.3 什么时候该用 Topic，什么时候该用 Tag？
总结：不同的业务应该使用不同的Topic如果是相同的业务里面有不同表的表现形式，那么我们要使用tag进行区分
可以从以下几个方面进行判断：
1.消息类型是否一致：如普通消息、事务消息、定时（延时）消息、顺序消息，不同的消息类型使用不同的 Topic，无法通过 Tag 进行区分。
2.业务是否相关联：没有直接关联的消息，如淘宝交易消息，京东物流消息使用不同的 Topic 进行区分；而同样是天猫交易消息，电器类订单、女装类订单、化妆品类订单的消息可以用 Tag 进行区分。
3.消息优先级是否一致：如同样是物流消息，盒马必须小时内送达，天猫超市 24 小时内送达，淘宝物流则相对会慢一些，不同优先级的消息用不同的 Topic 进行区分。
4.消息量级是否相当：有些业务消息虽然量小但是实时性要求高，如果跟某些万亿量级的消息使用同一个 Topic，则有可能会因为过长的等待时间而“饿死”，此时需要将不同量级的消息进行拆分，使用不同的 Topic。
总的来说，针对消息分类，您可以选择创建多个 Topic，或者在同一个 Topic 下创建多个 Tag。但通常情况下，不同的 Topic 之间的消息没有必然的联系，而 Tag 则用来区分同一个 Topic 下相互关联的消息，例如全集和子集的关系、流程先后的关系。
18. RocketMQ中消息的Key
在rocketmq中的消息，默认会有一个messageId当做消息的唯一标识，我们也可以给消息携带一个key，用作唯一标识或者业务标识，包括在控制面板查询的时候也可以使用messageId或者key来进行查询
18.1 带key消息生产者
| @Testpublic void testKeyProducer() throws Exception {
_// 创建默认的生产者 _
DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _
producer.setNamesrvAddr(“localhost:9876”);
_// 启动实例 _
producer.start();
Message msg = new Message(“TopicTest”,“tagA”,“key”, “我是一个带标记和key的消息”.getBytes());
SendResult send = producer.send(msg);
System.out.println(send);
_// 关闭实例 _
producer.shutdown();
| } |
|---|
18.2 带key消息消费者
| @Testpublic void testKeyConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
_// 设置nameServer地址 _
consumer.setNamesrvAddr(“localhost:9876”);
_// 订阅一个主题来消费 表达式，默认是*,支持"tagA || tagB || tagC" 这样或者的写法 只要是符合任何一个标签都可以消费 _
consumer.subscribe(“TopicTest”, “tagA || tagB || tagC”);
_// 注册一个消费监听 MessageListenerConcurrently是并发消费 // 默认是20个线程一起消费，可以参看 consumer.setConsumeThreadMax() _
_ _consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override public ConsumeConcurrentlyStatus
consumeMessage(List msgs,
ConsumeConcurrentlyContext context) {
_// 这里执行消费的代码 默认是多线程消费 _
_ _System.out.println(Thread.currentThread().getName() + “----” + new String(msgs.get(0).getBody()));
System.out.println(msgs.get(0).getTags());
System.out.println(msgs.get(0).getKeys());
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.in.read();
}
|
| — |
19. RocketMQ重试机制
19.1 生产者重试
// 失败的情况重发3次
producer.setRetryTimesWhenSendFailed(3);
// 消息在1S内没有发送成功，就会重试
producer.send(msg, 1000);
19.2 消费者重试
在消费者放return ConsumeConcurrentlyStatus.RECONSUME_LATER;后就会执行重试
上图代码中说明了，我们再实际生产过程中，一般重试3-5次，如果还没有消费成功，则可以把消息签收了，通知人工等处理
| /** * 测试消费者 * * @throws Exception */
@Testpublic void testConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
_// 设置nameServer地址 _
consumer.setNamesrvAddr(“localhost:9876”);
_// 订阅一个主题来消费 表示没有过滤参数 表示这个主题的任何消息 _
consumer.subscribe(“TopicTest”, "");
_// 注册一个消费监听 _
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override public ConsumeConcurrentlyStatus consumeMessage(List
msgs,
ConsumeConcurrentlyContext context) {
try {
_// 这里执行消费的代码 _
System.out.println(Thread.currentThread().getName() + “----” + msgs);
_// 这里制造一个错误 _
int i = 10 / 0;
} catch (Exception e) {
_// 出现问题 判断重试的次数 _
MessageExt messageExt = msgs.get(0);
_// 获取重试的次数 失败一次消息中的失败次数会累加一次 _
int reconsumeTimes = messageExt.getReconsumeTimes();
if (reconsumeTimes >= 3) {
_// 则把消息确认了，可以将这条消息记录到日志或者数据库 通知人工处理 _
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
} else {
return ConsumeConcurrentlyStatus.RECONSUME_LATER;
}
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.in.read();
| } |
|---|
20. RocketMQ死信消息
当消费重试到达阈值以后，消息不会被投递给消费者了，而是进入了死信队列
当一条消息初次消费失败，RocketMQ会自动进行消息重试，达到最大重试次数后，若消费依然失败，则表明消费者在正常情况下无法正确地消费该消息。此时，该消息不会立刻被丢弃，而是将其发送到该消费者对应的特殊队列中，这类消息称为死信消息（Dead-Letter Message），存储死信消息的特殊队列称为死信队列（Dead-Letter Queue），死信队列是死信Topic下分区数唯一的单独队列。如果产生了死信消息，那对应的ConsumerGroup的死信Topic名称为%DLQ%ConsumerGroupName，死信队列的消息将不会再被消费。可以利用RocketMQ Admin工具或者RocketMQ Dashboard上查询到对应死信消息的信息。我们也可以去监听死信队列，然后进行自己的业务上的逻辑
20.1 消息生产者
| @Testpublic void testDeadMsgProducer() throws Exception {
DefaultMQProducer producer = new DefaultMQProducer(“dead-group”);
producer.setNamesrvAddr(“localhost:9876”);
producer.start(); Message message = new Message(“dead-topic”, “我是一个死信消息”.getBytes());
producer.send(message);
producer.shutdown();
| } |
|---|
20.2 消息消费者
| @Testpublic void testDeadMsgConsumer() throws Exception {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“dead-group”);
consumer.setNamesrvAddr(“localhost:9876”);
consumer.subscribe(“dead-topic”, “*”);
_// 设置最大消费重试次数 2 次 _
consumer.setMaxReconsumeTimes(2);
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override public ConsumeConcurrentlyStatus
consumeMessage(List msgs, ConsumeConcurrentlyContext context) {
System.out.println(msgs);
_// 测试消费失败 _
return ConsumeConcurrentlyStatus.RECONSUME_LATER;
}
});
consumer.start();
System.in.read();
| } |
|---|
20.3 死信消费者
注意权限问题
| @Testpublic void testDeadMq() throws Exception{
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“dead-group”);
consumer.setNamesrvAddr(“localhost:9876”);
_// 消费重试到达阈值以后，消息不会被投递给消费者了，而是进入了死信队列 _
_// 队列名称 默认是 %DLQ% + 消费者组名 _
consumer.subscribe(“%DLQ%dead-group”, “*”);
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override public ConsumeConcurrentlyStatus
consumeMessage(List msgs, ConsumeConcurrentlyContext context) {
System.out.println(msgs);
_// 处理消息 签收了 _
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.in.read();
| } |
|---|
20.4 控制台显示
21. RocketMQ消息重复消费问题
21.1 为什么会出现重复消费问题呢？
BROADCASTING(广播)模式下，所有注册的消费者都会消费，而这些消费者通常是集群部署的一个个微服务，这样就会多台机器重复消费，当然这个是根据需要来选择。
CLUSTERING（负载均衡）模式下，如果一个topic被多个consumerGroup消费，也会重复消费。
即使是在CLUSTERING模式下，同一个consumerGroup下，一个队列只会分配给一个消费者，看起来好像是不会重复消费。但是，有个特殊情况：一个消费者新上线后，同组的所有消费者要重新负载均衡（反之一个消费者掉线后，也一样）。一个队列所对应的新的消费者要获取之前消费的offset（偏移量，也就是消息消费的点位），此时之前的消费者可能已经消费了一条消息，但是并没有把offset提交给broker，那么新的消费者可能会重新消费一次。虽然orderly模式是前一个消费者先解锁，后一个消费者加锁再消费的模式，比起concurrently要严格了，但是加锁的线程和提交offset的线程不是同一个，所以还是会出现极端情况下的重复消费。
还有在发送批量消息的时候，会被当做一条消息进行处理，那么如果批量消息中有一条业务处理成功，其他失败了，还是会被重新消费一次。
那么如果在CLUSTERING（负载均衡）模式下，并且在同一个消费者组中，不希望一条消息被重复消费，改怎么办呢？我们可以想到去重操作，找到消息唯一的标识，可以是msgId也可以是你自定义的唯一的key，这样就可以去重了
21.2 解决方案
使用去重方案解决，例如将消息的唯一标识存起来，然后每次消费之前先判断是否存在这个唯一标识，如果存在则不消费，如果不存在则消费，并且消费以后将这个标记保存。
想法很好，但是消息的体量是非常大的，可能在生产环境中会到达上千万甚至上亿条，那么我们该如何选择一个容器来保存所有消息的标识，并且又可以快速的判断是否存在呢？
我们可以选择布隆过滤器(BloomFilter)
布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。
**在hutool的工具中我们可以直接使用，当然你自己使用redis的bitmap类型手写一个也是可以的 **https://hutool.cn/docs/#/bloomFilter/%E6%A6%82%E8%BF%B0
21.3 测试生产者
| @Testpublic void testRepeatProducer() throws Exception {
_// 创建默认的生产者 _
DefaultMQProducer producer = new DefaultMQProducer(“test-group”);
_// 设置nameServer地址 _producer.setNamesrvAddr(“localhost:9876”);
_// 启动实例 producer.start();
// 我们可以使用自定义key当做唯一标识** _**
**String keyId = UUID.randomUUID().toString(); **
**System.out.println(keyId); **
Message msg = new Message(“TopicTest”, “tagA”, keyId, “我是一个测试消息”.getBytes());
SendResult send = producer.send(msg);
System.out.println(send);
_// 关闭实例 _
_ _producer.shutdown();
| } |
|---|
21.4 添加hutool的依赖
|
cn.hutool
hutool-all
5.7.11
21.5 测试消费者
| /** * 在boot项目中可以使用@Bean在整个容器中放置一个单利对象 */
public static BitMapBloomFilter _bloomFilter _= new BitMapBloomFilter(100);
@Testpublic void testRepeatConsumer() throws Exception {
_// 创建默认消费者组 _
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(“consumer-group”);
consumer.setMessageModel(MessageModel.BROADCASTING);
_// 设置nameServer地址 _
consumer.setNamesrvAddr(“localhost:9876”);
_// 订阅一个主题来消费 表达式，默认是* _
consumer.subscribe(“TopicTest”, “*”);
_// 注册一个消费监听 MessageListenerConcurrently是并发消费 _
_ // 默认是20个线程一起消费，可以参看 consumer.setConsumeThreadMax() _
_ consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override public ConsumeConcurrentlyStatus consumeMessage(List msgs,
ConsumeConcurrentlyContext context) {
// 拿到消息的key ** **
**MessageExt messageExt = msgs.get(0); **
**String keys = messageExt.getKeys(); **
**// 判断是否存在布隆过滤器中 **
if (bloomFilter.contains(keys)) { **
** _// 直接返回了 不往下处理业务 _
**return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; **
**} **
**// 这个处理业务，然后放入过滤器中 **
**// do sth… _**
**bloomFilter.add(keys); **
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.in.read();
| } |
|---|