Spring Boot利用RabbitMQ的死信队列实现定时任务,如超时未支付,自动取消订单等等......

最新推荐文章于 2024-04-24 08:49:11 发布
最新推荐文章于 2024-04-24 08:49:11 发布
阅读量3.9k 收藏 15
点赞数 2
分类专栏： RabbitMQ 文章标签： Spring Boot RabbitMQ 定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a870368162/article/details/99578747
版权

RabbitMQ死信队列

本文不介绍如何整合消息队列,有需要请参考我之前发布:https://blog.csdn.net/a870368162/article/details/99566685

git链接：https://github.com/a870368162/SpringBoot-RabbitMQ

RabbitMQ要实现延时任务，需要使用RabbitMQ的死信交换机（Exchange）和消息的存活时间TTL（Time To Live）来实现

死信交换机

死信交换机跟普通交换机一样,只是这个交换机用来存放过期的消息

  1. 当一个消息没有相对应的消费者对其进行消费, 并且消息设置了TTL,消息过期后会进入死信交换机。
  2. 队列的长度限制满了。排在前面的消息会被丢弃或者扔到死信路由上。
  3. 当消息进入死信交换机后,死信交换机在把消息转发给专门处理死信消息的消费者,及可实现定时任务

设置消息TTL（消息存活时间）

  1. 消息的TTL就是消息的存活时间。RabbitMQ可以对队列和消息分别设置TTL。对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的设置。超过了这个时间，我们认为这个消息就死了，称之为死信。如果队列设置了，消息也设置了，那么会取小的。所以一个消息如果被路由到不同的队列中，这个消息死亡的时间有可能不一样（不同的队列设置）。这里单讲单个消息的TTL，因为它才是实现延迟任务的关键。
  2. 可以通过设置消息的expiration字段属性来设置时间,代码如下:
	MessageProperties messageProperties = new MessageProperties();
	//这里设置消息过期的时间
	messageProperties.setExpiration(60+ "000");
	messageProperties.setCorrelationIdString(serialClient.getGlobalSerial().toString());
	Message message = new Message(JSONObject.toJSONString(这里写你要发送给队列的消息).getBytes(), messageProperties);
	// 消息持久化
	message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
	//发送消息给死信队列
	this.send.beadSend(RabbitMQConstant.TOPIC_ROUTINGKEY1, message);

当上面的消息扔到队列中后，过了60秒，如果没有被消费，它就会发送到死信交换机。
在这里插入图片描述

创建死信交换机, 死信队列以及处理死信消息的消费者

实现代码如下:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.DelayQueue;

/**
 * @消息队列配置
 * @Autor zxf
 * @Date 2019/8/15
 */
@Configuration
public class QueueConfig {

    private  static final Logger logger = LoggerFactory.getLogger(QueueConfig.class);


    /**
     *  创建订阅模式交换机
     *  @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(RabbitMQConstant.FANOUT_EXCHANGE,true, false);
    }

    /**
     * 创建路由模式交换机
     * @return
     */
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(RabbitMQConstant.DIRECT_EXCHANGE,true, false);
    }

    /**
     * 创建主题模式交换机
     * @return
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(RabbitMQConstant.TOPIC_EXCHANGE,true, false);
    }

    /**
     * 创建死信交换机,跟普通交换机一样,只是死信交换机只用来接收过期的消息
     * @return
     */
    @Bean
    public DirectExchange deadExchange() {
        return new DirectExchange(RabbitMQConstant.DEAD_EXCHANGE, true, false);
    }

    /**
     * 创建死信队列,该队列没有消费者,消息会设置过期时间,消息过期后会发送到死信交换机,在由死信交换机转发至处理该消息的队列中
     * @return
     */
    @Bean
    public Queue BeadQueue() {
        Map<String, Object> arguments = new HashMap<>(2);
        // 死信路由到死信交换器DLX
        arguments.put("x-dead-letter-exchange", RabbitMQConstant.DEAD_EXCHANGE);
        arguments.put("x-dead-letter-routing-key", RabbitMQConstant.ROUTING_KEY2);
        return new Queue(RabbitMQConstant.DEAD_QUEUE, true, false, false, arguments);

    }

    /**
     * 处理死信队列的消费队列
     *
     */
    @Bean
    public Queue consumerBeadQueue() {
        return new Queue(RabbitMQConstant.CONSUMER_BEAD_QUEUE, true); // 队列持久

    }

    /**
     * 创建队列1
     * @return
     */
    @Bean
    public Queue Queue1() {
        //队列持久化
        return new Queue(RabbitMQConstant.QUEUE_1, true);
    }

    /**
     * 创建队列2
     * @return
     */
    @Bean
    public Queue Queue2() {
        return new Queue(RabbitMQConstant.QUEUE_2, true);
    }

    /**
     * 订阅模式队列1绑定交换机
     * @return
     */
    @Bean
    public Binding fanoutBinding1() {
        return BindingBuilder.bind(Queue1()).to(fanoutExchange());
    }

    /**
     * 订阅模式队列2绑定交换机
     * @return
     */
    @Bean
    public Binding fanoutBinding2() {
        return BindingBuilder.bind(Queue2()).to(fanoutExchange());
    }

    /**
     * 路由模式队列1绑定交换机,通过key1发送
     * @return
     */
    @Bean
    public Binding directBinding1() {
        return BindingBuilder.bind(Queue1()).to(directExchange()).with(RabbitMQConstant.ROUTING_KEY1);
    }

    /**
     * 路由模式队列2绑定交换机,通过key2发送
     * @return
     */
    @Bean
    public Binding directBinding2() {
        return BindingBuilder.bind(Queue2()).to(directExchange()).with(RabbitMQConstant.ROUTING_KEY2);
    }

    /**
     * 主题模式队列1绑定交换机
     * 符号“#”匹配一个或多个词，符号“*”匹配一个词。比如“hello.#”能够匹配到“hello.123.456”，但是“hello.*”只能匹配到“hello.123”
     * @return
     */
    @Bean
    public Binding topicBinding1() {
        return BindingBuilder.bind(Queue1()).to(topicExchange()).with(RabbitMQConstant.TOPIC_ROUTINGKEY1);
    }

    /**
     * 主题模式队列1绑定交换机
     * 符号“#”匹配一个或多个词，符号“*”匹配一个词。比如“hello.#”能够匹配到“hello.123.456”，但是“hello.*”只能匹配到“hello.123”
     * @return
     */
    @Bean
    public Binding topicBinding2() {
        return BindingBuilder.bind(Queue2()).to(topicExchange()).with(RabbitMQConstant.TOPIC_ROUTINGKEY2);
    }


    /**
     * 将死信队列与死信交换机绑定,key1
     *
     * @return
     */
    @Bean
    public Binding beadQueuebinding() {
        return BindingBuilder.bind(BeadQueue()).to(deadExchange()).with(RabbitMQConstant.ROUTING_KEY1);
    }

    /**
     * 将处理死信队列的消费队列与死信交换机绑定 key2
     *
     * @return
     */
    @Bean
    public Binding consumerBeadQueuebinding() {
        return BindingBuilder.bind(consumerBeadQueue()).to(deadExchange()).with(RabbitMQConstant.ROUTING_KEY2);
    }
}


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


/**
 * @消息队列发送工具类
 * @Autor zxf
 * @Date 2019/8/15
 */
@Component
public class Send implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback {

    private  static final Logger log = LoggerFactory.getLogger(Send.class);

    private RabbitTemplate rabbitTemplate;

    @Autowired
    public Send(RabbitTemplate rabbitTemplate) {
        super();
        this.rabbitTemplate = rabbitTemplate;
        this.rabbitTemplate.setMandatory(true);
        this.rabbitTemplate.setReturnCallback(this);
        this.rabbitTemplate.setConfirmCallback(this);
    }

    /**
     * 发布/订阅模式发送
     * @param json
     */
    public void routeSend(String json) {
        Message message = this.setMessage(json);
        //在fanoutExchange中在绑定Q到X上时，会自动把Q的名字当作bindingKey。
        this.rabbitTemplate.convertAndSend(RabbitMQConstant.FANOUT_EXCHANGE, "", message);
    }

    /**
     * 简单模式发送
     * @param json
     */
    public void simplSend(String json) {
        Message message = this.setMessage(json);
        this.rabbitTemplate.convertAndSend(RabbitMQConstant.QUEUE_1, message);
    }

    /**
     * 路由模式发送
     *  @param routingKey
     * @param json
     */
    public void routingSend(String routingKey, String json) {
        Message message = this.setMessage(json);
        this.rabbitTemplate.convertAndSend(RabbitMQConstant.DIRECT_EXCHANGE, routingKey, message);
    }

    /**
     * 主题模式发送
     *
     * @param routingKey
     * @param json
     */
    public void topicSend(String routingKey, String json) {
        Message message = this.setMessage(json);
        this.rabbitTemplate.convertAndSend(RabbitMQConstant.TOPIC_EXCHANGE, routingKey, message);
    }

    /**
     * 死信模式发送,用于定时任务处理
     *  @param routingKey
     * @param message
     */
    public void beadSend(String routingKey, Message message) {
        this.rabbitTemplate.convertAndSend(RabbitMQConstant.DEAD_EXCHANGE, routingKey, message);
    }

    /**
     * 设置消息参数
     * @param json
     * @return
     */
    private Message setMessage(String json){
        MessageProperties messageProperties = new MessageProperties();
        Message message = new Message(json.getBytes(), messageProperties);
        //消息持久化
        message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
        return message;
    }

    /**
     * 消息确认
     * @param correlationData
     * @param ack
     * @param cause
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if (ack) {
            log.info("消息发送确认成功");
        } else {
            log.info("消息发送失败:" + cause);
        }
    }

    /**
     * 消息发送失败回传
     * @param message
     * @param replyCode
     * @param replyText
     * @param exchange
     * @param routingKey
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        log.info("return--message:" + new String(message.getBody()) + ",replyCode:" + replyCode + ",replyText:"
                + replyText + ",exchange:" + exchange + ",routingKey:" + routingKey);
        try {
            Thread.sleep(10000L);
            // TODO 重新发送消息至队列,此处应写一套重发机制,重发多少次结束,否则如果消息如果一直发送失败,则会一直发下去!
            this.rabbitTemplate.convertAndSend(exchange, routingKey, message);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

超时未支付取消订单步骤如下:

  1. 创建订单入库后发送该订单的id到死信队列,设置过期时间(该队列不能有消费者)
  2. 消息过期后会通过死信交换机发送到相对应的处理队列中
  3. 从处理队列中获得订单id,修改订单状态为取消
Epiphany丶
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
rabbitmq死信队列详解与使用
congge
08-28 14万+
什么是死信队列 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列； 以上是个人的通俗解释，专业术语解释的比...
RabbitMq（1）死信队列、延迟队列
qq_34708359的博客
01-11 4088
一、死信队列 DLX（Dead Letter Exchange），死信交换器。当队列中的消息被拒绝、或者过期会变成死信，死信可以被重新发布到另一个交换器，这个交换器就是DLX，与DLX绑定的队列称为死信队列。 造成死信的原因： 信息被拒绝 信息超时 超过了队列的最大长度 可以通过设置x-dead-letter-exchange参数指定DLX，设置x-dead-letter-routing-ke...
SpringBoot基于RabbitMQ实现死信队列 (SpringBoot整合RabbitMQ实战篇)
莫等闲 白了少年头 空悲切
04-24 1911
消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机将消费者监听的队列绑定到死信交换机发送消息时给消息设置超时时间为20秒每一项技术深挖都是一个庞大的体系，学海无涯，共勉。
Java秒杀系统实战系列~RabbitMQ死信队列处理超时未支付的订单
weixin_30583563的博客
07-31 1143
摘要：本篇博文是“Java秒杀系统实战系列文章”的第十篇，本篇博文我们将采用RabbitMQ的死信队列的方式处理“用户秒杀成功生成订单后，却迟迟没有支付”的情况，一起来见识一下RabbitMQ死信队列在实际业务环境下的强大之处！内容：对于消息中间件RabbitMQ，Debug其实在前面的篇章中已经简单分享介绍过了，在这里就不再赘述了！在本文我们将采用RabbitMQ的死信队列实现这样的业务需求：“...
Spring boot 整合 rabbit MQ 死信队列的应用-订单过期自动取消
p_moriarty的博客
10-06 1236
用户下了订单之后，还未付款，在规定的期限内如果没有支付，则这个订单应该标记为取消。 如果实现过期自动取消，下面有几种解决方案 定时轮询订单，超过期限且未支付 创建订单后，开启一个消息队列，等待X时间后执行 通过死信队列回调 其实方案二和死信队列的原理差不多，但是MQ已经拥有类似的机制，所以我们直接沿用即可。 死信队列介绍 死信队列：DLX，dead-letter-exchange 利...
RabbitMq（四）延时队列，订单过期，取消支付场景
干饭两斤半
11-05 4328
延时队列RabbitMq延时队列实际应用场景基于死信队列的延时队列基于延时交换机的延时队列延时队列图解SpringBoot伪代码配置类生产者消息的TTL和队列的TTL总结 RabbitMq延时队列实际应用场景 比如，boss让你开发一个30分钟客户不付款就取消订单的场景； 如果在促销活动期间，肯定会有大量的未付款的订单数据，如果用轮训，或者是redis失效key来作为处理方案，肯定会被CTO骂死；因为，如果高频次轮训，虽然能保证比较及时的取消订单。但是无疑给系统造成了很大压力。如果用redis失效key来做
Spring Boot-Shiro-Vue的权限管理思路.前后端都加以控制
最新发布
06-14
本项目以"Spring Boot-Shiro-Vue"为技术栈，构建了一套完整的权限管理系统，虽然最新版本已移除Shiro，但我们可以探讨基于Shiro的权限管理思路，以及Spring Boot和Vue.js如何协同实现这一目标。 **Spring Boot** 是...
springboot结合rabbitmq实现订单超时自动关闭
02-05
至此，我们已经实现了使用Spring Boot和RabbitMQ来监控订单超时并自动关闭的功能。这个方案不仅有助于优化系统性能，还能降低系统复杂性，因为订单超时处理与主要业务流程分离，成为了一个独立的异步任务。 通过...
基于Spring boot的声明式和编程式分布式锁.zip
05-30
例如，可以利用Spring的`@Transactional`注解结合特定的分布式锁实现（如Redis、Zookeeper或RabbitMQ）来实现声明式锁。这种方式简单易用，但灵活性相对较低，对于复杂的锁逻辑可能不够适用。 编程式分布式锁则更为...
Spring Boot RabbitMQ 延迟消息实现完整版示例
08-27
在本文中，我们将深入探讨如何在Spring Boot应用中利用RabbitMQ实现延迟消息功能。延迟消息是一种机制，允许消息在特定延迟时间后才被消费者处理，这对于处理如订单超时、定时任务等场景非常有用。这里我们将使用...
liuge1988-spring-boot-demo-master.zip
08-20
本文将深入探讨在"liuge1988-spring-boot-demo-master.zip"压缩包中的实例，涵盖Spring Boot与Druid数据源、MyBatis、RabbitMQ、Redis、Spring Data JPA和Spring Security的集成，以及如何利用Swagger进行API文档的...
rabbitMQ实现订单超时未支付自动取消订单
晨风若曦的博客
10-21 2802
rabbitMQ实现订单超时未支付自动取消订单
RabbitMq延迟消息队列死信队列实现定时任务 --菜鸟小回
菜鸟小回的博客
09-10 1193
延迟消息队列 TradeProcess @Service public class TradeProcess { @Autowired private AmqpTemplate amqpTemplate; @RabbitListener(queues= MqConstant.MY_TRANS_QUEUE) @RabbitHandler public void process(String content) { String msg = cont
利用RabbitMQ 的死信队列来做定时任务
Guiyun的博客
05-02 552
常用的应用场景 死信队列常常用作延时关闭订单(如订单的超时后的取消订单等)，虽然小项目中可以用定时轮询的方法进行检查，但是数据量一旦比较大时，定时轮询将给数据库带来不小的压力，而且定时间隔无法进行动态调整，特别是一个系统中，同时存在好几个定时器的时候，就显得非常的麻烦，同时给数据库造成巨大的访问压力。这时候就可以使RabbitMQ的死信队列。 概念解释 DLX Dead Letter Exc...
SPringBoot集成RabbitMQ实现30秒过期删除功能
军大君的博客
02-01 1180
1.引入RabbitMQ 包 <!--RabbitMQ--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2.编写配置文件 spring:
SpringBoot + RabbitMQ从延时队列中删除指定的值【RabbitMQ中的basicAck和basicNack的区别以及basicReject又是什么？】
番茄Salad
04-15 3570
业务需求是，就是我本来是有一个order-queue队列绑定到了死信队列交换机order-dead-direct-exchange上，然后我的业务是，现在有一个用户下单但是没有付款，order-queue队列写入该条信息并计时24小时后如果用户还是未付款状态则移除到死信队列order-dead-queue中。问题来了，如果在这个24小时内，用户取消订单，这时候就要从order-queue队列中移除该条信息。怎么操作呢？
RabbitMQ死信队列应用场景之模拟未支付订单自动取消
weixiaohuai的博客
07-25 4998
一、简介 在前面的博客中已经介绍了死信队列的使用方法，具体可以参考https://blog.csdn.net/Weixiaohuai/article/details/94760975这篇文章。 场景介绍：我们都经常在淘宝上买东西，当我们提交订单后，如果某个时间段之内我们没有支付，淘宝肯定不会帮我们一直保留那个订单，如果超过半个小时我们未支付的话，淘宝会自动帮我们取消订单。在没有用R...
RabbitMQ场景应用-死信队列模拟未支付订单自动取消
11-03 1103
1.简介 场景介绍： 我们都经常在淘宝上买东西，当我们提交订单后，如果某个时间段之内我们没有支付，淘宝肯定不会帮我们一直保留那个订单，如果超过半个小时我们未支付的话，淘宝会自动帮我们取消订单。在没有用RabbitMQ消息队列之前，我们可以通过设置一个定时任务，设定一个定时规则去轮询数据库查询超过半个小时而且未支付的订单，然后修改订单状态为已取消，这也是一个解决方案，但是需要轮询数据库，增加了对数据...
基于RabbitMQ订单未支付30分钟自动取消
Gblfy_Blog
08-18 2152
基于RabbitMQ订单未支付30分钟自动取消
springboot+rabbitmq+application.yml配置的完整代码示例
03-31
以下是一个简单的Spring Boot RabbitMQ应用程序的完整application.yml配置代码示例： ```yaml spring: rabbitmq: host: localhost port: 5672 username: guest password: guest virtual-host: / listener: simple: acknowledge-mode: manual concurrency: 1 max-concurrency: 1 template: exchange: example.exchange routing-key: example.routingKey ``` 解释： - `spring.rabbitmq.host`：RabbitMQ服务器的主机名或IP地址。 - `spring.rabbitmq.port`：RabbitMQ服务器的端口号。 - `spring.rabbitmq.username`：连接RabbitMQ服务器的用户名。 - `spring.rabbitmq.password`：连接RabbitMQ服务器的密码。 - `spring.rabbitmq.virtual-host`：连接RabbitMQ服务器的虚拟主机。 - `spring.rabbitmq.listener.simple.acknowledge-mode`：确认模式，这里是手动确认模式。 - `spring.rabbitmq.listener.simple.concurrency`：消费者线程数。 - `spring.rabbitmq.listener.simple.max-concurrency`：最大消费者线程数。 - `spring.rabbitmq.template.exchange`：消息发送时使用的交换机名。 - `spring.rabbitmq.template.routing-key`：消息发送时使用的路由键。 你也可以通过application.yml文件配置RabbitMQ的其他参数，例如： ```yaml spring: rabbitmq: host: localhost port: 5672 username: guest password: guest virtual-host: / listener: simple: acknowledge-mode: manual concurrency: 1 max-concurrency: 1 template: exchange: example.exchange routing-key: example.routingKey cache: channel: size: 100 checkout-timeout: 5000 connection: mode: connection size: 10 validated: true ``` 解释： - `spring.rabbitmq.cache.channel.size`：通道缓存的大小。 - `spring.rabbitmq.cache.channel.checkout-timeout`：通道缓存中的通道检出超时时间（毫秒）。 - `spring.rabbitmq.cache.connection.mode`：缓存模式，这里是连接模式。 - `spring.rabbitmq.cache.connection.size`：连接缓存的大小。 - `spring.rabbitmq.cache.connection.validated`：连接是否需要验证。 请注意，以上参数仅为示例，具体配置可能因应用程序需求而异。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值