今日主题内容：

----------------------------------------

1、What is RabbitMQ？

2、MQ的应用场景？

3、RabbitMQ运行部署

4、RabbitMQ工作模型

5、RabbitMQ交换机类型

6、RabbitMQ过期消息

7、RabbitMQ死信队列

8、RabbitMQ延迟队列

-------------------------------------------

1. What is RabbitMQ？

1.1简介

RabbitMQ是一个广泛使用的消息服务器，采用Erlang语言编写，是一种开源的实现 AMQP（高级消息队列协议）的消息中间件；

RabbitMQ最初起源于金融系统，它的性能及稳定性都非常出色；

AMQP协议（http://www.amqp.org），即 Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计；

我们学的协议有哪些：（http、ftp）

1.2 相关网址

官网：https://www.rabbitmq.com

Github：https://github.com/rabbitmq

镜像下载、域名解析、时间同步请点击阿里云开源镜像站

下载安装启动RabbitMQ

环境准备：阿里云centos7.9 服务器,自行搭建

# 查看系统版本
[root@zsr ~]# lsb_release -a
LSB Version:    :core-4.1-amd64:core-4.1-noarch
Distributor ID:    CentOS
Description:    CentOS Linux release 7.9.1810 (Core) 
Release:    7.9.1810
Codename:    Core

1.3 消息中间件（MQ=Message Queue）:消息队列

简单来说，消息中间件就是指保存数据的一个容器（服务器），可以用于两个系统之间的数据传递。

消息中间件一般有三个主要角色：生产者、消费者、消息代理(消息队列、消息服务器)；

下载Erlang

RabbitMQ是采用 Erlang语言开发的，所以系统环境必须提供 Erlang环境，需要是安装 Erlang

Erlang和RabbitMQ版本对照：https://www.rabbitmq.com/which-erlang.html

Erlang官网

https://www.erlang.org/

Linux下载：

wget https://github.com/erlang/otp/releases/download/OTP-25.1.1/otp_src_25.1.1.tar.gz

说明：wget 是linux命令，可以用来下载软件

安装Erlang

3.3.1 安装erlang前先安装Linux依赖库

yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel

说明：yum -y install 安装linux的一些依赖库的命令，-y表示自动确认；

3.3.2 解压erlang压缩包文件

tar -zxvf otp_src_25.1.1.tar.gz

3.3.3 配置

切换到解压的目录下，运行相应命令

cd otp_src_25.1.1

./configure

3.3.4 编译

make

3.3.5安装

make install

安装好了erlang后可以将解压的文件夹删除：

rm -rf otp_src_25.1.1

3.3.6 验证erlang是否安装成功

在命令行输入： erl 如果进入了编程命令行则表示安装成功，然后按ctrl + z 退出编程命令行；

3.4 下载RabbitMQ

从RabbitMQ官网https://www.rabbitmq.com找到下载链接

Linux：下载3.10.11

wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.10.11/rabbitmq-server-generic-unix-3.10.11.tar.xz

generic 是通用的意思，这个版本也就是通用的unix版本

3.5 安装RabbitMQ

解压RabbitMQ的压缩包，即安装完成，无需再编译，xz不需要-zxvf

tar -xvf rabbitmq-server-generic-unix-3.10.11.tar.xz -C /usr/local/

说明 -C 选项是指定解压目录，如果不指定会解压到当前目录

此时rabbitmq就安装好了；

1. 启动及停止RabbitMQ

4.1启动RabbitMQ

#启动

./rabbitmq-server -detached

说明：

-detached 将表示在后台启动运行rabbitmq；不加该参数表示前台启动；

rabbitmq的运行日志存放在安装目录的var目录下；

现在的目录是：/usr/local/rabbitmq_server-3.10.11/var/log/rabbitmq

4.2 查看RabbitMQ的状态

切换到sbin目录下执行：

./rabbitmqctl -n rabbit status

说明：-n rabbit 是指定节点名称为rabbit，目前只有一个节点，节点名默认为rabbit

此处-n rabbit 也可以省略

4.3 停止RabbitMQ

切换到sbin目录下执行：

./rabbitmqctl shutdown

4.4 配置path环境变量

vi /etc/profile

RABBIT_HOME=/usr/local/rabbitmq_server-3.10.11

PATH=$PATH:$RABBIT_HOME/sbin

export RABBIT_HOME PATH

刷新环境变量，命令如下

source /etc/profile

5.RabbitMQ管理命令

./rabbitmqctl 是一个管理命令，可以管理rabbitmq的很多操作。

./rabbitmqctl help可以查看一下有哪些操作

查看具体子命令可以使用 ./rabbitmqctl help 子命令名称

5.1 用户管理

用户管理包括增加用户，删除用户，查看用户列表，修改用户密码。

这些操作都是通过rabbitmqctl管理命令来实现完成。

查看帮助：

rabbitmqctl add_user --help

相应的命令

(1) 查看当前用户列表

rabbitmqctl list_users

(2) 新增一个用户

语法：rabbitmqctl add_user Username Password

示例: rabbitmqctl add_user admin 123456

5.2 设置用户角色

rabbitmqctl set_user_tags User Tag

示例：rabbitmqctl set_user_tags admin administrator

说明：此处设置用户的角色为管理员角色

5.3 设置用户权限

rabbitmqctl set_permissions -p / admin ".*" ".*" ".*"

说明：此操作是设置admin用户拥有操作虚拟主机/下的所有权限，读.写.配置

查看用户权限

./rabbitmqctl list_permissions

2. web管理后台

Rabbitmq有一个web管理后台，这个管理后台是以插件的方式提供的，启动后台web管理功能，切换到sbin目录下执行：

6.1 启用管理后台

# 查看rabbitmq 的插件列表

./rabbitmq-plugins list

#启用

./rabbitmq-plugins enable rabbitmq_management

#禁用

./rabbitmq-plugins disable rabbitmq_management

rabbitmq-plugins list

6.2防火墙操作

systemctl status firewalld --检查防火墙状态

systemctl stop firewalld --关闭防火墙，Linux重启之后会失效

systemctl disable firewalld --防火墙置为不可用，Linux重启后，防火墙服务不自动启动，依然是不可用

6.3 访问

http://192.168.131.131:15672

用户名/密码为我们上面创建的admin/123456

注意上面改成你的虚拟主机的ip地址

备注：如果使用默认用户guest、密码guest登录，会提示User can only log in via localhost

说明guest用户只能从localhost本机登录，所以不要使用该用户。

rabbitmqctl status

6.4 通过web页面新建虚拟主机

中文翻译

概述

连接

渠道

交流

7. RabbitMQ工作模型（核心知识点）

broker 相当于mysql服务器，virtual host相当于数据库（可以有多个数据库）

queue相当于表，消息相当于记录。

消息队列有三个核心要素： 消息生产者(发消息）、消息队列、消息消费者(接消息)；

生产者（Producer）：发送消息的应用；（java程序，也可能是别的语言写的程序）

消费者（Consumer）：接收消息的应用；（java程序，也可能是别的语言写的程序）

代理（Broker）：就是消息服务器，RabbitMQ Server就是Message Broker；

连接（Connection）：连接RabbitMQ服务器的TCP长连接；

信道（Channel）：连接中的一个虚拟通道，消息队列发送或者接收消息时，都是通过信道进行的；

虚拟主机（Virtual host）：一个虚拟分组，在代码中就是一个字符串，当多个不同的用户使用同一个RabbitMQ服务时，可以划分出多个Virtual host，每个用户在自己的Virtual host创建exchange/queue等；（分类比较清晰、相互隔离）

交换机（Exchange）：交换机负责从生产者接收消息，并根据交换机类型分发到对应的消息队列中，起到一个路由的作用；

路由键（Routing Key）：交换机根据路由键来决定消息分发到哪个队列，路由键是消息的目的地址；

绑定（Binding）：绑定是队列和交换机的一个关联连接（关联关系）；

队列（Queue）：存储消息的缓存；

消息（Message）：由生产者通过RabbitMQ发送给消费者的信息；（消息可以任何数据，字符串、user对象，json串等等）

1. RabbitMQ交换机类型

Exchange（X）可翻译成交换机/交换器/路由器

8.1 RabbitMQ交换器 (Exchange)类型

1、Fanout Exchange（扇形）

2、Direct Exchange（直连）

3、Topic Exchange（主题）

4、Headers Exchange（头部）

8.2 Fanout Exchange （扇形）

8.2.1 介绍

Fanout 扇形的，散开的；扇形交换机

投递到所有绑定的队列，不需要路由键，不需要进行路由键的匹配，相当于广播、群发

8.2.2 示例

创建项目，添加依赖

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

application.yml配置

server:
  port: 8080
spring:
  application:
    name: fanout-learn

# 消息队列配置：
  rabbitmq:
    host: 192.168.0.67 # rabbitmq主机
    port: 5672 # 注：15672是控制台端口，接发消息使用5672
    username: admin
    password: 123456
    virtual-host: powernode #虚拟主机

rabbitmq三部曲

定义交换机
定义队列
绑定交换机和队列

Config/RabbitmqConfig

定义队列：2个队列

绑定模式：spring容器对象使用的kv键值对，Map(k,v)，key=方法名=queueA()，value=返回的对象=Queue("queue.fanout.a")

完整config/RabbitConfig

注意：import org.springframework.amqp.core 核心引入

package com.tongda.config;

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

import javax.naming.Name;

@Configuration
public class RabbitConfig {
    // rabbitmq 三部曲
    // 1.定义交换机
    @Bean
    // 扇形交换机
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("exchange.fanout"); // 线程名称规范，对应
    }

    // 2.定义队列
    @Bean
    public Queue queueA() {
        return new Queue("queue.fanout.a"); // 构造方法创建队列a
    }
    @Bean
    public Queue queueB() {
        return new Queue("queue.fanout.b"); // 构造方法创建队列b
    }

    // 3.绑定交换机和队列
    @Bean
    // 依赖注入bingdingA(交换机名，队列方法名),
    public Binding bindingA(FanoutExchange fanoutExchange,Queue queueA) {
        // 将队列A绑定fanoutExchange扇形交换机，使用建造者模式创建BingdingBuilder
        return BindingBuilder.bind(queueA).to(fanoutExchange);
    }
    @Bean
    // 依赖注入bingdingA(交换机名，队列方法名),
    public Binding bindingB(FanoutExchange fanoutEchange,Queue queueB) {
        // 将队列A绑定fanoutExchange扇形交换机，使用建造者模式创建BingdingBuilder
        return BindingBuilder.bind(queueB).to(fanoutEchange);
    }
}

发消息：service/MessageService

package com.tongda.config.service;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;


@Component
@Slf4j
public class MessageService {
    // 调用消息模版
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendMsg() {
        // 定义要发送的消息
        String msg = "hello world";
        // 封装
        Message message = new Message(msg.getBytes());
        // 发消息:转换并且发送convertAndSend("交换机","路由key",message)
        rabbitTemplate.convertAndSend("exchange.fanout","",message);
        log.info("消息发送完毕，发送时间为：{}",new Date()); // {}占位符，时间
    }
}

启动类上继承 implements ApplicationRunner重写方法

package com.tongda;

import com.tongda.config.service.MessageService;
import jakarta.annotation.Resource;
import org.apache.logging.log4j.message.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Rabbit01FanoutApplication implements ApplicationRunner {

    public static void main(String[] args) {
        SpringApplication.run(Rabbit01FanoutApplication.class, args);
    }

    @Resource
    private MessageService messageService;

    /**
     * 程序一启动就运行该方法
     *
     *
     * @param args
     * @return
     **/
    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}

成功查看：Rabbitmq

信道

交换机

队列

以上是发消息

创建接消息模块：rabbit-01-receivemessage

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

application.yml

server:
  port: 9090
spring:
  application:
    name: receive-message
  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: admin
    password: 123456
    virtual-host: powernode

消息接收message/ReceiveMessage

package com.tongda.message;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component // 加入spring容器管理
@Slf4j // 日志
public class ReceiveMessage {

    // 接收2个队列消息
    @RabbitListener(queues = {"queue.fanout.a","queue.fanout.b"}) // 监听队列{}
    public void receivemsg(Message message){
        byte[] body = message.getBody(); // 字节数组
        String msg = new String(body); // 将字节转字符串
        log.info("接收到的消息为：{}",msg); // 日志输出
    }
}

启动测试

查看RabbitMQ控制台：队列

8.3 Direct Exchange（直连交换机）

8.3.1 介绍

根据路由键精确匹配（一模一样）进行路由消息队列；

8.3.2 示例

创建项目：rabbit-02-direct

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

application.yml

server:
  port: 8080
spring:
  application:
    name: direct-exchange

  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: admin
    password: 123456
    virtual-host: powernode

将队列信息放入yml配置中

server:
  port: 8080

spring:
  application:
    name: direct-exchange

  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: admin
    password: 123456
    virtual-host: powernode

my:
  exchangeName: exchange.direct
  queueAName: queue.direct.a
  queueBName: queue.direct.b

注意：import org.springframework.amqp.core 核心引入

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
@ConfigurationProperties(prefix = "my") // yml配置属性
public class RabbitConfig {

    // 交换机的名字
    private String exchangeName;

    // 队列A名称
    private String queueAName;

    // 队列B名称
    private String queueBName;

    // 三部曲
    // 1.定义交换机
    @Bean
    public DirectExchange directExchange(){
        //使用建造者模式创建
        return ExchangeBuilder.directExchange(exchangeName).build();
    }
    // 2.定义队列
    @Bean
    public Queue queueA() {
        // 使用建造者模式创建
        return QueueBuilder.durable(quequeAName).build();
    }
    @Bean
    public Queue queueB() {
        //使用建造者模式创建
        return QueueBuilder.durable(quequeBName).build();
    }
    // 3.交换机绑定队列
    @Bean
    public Binding bindingA(DirectExchange directExchange,Queue queueA){
        // 直连交换：精准匹配error
        return BindingBuilder.bind(queueA).to(directExchange).with("error");
    }
    @Bean
    public Binding bindingB1(DirectExchange directExchange,Queue queueB){
        // 直连交换：精准匹配info
        return BindingBuilder.bind(queueB).to(directExchange).with("info");
    }
    @Bean
    public Binding bindingB2(DirectExchange directExchange,Queue queueB){
        // 直连交换：精准匹配info
        return BindingBuilder.bind(queueB).to(directExchange).with("error");
    }
    @Bean
    public Binding bindingB3(DirectExchange directExchange,Queue queueB){
        // 直连交换：精准匹配info
        return BindingBuilder.bind(queueB).to(directExchange).with("info");
    }
}

发消息：service/MessageService

技巧：使用创造者模式比new构造更好用

package com.tongda.service;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
@Slf4j
public class MessageService {
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendMsg() {
        // 使用构造者builder.withbody(字符串.转换成字节数组).build()创建一个消息
        Message message = MessageBuilder.withBody("hello world".getBytes()).build();
        // 发送:重载方法参数（"交换机","路由key",对象）
        rabbitTemplate.convertAndSend("exchange.direct","info",message);
        log.info("消息发送完毕，发送时间为：{}",new Date());
    }

}

修改启动类

package com.tongda;

import com.tongda.service.MessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Rabbit02DirectApplication implements ApplicationRunner { // 重写启动

    public static void main(String[] args) {
        SpringApplication.run(Rabbit02DirectApplication.class, args);
    }

    @Autowired
    private MessageService messageService;
    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg(); // 项目启动发送消息
    }
}

启动报错：没有注入成功，name为空

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'queueA' defined in class path resource [com/tongda/config/RabbitConfig.class]: Failed to instantiate [org.springframework.amqp.core.Queue]: Factory method 'queueA' threw exception with message: 'name' cannot be null

以上是我一开始的配置，使用lombok的@Data注解自动生成get,set等方法，但是这种情况下，测试调用sourceConfig为null，主要参考了stackflow的办法，

问题在于：当前springboot版本里面@ConfigurationProperties默认配置properties文件，而暂时不支持默认导入yml文件（以上yml文件改用properties文件导入是可行不会出现null）

解决办法：

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Configuration
// @ConfigurationProperties(prefix = "my") // yml配置属性
public class RabbitConfig {

    // 交换机的名字
    @Value("${my.exchangeName}") // 解决：报错时name为null
    private String exchangeName;

    // 队列A名称
    @Value("${my.queueAName}")
    private String queueAName;

    // 队列B名称
    @Value("${my.queueBName")
    private String queueBName;

    // 三部曲
    // 1.定义交换机
    @Bean
    public DirectExchange directExchange(){
        //使用建造者模式创建
        return ExchangeBuilder.directExchange(exchangeName).build();
    }
    // 2.定义队列
    @Bean
    public Queue queueA() {
        // 使用建造者模式创建
        return QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB() {
        //使用建造者模式创建
        return QueueBuilder.durable(queueBName).build();
    }
    // 3.交换机绑定队列
    @Bean
    public Binding bindingA(DirectExchange directExchange,Queue queueA){
        // 直连交换：精准匹配error
        return BindingBuilder.bind(queueA).to(directExchange).with("error");
    }
    @Bean
    public Binding bindingB1(DirectExchange directExchange,Queue queueB){
        // 直连交换：精准匹配info
        return BindingBuilder.bind(queueB).to(directExchange).with("info");
    }
    @Bean
    public Binding bindingB2(DirectExchange directExchange,Queue queueB){
        // 直连交换：精准匹配info
        return BindingBuilder.bind(queueB).to(directExchange).with("error");
    }
    @Bean
    public Binding bindingB3(DirectExchange directExchange,Queue queueB){
        // 直连交换：精准匹配info
        return BindingBuilder.bind(queueB).to(directExchange).with("info");
    }
}

8.4 Topic Exchange（最复杂）主题交换机

8.4.1 介绍

通配符匹配，相当于模糊匹配；

# 匹配多个单词，用来表示任意数量（零个或多个）单词

* 匹配一个单词（必须有一个，而且只有一个），用 . 隔开的为一个单词：

beijing.# == beijing.queue.abc, beijing.queue.xyz.xxx

beijing.* == beijing.queue, beijing.xyz

发送时指定的路由键：lazy.orange.rabbit，注：*.*.rabbit,lazy.#都符合，但数据只有1条进入Q2符合逻辑。

8.4.2 示例

三部曲：依赖rabbitmq:amqp,yml配置，核心引入：交换机三部曲

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

server:
  port: 8080

spring:
  application:
    name: topic-exchange

  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: admin
    password: 123456

my:
  exchangeName: exchange.topic
  queueAName: queue.topic.a
  queueBName: queue.topic.b

config/RabbitConfig

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class RabbitConfig {
    // 对应yml配置
    @Value("${my.exchangeName}")
    // 交换机名字
    private String exchangeName;

    @Value("${my.queueAName}")
    // 队列A名字
    private String queueAName;

    @Value("${my.exchangeBName")
    // 队列B名字
    private String queueBName;

    // rabbitmq三部曲
    @Bean
    public TopicExchange topicExchange() {
        // 创造者模式创建交换机
        return ExchangeBuilder.topicExchange(exchangeName).build();
    }

    @Bean
    public Queue queueA(){
        // 创造队列.durble持久化
        return QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB() {
        return QueueBuilder.durable(queueBName).build();
    }

    // 绑定3个队列
    @Bean
    public Binding bindingA(TopicExchange topicExchange,Queue queueA) {
        // 创造者模式绑定bind(队列A).to(topic交换机).with(通配符)
        return BindingBuilder.bind(queueA).to(topicExchange).with("*.orange.*");
    }
    @Bean
    public Binding bindingB1(TopicExchange topicExchange,Queue queueB){
        // 创造者模式绑定bind(队列A).to(topic交换机).with(通配符)
        return BindingBuilder.bind(queueB).to(topicExchange).with("*.*.rabbit");
    }
    @Bean
    public Binding bindingB2(TopicExchange topicexchange,Queue queueB){
        // 创造者模式绑定bind(队列A).to(topic交换机).with(通配符)
        return BindingBuilder.bind(queueB).to(topicexchange).with("lazy.#");
    }
}

发消息

package com.tongda.service;

import jakarta.annotation.Resource;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Service;


@Service
public class MessageService {

    @Resource
    private AmqpTemplate amqpTemplate; // amqp包含了RabbitTemplate

    public void sendMsg() {
        Message message = MessageBuilder.withBody("hello world".getBytes()).build();
        // 参数1：交换机,参数2：路由key,参数3：消息对象
        amqpTemplate.convertAndSend("exchange.topic","hello.world",message);
    }
}

修改启动类

package com.tongda;

import com.tongda.service.MessageService;
import jakarta.annotation.Resource;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Rabbit03TopicApplication implements ApplicationRunner {

    public static void main(String[] args) {
        SpringApplication.run(Rabbit03TopicApplication.class, args);
    }

    @Resource
    private MessageService messageService;
    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}

解决RabbitMQ Caused by: org.springframework.amqp.AmqpIOException: java.io.IOException

解决 Caused by: org.springframework.amqp.AmqpIOException: java.io.IOException

安装好rabiitmq，创建了一个队列，然后启动监听后报错，现在记录一下。

Caused by: org.springframework.amqp.AmqpIOException: java.io.IOException
    at org.springframework.amqp.rabbit.support.RabbitExceptionTranslator.convertRabbitAccessException(RabbitExceptionTranslator.java:71) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.connection.RabbitAccessor.convertRabbitAccessException(RabbitAccessor.java:113) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitTemplate.doExecute(RabbitTemplate.java:1461) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitTemplate.execute(RabbitTemplate.java:1411) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitTemplate.execute(RabbitTemplate.java:1387) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitAdmin.initialize(RabbitAdmin.java:500) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitAdmin$11.onCreate(RabbitAdmin.java:419) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.connection.CompositeConnectionListener.onCreate(CompositeConnectionListener.java:33) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.connection.CachingConnectionFactory.createConnection(CachingConnectionFactory.java:579) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitTemplate.doExecute(RabbitTemplate.java:1430) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitTemplate.execute(RabbitTemplate.java:1411) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitTemplate.execute(RabbitTemplate.java:1387) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.core.RabbitAdmin.getQueueProperties(RabbitAdmin.java:336) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.redeclareElementsIfNecessary(SimpleMessageListenerContainer.java:1171) ~[spring-rabbit-1.7.4.RELEASE.jar:na]
    ... 2 common frames omitted

发现都是说RabbitMQ 用户的访问权限没有打开。于是登录web端

发现admin账户确实没有设置主题权限（Topic permissions）

给admin添加Topic permissions 权限

账户添加好权限后系统不在报错。

交换机之间的区别

8.5 Headers Exchange （用的比较少）头部交换机

8.5.1 介绍

基于消息内容中的headers属性进行匹配；

8.5.2 示例

绑定参考代码：

server:
  port: 8080
spring:
  application:
    name: headers-exchange

  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: admin
    password: 123456
    virtual-host: powernode

my:
  exchangeName: exchange.headers
  queueAName: queue.headers.a
  queueBName: queue.headers.b

config/RabbitConfig

ctrl点击whereAll()进入，查找Map<String,Object> headerValues ，复制返回定义变量。

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


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

@Configuration
public class RabbitConfig {
    // Rabbitmq三部曲

    // 获取yml配置:交换机、队列A\队列B
    @Value("${my.exchanggeName}")
    private String exchangeName;
    @Value("${my.queueAName}")
    private String queueAName;
    @Value("${queueBName}")
    private String queueBName;

    // 1.交换机
    @Bean
    public HeadersExchange headersExchange(){
        // 使用建造者模式创建
        return ExchangeBuilder.headersExchange(exchangeName).build();
    }
    // 2.队列
    @Bean
    public Queue queueA(){
        return QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB(){
        return QueueBuilder.durable(queueBName).build();
    }
    // 3. 绑定
    @Bean
    public Binding bindingA(HeadersExchange headersExchange,Queue queueA){
        Map<String, Object> headerValues = new HashMap<>();
        // 绑定头部指定参数
        headerValues.put("type","m");
        headerValues.put("status",1);
        return BindingBuilder.bind(queueA).to(headersExchange).whereAll(headerValues).match();
    }
    @Bean
    public Binding bindingB(HeadersExchange headersExchange,Queue queueB){
        Map<String, Object> headerValues = new HashMap<>();
        // 绑定头部指定参数
        headerValues.put("type","m");
        headerValues.put("status",1);
        return BindingBuilder.bind(queueB).to(headersExchange).whereAll(headerValues).match();
    }
}

servcie/MessageService

package com.tongda.service;


import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

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

@Service
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Value("${my.exchangeName}")
    private String exchangeName;

    public void sendMsg(){
        // 消息属性
        MessageProperties messageProperties = new MessageProperties();
        Map<String, Object> headers = new HashMap<>();
        headers.put("type","s");
        headers.put("status",0);
        // 设置消息头
        messageProperties.setHeaders(headers);
        // 添加了消息属性
        Message message = MessageBuilder.withBody("hello world".getBytes())
                .andProperties(messageProperties).build();
        // 头部交换机，路由key无所谓
        rabbitTemplate.convertAndSend(exchangeName,"",message);
        log.info("消息发送完毕，发送时间：{}",message);
    }
}

修改启动

package com.tongda;

import com.tongda.service.MessageService;
import jakarta.annotation.Resource;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Rabbit04HeadersApplication implements ApplicationRunner {

    public static void main(String[] args) {
        SpringApplication.run(Rabbit04HeadersApplication.class, args);
    }

    @Resource
    private MessageService messageService;
    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}

学习它的目的是：发消息时可以指定消息属性（MessageProperties）

9. RabbitMQ过期消息

过期消息也叫TTL消息，TTL：Time To Live

消息的过期时间有两种设置方式：（过期消息）

9.1 设置单条消息的过期时间

参考代码

MessageProperties messageProperties = new MessageProperties();
messageProperties.setExpiration("15000"); // 设置过期时间，单位：毫秒
Message message = new Message(json.getBytes(), messageProperties);
//发送消息
amqpTemplate.convertAndSend(RabbitConfig.DIRECT_EXCHANGE, RabbitConfig.DIRECT_ROUTINGKEY, message);
System.out.println("发送完毕：" + new Date());
单条消息的过期时间决定了在没有任何消费者消费时，消息可以存活多久；

package com.tongda.service;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;

import java.util.Date;


@Service
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Bean
    public void sendMsg(){
        MessageProperties messageProperties = new MessageProperties();
        // 设置过期时间:setExpiration
        messageProperties.setExpiration("35000"); // 过期的毫秒数,35秒
        Message message = MessageBuilder.withBody("hello world".getBytes())
                .andProperties(messageProperties).build();
        rabbitTemplate.convertAndSend("exchange.ttl","info",message);
        log.info("消息发送时间{}",new Date());
    }
}

9.2 通过队列属性设置消息过期时间

@Bean
public Queue directQueue() {
    Map<String, Object> arguments = new HashMap<>();
    arguments.put("x-message-ttl", 10000);
    return new Queue(DIRECT_QUEUE, true, false, false, arguments);
}

队列的过期时间决定了在没有任何消费者的情况下，队列中的消息可以存活多久；

注意事项：

如果消息和对列都设置过期时间，则消息的TTL以两者之间较小的那个数值为准。

config/RabbitConfig

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class RabbitConfig {
    @Value("my.exchangeName")
    private String exchangeName;

    @Value("my.queueNme")
    private String queueName;

    // 1.交换机
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange(exchangeName).build();
    }
    // 2.队列
    @Bean
    public Queue queueA(){
        // 方式一：new Queue 的方式
        Map<String, Object> arguments = new HashMap<>();
        // 设置队列消息过期时间
        arguments.put("x-message-ttl","15000");
        // Queue(队列名，持久化，是否排查队列，是否自动删除，Map)
        return new Queue(queueName,true,false,false,arguments);
        // 方式二： 建造者模式
/*        return QueueBuilder
                .durable(queueName)
                .withArguments(arguments)
                .build();*/
    }
    // 3.绑定
    @Bean
    public Binding binding(DirectExchange directExchange,Queue queueA){
        return BindingBuilder.bind(queueA).to(directExchange).with("info");
    }
}

service/MessageService

package com.tongda.service;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;

import java.util.Date;


@Service
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Bean
    public void sendMsg(){
/*        MessageProperties messageProperties = new MessageProperties();
        // 设置过期时间:setExpiration
        messageProperties.setExpiration("35000"); // 过期的毫秒数,35秒
        Message message = MessageBuilder.withBody("hello world".getBytes())
                .andProperties(messageProperties).build();*/
        Message message = MessageBuilder.withBody("hello world".getBytes()).build();
        rabbitTemplate.convertAndSend("exchange.ttl.b","info",message);
        log.info("消息发送时间{}",new Date());
    }
}

10. RabbitMQ死信队列(面试常问）

也有叫死信交换机、死信邮箱等说法；

DLX: Dead-Letter-Exchange 死信交换器，死信邮箱

如下情况下一个消息会进入DLX（Dead Letter Exchange）死信交换机。

场景：如火车票购买倒计时，延迟队列就是在死信队列基础上实现的。当用户下订单时，消息通过交换机到队列，当前时间7点，ttl队列消息过期30分钟，7点30进入死信交换机到死信队列，消费者7点30收到消息，对比数据库订单号查询点单是否支付，如未支付订单状态改成取消，也不能继续支付。

10.1 消息过期

参考代码

application.yml

server:
  port: 8080
# 死信交换机
spring:
  application:
    name: dlx-learn1

  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: admin
    password: 123456
    virtual-host: powernode
# 死信有2个交换机，2个队列
my:
  exchangeNormalNameA: exchange.normal.a # 正常交换机
  exchangeDlxNameB: exchange.dlx.b  # 死信交换机
  queueNormalNameA: queue.normal.a  # 正常队列
  queueDlxNameB: queue.dlx.b  # 死信队列

config/RabbitConfig：1234和6789步骤按直连交换机和队列设置

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    // 获取yml中的配置
    @Value("${my.exchangNormalNameA}")
    public String exchangeNormalNameA;
    @Value("${my.queueNormalNameA}")
    public String queueNormalNameA;
    @Value("${my.exchangeDlxNameB}")
    public String exchangeDlxNameB;
    @Value("${my.queueDlxNameB}")
    public String queueDlxNameB;

    // Rabbitmq三部曲
    // 1.正常交换机: 直连
    /**
     * 正常交换机和正常队列绑定
     * @param
     * @return {@link DirectExchange}
     * @throws
     * @date 2024/1/9 14:37
     **/
    @Bean
    public DirectExchange normalExchange(){ // 正常交换机
        return ExchangeBuilder.directExchange(exchangeNormalNameA).build();
    }
    @Bean
    public Queue normalQueue(){ // 2.直连队列
        return QueueBuilder.durable(queueNormalNameA).build();
    }
    // 绑定交换机和队列
    @Bean
    public Binding bindingNormal(DirectExchange normalExchange,Queue normalQueue){
        return BindingBuilder.bind(normalQueue).to(normalExchange).with("order");

    }

    // 死信交换机：直连
    @Bean
    public DirectExchange dxlExchange(){ // 1.死信交换机
        return ExchangeBuilder.directExchange(exchangeDlxNameB).build();
    }
    @Bean
    public Queue dxlQueue(){ // 2. 死信队列
        return QueueBuilder.durable(queueDlxNameB).build();
    }
    // 3. 绑定死信交换机和队列
    @Bean
    // 依赖注入（dxlExchange,dxlQueue）
    public Binding bindingDxl(DirectExchange dxlExchange,Queue dxlQueue){
        return BindingBuilder.bind(dxlQueue).to(dxlExchange).with("error");
    }
}

10.2 队列过期

第一步：设置过期形成死信

设置5到6死信的关键点

设置7死信路由key

config/RabbitConfig

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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


@Configuration
public class RabbitConfig {
    @Value("${my.exchangeNormalName}")
    private String exchangeNormalName;
    @Value("${my.queueNormalName}")
    private String queueNormalName;
    @Value("${my.exchangeDlxName}")
    private String exchangeDlxName;
    @Value("${my.queueDlxName}")
    private String queueDlxName;

    // rabbit三部曲
    // 1.正常交换机
    @Bean
    public DirectExchange normalexchange() {
        return ExchangeBuilder.directExchange(exchangeNormalName).build();
    }
    // 2.正常队列
    @Bean
    public Queue normalQueue(){
        Map<String, Object> arguments = new HashMap<>();
        // arguments.put("x-messag-ttl",20000); // 设置队列的过期时间为20秒
        // 重点：：设置这2个参数
/*        arguments.put("x-dead-letter-exchange",exchangeDlxName);// 设置队列的死信交换机
        // 设置死信路由key,要和死信交换机和死信队列绑定key: error一致,因为死信交换机是直连类型
        arguments.put("x-dead-letter-routing-key","error");
        return QueueBuilder
                .durable(queueNormalName)
                .withArguments(arguments)
                .build();*/
        // 第二种写法: 重点2参数直接进行构造创建,更简洁durable(正常队列).deadLetterExchange（死信交换机）.deadLetterRoutingKey(死信路由key)
        return QueueBuilder
                .durable(queueNormalName)
                .deadLetterExchange(exchangeDlxName)
                .deadLetterRoutingKey("error")
                .withArguments(arguments)
                .build();
    }
    // 3.绑定交换机和队列:注入依赖
    @Bean
    public Binding normalBinding(DirectExchange normalexchange,Queue normalQueue){
        return BindingBuilder.bind(normalQueue).to(normalexchange).with("order");
    }

    // 1.死信交换机
    @Bean
    public DirectExchange dlxExchange(){
        return ExchangeBuilder.directExchange(exchangeDlxName).build();
    }
    // 2.死信队列
    @Bean
    public Queue dlxQueue() {
        return QueueBuilder.durable(queueDlxName).build();
    }
    // 3.绑定交换机和队列
    @Bean
    public Binding dlxBinding(DirectExchange dlxExchange,Queue dlxQueue){
        return BindingBuilder.bind(dlxQueue).to(dlxExchange).with("error");
    }
}

service/MessageService发消息

package com.tongda.service;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendMsg() {
        // 消息属性
        MessageProperties messageProperties = new MessageProperties();
        // 设置单条消息的过期时间，单位为毫秒,数据类型为字符串
        messageProperties.setExpiration("15000");
        // 构造发消息：字符串转字节
        Message message = MessageBuilder.withBody("hello world".getBytes())
                .andProperties(messageProperties)
                .build();
        rabbitTemplate.convertAndSend("exchange.normal.2","order",message);
        log.info("消息发送完毕，发送时间：{}",new Date());
    }
}

修改启动类：启动时发送消息

package com.tongda;

import com.tongda.service.MessageService;
import jakarta.annotation.Resource;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Rabbit06Dlx1Application implements ApplicationRunner {

    public static void main(String[] args) {
        SpringApplication.run(Rabbit06Dlx1Application.class, args);
    }

    @Resource
    private MessageService messageService;
    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}

TTL: Time to Live的简称，过期时间

10.3 队列达到最大长度（先入队的消息会被发送到DLX）

Map<String, Object> arguments = new HashMap<String, Object>();
//设置队列的最大长度 ，对头的消息会被挤出变成死信
arguments.put("x-max-length", 5);

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class RabbitConfig {
    @Value("${my.exchangeNormalName}")
    private String exchangeNormalName;
    @Value("${my.queueNormalName}")
    private String queueNormalName;
    @Value("${my.exchangeDlxName}")
    private String exchangeDlxName;
    @Value("${my.queueDlxName}")
    private String queueDlxName;

    // rabbit三部曲
    // 1.正常交换机
    @Bean
    public DirectExchange normalexchange() {
        return ExchangeBuilder.directExchange(exchangeNormalName).build();
    }
    // 2.正常队列
    @Bean
    public Queue normalQueue(){
        Map<String, Object> arguments = new HashMap<>();
        // 设置队列的最大的长度
        arguments.put("x-max-length",5);
        // arguments.put("x-messag-ttl",20000); // 设置队列的过期时间为20秒
        // 重点：：设置这2个参数
/*        arguments.put("x-dead-letter-exchange",exchangeDlxName);// 设置队列的死信交换机
        // 设置死信路由key,要和死信交换机和死信队列绑定key: error一致,因为死信交换机是直连类型
        arguments.put("x-dead-letter-routing-key","error");
        return QueueBuilder
                .durable(queueNormalName)
                .withArguments(arguments)
                .build();*/
        // 第二种写法: 重点参数直接进行构造创建,更简洁
        // durable(正常队列).deadLetterExchange（死信交换机）.deadLetterRoutingKey(死信路由key)
        return QueueBuilder
                .durable(queueNormalName)
                .deadLetterExchange(exchangeDlxName)
                .deadLetterRoutingKey("error")
                .withArguments(arguments) // 设置队列的参数
                .build();
    }
    // 3.绑定交换机和队列:注入依赖
    @Bean
    public Binding normalBinding(DirectExchange normalexchange,Queue normalQueue){
        return BindingBuilder.bind(normalQueue).to(normalexchange).with("order");
    }

    // 1.死信交换机
    @Bean
    public DirectExchange dlxExchange(){
        return ExchangeBuilder.directExchange(exchangeDlxName).build();
    }
    // 2.死信队列
    @Bean
    public Queue dlxQueue() {
        return QueueBuilder.durable(queueDlxName).build();
    }
    // 3.绑定交换机和队列
    @Bean
    public Binding dlxBinding(DirectExchange dlxExchange,Queue dlxQueue){
        return BindingBuilder.bind(dlxQueue).to(dlxExchange).with("error");
    }
}

service/MessageService

package com.tongda.service;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendMsg() {
/*        // 消息属性
        MessageProperties messageProperties = new MessageProperties();
        // 设置单条消息的过期时间，单位为毫秒,数据类型为字符串
        messageProperties.setExpiration("15000");
        // 构造发消息：字符串转字节
        Message message = MessageBuilder.withBody("hello world".getBytes())
                .andProperties(messageProperties)
                .build();*/
        // 队列的最大长度是5
        for (int i = 1; i <= 8; i++) {
            String str = "hello world" + i;
            Message message = MessageBuilder.withBody(str.getBytes()).build();
            rabbitTemplate.convertAndSend("exchange.normal.3","order",message);
        }
        log.info("消息发送完毕，发送时间：{}",new Date());
    }
    // 问题1：for循环1-8条消息，哪几条消息会进入死信队列，是123没进入队列还是678没进入
    // 问题2：发完消息多长时间进入队列，有3条会进入死信队列，没有过期时间直接进入
}

队列达到最大长度（先入队的消息会被发送到DLX）

Map<String, Object> arguments = new HashMap<String, Object>();

// 设置队列的最大长度，对头的消息会被挤出变成死信

arguments.put("x-max-length", 5);

10.4 消费者拒绝消息不进行重新投递

从正常的队列接收消息，但是对消息不进行确认，并且不对消息进行重新投递，此时消息就进入死信队列。

创建消费者接收信息

application.yml

# 消费者（接收）
server:
  port: 9090

spring:
  application:
    name: dlx-receiver-msg
  #配置rabbitmq服务器的信息
  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: 123456
    virtual-host: powernode
# 自定义

message.MessageReceiver

package com.tongda.message;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class MessageReceiver {
    // 接收消息:监听dlx4正常队列中的消息
    @RabbitListener(queues = {"queue.normal.4"})
    public void sendMsg(Message message){
        // 获取消息体
        byte[] body = message.getBody();
        // 字节转字符串
        String str = new String(body);
        log.info("接收到的消息为：{},接收时间为：{}" , str,new Date());
    }
}

消费者的自动确认！但有问题

解决方法：消费者接收端配置

application.yml 启动手动确认

# 消费者（接收）
server:
  port: 9090

spring:
  application:
    name: dlx-receiver-msg
  #配置rabbitmq服务器的信息
  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: 123456
    virtual-host: powernode
    # 监听开启：消费者手动确认开启
    listener:
      simple:
        acknowledge-mode: manual
# 自定义

增加信道channel

package com.tongda.message;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Date;

@Component
@Slf4j
public class MessageReceiver {
    // 接收消息:监听dlx4正常队列中的消息
    @RabbitListener(queues = {"queue.normal.4"})
    public void sendMsg(Message message, Channel channel){
        // 获取消息属性
        MessageProperties messageProperties = message.getMessageProperties();
        // 获取消息属性唯一标识，长整型类似身份证或者学号
        long deliveryTag = messageProperties.getDeliveryTag();
        try {
            // 获取消息体
            byte[] body = message.getBody();
            // 字节转字符串
            String str = new String(body);
            log.info("接收到的消息为：{},接收时间为：{}" , str,new Date());
            // TODO 业务逻辑处理
            int a = 1/0; // 错误模拟
            // 消费者的手动确认，使用信道channel：告知服务器可以删除信息
            // deliveryTag唯一标识，false一次只确认当前一条，true为批量
            channel.basicAck(deliveryTag,false);
        } catch (Exception e) {
            log.error("接受者出现问题：{}",e.getMessage());
            try {
                // 信道.告诉服务器不要删（标识，当前信息，true重新入队列）,不会进入死信队列
                // channel.basicNack(deliveryTag,false,true);
                // 信道.告诉服务器不要删（标识，当前信息，flash不重新入队）,会进入死信队列
                channel.basicNack(deliveryTag,false,true);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }
    }
}

参考代码

/**
         * 参考代码
         * 监听正常的那个队列的名字，不是监听那个死信队列
         * 我们从正常的队列接收消息，但是对消息不进行确认，并且不对消息进行重新投递，此时消息就进入死信队列
         *
         * channel 消息信道（是连接下的一个消息信道，一个连接下有多个消息信息，发消息/接消息都是通过信道完成的）
         */
        @RabbitListener(queues = {RabbitConfig.QUEUE})
        public void process(Message message, Channel channel) {
            System.out.println("接收到的消息：" + message);
            //对消息不确认, ack单词是 确认 的意思
            // void basicNack(long deliveryTag, boolean multiple, boolean requeue)
            // deliveryTag：消息的一个数字标签
            // multiple：翻译成中文是多个的意思，如果是true表示对小于deliveryTag标签下的消息都进行Nack不确认，false表示只对当前deliveryTag标签的消息Nack
            // requeue：如果是true表示消息被Nack后，重新发送到队列，如果是false，消息被Nack后，不会重新发送到队列
            try {
                System.out.println("deliveryTag = " + message.getMessageProperties().getDeliveryTag());
                //要开启rabbitm消息消费的手动确认模式，然后才这么写代码；
                channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

10.5 消费者拒绝消息

开启手动确认模式，并拒绝消息，不重新投递，则进入死信队列

    # 监听开启：消费者手动确认开启
    listener:
      simple:
        acknowledge-mode: manual

package com.tongda.message;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Date;

@Component
@Slf4j
public class MessageReceiver {
    // 接收消息:监听dlx4正常队列中的消息
    @RabbitListener(queues = {"queue.normal.5"})
    public void sendMsg(Message message, Channel channel){
        // 获取消息属性
        MessageProperties messageProperties = message.getMessageProperties();
        // 获取消息属性唯一标识，长整型类似身份证或者学号
        long deliveryTag = messageProperties.getDeliveryTag();
        try {
            // 获取消息体
            byte[] body = message.getBody();
            // 字节转字符串
            String str = new String(body);
            log.info("接收到的消息为：{},接收时间为：{}" , str,new Date());
            // TODO 业务逻辑处理
            int a = 1/0; // 错误模拟
            // 消费者的手动确认，使用信道channel：告知服务器可以删除信息
            // deliveryTag唯一标识，false一次只确认当前一条，true为批量
            channel.basicAck(deliveryTag,false);
        } catch (Exception e) {
            log.error("接受者出现问题：{}",e.getMessage());
            try {
                // 信道.告诉服务器不要删（标识，当前信息，true重新入队列）,不会进入死信队列
                // channel.basicNack(deliveryTag,false,true);
                // 信道.告诉服务器不要删（标识，是否批量处理当前信息，flash不重新入队）,会进入死信队列
                // channel.basicNack(deliveryTag,false,true);
                // basicReject拒绝消息，消息的标识：参数1消息的标识，参数2是否重新入队，与上面Nack区别Reject单条处理。
                channel.basicReject(deliveryTag,false);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }
    }
}

参考代码：

/**

* 监听正常的那个队列的名字，不是监听那个死信队列

* 我们从正常的队列接收消息，但是对消息不进行确认，并且不对消息进行重新投递，此时消息就进入死信队列

* channel 消息信道（是连接下的一个消息信道，一个连接下有多个消息信息，发消息/接消息都是通过信道完成的）

@RabbitListener(queues = {RabbitConfig.QUEUE})

public void process(Message message, Channel channel) {

System.out.println("接收到的消息：" + message);

//对消息不确认, ack单词是确认的意思

// void basicNack(long deliveryTag, boolean multiple, boolean requeue)

// deliveryTag：消息的一个数字标签

// multiple：翻译成中文是多个的意思，如果是true表示对小于deliveryTag标签下的消息都进行Nack不确认，false表示只对当前deliveryTag标签的消息Nack

// requeue：如果是true表示消息被Nack后，重新发送到队列，如果是false，消息被Nack后，不会重新发送到队列

try {

System.out.println("deliveryTag = " + message.getMessageProperties().getDeliveryTag());

//要开启rabbitm消息消费的手动确认模式，然后才这么写代码；

channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);

} catch (IOException e) {

e.printStackTrace();

}

11. RabbitMQ延迟队列

场景：有一个订单，15分钟内如果不支付，就把该订单设置为交易关闭，那么就不能支付了，这类实现延迟任务的场景就可以采用延迟队列来实现，当然除了延迟队列来实现，也可以有一些其他办法实现；

11.1 定时任务方式

每隔3秒扫描一次数据库，查询过期的订单然后进行处理；

优点：

简单，容易实现；

缺点：

　　1、存在延迟（延迟时间不准确），如果你每隔1分钟扫一次，那么就有可能延迟1分钟；

　　2、性能较差，每次扫描数据库，如果订单量很大

1、被动取消

当用户查询订单的时候，判断订单是否超时，超时了就取消（交易关闭）；

优点：

对服务器而言，压力小；

缺点：

1、用户不查询订单，将永远处于待支付状态，会对数据统计等功能造成影响；

2、用户打开订单页面，有可能比较慢，因为要处理大量订单，用户体验少稍差；

11.2 JDK延迟队列（单体应用，不能分布式下）

DelayedQueue

无界阻塞队列，该队列只有在延迟期满的时候才能从中获取元素

优点：

实现简单，任务延迟低；

缺点：

服务重启、宕机，数据丢失；

只适合单机版，不适合集群；

订单量大，可能内存不足而发生异常； oom：out of memory 内存溢出

11.3 采用消息中间件（rabbitmq）

1、RabbitMQ本身不支持延迟队列，可以使用TTL结合DLX的方式来实现消息的延迟投递，即把DLX跟某个队列绑定，到了指定时间，消息过期后，就会从DLX路由到这个队列，消费者可以从这个队列取走消息。

代码：正常延迟

//问题？如果先发送的消息，消息延迟时间长，会影响后面的延迟时间段的消息的消费；

//解决：不同延迟时间的消息要发到不同的队列上，同一个队列的消息，它的延迟时间应该一样

问题模拟：

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {
    @Value("${my.exchangeName}")
    private String exchangeName;
    @Value("${queueNormalName}")
    private String queueNormalName;
    @Value("${my.queueDlxName}")
    private String queueDlxName;

    // RabbitMq三部曲
    // 1.交换机（正常和死信）
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange(exchangeName).build();
    }
    // 2.队列
    @Bean
    public Queue normalQueue(){
        // 方法1 new Queue的方法
        /*Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-message-ttl",25000); // 消息过期时间25秒
        return new Queue(queueNormalName,true,false,false,arguments);
        */
        // 方法2 建造者模式
        return QueueBuilder
                .durable(queueNormalName)
                // .ttl(25000) // 队列的过期时间
                .deadLetterExchange(exchangeName) // 过期返回到死信交换机,相同的交换机
                .deadLetterRoutingKey("error") // 设置死信路由key,设置成交换机和死信队列绑定的key
                .build();
    }
    @Bean
    public Queue dlxQueue(){
        return QueueBuilder.durable(queueDlxName).build();
    }
    // 绑定交换机和队列
    @Bean
    public Binding bindingNormal(DirectExchange directExchange,Queue normalQueue){
        return BindingBuilder.bind(normalQueue).to(directExchange).with("order");
    }
    @Bean
    public Binding bindingDlx(DirectExchange directExchange,Queue dlxQueue){
        return BindingBuilder.bind(dlxQueue).to(directExchange).with("error");
    }
}

service.MessageService,发送消息

package com.tongda.service;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendMsg(){
        {// 设置单条消息过期时间
            MessageProperties messageProperties = new MessageProperties();
            messageProperties.setExpiration("25000"); // 当前消息大于第二条消息时间
            Message message = MessageBuilder
                    .withBody("hello world 1".getBytes())
                    .andProperties(messageProperties)
                    .build();
            rabbitTemplate.convertAndSend("exchange.delay.2", "error", message);
            log.info("消息发送完毕，发送时间：{}", new Date());
        }
        {// 设置单条消息过期时间
            MessageProperties messageProperties = new MessageProperties();
            messageProperties.setExpiration("15000"); // 第二条消息时间
            Message message = MessageBuilder
                    .withBody("hello world 2".getBytes())
                    .andProperties(messageProperties)
                    .build();
            rabbitTemplate.convertAndSend("exchange.delay.2", "error", message);
            log.info("消息发送完毕，发送时间：{}", new Date());
        }
    }
}

延迟队列一定要接收死信队列的消息,message.ReceiveMessage模拟接收者：注意接收死信队列里的消息,

package com.tongda.message;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;


@Component
@Slf4j
public class ReceiveMessage {
    // 监听：自发自接
    /**
     * 延迟队列一定要接收死信队列的消息
     * @date 2024/1/11 15:19
     **/
    @RabbitListener(queues = "queue.dlay.dlx.2")
    public void receiveMsg(Message message){
        // 消息以字节数组放入消息体中
        String body = new String((message.getBody()));
        log.info("接收到的消息为：{},接收时间为：{}",body,new Date());
    }



}

yml

server:
  port: 8080

spring:
  application:
    name: delay-learn3
  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: admin
    password: 123456
    virtual-host: powernode

my:
  exchangeName: exchange.delay.3 # 交换机（正常交换机、死信交换机）
  queueOrderName: queue.delay.normal.order.3 # 正常订单队列
  queuePayName: queue.delay.normal.pay.3 # 正常支付队列
  queueDlxName: queue.delay.dlx.3 # 死信队列

RabbitConfig

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;


@Configuration
public class RabbitConfig {

    @Value("${my.exchangeName}")
    private String exchangeName;
    @Value("${my.queueOrderName}")
    private String queueOrderName;
    @Value("${my.queuePayName}")
    private String queuePayName;
    @Value("${my.queueDlxName}")
    // @Value("queue.delay.dlx.3")
    private String queueDlxName;

    // RabbitMq三部曲
    // 1.交换机（正常交换机和死信交换机）
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange(exchangeName).build();
    }
    // 2.消息队列: 正常和死信队列
    @Bean
    public Queue orderQueue() {
        // 方法1 new Queue的方法
        /*Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-message-ttl",25000); // 消息过期时间25秒
        return new Queue(queueNormalName,true,false,false,arguments);
        */
        // 方法2 建造者模式
        return QueueBuilder
                .durable(queueOrderName)
                // .ttl(25000) // 队列的过期时间
                .deadLetterExchange(exchangeName) // 过期返回到死信交换机,相同的交换机
                .deadLetterRoutingKey("error") // 设置死信路由key,设置成交换机和死信队列绑定的key
                .build();
    }
    @Bean
    public Queue payQueue(){
        return QueueBuilder
                .durable(queuePayName)
                // .ttl(15000)
                .deadLetterExchange(exchangeName)
                .deadLetterRoutingKey("error")
                .build();
    }
    @Bean
    public Queue dlxQueue(){
        return QueueBuilder.durable(queueDlxName).build();
    }

    // 绑定交换机和队列
    @Bean
    public Binding orderNormalBinding(DirectExchange directExchange,Queue orderQueue){
        return BindingBuilder.bind(orderQueue).to(directExchange).with("order");
    }
    @Bean
    public Binding payNormalBinding(DirectExchange directExchange, Queue payQueue){
        return BindingBuilder.bind(payQueue).to(directExchange).with("pay");
    }
    @Bean
    public Binding dlxBinding(DirectExchange directExchange,Queue dlxQueue){
        return BindingBuilder.bind(dlxQueue).to(directExchange).with("error");
    }
}

MessageService

package com.tongda.service;


import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendMsg() {
        {
            MessageProperties messageProperties = new MessageProperties();
            messageProperties.setExpiration("25000"); //第一条消息
            Message message = MessageBuilder.withBody("hello world 1".getBytes())
                    .andProperties(messageProperties)
                    .build();
            rabbitTemplate.convertAndSend("exchange.delay.3", "order", message);
            log.info("消息发送完毕，发送时间为：{}", new Date());
        }
        {
            MessageProperties messageProperties = new MessageProperties();
            messageProperties.setExpiration("15000"); //第二条消息
            Message message = MessageBuilder.withBody("hello world 2".getBytes())
                    .andProperties(messageProperties)
                    .build();
            rabbitTemplate.convertAndSend("exchange.delay.3", "pay", message);
            log.info("消息发送完毕，发送时间为：{}", new Date());
        }
    }
}

ReceiveMessage

package com.tongda.message;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class ReceiveMessage {
   
    /**
     * 延迟队列一定要接收死信队列的消息
     */
    @RabbitListener(queues = "queue.delay.dlx.3")
    public void receiveMsg(Message message){
        String body=new String(message.getBody());
        log.info("接收到的消息为：{},接收时间为：{}",body,new Date());
    }
}

启动测试

package com.tongda;

import com.tongda.service.MessageService;
import jakarta.annotation.Resource;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Rabbit07Delay3ResolveApplication implements ApplicationRunner {

    @Resource
    private MessageService messageService;

    public static void main(String[] args) {
        SpringApplication.run(Rabbit07Delay3ResolveApplication.class, args);
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}

代码延迟问题

11.4 使用rabbitmq-delayed-message-exchange 延迟插件

11.4.1 下载

选择对应的版本下载 rabbitmq-delayed-message-exchange 插件，下载地址：http://www.rabbitmq.com/community-plugins.html

11.4.2 解压

unzip rabbitmq_delayed_message_exchange-3.10.2.ez

如果unzip 没有安装，先安装一下

yum install unzip -y

11.4.3 启用插件

./rabbitmq-plugins enable rabbitmq_delayed_message_exchange 开启插件；

11.4.4查询安装情况

./rabbitmq-plugins list 查询安装的所有插件；

重启rabbitmq使其生效；（此处也可以不重启）

看原理

消息发送后不会直接投递到队列，

而是存储到 Mnesia（嵌入式数据库），检查 x-delay 时间（消息头部）；

延迟插件在 RabbitMQ 3.5.7 及以上的版本才支持，依赖 Erlang/OPT 18.0 及以上运行环境；

Mnesia 是一个小型数据库，不适合于大量延迟消息的实现

解决了消息过期时间不一致出现的问题。

参考代码：

@Component
@Slf4j
public class RabbitConfig {
    public static final String EXCHANGE = "exchange:plugin";
    public static final String QUEUE = "queue.plugin";
    public static final String KEY = "plugin";
    
    @Bean
    public CustomExchange customExchange() {
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", "direct");
        // CustomExchange(String name, String type, boolean durable, boolean autoDelete, Map<String, Object> arguments)
        return new CustomExchange(EXCHANGE, "x-delayed-message", true, false, arguments);
    }

    @Bean
    public Queue queue() {
        return QueueBuilder.durable(QUEUE).build();
    }

    @Bean
    public Binding binding(CustomExchange customExchange, Queue queue) {
        return BindingBuilder.bind(queue).to(customExchange).with(KEY).noargs();
    }
}

发消息参考代码

MessageProperties messageProperties=new MessageProperties();
messageProperties.setHeader("x-delay",16000);
String msg = "hello world";
Message message=new Message(msg.getBytes(),messageProperties);
rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE, "plugin", message);
log.info("发送完毕，发送时间为：{}",new Date());

完整项目代码

yml

server:
  port: 8080

spring:
  application:
    name: delay-learn4 # 消息延迟

  rabbitmq:
    host: 192.168.0.67
    port: 5672
    username: admin
    password: 123456
    virtual-host: powernode
# 使用delay延迟插件，
my:
  exchangeName: exchange.delay.4 # 延迟交换机
  queueDelayName: queue.delay.4 # 延迟队列

config.RabbitConfig

package com.tongda.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.lang.model.element.NestingKind;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitConfig {

    @Value("${my.exchangeName}")
    private String exchangeName;
    @Value("${my.queueDelayName}")
    private String queueDelayName;

    /**
     * 创建自定义交换机
     * @return
     */
    @Bean
    public CustomExchange customExchange() {
        Map<String, Object> arguments =new HashMap<>();
        arguments.put("x-delayed-type","direct"); //放一个参数
//        CustomExchange(String name, String type, boolean durable, boolean autoDelete, Map<String, Object> arguments)
        return  new CustomExchange(exchangeName,"x-delayed-message",true,false,arguments);

    }

    @Bean
    public Queue queue() {
        //方式2 建造者
        return QueueBuilder
                .durable(queueDelayName) //队列名称
                .build();
    }

    @Bean
    public Binding binding(CustomExchange customExchange, Queue queue) {
        //绑定，也指定路由key，加noargs 方法
        return BindingBuilder.bind(queue).to(customExchange).with("plugin").noargs();
    }
}

service.MessageService

package com.tongda.service;

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void senMsg(){
        {
            MessageProperties messageProperties = new MessageProperties();
            // 第一条消息，延迟时间
            messageProperties.setHeader("x-delay",25000); // 第一条消息，延迟时间
            // messageProperties.setExpiration("25000"); // 不要用这个
            Message message = MessageBuilder.withBody("hello world 1".getBytes())
                    .andProperties(messageProperties)
                    .build();
            rabbitTemplate.convertAndSend("exchange.delay.4", "plugin", message);
            log.info("消息发送完毕，发送时间为：{}", new Date());
        }
        {
            MessageProperties messageProperties = new MessageProperties();
            // 第一条消息，延迟时间
            messageProperties.setHeader("x-delay",15000); // 第一条消息，延迟时间
            // messageProperties.setExpiration("15000"); // 不要用这个
            Message message = MessageBuilder.withBody("hello world 2".getBytes())
                    .andProperties(messageProperties)
                    .build();
            rabbitTemplate.convertAndSend("exchange.delay.4", "plugin", message);
            log.info("消息发送完毕，发送时间为：{}", new Date());
        }
    }

}

message.ReceiveMessage

package com.tongda.message;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class ReceiveMessage {
    /**
     * 延迟队列的消息,延迟队列使用的是延迟交换机
     * @param
     * @return {@link null}
     * @date 2024/1/12 15:37
     **/
    @RabbitListener(queues = "queue.delay.4")
    public void receiveMsg(Message message){
        String body = new String(message.getBody());
        log.info("接收到的消息为：{}，接收时间为：{}",body,new Date());
    }
}

application

package com.tongda;

import com.tongda.service.MessageService;
import jakarta.annotation.Resource;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Rabbit07Delay4Application implements ApplicationRunner {

    @Resource
    private MessageService messageService;

    public static void main(String[] args) {
        SpringApplication.run(Rabbit07Delay4Application.class, args);
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.senMsg();
    }
}