SpringBoot教程（十五） | SpringBoot集成RabbitMq（死信队列、延迟队列）

已于 2024-09-14 16:20:53 修改
阅读量862 收藏 29
点赞数 24
分类专栏： SpringBoot学习篇 文章标签： java-rabbitmq spring boot rabbitmq
于 2024-09-05 15:58:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20236937/article/details/141926597
版权

SpringBoot教程（十五） | SpringBoot集成RabbitMq（死信队列、延迟队列）

（一）死信队列

死信队列是一个重要的概念，用于处理那些因各种原因无法被正常消费的消息。
它不是RabbitMQ直接提供的一个现成的方法或工具，而是通过特定的配置和机制来实现的。

使用场景

死信队列在多种场景下都非常有用，包括但不限于：

  1. 消息重试机制：当消息处理失败时，可以将其发送到死信队列进行重试。
  2. 异常消息处理：对于无法被正常处理的异常消息，可以将其存储在死信队列中，以便后续分析处理。
  3. 延迟消息处理：通过结合消息的TTL（Time-To-Live，生存时间）和死信队列，可以实现消息的延迟处理。
  4. 确保消息不丢失：在消息处理过程中，如果发生消费者崩溃或网络故障等情况，消息可能会丢失。通过死信队列，可以确保这些消息得到保留，并在系统恢复后重新处理。

具体用法

要在RabbitMQ中设置和使用死信队列，通常需要按照以下步骤进行：

  1. 定义死信交换机（DLX）：首先，需要定义一个交换机作为死信交换机，它可以是任何类型的交换机（如direct、fanout、topic等）。
  2. 配置原队列：在声明原队列时，需要指定两个参数：x-dead-letter-exchange和x-dead-letter-routing-key。前者指定了当消息变成死信时应该发送到的交换机（即死信交换机），后者指定了发送到该交换机的路由键。
  3. 声明死信队列：接着，需要声明一个或多个死信队列，并将它们绑定到死信交换机上。这样，当死信消息被发送到死信交换机时，就可以根据路由键将其路由到相应的死信队列中。
  4. 处理死信消息：最后，需要编写消费者代码来监听死信队列中的消息，并对这些消息进行相应的处理。

前提

要想进入死信队列，得出现异常，出现异常后，会根据你的配置帮你放到死信队列中 所以异常不要被捕获。
如果实在要捕获的话，就得你在消费者这边去做“发送消息的”操作，自己把发送过来消息塞到死信队列中

示例:

消费者 mq的yml配置（重试机制）

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        # 重试机制
        retry:
          enabled: true #是否开启消费者重试

配置类：

package com.example.reactboot.config;


import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class DirectExchangeConfig {

    //===========================普通===========================
    //定义队列的名称常量
    public static final String DIRECT_QUEUE = "directQueue";
    public static final String DIRECT_QUEUE2 = "directQueue2";
    //定义直接交换机的名称常量
    public static final String DIRECT_EXCHANGE = "directExchange";
    //定义路由键常量，用于交换机和队列之间的绑定
    public static final String DIRECT_ROUTING_KEY = "direct";
    //定义路由键常量，用于交换机和队列之间的绑定
    public static final String DIRECT_ROUTING_KEY_2= "direct2";





    //定义队列，名称为DIRECT_QUEUE
    //为普通队列 绑设置 死信参数
    @Bean
    public Queue directQueue() {
        //return new Queue(DIRECT_QUEUE, true);
        Map<String, Object> args = new HashMap<>();
        // 设置死信交换机
        args.put("x-dead-letter-exchange", DLX_EXCHANGE);
        // 设置发送到死信交换机的路由键
        args.put("x-dead-letter-routing-key", DLX_ROUTING_KEY);
        // 创建队列，设置为持久化、非排他、非自动删除，并附带死信参数
        return new Queue(DIRECT_QUEUE, true, false, false, args);
    }


    //定义直接交换机
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(DIRECT_EXCHANGE, true, false);
    }

    //定义队列，名称为DIRECT_QUEUE2
    @Bean
    public Queue directQueue2() {
        return new Queue(DIRECT_QUEUE2, true);
    }


    //定义一个绑定，将directQueue队列绑定到directExchange交换机上，
    //使用direct作为路由键
    @Bean
    public Binding bindingDirectExchange(Queue directQueue, DirectExchange directExchange) {
        return BindingBuilder.bind(directQueue).to(directExchange).with(DIRECT_ROUTING_KEY);
    }

    // 定义一个绑定Bean，将directQueue2队列也绑定到directExchange交换机上，
    @Bean
    public Binding bindingDirectExchange2(Queue directQueue2, DirectExchange directExchange) {
        return BindingBuilder.bind(directQueue2).to(directExchange).with(DIRECT_ROUTING_KEY_2);
    }

    //===========================死信===========================
    // 定义死信交换机的名称
    public static final String DLX_EXCHANGE = "dlx_exchange";
    // 定义发送到死信交换机的路由键
    public static final String DLX_ROUTING_KEY = "dlx.routing.key";
    // 定义死信队列的名称
    public static final String DLX_QUEUE = "dlx_queue";

    /**
     * 声明死信交换机，这里使用Direct类型。
     * @return 返回一个配置好的DirectExchange对象。
     */
    @Bean
    DirectExchange dlxExchange() {
        // 创建并返回Direct类型的交换机
        return new DirectExchange(DLX_EXCHANGE,true, false);
    }
    /**
     * 声明死信队列。
     * @return 返回一个配置好的Queue对象，用作死信队列。
     */
    @Bean
    Queue dlxQueue() {
        // 创建并返回死信队列，设置为持久化
        return new Queue(DLX_QUEUE, true);
    }

    /**
     * 绑定死信队列到死信交换机，使用指定的路由键。
     */
    @Bean
    Binding binding(Queue dlxQueue,DirectExchange dlxExchange) {
        return BindingBuilder.bind(dlxQueue).to(dlxExchange).with(DLX_ROUTING_KEY);
    }

}

生产者发送消息：

package com.example.reactboot.controller;

import com.example.reactboot.config.DirectExchangeConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.nio.charset.StandardCharsets;

@RestController
public class RabbitMqTest {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @RequestMapping("/sendMQ")
    public String sendMessage() {
        rabbitTemplate.convertAndSend(DirectExchangeConfig.DIRECT_EXCHANGE,
                DirectExchangeConfig.DIRECT_ROUTING_KEY, "发送一条测试消息：direct");
        return "direct消息发送成功！！";
    }
   }

消费者消费消息：

package com.example.reactboot.queueListener;

import com.example.reactboot.config.DirectExchangeConfig;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @className: DirectQueueListener
 * @description: 直连交换机的监听器
 * @author: sh.Liu
 * @date: 2021-08-23 16:03
 */
@Slf4j
@Component
public class DirectQueueListener {
 
   //监听普通队列
    @RabbitHandler
    @RabbitListener(queues = DirectExchangeConfig.DIRECT_QUEUE)
    public void process(String xx){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("DirectReceiver消费者收到消息1  : " + xx + " 接收时间：" + sdf.format(new Date()) + "\n");
        //先执行业务代码
        int i = 1 / 0;
    }

    //监听死信队列
    @RabbitHandler
    @RabbitListener(queues = DirectExchangeConfig.DLX_QUEUE)
    public void process3(String testMessage) {
        System.out.println("死信得列里面的  : " + testMessage + "\n");
    }

}

（二）延迟队列

延迟队列是一种特殊的消息队列，其内部消息是有序的，并且具有延时属性。
在RabbitMQ中，虽然AMQP协议本身没有直接支持延迟队列，但可以通过一些变通的方法（如使用死信队列配合消息的TTL属性，或者使用RabbitMQ的延迟消息插件）来实现延迟队列的功能。

使用场景

延迟队列在多种业务场景中都有广泛的应用，包括但不限于：

  1. 订单超时未支付自动取消：用户下单后，如果在规定时间内未完成支付，系统可以自动取消订单。
  2. 退款超时通知：用户申请退款后，如果长时间未得到处理，系统可以自动通知相关运营人员介入。
  3. 新用户注册后的引导邮件：用户注册账号后，系统可以在一段时间后发送欢迎邮件或引导邮件。
  4. 会议提醒：在预定的会议开始前一段时间，系统自动发送提醒给参会人员。
  5. 任务调度：在指定时间后执行某项任务，如定时清理日志、执行批处理任务等。

方法一：通过死亡队列实现

以下是使用死信队列配合TTL属性实现延迟队列的基本步骤：

  1. 定义死信交换机（DLX, Dead-Letter Exchange）和死信队列（DLQ, Dead-Letter Queue）
  2. 设置普通队列的TTL和死信交换机：在创建普通队列时，可以为其设置TTL属性，指定消息在该队列中的最大存活时间。同时，需要将该队列的死信交换机设置为前面定义的DLX，以便消息在过期后能够被发送到DLQ。
  3. 生产者发送消息：生产者将消息发送到普通队列，并指定消息的TTL。消息在队列中等待，直到TTL过期。
  4. 消息过期并发送到死信队列：当消息的TTL过期后，RabbitMQ会自动将该消息发送到其配置的死信交换机，再由死信交换机根据路由键将其发送到DLQ。
  5. 消费者从死信队列消费消息：消费者监听DLQ，当有新消息到达时，进行消费处理。

就是：把普通队列的消息设置存活时间，目前有两者方式：
1.在队列上面设置消息的过期时间
2.直接在消息上面设置过期时间。

方式一（队列上面设置消息过期时间）：

上面的关于 死信示例 完全可以复用进行测试

在以下的方法里面多加一行 args.put(“x-message-ttl”, 10000);

    //定义队列，名称为DIRECT_QUEUE
    //为普通队列 绑设置 死信参数
    @Bean
    public Queue directQueue() {
        //return new Queue(DIRECT_QUEUE, true);
        Map<String, Object> args = new HashMap<>();
        // 设置消息TTL为10秒
        args.put("x-message-ttl", 10000);
        // 设置死信交换机
        args.put("x-dead-letter-exchange", DLX_EXCHANGE);
        // 设置发送到死信交换机的路由键
        args.put("x-dead-letter-routing-key", DLX_ROUTING_KEY);
        // 创建队列，设置为持久化、非排他、非自动删除，并附带死信参数
        return new Queue(DIRECT_QUEUE, true, false, false, args);
    }

你可以把 DirectQueueListener 里面的 process 方法注释掉（以免被消费掉）。
再执行生产者的 sendMessage 方法。
这个时候你就可以看到下面关于消费者那边 监听死信队列 的方法 ，等10秒后就会打印你发的消息了

方式二（消息上面设置过期时间）：

上面的关于 死信示例 完全可以复用进行测试

改一下 这个 生产者发送消息：

package com.example.reactboot.controller;

import com.example.reactboot.config.DirectExchangeConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.nio.charset.StandardCharsets;

@RestController
public class RabbitMqTest {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @RequestMapping("/sendMQ")
    public String sendMessage() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        rabbitTemplate.convertAndSend(DirectExchangeConfig.DIRECT_EXCHANGE, DirectExchangeConfig.DIRECT_ROUTING_KEY, "发送一条测试消息：direct! "+sdf.format(new Date()), new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //设置过期时间，超过5秒消息就会消失
                message.getMessageProperties().setExpiration("5000");
                //设置编码格式
                message.getMessageProperties().setContentEncoding("UTF-8");
                return message;
            }
        });     
           
       return "direct消息发送成功！！";
    }
   }

你可以把 DirectQueueListener 里面的 process 方法注释掉（以免被消费掉）。
再执行生产者的 sendMessage 方法。
这个时候你就可以看到下面关于消费者那边 监听死信队列 的方法 ，等5秒后就会打印你发的消息了

到这里其实就结束了，剩下的就是监听到死信队列里面的消息后的业务操作了

方法二：通过延迟消息插件（rabbitmq_delayed_message_exchange）实现

后续在说

Slow菜鸟
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
springboot+rabbitmq实现延时队列
08-29
springboot+rabbitmq实现延时队列，包括消息发送和消费确认，消费者端使用策略模式处理业务
springboot、rabbitMQ 死信队列
路的尽头在哪
09-13 3227
前言 死信：无法被消费的消息，称为死信。 如果死信一直留在队列中，会导致一直被消费，却从不消费成功。 所以我们专门开辟了一个来存放死信的队列，叫死信队列（DLX，dead-letter-exchange）。 死信的几种来源： 消息 TTL 过期（time to live，存活时间，可以用在限时支付消息） 队列达到最大长度（队列满了，无法路由到该队列） 消息被拒绝（ basic.reject / basic.nack ），并且 requeue = false 环境准备配置 准备 MQ 的队列和环境
SpringBoot整合RabbitMQ实现死信队列
二蛋的博客
12-14 2088
消费者使用basic.reject或basic.nack（重新排队参数设置为false）对消息进行否定确认。消息到达生存时间还未被消费。队列超过长度限制，消息被丢弃。这些消息会被发送到死信交换机并路由到死信队列中（在RabbitMQ中死信交换机和死信队列就是普通的交换机和队列）。其流转过程如下图。
SpringBoot简单实现RabbitMq的死信队列
最新发布
Aa5107033的博客
06-28 871
死信队列是一种用于处理无法被正常消费的消息机制，当消息在队列中变成 '死信' 时，RabbitMq会自动将这些消息从新发送到另一个队列，即死信队列。那么在消息队列中，什么情况下会变成 '死信'?
SpringBoot+RabbitMQ 死信队列
Java知音
05-22 232
点击关注公众号，实用技术文章及时了解前言死信：无法被消费的消息，称为死信。如果死信一直留在队列中，会导致一直被消费，却从不消费成功。所以我们专门开辟了一个来存放死信的队列，叫死信队列（DLX，dead-letter-exchange）。死信的几种来源：消息 TTL 过期（time to live，存活时间，可以用在限时支付消息）队列达到最大长度（队列满了，无法路由到该队列...
Spring Boot（十四）RabbitMQ延迟队列
weixin_34015860的博客
11-16 176
一、前言 延迟队列的使用场景：1.未按时支付的订单，30分钟过期之后取消订单；2.给活跃度比较低的用户间隔N天之后推送消息，提高活跃度；3.过1分钟给新注册会员的用户，发送注册邮件等。 实现延迟队列的方式有两种： 通过消息过期后进入死信交换器，再由交换器转发到延迟消费队列，实现延迟功能； 使用rabbitmq-delayed-message-exchange插件实现延迟功能； 注意： 延迟插...
SpringBoot整合RabbitMQ实现延时队列
PGL2009的博客
12-12 2296
组件的版本 SpringBoot : V2.5.5 RabbitMQ: 3.9.9 延时队列 延时队列的典型应用场景，例如购买火车票，下单占座后20分钟内未支付的订单会被强制取消，避免在余票紧张的情况下，车票一直被占用，其他人无法购买。还有电商平台，客户下单后，订单进入购物车，如果购物车内的订单超过特定时间未支付，则会失效，回滚库存。 RabbitMQ实现延时队列 利用 RabbitMQ 做延时队列是比较常见的一种方式，而实际上RabbitMQ 自身并没有直接支持提供延迟队列功能，而是通过 RabbitMQ
springboot集成RabbitMQ使用死信队列实现消息延迟功能
program_tiger的博客
11-19 282
springboot集成RabbitMQ使用死信队列实现消息延迟功能 为了实现消息延迟功能，一共有两种方案： RabbitMQ + 延迟消息插件 利用MQ的消息超时机制和死信队列 本文使用springboot和RabbitMQ，通过超时时间设置自动投递到死信队列 主要原理： 把一个设有过期时间的消息投入一个临时队列（该队列没有消费者）等待过期，也没有设置requeue（重新入对），该消息就变成死信，死信会自动的被投入到配置好的死信队列中去，然后发送给配置好的消费者消费 主要步骤： 创建临时队列和临时交
SpringBoot集成RabbitMQ实现消息重试机制，消息重试3次失败后写入死信队列，消息重试3次失败后入库
hsuan_CSDN的博客
04-09 3890
yml配置 spring: rabbitmq: username: admin password: admin host: localhost port: 5672 virtual-host: / publisher-confirm: true #发布确认 开启confirms回调 Producer -> Exchange publisher-returns: true #发布返回 开启returnedMessage回调 Exchange..
springboot rabbitmq 延时队列
qq_38718211的博客
08-07 279
配置： spring: rabbitmq: host: 127.0.0.1 port: 5672 username: guest password: guest virtual-host: / publisher-confirms: true config: package com.uban.config; import lombok....
十、RabbitMQ高级 - 死信交换机
莫等闲 白了少年头 空悲切
05-04 663
消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机将消费者监听的队列绑定到死信交换机发送消息时给消息设置超时时间为20秒。
Spring Boot+RabbitMQ 基于死信队列和插件实现延迟队列详解
huangjhai的博客
10-07 2182
延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用 RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正 确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为 单个节点挂掉导致延时队列不可用或者消息丢失。
SpringBoot 整合 RabbitMQ 实现死信队列
死牛胖子的技术随笔
01-09 1683
相关知识 什么是死信队列 “死信”是RabbitMQ中的一种消息机制，当你在消费消息时，如果队列里的消息出现以下情况： 消息被否定确认，使用 channel.basicNack 或 channel.basicReject ，并且此时requeue 属性被设置为false。 消息在队列的存活时间超过设置的TTL时间。 消息队列的消息数量已经超过最大队列长度。 那么该消息将成为“死信”，“死信”消...
springboot rabbitMQ 死信队列
weixin_42494845的博客
09-26 797
死信队列是什么？ 死信队列实际上就是，当我们的业务队列处理失败(比如抛异常并且达到了retry的上限)，就会将消息重新投递到另一个Exchange(Dead Letter Exchanges)，该Exchange再根据routingKey重定向到另一个队列，在这个队列重新处理该消息。 本文通过springboot 集成rabbitMQ，配置一个正常队列和一个死信队列，正常队列设置了消息最长存活时间，当队列中的消息超过存活时间且还没有被消费时，该消息就会存入死信队列。 生产者 pom.xml <?xml
springBoot rabbitMQ 死信队列
ChenLong_0317的博客
04-09 764
假设一种场景：当我们生产者发送了错误的参数，或者消费者这边处理的时候抛出异常，然后这条消息会被重新放入队列中再次分发给消费者进行消费，这样子会造成一个死循环报错，十分影响性能和服务器资源。 简单的解决办法：直接try cath，报错以后消息直接丢失 比较好的解决办法：创建一个队列，用来处理抛出异常的消息。 // 首先声明死信队列 @Bean("redirectQueue") public Queu...
SpringBoot RabbitMQ 死信队列
天行健，君子以自强不息；地势坤，君子以厚德载物。
04-27 1180
1. 死信定义无法被消费的消息，称为死信。如果死信一直留在队列中，会导致一直被消费，却从不消费成功，专门有一个存放死信的队列，称为死信队列(DDX, dead-letter-exchange)。死信队列DLX，Dead Letter Exchange的缩写，又死信邮箱、死信交换机。其实DLX就是一个普通的交换机，和一般的交换机没有任何区别。当消息在一个队列中变成死信（dead message）时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值