Springboot+rabbitmq實現延時隊列的兩種方式

更新時間：2021年05月11日 09:35:46 作者：酸酸的酸酸醬

這篇文章主要介紹了Springboot+rabbitmq實現延時隊列的兩種方式，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧

什么是延時隊列，延時隊列應用于什么場景

延時隊列顧名思義，即放置在該隊列里面的消息是不需要立即消費的，而是等待一段時間之后取出消費。
那么，為什么需要延遲消費呢？我們來看以下的場景

網上商城下訂單后30分鐘后沒有完成支付，取消訂單(如：淘寶、去哪兒網)
系統(tǒng)創(chuàng)建了預約之后，需要在預約時間到達前一小時提醒被預約的雙方參會
系統(tǒng)中的業(yè)務失敗之后，需要重試

這些場景都非常常見，我們可以思考，比如第二個需求，系統(tǒng)創(chuàng)建了預約之后，需要在預約時間到達前一小時提醒被預約的雙方參會。那么一天之中肯定是會有很多個預約的，時間也是不一定的，假設現在有1點 2點 3點三個預約，如何讓系統(tǒng)知道在當前時間等于0點 1點 2點給用戶發(fā)送信息呢，是不是需要一個輪詢，一直去查看所有的預約，比對當前的系統(tǒng)時間和預約提前一小時的時間是否相等呢？這樣做非常浪費資源而且輪詢的時間間隔不好控制。如果我們使用延時消息隊列呢，我們在創(chuàng)建時把需要通知的預約放入消息中間件中，并且設置該消息的過期時間，等過期時間到達時再取出消費即可。

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可以不同)，來控制消息的生存時間，如果超時(兩者同時設置以最先到期的時間為準)，則消息變?yōu)閐ead letter(死信)

Dead Letter Exchanges（DLX）
RabbitMQ的Queue可以配置x-dead-letter-exchange和x-dead-letter-routing-key（可選）兩個參數，如果隊列內出現了dead letter，則按照這兩個參數重新路由轉發(fā)到指定的隊列。
x-dead-letter-exchange：出現dead letter之后將dead letter重新發(fā)送到指定exchange
x-dead-letter-routing-key：出現dead letter之后將dead letter重新按照指定的routing-key發(fā)送

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 {

    // 創(chuàng)建一個立即消費隊列
    @Bean
    public Queue immediateQueue() {
        // 第一個參數是創(chuàng)建的queue的名字，第二個參數是是否支持持久化
        return new Queue(Constants.IMMEDIATE_QUEUE, true);
    }

    // 創(chuàng)建一個延時隊列
    @Bean
    public Queue delayQueue() {
        Map<String, Object> params = new HashMap<>();
        // x-dead-letter-exchange 聲明了隊列里的死信轉發(fā)到的DLX名稱，
        params.put("x-dead-letter-exchange", Constants.IMMEDIATE_EXCHANGE);
        // x-dead-letter-routing-key 聲明了這些死信在轉發(fā)時攜帶的 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);
 }
}

總結第一種方式：經過測試，我們可以發(fā)現，當我們先增加一條過期時間大(10000)的A消息進入，之后再增加一個過期時間小的(1000)消息B,并沒有出現想象中的B消息先被消費，A消息后被消費，而是出現了當10000過去的時候，AB消息同時被消費，也就是B消息的消費被阻塞了。

為什么會出現這樣的現象呢？

我們知道利用TTL DLX特性實現的方式，實際上在第一個延時隊列C里面設置了dlx，生產者生產了一條帶ttl的消息放入了延時隊列C中，等到延時時間到了，延時隊列C中的消息變成了死信，根據延時隊列C中設置的dlx的exchange的轉發(fā)規(guī)則，轉發(fā)到了實際消費隊列D中，當該隊列中的監(jiān)聽器監(jiān)聽到消息時就會正式開始消費。那么實際上延時隊列中的消息也是放入隊列中的，隊列滿足先進先出，而延時大的消息A還沒出隊，所以B消息也不能順利出隊。

利用Rabbitmq的插件x-delay-message實現

為了解決上面的問題，Rabbitmq實現了一個插件x-delay-message來實現延時隊列。

x-delay-message安裝

介紹Ubuntu系統(tǒng)下插件安裝方式：
選擇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 {

    // 創(chuàng)建一個立即消費隊列
    @Bean
    public Queue immediateQueue() {
        // 第一個參數是創(chuàng)建的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延時隊列內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

JavaWeb開發(fā)之使用jQuery與Ajax實現動態(tài)聯(lián)級菜單效果
這篇文章主要介紹了JavaWeb開發(fā)之使用jQuery與Ajax實現動態(tài)聯(lián)級菜單效果的相關資料,非常不錯，具有參考借鑒價值，需要的朋友可以參考下
2016-10-10
Spring?Boot+微信小程序開發(fā)平臺保存微信登錄者的個人信息
這篇文章主要介紹了Spring?Boot+微信小程序開發(fā)平臺保存微信登錄者的個人信息,本文主要介紹?wx.login和wx.getProfile接口，因篇幅所限，不能對其它接口做詳細介紹?，有興趣者可以查閱官方文檔
2022-05-05
SpringBoot之攔截器與過濾器解讀
這篇文章主要介紹了SpringBoot之攔截器與過濾器解讀，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2023-07-07
Springboot 使用具體化類和配置來縮短單元測試時間
這篇文章主要介紹了Springboot 使用具體化類和配置來縮短單元測試時間，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2021-11-11
java如何替換word/doc文件中的內容
docx格式的文件本質上是一個XML文件,只要用占位符在指定的地方標記,然后替換掉標記出的內容，這篇文章主要介紹了java替換word/doc文件中的內容,需要的朋友可以參考下
2023-06-06
SpringBoot整合Guava Cache實現全局緩存的示例代碼
這篇文章主要介紹了SpringBoot整合Guava Cache實現全局緩存,Guava Cache是Google Guava庫中的一個模塊,提供了基于內存的本地緩存實現,文中介紹了SpringBoot整合使用Guava Cache的具體步驟,需要的朋友可以參考下
2024-03-03
java簡單網頁抓取的實現方法
這篇文章主要介紹了java簡單網頁抓取的實現方法,詳細分析了與Java網頁抓取相關的tcp及URL相關概念,以及對應的類文件原理,具有一定的參考借鑒價值,需要的朋友可以參考下
2014-12-12
Java實現簡單客戶信息管理系統(tǒng)
這篇文章主要為大家詳細介紹了Java實現簡單客戶信息管理系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2022-05-05
java 實現線程同步的方式有哪些
當使用多個線程來訪問同一個數據時，非常容易出現線程安全問題,所以我們用同步機制來解決這些問題,本文將詳細介紹，需要的朋友可以參考下
2012-11-11
淺談mybatis mapper.xml文件中$和＃的區(qū)別
這篇文章主要介紹了淺談mybatis mapper.xml文件中$和＃的區(qū)別，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
2020-11-11