Redis中Rocket重试机制

最新推荐文章于 2024-03-05 16:39:03 发布
最新推荐文章于 2024-03-05 16:39:03 发布
阅读量192 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78102191/article/details/130836530
版权

Rocket重试机制，消息模式，刷盘方式

一、Consumer 批量消费（推模式）

Consumer端先启动 

Consumer端后启动. 正常情况下：应该是Consumer需要先启动

consumer.setConsumeMessageBatchMaxSize(10);//每次拉取10条

package quickstart;

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("please_rename_unique_group_name_4");

consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876");

consumer.setConsumeMessageBatchMaxSize(10);

/**

* 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>

* 如果非第一次启动，那么按照上次消费的位置继续消费 ,（消费顺序消息的时候设置）

*/

consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

consumer.subscribe("TopicTest", "*");

consumer.registerMessageListener(new MessageListenerConcurrently() {

public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {

try {

System.out.println("msgs的长度" + msgs.size());

System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);

} catch (Exception e) {

e.printStackTrace();

return ConsumeConcurrentlyStatus.RECONSUME_LATER;

}

return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;

}由于这里是Consumer先启动，所以他回去轮询MQ上是否有订阅队列的消息，由于每次producer插入一条，Consumer就拿一条所以测试结果如下（每次size都是1）

2、Consumer端后启动，也就是Producer先启动

由于这里是Consumer后启动，所以MQ上也就堆积了一堆数据，Consumer的

1、Producer端重试

也就是Producer往MQ上发消息没有发送成功，我们可以设置发送失败重试的次数,发送并触发回调函数

2、Consumer端重试

2.1、exception的情况，一般重复16次 10s、30s、1分钟、2分钟、3分钟等等

上面的代码中消费异常的情况返回

return ConsumeConcurrentlyStatus.RECONSUME_LATER;//重试

正常则返回：

return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;//成功

二、消息重试机制：消息重试分为2种

1、Producer端重试

2、Consumer端重试

});

consumer.start();

System.out.println("Consumer Started.");

}

}

consumer.setConsumeMessageBatchMaxSize(10);//每次拉取10条

//设置重试的次数

producer.setRetryTimesWhenSendFailed(3);

//开启生产者

producer.start();

//创建一条消息

Message msg = new Message("PushTopic", "push", "1", "我是一条普通消息".getBytes());

//发送消息

SendResult result = producer.send(msg);

//发送，并触发回调函数

producer.send(msg, new SendCallback() {

@Override

//成功的回调函数

public void onSuccess(SendResult sendResult) {

System.out.println(sendResult.getSendStatus());

System.out.println("成功了");

}

@Override

//出现异常的回调函数

public void onException(Throwable e) {

System.out.println("失败了"+e.getMessage());

}

});

package quickstart;

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("please_rename_unique_group_name_4");

consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876");

consumer.setConsumeMessageBatchMaxSize(10);

/**

* 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>

* 如果非第一次启动，那么按照上次消费的位置继续消费

*/

consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

consumer.subscribe("TopicTest", "*");

consumer.registerMessageListener(new MessageListenerConcurrently() {

public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {

try {

// System.out.println("msgs的长度" + msgs.size());

System.out.println(Thread.currentThread().getName() + " Receive New Messages: " + msgs);

for (MessageExt msg : msgs) {

String msgbody = new String(msg.getBody(), "utf-8");

if (msgbody.equals("Hello RocketMQ 4")) {

System.out.println("======错误=======");

int a = 1 / 0;

}

}

} catch (Exception e) {

e.printStackTrace();

if(msgs.get(0).getReconsumeTimes()==3){

//记录日志

return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;// 成功

}else{

return ConsumeConcurrentlyStatus.RECONSUME_LATER;// 重试

}

}

return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;// 成功

}

});

consumer.start();

System.out.println("Consumer Started.");

}

}

假如超过了多少次之后我们可以让他不再重试记录 日志。

if(msgs.get(0).getReconsumeTimes()==3){

//记录日志

return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;// 成功

}

2.2超时的情况，这种情况MQ会无限制的发送给消费端。

就是由于网络的情况，MQ发送数据之后，Consumer端并没有收到导致超时。也就是消费端没有给我返回return 任何状态，这样的就认为没有到达Consumer端。

这里模拟Producer只发送一条数据。consumer端暂停1分钟并且不发送接收状态给MQ

package model;

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 {1、集群消费

2、广播消费

rocketMQ默认是集群消费,我们可以通过在Consumer来支持广播消费

三、消费模式

DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("message_consumer");

consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876");

consumer.setConsumeMessageBatchMaxSize(10);

/**

* 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>

* 如果非第一次启动，那么按照上次消费的位置继续消费

*/

consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

consumer.subscribe("TopicTest", "*");

consumer.registerMessageListener(new MessageListenerConcurrently() {

public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {

try {

// 表示业务处理时间

System.out.println("=========开始暂停===============");

Thread.sleep(60000);

for (MessageExt msg : msgs) {

System.out.println(" Receive New Messages: " + msg);

}

} catch (Exception e) {

e.printStackTrace();

return ConsumeConcurrentlyStatus.RECONSUME_LATER;// 重试

}

return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;// 成功

}

});

consumer.start();

System.out.println("Consumer Started.");

}

}

consumer.setMessageModel(MessageModel.BROADCASTING);// 广播消费

package model;

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;

import com.alibaba.rocketmq.common.protocol.heartbeat.MessageModel;

/**

* Consumer，订阅消息

*/

public class Consumer2 {

public static void main(String[] args) throws InterruptedException, MQClientException {

DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("message_consumer");

consumer.setNamesrvAddr("192.168.100.145:9876;192.168.100.146:9876");

consumer.setConsumeMessageBatchMaxSize(10);

consumer.setMessageModel(MessageModel.BROADCASTING);// 广播消费

consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

consumer.subscribe("TopicTest", "*");

consumer.registerMessageListener(new MessageListenerConcurrently() {

public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {异步复制和同步双写主要是主和从的关系。消息需要实时消费的，就需要采用主从模式部署

异步复制:比如这里有一主一从，我们发送一条消息到主节点之后，这样消息就算从producer端发送成功了，然后通过异步复制的方法将数据复制到从节点

同步双写:比如这里有一主一从，我们发送一条消息到主节点之后，这样消息就并不算从producer端发送成功了，需要通过同步双写的方法将数据同步到从节点后， 才算数据发

送成功。

如果rocketMq才用双master部署，Producer往MQ上写入20条数据 其中Master1中拉取了12条 。Master2中拉取了8 条，这种情况下，Master1宕机，那么我们消费数据的时

候，只能消费到Master2中的8条，Master1中的12条默认持久化，不会丢失消息，需要Master1恢复之后这12条数据才能继续被消费，如果想保证消息实时消费，就才用双

Master双Slave的模式

同步刷盘：在消息到达MQ后，RocketMQ需要将数据持久化，同步刷盘是指数据到达内存之后，必须刷到commitlog日志之后才算成功，然后返回producer数据已经发送成功。

异步刷盘：，同步刷盘是指数据到达内存之后,返回producer说数据已经发送成功。，然后再写入commitlog日志。

commitlog：

commitlog就是来存储所有的元信息，包含消息体，类似于MySQL、Oracle的redolog,所以主要有CommitLog在，Consume Queue即使数据丢失，仍然可以恢复出来。

consumequeue：记录数据的位置,以便Consume快速通过consumequeue找到commitlog中的数据

Redis的键值可以使用物种数据类型：字符串，散列表，列表，集合，有序集合。本文详细介绍这五种数据类型的使用方法。本文命令介绍部分只是列举了基本的命令，至于具体

的使用示例，可以参考Redis官方文档：http://redis.readthedocs.org/en/latest

字符串是Redis中最基本的数据类型，它能够存储任何类型的字符串，包含二进制数据。可以用于存储邮箱，JSON化的对象，甚至是一张图片，一个字符串允许存储的最大容量

为512MB。字符串是其他四种类型的基础，与其他几种类型的区别从本质上来说只是组织字符串的方式不同而已。

四、conf下的配置文件说明

五、刷盘方式

心是凉的
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
轻量级重试机制方案(mq)
Miao_W的专栏
03-11 1017
1.Points (1)业务与重试分离 (2)重试机制只负责重试 (3)具体重试内容由业务负责 (4)采用消息机制重试 (5)重试参数类型具体由业务自己转换 (6)参数记录当前重试目标，重试次数，重试间隔参数等 2.API RetryInterface RetryResultEntity retry(String param...
Redis Cluster及JedisPool底层重试机制
吒哇
06-03 756
参考：https://www.cnblogs.com/williamjie/p/11132211.html
spring-data-redis 实现用户登录次数限制以及冻结时间重试机制
不管风吹浪打，胜似闲庭信步
04-10 1722
本周收到一个优化请求，是对一个web项目实现登录用户的安全性校验，也就是实现登录次数的限制以及重试次数用完之后间隔时间再次恢复登录的功能。
重试间隔推送机制之Redis 有序集合
哦，你怎么又来了
04-23 993
在我们开发过程中，难免需要各种服务的对接，在对接过程中由于网络等其他原因影响可能导致推送数据异常，这时候我们会采取一些重试机制 那么，类似于微信的重试推送机制的实现，如【15s/15s/30s/3m/10m/20m/30m/30m/30m/60m/3h/3h/3h/6h/6h】,我们可以采用redis有序集合 1、推送失败后，我们需要记录推送失败次数【用于取出下次推送的间隔时间节点】 2、采用Re...
重试机制的实现（4m,10m,10m,1h,2h,6h,15h）
weixin_45062785的博客
01-26 3130
项目场景： 由于我我们现在所作的项目有有很多的外放接口供代理商调用，但是有些接口的响应并不是实时返回的，此时我们就需要以回调接口的方式，将信息响应给代理商。在这期间可能会出网络不稳定等其他情况，导致回调接口调用失败。所以需要特定的回调重试机制。这个机制参考了支付宝的通知模式。 思考过程： 回调本身很简单，只需代理商按要求实现我们的接口便可，但是重试机制比较麻烦，他的重试时间间隔不固定，而且到后面时间的间隔过长，使用定时任务达到的效果也并不理想，最后，通过使用rabbitmq，死信队列的特性，完美的实现了
Redis集群的扩展测试.docx
10-20
Redis集群的扩展测试是指在高可用架构环境中，通过添加新的Redis节点来扩展Redis集群的容量和性能。本节教程将指导您如何安装新的Redis节点，并进行扩展性测试。 安装新的Redis节点 要安装新的Redis节点，需要在...
Redis基础学习之管道机制详析
12-16
总的来说，Redis的管道机制是提高客户端与服务器间交互效率的关键技术，尤其在需要批量处理命令的场景中，它能显著降低网络延迟，提升系统性能。通过适当调整命令批量大小，可以达到最佳的性能效果。在实际开发中，...
Redis的LRU机制介绍
09-10
在内存有限的情况下，为了保证服务的持续性，Redis提供了LRU（Least Recently Used，最近最少使用）机制来管理内存。LRU策略的核心思想是优先淘汰那些最近最少使用的数据，以确保热数据能够被保留在内存中。 在...
redis锁与zk锁机制处理
09-11
在标题提到的"redis锁与zk锁机制处理"中，我们主要关注两种常见的分布式锁实现：基于Redis的分布式锁和基于Zookeeper（ZK）的分布式锁。下面将详细讨论这两种锁的原理、优缺点以及适用场景。 1. Redis分布式锁 ...
Redisson分布式锁的可重入、重试、续约机制原理
最新发布
Shadow_T的博客
03-05 3191
Redisson分布式锁的可重入、重试和看门狗机制的原理
ssm+shiro+redis 登录控制及重试次数超过5次账号锁定一分钟
03-16
shiro+redis 实现登录控制及密码重试次数超过5次后账号锁定一分钟不能登录
guava-retrying模块实现redis连接重试
jyj019的博客
09-08 559
guava-retrying是一个优秀的连接重试工具，最近项目也在多处使用这个工具做相应模块的连接，其中关于redis的连接重试比较有意思。这里分享下。
基于redis、quartz的可重试的异步通知实现
流云小筑
08-06 1370
1、数据库表设计 CREATE TABLE `crl_notify_record` ( `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增主键', `notice_owner` varchar(30) NOT NULL COMMENT '通知发起方的简称', `notice_owner_serial` varchar(80) ...
redis后台请求防重发
keeper42的博客
11-21 367
通过spirng的切面aop机制来统一拦截所有的方法，采用用户唯一标记和所调用的方法名结合作为key来加锁，保证同一用户的同一方法在单位时间内只有一个请求会被执行，另外的请求在当前请求执行中会被丢弃，返回特定的返回码给前端，不影响用户使用，用户无感知。加锁采用的是redis数据库，redis比传统的数据要更高效快速并发更高，和java自带的锁比又满足系统分布式要求。redis是单进程机制，天生满足并发要求，因为在是操作内存速度又快，综合比较满足请求防重发的要求。 ...
Redis(十三)：作为缓存服务器时的问题
weixin_43844995的博客
03-22 715
上一篇介绍了 Redis 的切片集群。这节开始介绍 Redis 作为缓存服务器时的问题。Redis 最常见的应用场景就是作为缓存数据库，以提高数据访问的速度。缓存的一大问题就是一致性问题，即如何尽量与存储数据库的数据保持一致的问题。本文介绍了 Redis 作为缓存服务器时的问题，Redis 作为缓存服务器时，通常会选用旁路缓存策略。这种策略的优点是性能好，非常适合作为读缓存，但是在更新缓存时可能存在数据一致性的问题。缓存本身还会有雪崩、击穿、穿透三个问题，每个问题都有各自的应对方案。
Redis整合Springboot，实现消息订阅发布以及key过期监听
tingfengqianqu的博客
12-06 949
整体思路 先通过pom引入redis，在properties或yml中添加redis配置，初步整合到Springboot中。然后实现RedisConfig。通过实现KeyExpirationEventMessageListener可以在过期或者时间发布的时候进行其他操作。先整体给大家看一下，如下图1所示。 具体实现 1.pom和properties就省略了。根据自己情况配置！ 2.实现RedisConfig实现 继承CachingConfigurerSupport 引入连接工厂 定义RedisTempl
【Redis】6、Redisson 分布式锁的简单使用（可重入、重试机制...）
m0_54189068的博客
07-19 3035
Redisson 的可重入锁原理、可重试原理
大厂都是怎么做Redis重试的？
Reische的博客
12-30 862
受网络和运行环境影响，应用程序可能遇到暂时性故障，如瞬时网络抖动、服务暂时不可用、服务繁忙导致超时等。自动重试机制可大幅避免此类故障，保障操作成功执行。
Scala/Java - Redis 连接检测与重试
BITDDD小栈
01-05 2306
项目实现中需要连接 redis，为了防止因网络抖动或其他原因造成的客户端连接失败，一般需要增加重试机制判断 client 是否连接成功，之前写了一版重连代码发现有 bug，借此机会看下代码 bug 以及如何更好的重连 redis。...
java redis 连接超时重试示例
05-26
在以上示例中，我们使用了 Jedis 提供的 `JedisConnectionException` 异常来判断是否连接 Redis 失败，并在连接失败时进行重试。如果重试次数超过了 `MAX_RETRIES`，则认为连接失败。 在连接失败后，我们使用了 `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

心是凉的

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

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

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

打赏作者

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

抵扣说明：

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

余额充值