前言:实际项目中经常遇到消息消费失败了,要进行消息的重发。比如支付消息消费失败后,要分不同时间段进行N次的消息重发提醒。

本文模拟场景

  1. 当金额少于100时,消息消费成功
  2. 当金额大于100,小于200时,会进行3次重发,第一次1秒;第二次2秒;第三次3秒。
  3. 当金额大于200时,消息消费失败,会进行5次重发,第一次1秒;第二次2秒;第三次3秒;第四次4秒;第五次5秒。重试五次后,消息自动进入死信队列,在死信队列存活60秒后消失。

代码实例

特别注意代码与配置文件中的注释,各个使用说明都已经详细写在配置文件中

pom包引入

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.12.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.cloudstream</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo</name>
<description>Demo project for Spring Boot</description> <properties>
<java.version>1.8</java.version>
<spring-cloud.version>Greenwich.SR5</spring-cloud.version>
</properties> <dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- ①关键配置:引入stream-rabbit 依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies> <dependencyManagement>
<dependencies>
<!-- ②关键配置:由于stream是基于spring-cloud的,所以这里要引入 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement> <build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build> <repositories>
<repository>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>https://repo.spring.io/snapshot</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories> </project>

配置application.yml文件

注意各个配置的缩进格式,别搞错了

server:
port: 8081
spring:
application:
name: stream-demo
#rabbitmq连接配置
rabbitmq:
host: 127.0.0.1
port: 5672
username: admin
password: 123456
cloud:
stream:
bindings:
#消息生产者,与DelayDemoTopic接口中的DELAY_DEMO_PRODUCER变量值一致
delay-demo-producer:
#①定义交换机名
destination: demo-delay-queue
#消息消费者,与DelayDemoTopic接口中的DELAY_DEMO_CONSUMER变量值一致
delay-demo-consumer:
#定义交换机名,与①一致,就可以使发送和消费都指向一个队列
destination: demo-delay-queue
#分组,这个配置可以开启消息持久化、可以解决在集群环境下重复消费的问题。
#比如A、B两台服务器集群,如果没有这个配置,则A、B都能收到同样的消息,如果有该配置则只有其中一台会收到消息
group: delay-consumer-group
consumer:
#最大重试次数,默认为3。不使用默认的,这里定义为1,由我们程序控制发送时间和次数
maxAttempts: 1
rabbit:
bindings:
#消息生产者,与DelayDemoTopic接口中的DELAY_DEMO_PRODUCER变量值一致
delay-demo-producer:
producer:
#②申明为延迟队列
delayedExchange: true
#消息消费者,与DelayDemoTopic接口中的DELAY_DEMO_CONSUMER变量值一致
delay-demo-consumer:
consumer:
#申明为延迟队列,与②的配置的成对出现的
delayedExchange: true
#开启死信队列
autoBindDlq: true
#死信队列中消息的存活时间
dlqTtl: 60000

定义队列通道

  1. 定义通道
/**
* 定义延迟消息通道
*/
public interface DelayDemoTopic {
/**
* 生产者,与yml文件配置对应
*/
String DELAY_DEMO_PRODUCER = "delay-demo-producer";
/**
* 消费者,与yml文件配置对应
*/
String DELAY_DEMO_CONSUMER = "delay-demo-consumer"; /**
* 定义消息消费者,在@StreamListener监听消息的时候用到
* @return
*/
@Input(DELAY_DEMO_CONSUMER)
SubscribableChannel delayDemoConsumer(); /**
* 定义消息发送者,在发送消息的时候用到
* @return
*/
@Output(DELAY_DEMO_PRODUCER)
MessageChannel delayDemoProducer();
}
  1. 绑定通道
/**
* 配置消息的binding
*
*/
@EnableBinding(value = {DelayDemoTopic.class})
@Component
public class MessageConfig { }

消息发送模拟

/**
* 发送消息
*/
@RestController
public class SendMessageController {
@Autowired
DelayDemoTopic delayDemoTopic; @GetMapping("send")
public Boolean sendMessage(BigDecimal money) throws JsonProcessingException { Message<BigDecimal> message = MessageBuilder.withPayload(money)
//设置消息的延迟时间,首次发送,不设置延迟时间,直接发送
.setHeader(DelayConstant.X_DELAY_HEADER,0)
//设置消息已经重试的次数,首次发送,设置为0
.setHeader(DelayConstant.X_RETRIES_HEADER,0)
.build();
return delayDemoTopic.delayDemoProducer().send(message);
}
}

消息监听处理

@Component
@Slf4j
public class DelayDemoTopicListener {
@Autowired
DelayDemoTopic delayDemoTopic; /**
* 监听延迟消息通道中的消息
* @param message
*/
@StreamListener(value = DelayDemoTopic.DELAY_DEMO_CONSUMER)
public void listener(Message<BigDecimal> message) {
//获取重试次数
int retries = (int)message.getHeaders().get(DelayConstant.X_RETRIES_HEADER);
//获取消息内容
BigDecimal money = message.getPayload();
try {
String now = DateUtils.formatDate(new Date(),"yyyy-MM-dd HH:mm:ss");
//模拟:如果金额大于200,则消息无法消费成功;金额如果大于100,则重试3次;如果金额小于100,直接消费成功
if (money.compareTo(new BigDecimal(200)) == 1){
throw new RuntimeException(now+":金额超出200,无法交易。");
}else if (money.compareTo(new BigDecimal(100)) == 1 && retries <= 3) {
if (retries == 0) {
throw new RuntimeException(now+":金额超出100,消费失败,将进入重试。");
}else {
throw new RuntimeException(now+":金额超出100,当前第" + retries + "次重试。");
}
}else {
log.info("消息消费成功!");
}
}catch (Exception e) {
log.error(e.getMessage());
if (retries < DelayConstant.X_RETRIES_TOTAL){
//将消息重新塞入队列
MessageBuilder<BigDecimal> messageBuilder = MessageBuilder.fromMessage(message)
//设置消息的延迟时间
.setHeader(DelayConstant.X_DELAY_HEADER,DelayConstant.ruleMap.get(retries + 1))
//设置消息已经重试的次数
.setHeader(DelayConstant.X_RETRIES_HEADER,retries + 1);
Message<BigDecimal> reMessage = messageBuilder.build();
//将消息重新发送到延迟队列中
delayDemoTopic.delayDemoProducer().send(reMessage);
}else {
//超过重试次数,做相关处理(比如保存数据库等操作),如果抛出异常,则会自动进入死信队列
throw new RuntimeException("超过最大重试次数:" + DelayConstant.X_RETRIES_TOTAL);
}
}
}
}

规则定义

目前写在一个常量类里,实际项目中,通常会配置在配置文件中

public class DelayConstant {
/**
* 定义当前重试次数
*/
public static final String X_RETRIES_HEADER = "x-retries";
/**
* 定义延迟消息,固定值,该配置放到消息的header中,会开启延迟队列
*/
public static final String X_DELAY_HEADER = "x-delay"; /**
* 定义最多重试次数
*/
public static final Integer X_RETRIES_TOTAL = 5; /**
* 定义重试规则,毫秒为单位
*/
public static final Map<Integer,Integer> ruleMap = new HashMap(){{
put(1,1000);
put(2,2000);
put(3,3000);
put(4,4000);
put(5,5000);
}};
}

测试

经过以上配置和实现就可完成模拟的重发场景。

  • 浏览器中输入http://127.0.0.1:8081/send?money=10,可以看到控制台中输出:
消息消费成功!
  • 浏览器中输入http://127.0.0.1:8081/send?money=110,可以看到控制台中输出:
2020-06-20 10:59:42:金额超出100,消费失败,将进入重试。
2020-06-20 10:59:43:金额超出100,当前第1次重试。
2020-06-20 10:59:45:金额超出100,当前第2次重试。
2020-06-20 10:59:48:金额超出100,当前第3次重试。
消息消费成功!
  • 浏览器中输入http://127.0.0.1:8081/send?money=110,可以看到控制台中输出:

注意事项

由于本文用到了延迟队列,需要在rabbitMQ中安装延迟插件,具体安装方式,可以查看:延迟队列安装参考

源码获取

以上示例都可以通过我的GitHub获取完整的代码.

使用SpringCloud Stream结合rabbitMQ实现消息消费失败重发机制的更多相关文章

  1. SpringCloud stream连接RabbitMQ收发信息

    百度上查的大部分都是一些很简单的单消费者或者单生产者的例子,并且多是同一个服务器的配置,本文的例子为多服务器配置下的消费生产和消费者配置. 参考资料:https://docs.spring.io/sp ...

  2. 九. SpringCloud Stream消息驱动

    1. 消息驱动概述 1.1 是什么 在实际应用中有很多消息中间件,比如现在企业里常用的有ActiveMQ.RabbitMQ.RocketMQ.Kafka等,学习所有这些消息中间件无疑需要大量时间经历成 ...

  3. Spring Cloud Stream消费失败后的处理策略(四):重新入队(RabbitMQ)

    应用场景 之前我们已经通过<Spring Cloud Stream消费失败后的处理策略(一):自动重试>一文介绍了Spring Cloud Stream默认的消息重试功能.本文将介绍Rab ...

  4. Spring Cloud Stream消费失败后的处理策略(三):使用DLQ队列(RabbitMQ)

    应用场景 前两天我们已经介绍了两种Spring Cloud Stream对消息失败的处理策略: 自动重试:对于一些因环境原因(如:网络抖动等不稳定因素)引发的问题可以起到比较好的作用,提高消息处理的成 ...

  5. Spring Cloud Stream消费失败后的处理策略(二):自定义错误处理逻辑

    应用场景 上一篇<Spring Cloud Stream消费失败后的处理策略(一):自动重试>介绍了默认就会生效的消息重试功能.对于一些因环境原因.网络抖动等不稳定因素引发的问题可以起到比 ...

  6. Spring Cloud Stream消费失败后的处理策略(一):自动重试

    之前写了几篇关于Spring Cloud Stream使用中的常见问题,比如: 如何处理消息重复消费 如何消费自己生产的消息 下面几天就集中来详细聊聊,当消息消费失败之后该如何处理的几种方式.不过不论 ...

  7. RockerMQ消息消费、重试

    消息中间件—RocketMQ消息消费(一) 消息中间件—RocketMQ消息消费(二)(push模式实现) 消息中间件—RocketMQ消息消费(三)(消息消费重试) MQ中Pull和Push的两种消 ...

  8. Rabbitmq消费失败死信队列

    Rabbitmq 重消费处理 一 处理流程图: 业务交换机:正常接收发送者,发送过来的消息,交换机类型topic AE交换机: 当业务交换机无法根据指定的routingkey去路由到队列的时候,会全部 ...

  9. RabbitMQ:消息发送确认 与 消息接收确认(ACK)

    默认情况下如果一个 Message 被消费者所正确接收则会被从 Queue 中移除 如果一个 Queue 没被任何消费者订阅,那么这个 Queue 中的消息会被 Cache(缓存),当有消费者订阅时则 ...

随机推荐

  1. 在树莓派里搭建 Lighttpd 服务器

    Lighttpd 像 Ngnix 一样,是被设计运行在低内存,低 CPU 负载的设备上,它们都非常适合在树莓派上运行. 本文将介绍如何在树莓派上运行基本配置的 Lighttpd ,以及如何与 PHP- ...

  2. KNIME快速入门指南

    一.介绍  KNIME Analytics Platform是用于创建数据科学应用程序和服务的开源软件.KNIME直观,开放,不断整合新的开发,使人们可以理解数据,设计数据科学工作流程和可重用组件. ...

  3. spring-kafka之KafkaListener注解深入解读

    简介 Kafka目前主要作为一个分布式的发布订阅式的消息系统使用,也是目前最流行的消息队列系统之一.因此,也越来越多的框架对kafka做了集成,比如本文将要说到的spring-kafka. Kafka ...

  4. nginx 配置重定向及nginx配置if

    需求:地址 http://testa/inlinePreview/live.html?id=463738305721405440重定向到 http://testb/shares/live.html?n ...

  5. docker出现相同的image条目的删除办法

    一.问题:在测试docker安装的prometheus系统时,由于异常操作,使用docker image ls出现了两条一模一样的条目,如下: [root@ELK prometheus]# docke ...

  6. Rocket - debug - TLDebugModuleInner - Hart Bus Access

    https://mp.weixin.qq.com/s/deNMEyJ1idJDVoZwwo0A1A 简单介绍TLDebugModuleInner中核心总线访问(Hart Bus Access). 参考 ...

  7. 从按下url到显示页面

    从按下url到渲染页面流程图 处理输入信息 检查用户输入 当用户在地址栏中输入一个查询关键字时,地址栏会判断输入的关键字是搜索内容,还是请求的 URL.如果是搜索内容,地址栏会使用浏览器默认的搜索引擎 ...

  8. eclipse 界面复原

    Windows-----Perspective-----Reset perspective

  9. Java实现洛谷 P1873 砍树(StreamTokenizer+IO+二分)

    P1873 砍树 输入输出样例 输入 5 20 4 42 40 26 46 输出 36 PS: get新知识,以前只知道STringTokenizer并没有了解过StreamTokenizer,这次才 ...

  10. Java实现 蓝桥杯VIP 算法训练 统计单词个数

    题目描述 给出一个长度不超过200的由小写英文字母组 成的字母串(约定;该字串以每行20个字母的方式输入,且保证每行一定为20个).要求将此字母串分成k份 (1< k< =40),且每份中 ...