springboot-rabbitmq:實現延時佇列

阿新 • • 發佈：2020-08-28

延時佇列應用於什麼場景

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

網上商城下訂單後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關係

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

import org.springframework.amqp.core.Queue;

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


@Configuration
public class Config {
    public static final String IMMEDIATE_QUEUE = "queue.demo.immediate";//立即消費的佇列名稱
    public static final String IMMEDIATE_EXCHANGE = "exchange.demo.immediate";//立即消費的exchange
    public static final String IMMEDIATE_ROUTING_KEY = "routingkey.demo.immediate";//立即消費的routing-key 名稱
    public static final String DELAY_QUEUE= "queue.demo.delay";//延時消費的佇列名稱
    public static final String DEAD_LETTER_EXCHANGE = "exchange.demo.delay";//延時消費的exchange
    public static final String DELAY_ROUTING_KEY = "routingkey.demo.delay";//延時消費的routing-key名稱

    // 建立一個立即消費佇列
    @Bean
    public Queue immediateQueue() {
        // 第一個引數是建立的queue的名字，第二個引數是是否支援持久化
        return new Queue(IMMEDIATE_QUEUE, true);
    }

    // 建立一個延時佇列
    @Bean
    public Queue delayQueue() {
        Map<String, Object> params = new HashMap<>();
        // x-dead-letter-exchange 聲明瞭佇列裡的死信轉發到的DLX名稱，
        params.put("x-dead-letter-exchange", IMMEDIATE_EXCHANGE);
        // x-dead-letter-routing-key 聲明瞭這些死信在轉發時攜帶的 routing-key 名稱。
        params.put("x-dead-letter-routing-key", IMMEDIATE_ROUTING_KEY);
        return new Queue(DELAY_QUEUE, true, false, false, params);
    }

    public DirectExchange immediateExchange() {
        // 一共有三種構造方法，可以只傳exchange的名字， 第二種，可以傳exchange名字，是否支援持久化，是否可以自動刪除，
        //第三種在第二種引數上可以增加Map，Map中可以存放自定義exchange中的引數
        return new DirectExchange(IMMEDIATE_EXCHANGE, true, false);
    }

    @Bean public DirectExchange deadLetterExchange() {
        // 一共有三種構造方法，可以只傳exchange的名字， 第二種，可以傳exchange名字，是否支援持久化，是否可以自動刪除，
        // 第三種在第二種引數上可以增加Map，Map中可以存放自定義exchange中的引數
        return new DirectExchange(DEAD_LETTER_EXCHANGE, true, false);
    }

    //把立即消費的佇列和立即消費的exchange繫結在一起
    @Bean
    public Binding immediateBinding() {
        return BindingBuilder.bind(immediateQueue()).to(immediateExchange()).with(IMMEDIATE_ROUTING_KEY);
    }

    //把延時消費的佇列和延時消費的exchange繫結在一起
    @Bean
    public Binding delayBinding() {
        return BindingBuilder.bind(delayQueue()).to(deadLetterExchange()).with(DELAY_ROUTING_KEY);
    }
}

生產者生產訊息

import com.microservice.amqqp.amqp.config.Config;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

/**
 * 生產者生產訊息
 */
@Component
public class ImmediateSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

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

}

消費者消費訊息：

import com.microservice.amqqp.amqp.config.Config;
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 java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 消費者消費訊息
 */
@Component
@EnableRabbit
@Configuration
public class ImmediateReceiver {
    @RabbitListener(queues = Config.IMMEDIATE_QUEUE)
    @RabbitHandler
    public void get(String msg) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("收到延時訊息時間："+sdf.format(new Date()) + " Delay sent.");
        System.out.println("收到延時訊息了:" + msg);
    }
}

測試類：

import com.microservice.amqqp.amqp.send.ImmediateSender;
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 java.util.concurrent.TimeUnit;

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

    @Autowired
    ImmediateSender immediateSender;
    @Test
    public void test() {
        immediateSender.send("我是一個延時訊息",3000);//3秒

        //讓服務一直掛起，不然，接收訊息時，服務已經停了
        while(true){
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

}

第一次執行，需要進入rabbitmq管理介面，加上exchange，不然會報錯（no exchange 'exchange.demo.immediate' in vhost '/'）

新增方式：1.瀏覽器開啟：http://127.0.0.1:15672 2.選擇Exchanges 3.Add a new exchange ,填寫name:exchange.demo.immediate,type選擇：direct,點選Add exchange ，完成。

執行測試類，結果：

再來一種測試：

import com.microservice.amqqp.amqp.send.ImmediateSender;
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 java.util.concurrent.TimeUnit;

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

    @Autowired
    ImmediateSender immediateSender;

    /**
     * 傳送三條訊息，設定延時時間，發現所有的都在等待；
     * 這是因為符合先進先出原則，三條訊息是依次被消費，並不會因為時間到了，就消費
     */
    @Test
    public void test() {
        immediateSender.send("我是一個延時訊息，睡10秒",10000);//10秒
        immediateSender.send("我是一個延時訊息，睡2秒",2000);//2秒
        immediateSender.send("我是一個延時訊息，睡1秒",1000);//1秒

        //讓服務一直掛起，不然，接收訊息時，服務已經停了
        while(true){
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

結果：

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

為什麼會出現這樣的現象呢？
我們知道利用TTL DLX特性實現的方式，實際上在第一個延時佇列C裡面設定了dlx，生產者生產了一條帶ttl的訊息放入了延時佇列C中，等到延時時間到了，延時佇列C中的訊息變成了死信，根據延時佇列C中設定的dlx的exchange的轉發規則，轉發到了實際消費佇列D中，當該佇列中的監聽器監聽到訊息時就會正式開始消費。那麼實際上延時佇列中的訊息也是放入佇列中的，佇列滿足先進先出，而延時大的訊息A還沒出隊，所以B訊息也不能順利出隊。

上面實現方式的原始碼地址：https://github.com/qjm201000/micro_service_amqp_ttldlx.git

利用Rabbitmq的外掛x-delay-message實現延時佇列的方式

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

安裝外掛：

1.rabbit官網下載外掛
外掛地址

2.找到這個外掛

3.下載下來複制到D:\RabbitMQ Server\rabbitmq_server-3.7.8\plugins中

4.doc執行：rabbitmq-plugins enable rabbitmq_delayed_message_exchange

開始寫程式碼：

配置：

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 java.util.HashMap;
import java.util.Map;

@Configuration
public class XdelayConfig {
    public static final String IMMEDIATE_QUEUE_XDELAY = "queue.xdelay.immediate";//立即消費的佇列名稱
    public static final String DELAYED_EXCHANGE_XDELAY = "exchange.xdelay.delayed";//延時的exchange
    public static final String DELAY_ROUTING_KEY_XDELAY = "routingkey.xdelay.delay";//

    // 建立一個立即消費佇列
    @Bean
    public Queue immediateQueue() {
        // 第一個引數是建立的queue的名字，第二個引數是是否支援持久化
        return new Queue(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(DELAYED_EXCHANGE_XDELAY, "x-delayed-message", true, false, args);
    }

    //把立即消費的佇列和延時消費的exchange繫結在一起
    @Bean
    public Binding bindingNotify() {
        return BindingBuilder.bind(immediateQueue()).to(delayExchange()).with(DELAY_ROUTING_KEY_XDELAY).noargs();
    }
}

傳送：

import com.microservice.amqp.config.XdelayConfig;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

@Component
public class XdelaySender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String msg, int delayTime) {
        System.out.println("msg= "+msg+ ".delayTime" + delayTime);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        this.rabbitTemplate.convertAndSend(XdelayConfig.DELAYED_EXCHANGE_XDELAY, XdelayConfig.DELAY_ROUTING_KEY_XDELAY, msg, message ->  {
            message.getMessageProperties().setDelay(delayTime);
            System.out.println(sdf.format(new Date()) + " Delay sent.");
            return message;
        });
    }
}

接收：

import com.microservice.amqp.config.XdelayConfig;
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 java.text.SimpleDateFormat;
import java.util.Date;

@Component
@EnableRabbit
@Configuration
public class XdelayReceiver {

    @RabbitListener(queues = XdelayConfig.IMMEDIATE_QUEUE_XDELAY)
    public void get(String msg) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("收到延時訊息時間："+sdf.format(new Date()) + " Delay sent.");
        System.out.println("收到延時訊息:" + msg);
    }
}

test:

import com.microservice.amqp.send.XdelaySender;
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 java.util.concurrent.TimeUnit;

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

    @Autowired
    XdelaySender xdelaySender;

    /**
     * 傳送三條訊息，設定延時時間，誰時間到了，誰就消費
     */
    @Test
    public void test() {
        xdelaySender.send("我來發一個測試訊息,10秒", 10000);//10秒
        xdelaySender.send("我來發一個測試訊息，2秒", 2000);//2秒
        xdelaySender.send("我來發一個測試訊息，1秒", 2000);//1秒

        //讓服務一直掛起，不然，接收訊息時，服務已經停了
        while(true){
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

結果：

原始碼地址：https://github.com/qjm201000/micro_service_amqp_xdelaymessage.git

來源地址：https://www.cnblogs.com/qjm201000/p/10346471.html

springboot-rabbitmq:實現延時佇列

延時佇列應用於什麼場景

利用TTL DLX實現延時佇列的方式

Springboot整合rabbitmq實現第一種方式

springboot-rabbitmq:實現延時佇列

Springboot整合Rabbitmq實現延時佇列之rabbitmq_delayed_message_exchange外掛方式

【日常摘要】- RabbitMq實現延時佇列

使用RabbitMQ實現延時任務

延時佇列基於Redis實現延時佇列服務

zset實現延時佇列

SpringBoot使用RabbitMQ延時佇列(小白必備)

rabbitmq 延時佇列外掛方式實現每條訊息都延時自己時間

基於golang的簡單分散式延時佇列服務的實現

一口氣說出Java 6種延時佇列的實現方法(面試官也得服)

Rabbitmq的死信佇列和延時佇列

docker安裝rabbitmq延時佇列外掛

延時佇列的6個實現方案

RabbitMQ死性佇列，延時佇列

運用.NetCore例項講解RabbitMQ死信佇列,延時佇列

RabbitMQ從零到叢集高可用.NetCore(.NET5) - 死信佇列，延時佇列（轉）

RabbitMQ延時佇列應用場景

面試官：RabbitMQ過期時間設定、死信佇列、延時佇列怎麼設計？

使用Redis實現延時任務(一)

使用Redis實現延時任務(二)

springboot-rabbitmq:實現延時佇列

延時佇列應用於什麼場景

利用TTL DLX實現延時佇列的方式

Springboot整合rabbitmq實現第一種方式

相關推薦