扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Springboot+rabbitmq实现延时队列的两种方式
  • 405

0
分享到

Springboot+rabbitmq实现延时队列的两种方式

2024-04-02 19:04:59 405人浏览 薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录什么是延时队列，延时队列应用于什么场景利用TTL DLX实现延时队列的方式TTL DLX是什么SpringBoot集成RabbitMQ实现第一种方式利用RabbitMQ的插件x-

什么是延时队列，延时队列应用于什么场景

延时队列顾名思义，即放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。
那么，为什么需要延迟消费呢？我们来看以下的场景

  • 网上商城下订单后30分钟后没有完成支付，取消订单(如：淘宝、去哪儿网)
  • 系统创建了预约之后，需要在预约时间到达前一小时提醒被预约的双方参会
  • 系统中的业务失败之后，需要重试

这些场景都非常常见，我们可以思考，比如第二个需求，系统创建了预约之后，需要在预约时间到达前一小时提醒被预约的双方参会。那么一天之中肯定是会有很多个预约的，时间也是不一定的，假设现在有1点 2点 3点 三个预约，如何让系统知道在当前时间等于0点 1点 2点给用户发送信息呢，是不是需要一个轮询，一直去查看所有的预约，比对当前的系统时间和预约提前一小时的时间是否相等呢？这样做非常浪费资源而且轮询的时间间隔不好控制。如果我们使用延时消息队列呢，我们在创建时把需要通知的预约放入消息中间件中，并且设置该消息的过期时间，等过期时间到达时再取出消费即可。

Rabbitmq实现延时队列一般而言有两种形式：
第一种方式：利用两个特性： Time To Live(TTL)、Dead Letter Exchanges（DLX）
第二种方式：利用rabbitmq中的插件x-delay-message

利用TTL DLX实现延时队列的方式

TTL DLX是什么

TTL

RabbitMQ可以针对队列设置x-expires(则队列中所有的消息都有相同的过期时间)或者针对Message设置x-message-ttl(对消息进行单独设置，每条消息TTL可以不同)，来控制消息的生存时间，如果超时(两者同时设置以最先到期的时间为准)，则消息变为dead letter(死信)

Dead Letter Exchanges（DLX）
RabbitMQ的Queue可以配置x-dead-letter-exchange和x-dead-letter-routing-key（可选）两个参数，如果队列内出现了dead letter，则按照这两个参数重新路由转发到指定的队列。
x-dead-letter-exchange：出现dead letter之后将dead letter重新发送到指定exchange
x-dead-letter-routing-key：出现dead letter之后将dead letter重新按照指定的routing-key发送

Springboot集成rabbitmq实现第一种方式

在pom.xml文件中增加rabbitmq的依赖


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

初始化queue exchange和queue及exchange之间的binding关系

Config.java


package com.example.demo.deadLetter;
import java.util.HashMap;
import java.util.Map;

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 com.example.demo.Constants.Constants;

@Configuration
public class Config {

    // 创建一个立即消费队列
    @Bean
    public Queue immediateQueue() {
        // 第一个参数是创建的queue的名字，第二个参数是是否支持持久化
        return new Queue(Constants.IMMEDIATE_QUEUE, true);
    }

    // 创建一个延时队列
    @Bean
    public Queue delayQueue() {
        Map<String, Object> params = new HashMap<>();
        // x-dead-letter-exchange 声明了队列里的死信转发到的DLX名称，
        params.put("x-dead-letter-exchange", Constants.IMMEDIATE_EXCHANGE);
        // x-dead-letter-routing-key 声明了这些死信在转发时携带的 routing-key 名称。
        params.put("x-dead-letter-routing-key", Constants.IMMEDIATE_ROUTING_KEY);
        return new Queue(Constants.DELAY_QUEUE, true, false, false, params);
    }

    @Bean
    public DirectExchange immediateExchange() {
        // 一共有三种构造方法，可以只传exchange的名字， 第二种，可以传exchange名字，是否支持持久化，是否可以自动删除，
        //第三种在第二种参数上可以增加Map，Map中可以存放自定义exchange中的参数
        return new DirectExchange(Constants.IMMEDIATE_EXCHANGE, true, false);
    }

    @Bean
    public DirectExchange deadLetterExchange() {
        // 一共有三种构造方法，可以只传exchange的名字， 第二种，可以传exchange名字，是否支持持久化，是否可以自动删除，
        //第三种在第二种参数上可以增加Map，Map中可以存放自定义exchange中的参数
        return new DirectExchange(Constants.DEAD_LETTER_EXCHANGE, true, false);
    }

    @Bean
    //把立即消费的队列和立即消费的exchange绑定在一起
    public Binding immediateBinding() {
        return BindingBuilder.bind(immediateQueue()).to(immediateExchange()).with(Constants.IMMEDIATE_ROUTING_KEY);
    }

    @Bean
    //把立即消费的队列和立即消费的exchange绑定在一起
    public Binding delayBinding() {
        return BindingBuilder.bind(delayQueue()).to(deadLetterExchange()).with(Constants.DELAY_ROUTING_KEY);
    }
}

生产者生产消息

ImmediateSender.java


package com.example.demo.deadLetter;

import java.text.SimpleDateFORMat;
import java.util.Date;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.example.demo.Constants.Constants;
import com.example.demo.model.Booking;

@Component
public class ImmediateSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(Booking booking, int delayTime) {
        System.out.println("delayTime" + delayTime);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        this.rabbitTemplate.convertAndSend(Constants.DEAD_LETTER_EXCHANGE, Constants.DELAY_ROUTING_KEY, booking, message -> {
            message.getMessageProperties().setExpiration(delayTime + "");
            System.out.println(sdf.format(new Date()) + " Delay sent.");
            return message;
        });
    }
}

消费者消费消息

ImmediateReceiver.java


package com.example.demo.deadLetter;

import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import com.example.demo.Constants.Constants;
import com.example.demo.model.Booking;

@Component
@EnableRabbit
@Configuration
public class ImmediateReceiver {

    @RabbitListener(queues = Constants.IMMEDIATE_QUEUE)
    @RabbitHandler
    public void get(Booking booking) {
        System.out.println("收到延时消息了" + booking);
    }
}

model类book

Book.java


package com.example.demo.model;

import java.io.Serializable;
import java.util.Date;

public class Booking implements Serializable {

    private static final long serialVersionUID = 1L;
    private String bookingName;
    private Date bookingTime;
    private String bookinGContent;
    private String operatorName;

    public Booking() {
    }

    public String getBookingName() {
        return bookingName;
    }

    public void setBookingName(String bookingName) {
        this.bookingName = bookingName;
    }

    public Date getBookingTime() {
        return bookingTime;
    }

    public void setBookingTime(Date bookingTime) {
        this.bookingTime = bookingTime;
    }

    public String getBookingContent() {
        return bookingContent;
    }

    public void setBookingContent(String bookingContent) {
        this.bookingContent = bookingContent;
    }

    public String getOperatorName() {
        return operatorName;
    }

    public void setOperatorName(String operatorName) {
        this.operatorName = operatorName;
    }

    @Override
    public String toString() {
        return super.toString();
    }
}

测试类

Test.java


package com.example.demo;

import java.util.Date;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.example.demo.Immediate.Sender;
import com.example.demo.deadLetter.ImmediateSender;
import com.example.demo.model.Booking;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitMQtestApplicationTests {

 @Autowired
 ImmediateSender immediateSender;
 
 @Test
 public void test() {
     Booking booking = new Booking();
        booking.setBookingContent("hhaha");
        booking.setBookingName("预定房子");
        booking.setBookingTime(new Date());
        booking.setOperatorName("hellen");
     immediateSender.send(booking, 1000);
 }
}

总结第一种方式：经过测试，我们可以发现，当我们先增加一条过期时间大(10000)的A消息进入，之后再增加一个过期时间小的(1000)消息B,并没有出现想象中的B消息先被消费，A消息后被消费，而是出现了当10000过去的时候，AB消息同时被消费，也就是B消息的消费被阻塞了。

为什么会出现这样的现象呢？

我们知道利用TTL DLX特性实现的方式，实际上在第一个延时队列C里面设置了dlx，生产者生产了一条带ttl的消息放入了延时队列C中，等到延时时间到了，延时队列C中的消息变成了死信，根据延时队列C中设置的dlx的exchange的转发规则，转发到了实际消费队列D中，当该队列中的监听器监听到消息时就会正式开始消费。那么实际上延时队列中的消息也是放入队列中的，队列满足先进先出，而延时大的消息A还没出队，所以B消息也不能顺利出队。

利用Rabbitmq的插件x-delay-message实现

为了解决上面的问题，Rabbitmq实现了一个插件x-delay-message来实现延时队列。

x-delay-message安装

介绍ubuntu系统下插件安装方式：
选择rabbitmq_delayed_message_exchange插件，选择3.6版本，进行下载
将安装包进行解压


uzip rabbitmq_delayed_message_exchange-20171215-3.6.x.zip

将插件移到rabbitmq安装的路径


sudo cp -r rabbitmq_delayed_message_exchange-20171215-3.6.x.ez /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.15/plugins

Enable插件


rabbitmq-plugins enable rabbitmq_delayed_message_exchange

windows同理

Springboot集成rabbitmq实现第二种方式

XdelayConfig.java


package com.example.demo.Xdelay;

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

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

import com.example.demo.Constants.Constants;

@Configuration
public class XdelayConfig {

    // 创建一个立即消费队列
    @Bean
    public Queue immediateQueue() {
        // 第一个参数是创建的queue的名字，第二个参数是是否支持持久化
        return new Queue(Constants.IMMEDIATE_QUEUE_XDELAY, true);
    }

    @Bean
    public CustomExchange delayExchange() {
        Map<String, Object> args = new HashMap<String, Object>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange(Constants.DELAYED_EXCHANGE_XDELAY, "x-delayed-message", true, false, args);
    }

    @Bean
    public Binding bindingNotify() {
        return BindingBuilder.bind(immediateQueue()).to(delayExchange()).with(Constants.DELAY_ROUTING_KEY_XDELAY).noargs();
    }
}

XdelaySender.java


package com.example.demo.Xdelay;

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

import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.demo.Constants.Constants;
import com.example.demo.model.Booking;

@Service
public class XdelaySender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(Booking booking, int delayTime) {
        System.out.println("delayTime" + delayTime);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        this.rabbitTemplate.convertAndSend(Constants.DELAYED_EXCHANGE_XDELAY, Constants.DELAY_ROUTING_KEY_XDELAY, booking, new MessagePostProcessor() {
            @Override
            public Message postProceSSMessage(Message message) throws AmqpException {
                message.getMessageProperties().setDelay(delayTime);
                System.out.println(sdf.format(new Date()) + " Delay sent.");
                return message;
            }
        });
    }
}

XdelayReceiver.java


package com.example.demo.Xdelay;

import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import com.example.demo.Constants.Constants;
import com.example.demo.model.Booking;

@Component
@EnableRabbit
@Configuration
public class XdelayReceiver {

    @RabbitListener(queues = Constants.IMMEDIATE_QUEUE_XDELAY)
    public void get(Booking booking) {
        System.out.println("Receive" + booking);
    }
}

Test.java


package com.example.demo;

import java.util.Date;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.example.demo.Xdelay.XdelaySender;
import com.example.demo.model.Booking;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitMqTestApplicationTests {
 
 @Autowired
 XdelaySender xdelaySender;
 @Test
 public void test11() {
     Booking booking = new Booking();
        booking.setBookingContent("hhaha");
        booking.setBookingName("预定房子");
        booking.setBookingTime(new Date());
        booking.setOperatorName("hellen");
        xdelaySender.send(booking, 2000);
 }
}

到此这篇关于Springboot+rabbitmq实现延时队列的两种方式的文章就介绍到这了,更多相关Springboot rabbitmq延时队列内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: Springboot+rabbitmq实现延时队列的两种方式

本文链接: https://lsjlt.com/news/125593.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Springboot+rabbitmq实现延时队列的两种方式
    目录什么是延时队列，延时队列应用于什么场景利用TTL DLX实现延时队列的方式TTL DLX是什么Springboot集成rabbitmq实现第一种方式利用Rabbitmq的插件x-...
    99+
    2024-04-02
  • RabbitMQ实现延迟队列的两种方式详解
    目录1. 用插件1.1 安装插件1.2 消息收发2. DLX 实现延迟队列2.1 延迟队列实现思路2.2 案例3. 小结定时任务各种各样，常见的定时任务例如日志备份，我们可能在每天凌...
    99+
    2024-04-02
  • redis实现延时队列的两种方式(小结)
    背景 项目中的流程监控，有几种节点，需要监控每一个节点是否超时。按传统的做法，肯定是通过定时任务，去扫描然后判断，但是定时任务有缺点：1，数据量大会慢；2，时间不好控制，太短，怕一...
    99+
    2024-04-02
  • RabbitMQ实现延迟队列的两种方式分别是什么
    这期内容当中小编将会给大家带来有关RabbitMQ实现延迟队列的两种方式分别是什么，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。定时任务各种各样，常见的定时任务例如日志备份，我们可能在每天凌晨 3 点去备...
    99+
    2023-06-22
  • .NETCore基于RabbitMQ实现延时队列的两方法
    目录前言实现延时队列的两种方式利用rabbitmq死信队列x-dead-letter-exchange和x-dead-letter-routing-key.NETCore实现方式ra...
    99+
    2024-04-02
  • C#通过rabbitmq实现定时任务(延时队列)
    本文主要讲解如何通过RabbitMQ实现定时任务(延时队列) 环境准备 需要在MQ中进行安装插件 地址链接 插件介绍地址：https://www.rabbitmq.com/blog/...
    99+
    2024-04-02
  • SpringBoot整合RabbitMQ实现延迟队列的示例详解
    目录如何保证消息不丢失什么是消息投递可靠性ttl死信队列什么是死信队列消息有哪几种情况成为死信延迟队列springboot整合rabbitmq实现订单超时自动关闭如何保证消息不丢失 ...
    99+
    2023-05-16
    SpringBoot RabbitMQ实现延迟队列 SpringBoot RabbitMQ延迟队列 SpringBoot RabbitMQ队列 SpringBoot RabbitMQ
  • RabbitMQ延时队列详解与Java代码实现
    目录RabbitMQ 延时队列介绍使用插件实现延时队列使用DLX机制实现延时队列Java语言设置延时队列安装插件创建延时交换机创建延时队列发送延时消息消费延时消息RabbitMQ延时...
    99+
    2023-05-18
    Java实现延时队列 RabbitMQ延时队列
  • 运用.NetCore实例讲解RabbitMQ死信队列,延时队列
    目录一、死信队列二、延时队列三、延时消息设置不同过期时间四、延时消息用延时插件的方式实现一、死信队列 描述：Q1队列绑定了x-dead-letter-exchange(死信交换机)...
    99+
    2024-04-02
  • 如何利用rabbitMq的死信队列实现延时消息
    目录前言mq基本的消息模型mq死信队列的消息模型maven依赖配置普通队列和死信队列死信队列消费者发送消息测试测试成功总结前言 使用mq自带的死信去实现延时消息要注意一个坑点，就是m...
    99+
    2023-01-28
    rabbitMq死信队列 rabbitMq延时消息 rabbitMq延时队列
  • 实战干货之基于SpringBoot的RabbitMQ多种模式队列
    目录环境准备安装RabbitMQ依赖连接配置五种队列模式实现1 点对点的队列2 工作队列模式Work Queue3 路由模式Routing4 发布/订阅模式Publish/Subsc...
    99+
    2024-04-02
  • Springboot集成RabbitMQ死信队列的实现
    目录关于死信队列什么样的消息会进入死信队列？场景分析代码实现场景模拟生产者消费者，设置死信队列监听关于死信队列 在大多数的MQ中间件中，都有死信队列的概念。死信队列同其他的队列一样都...
    99+
    2024-04-02
  • SpringBoot+RabbitMQ 实现死信队列的示例
    前言 死信：无法被消费的消息，称为死信。 如果死信一直留在队列中，会导致一直被消费，却从不消费成功。 所以我们专门开辟了一个来存放死信的队列，叫死信队列（DLX，dead-lette...
    99+
    2024-04-02
  • RabbitMQ死信机制实现延迟队列的实战
    目录延迟队列应用场景TimeToLive(TTL) DeadLetterExchanges（DLX）延迟队列 延迟队列存储的对象肯定是对应的延时消息，所谓”延时消息”是指当...
    99+
    2024-04-02
  • RabbitMQ消息队列实现延迟任务示例
    目录一、序言1、实现原理2、组件选型二、方案设计（一）服务器（二）生产者（三）消费者三、SpringBoot实现（一）生产者（二）消费者（三）通用工具包一、序言 延迟任务应用广泛，延...
    99+
    2024-04-02
  • RabbitMQ消息队列怎么实现延迟任务
    这篇文章主要介绍“RabbitMQ消息队列怎么实现延迟任务”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“RabbitMQ消息队列怎么实现延迟任务”文章能帮助大家解决问题。一、序言延迟任务应用广泛，延...
    99+
    2023-06-29
  • Redis延迟队列和分布式延迟队列的简答实现
            最近，又重新学习了下Redis，Redis不仅能快还能慢，简直利器，今天就为大家介绍一下Redi...
    99+
    2024-04-02
  • kafka延时队列怎么实现
    Kafka是一个分布式的消息队列系统，它本身并不直接支持延时队列的功能。但是可以通过一些策略来实现延时队列的功能，下面是一种常见的实...
    99+
    2023-08-08
    kafka
  • Java 延迟队列的常用的实现方式
    目录1.  DelayQueue2.  Redis Key过期回调3.  RocketMQ延迟队列的使用场景还比较多，例如： 1、超时未收到支付回调，主...
    99+
    2024-04-02
  • Spring Boot与RabbitMQ结合实现延迟队列的示例
    背景何为延迟队列？顾名思义，延迟队列就是进入该队列的消息会被延迟消费的队列。而一般的队列，消息一旦入队了之后就会被消费者马上消费。场景一：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单...
    99+
    2023-05-30
    spring boot rabbitmq
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作