当前位置: 开发笔记 > 运维 > 正文

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

作者：手机用户2502922713 | 来源：互联网 | 2021-10-31 08:51

这篇文章主要介绍了Springboot+rabbitmq实现延时队列的两种方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

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

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

网上商城下订单后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的依赖


    org.springframework.boot
    spring-boot-starter-amqp

初始化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 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 args = new HashMap();
        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延时队列内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

推荐阅读

服务器
搭建Jenkins、Ant与TestNG集成环境

本文详细介绍了如何在Ubuntu 16.04系统上配置Jenkins、Ant和TestNG的集成开发环境，涵盖从安装到配置的具体步骤，并提供了创建Windows Slave节点及项目构建的指南。 ... [详细]

蜡笔小新 2024-12-20 16:50:58
centos
在Ubuntu系统中安装Windows 7的详细步骤

本文详细介绍了如何在预装Ubuntu系统的笔记本电脑上安装Windows 7。针对没有光驱的情况，提供了通过USB安装的具体方法，并解决了分区、驱动器无法识别等问题。 ... [详细]

蜡笔小新 2024-12-22 18:26:55
centos
嵌入式开发环境搭建与文件传输指南

本文详细介绍了如何为嵌入式应用开发搭建必要的软硬件环境，并提供了通过串口和网线两种方式将文件传输到开发板的具体步骤。适合Linux开发初学者参考。 ... [详细]

蜡笔小新 2024-12-22 13:38:48
服务器
探究同一请求在不同机器上返回不同HTTP状态码200和429的原因

本文探讨了为何相同的HTTP请求在两台不同操作系统（Windows与Ubuntu）的机器上会分别返回200 OK和429 Too Many Requests的状态码。我们将分析代码、环境差异及可能的影响因素。 ... [详细]

蜡笔小新 2024-12-21 19:35:11
服务器
语言岛智能记单词V0.3.4.554正式开源发布

2012年7月30日，语言岛团队宣布其智能记单词软件V0.3.4.554版本正式开源。该版本不仅支持跨平台使用，还引入了多项创新功能，旨在帮助用户更高效地记忆单词。 ... [详细]

蜡笔小新 2024-12-21 11:49:02
server
解决Classic ASP与PHP HMAC_SHA256哈希结果不一致的问题

本文探讨了如何在Classic ASP中实现与PHP的hash_hmac('SHA256', $message, pack('H*', $secret))函数等效的哈希生成方法。通过分析不同实现方式及其产生的差异，提供了一种使用Microsoft .NET Framework的解决方案。 ... [详细]

蜡笔小新 2024-12-21 10:38:09
server
ListView简单使用

先上效果：主要实现了Listview的绑定和点击事件。项目资源结构如下：先创建一个动物类，用来装载数据：Animal类如下：packagecom.example.simplelis ... [详细]

蜡笔小新 2024-12-20 18:17:25
服务器
理解远程过程调用 (RPC) 的概念与演变

远程过程调用（RPC）是一种允许客户端通过网络请求服务器执行特定功能的技术。它简化了分布式系统的交互，使开发者可以像调用本地函数一样调用远程服务，并获得返回结果。本文将深入探讨RPC的工作原理、发展历程及其在现代技术中的应用。 ... [详细]

蜡笔小新 2024-12-20 15:12:33
服务器
Android 中 layout_gravity 的应用与注意事项

本文详细介绍了 Android 开发中 layout_gravity 属性的使用方法及其在不同布局下的效果，旨在帮助开发者更好地理解和利用这一属性来精确控制视图的布局。 ... [详细]

蜡笔小新 2024-12-20 14:38:17
服务器
Servlet过滤器入门：实现与配置

本文介绍如何在Java Web应用中实现和配置Servlet过滤器，通过实现`javax.servlet.Filter`接口来创建过滤器，并详细说明其在web.xml文件中的配置方法。 ... [详细]

蜡笔小新 2024-12-19 14:13:30
unix
C语言编程常用工具推荐

俗话说得好，“工欲善其事，必先利其器”。这句话不仅强调了工具的重要性，也提醒我们在任何项目开始前，准备合适的工具至关重要。本文将介绍几款C语言编程中常用的工具，帮助初学者更好地选择适合自己学习和工作的编程环境。 ... [详细]

蜡笔小新 2024-12-19 14:09:36
server
CactiEZ 中文版安装与使用指南

本文将详细介绍如何安装和使用 CactiEZ 的中文版本，帮助那些对英文界面不太熟悉的用户轻松掌握这一强大的网络监控工具。 ... [详细]

蜡笔小新 2024-12-19 12:14:26
touch
Appium + Java 自动化测试中处理页面空白区域点击问题

在进行移动应用自动化测试时，有时会遇到某些页面没有返回按钮，只能通过点击空白区域返回的情况。本文将探讨如何在Appium + Java环境中有效解决此类问题，并提供详细的解决方案。 ... [详细]

蜡笔小新 2024-12-22 17:30:25
touch
如何清除Chrome浏览器地址栏的特定历史记录

在使用Chrome浏览器时，你可能会发现地址栏保存了大量浏览记录。有时你可能希望删除某些特定的历史记录而不影响其他数据。本文将详细介绍如何单独删除地址栏中的特定记录以及批量清除所有历史记录的方法。 ... [详细]

蜡笔小新 2024-12-22 17:14:01
touch
Coursera ML 机器学习

2019独角兽企业重金招聘Python工程师标准线性回归算法计算过程CostFunction梯度下降算法多变量回归![选择特征](https:static.oschina.n ... [详细]

蜡笔小新 2024-12-22 16:09:09

手机用户2502922713

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章