RabbitMQ的四种交换器以及死信队列介绍

已于 2024-08-08 15:13:25 修改
阅读量990 收藏 23
点赞数 28
文章标签： rabbitmq 分布式 java spring
于 2024-08-07 18:37:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73402102/article/details/140991010
版权

前言

RabbitMQ作为一款用途非常广泛的消息队列，可以做到解耦，异步调用，以及流量削峰等非常强大的功能（上一篇博客有详细介绍
四种MQ的介绍与区别
）。接下来详细介绍RabbitMQ的具体代码实现~

一，RabbitMQ概述

RabbitMQ是一个使用Erlang语言开发的（即安装RabbitMQ之前，必须先安装Erlang，一键式傻瓜安装），实现AMQP (高级消息队列协议)的开源消息中间件。它可以实现异步消息处理，是一款消息代理，它接受和转发消息。

RabbitMQ有以下特点：

  • 可靠性。支持持久化，传输确认，发布确认等保证了MQ的可靠性。
  • 灵活的分发消息策略。在消息进入MQ前由Exchange (交换机)进行路由消息。分发消息策略有：简单模式、工作队列模式、发布订阅模式、路由模式、通配符模式。
  • 支持集群。多台RabbitMQ服务器可以组成一个集群，形成一个逻辑Broker。
  • 多种协议。RabbitMQ支持多种消息队列协议，比如 STOMP、MQTT 等等。
  • 支持多种语言客户端。RabbitMQ几乎支持所有常用编程语言，包括 Java、.NET、Ruby 等等。

二，基础代码实现

2.1 添加依赖以及配置相关信息

首先添加依赖，如下

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

这里使用了自动配置版本，若指定version，需要和springboot版本保持一致。
然后在yaml文件配置RabbitMQ的相关ip以及端口

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest

这里使用了自动配置版本，若指定version，需要和springboot版本保持一致

2.2 创建队列相关配置

@Configuration
public class RabbitMQConfig {
    /**
     * 创建队列*/
    @Bean
    public Queue createQ1(){
        return new Queue("queue01");
    }
}

2.3 创建监听器相关配置

@Component
@RabbitListener(queues = "queue01")       //queues指定监听的队列名称，即要消费哪一个队列的消息
public class MqListener {
    @RabbitHandler
    public void handler(String msg){        //处理消息
        System.err.println("监听器消费消息："+msg+"--->"+ LocalTime.now());
    }
}

2.4 发送消息

这里我们创建一个接口，来向队列发送消息，看看能不能被监听器消费掉

@RestController

public class Controller {
    @Resource
    private RabbitTemplate template;

    @GetMapping("/api/mq/test1")
    public String sendMsg(String msg){
        System.out.println("发送消息："+msg+"--->"+ LocalTime.now());
        template.convertAndSend("","queue01",msg);
        return "OK";
    }
}

在这里插入图片描述
上述便是最基础的消息队列（点对点），一个队列，一个生产者，一个消费者。
总

三，Work消息（一个队列，多个消费者）

如果同时有多个监听器监听同一个队列呢？下面再添加一个监听器

@Component
@RabbitListener(queues = "queue01")
public class MqListener01 {
    @RabbitHandler
    public void handler(String msg){
        System.err.println("（MqListener01）监听器消费消息："+msg+"--->"+ LocalTime.now());
    }
}

接下来我们多次向队列发送消息
修改一下发送消息接口：

@RestController

public class Controller {
    @Resource
    private RabbitTemplate template;

    @GetMapping("/api/mq/test1")
    public String sendMsg(String msg){
        for(int i=1; i<11; i++){
            System.out.println("第"+i+"次发送消息："+msg+"--->"+ LocalTime.now());
            template.convertAndSend("","queue01","第"+i+"个消息"+msg);
        }
        return "OK";
    }
}

控制台输出如下：
在这里插入图片描述因此，我们可以总结以下：
当有多个监听器监听同一个消息队列，监听器会相互竞争处理消息。

四，Exchange消息(核心)

RabbitMQ基于Exchange实现消息的一对多，一个消息可以被消费多次

Exchange有4种类型：

1.fanout 直接转发，不对消息做过滤

2.direct 路由关键字过滤，只支持精确值，可以对消息进行过滤匹配

3.topic 路由关键字过滤，支持模糊值， *:1个单词 #:0或多个单词

4.header 消息头过滤，对消息的请求消息头进行匹配过滤，any（类似 or）:任意1个 all:全部（类似 and）

4.1 fanout 交换器

首先，创建两个消息队列，以及一个交换器，两个消息队列分别与交换器绑定

public class RabbitMQConfig01 {
    /**
     * 创建交换器*/
    @Bean
    public FanoutExchange createFe(){
        return new FanoutExchange("fanout");
    }
    /**
     * 创建队列*/
    @Bean
    public Queue createQ2(){
        return new Queue("queue02");
    }
    @Bean
    public Queue createQ3(){
        return new Queue("queue03");
    }
    /**
     * 创建绑定关系*/
    @Bean
    public Binding createBq2(FanoutExchange fe){
        return BindingBuilder.bind(createQ2()).to(fe);
    }
    @Bean
    public Binding createBq3(FanoutExchange fe){
        return BindingBuilder.bind(createQ3()).to(fe);
    }
}

接下来我们创建两个监听器，分别监听queue02和queue03这两个消息队列

@Component
@RabbitListener(queues = "queue02")
public class MqListener02 {
    @RabbitHandler
    public void handler(String msg){
        System.err.println("（MqListener02）监听器消费消息："+msg+"--->"+ LocalTime.now());
    }
    @Component
    @RabbitListener(queues = "queue03")
    class MqListener03 {
        @RabbitHandler
        public void handler(String msg) {
            System.err.println("（MqListener03）监听器消费消息：" + msg + "--->" + LocalTime.now());
        }
    }
}

现在，创建一个接口，来向交换器发送信息

@GetMapping("/api/mq/test2")
public String sendMsg02(String msg) {
    System.out.println("向交换器发送消息");
    template.convertAndSend("fanout", "", msg);
    return "OK";
}

结果如下
在这里插入图片描述可以得到以下结论：
向交换器发送消息，该交换器绑定的所有队列都会收到消息。即一条消息被多个消费者多次消费

4.2 direct 交换器

direct 交换器可以对指定的固定字符进行过滤
首先创建direct交换器，并且绑定队列
@Configuration
public class RabbitMQConfig02 {
    /**
     * 创建交换器*/
    @Bean
    public DirectExchange createDe(){
        return new DirectExchange("direct");
    }
    /**
     * 创建队列*/
    @Bean
    public Queue createQ4(){
        return new Queue("queue04");
    }
    @Bean
    public Queue createQ5(){
        return new Queue("queue05");
    }
    /**
     * 创建绑定关系*/
    @Bean
    public Binding createBq4(DirectExchange de){
        return BindingBuilder.bind(createQ4()).to(de).with("info");    //创建绑定关系，并且声明固定字符
    }
    @Bean
    public Binding createBq5(DirectExchange de){
        return BindingBuilder.bind(createQ5()).to(de).with("error");
    }
}

创建监听器
@Component
@RabbitListener(queues = "queue04")
public class MqListener04 {
    @RabbitHandler
    public void handler(String msg){
        System.err.println("（MqListener04_info）监听器消费消息："+msg+"--->"+ LocalTime.now());
    }
    @Component
    @RabbitListener(queues = "queue05")
    class MqListener05 {
        @RabbitHandler
        public void handler(String msg) {
            System.err.println("（MqListener05_error）监听器消费消息：" + msg + "--->" + LocalTime.now());
        }
    }
}

创建接口，向交换器发送消息

  @GetMapping("/api/mq/test3")
    public String sendMsg03(String msg,String key) {
        System.out.println("向交换器发送消息");
        template.convertAndSend("direct", key, msg);    //且指定key，对应交换器的过滤字符
        return "OK";
    }

结果如下
在这里插入图片描述可以看到，我们向direct交换器发送消息时，指定了key，即该消息只会被转发到指定了相同key的消息队列上

4.3 topic 交换器

首先，创建topic交换器，且绑定队列

@Configuration
public class RabbitMQConfig03 {
    /**
     * 创建交换器*/
    @Bean
    public TopicExchange createTe(){
        return new TopicExchange("topic");
    }
    /**
     * 创建队列*/
    @Bean
    public Queue createQ6(){
        return new Queue("queue06");
    }
    @Bean
    public Queue createQ7(){
        return new Queue("queue07");
    }
    /**
     * 创建绑定关系*/
    @Bean
    public Binding createBq6(TopicExchange te){
        return BindingBuilder.bind(createQ6()).to(te).with("*"); //*表示一个单词
    }
    @Bean
    public Binding createBq7(TopicExchange te){
        return BindingBuilder.bind(createQ7()).to(te).with("#");// #表示任意个单词
    }
}

创建监听器监听队列
@Component
@RabbitListener(queues = "queue06")
public class MqListener06 {
    @RabbitHandler
    public void handler(String msg){
        System.err.println("（MqListener06_*）监听器消费消息："+msg+"--->"+ LocalTime.now());
    }
    @Component
    @RabbitListener(queues = "queue07")
    class MqListener07 {
        @RabbitHandler
        public void handler(String msg) {
            System.err.println("（MqListener07_#）监听器消费消息：" + msg + "--->" + LocalTime.now());
        }
    }
}

创建接口，向交换器发送消息

  @GetMapping("/api/mq/test4")
    public String sendMsg04(String msg,String key) {
        System.out.println("向交换器发送消息");
        template.convertAndSend("topic", key, msg);
        return "OK";
    }

结果如下
在这里插入图片描述
可以看到，我们指定发送的key为“skr”，两个队列的绑定关系都成立
接下来，我们换一下,key為“skr.skr”
在这里插入图片描述
可以看到成功发送消息到过滤字符为‘#’的队列，应为“skr.skr”相当于两个单词（.为分隔符）

4.4 header 交换器

创建header交换器

@Configuration
public class RabbitMQConfig04 {
    /**
     * 创建交换器*/
    @Bean
    public HeadersExchange createHe(){
        return new HeadersExchange("header");
    }
    /**
     * 创建队列*/
    @Bean
    public Queue createQ8(){
        return new Queue("queue08");
    }
    @Bean
    public Queue createQ9(){
        return new Queue("queue09");
    }
    /**
     * 创建绑定关系*/
    @Bean
    public Binding createBq8(HeadersExchange he){
        return BindingBuilder.bind(createQ8()).to(he).whereAny("id","author").exist();
        //any 任意1个即可
    }

    @Bean
    public Binding createBq9(HeadersExchange he){
        return BindingBuilder.bind(createQ9()).to(he).whereAll("id","author").exist();
        //all 同时满足
    }
}

创建监听器

@Component
@RabbitListener(queues = "queue08")
public class MqListener08 {
    @RabbitHandler
    public void handler(String msg){
        System.err.println("（MqListener08_any）监听器消费消息："+msg+"--->"+ LocalTime.now());
    }
    @Component
    @RabbitListener(queues = "queue09")
    class MqListener09 {
        @RabbitHandler
        public void handler(String msg) {
            System.err.println("（MqListener09_all）监听器消费消息：" + msg + "--->" + LocalTime.now());
        }
    }
}

创建接口发送消息

@GetMapping("/api/mq/test5")
public String sendMsg(String msg){
    MessagePostProcessor postProcessor=new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            message.getMessageProperties().setHeader("id","121");   //指定消息头
            return message;
        }
    };
    template.convertAndSend("header","",msg,postProcessor);
    return "OK";
}

结果如下
在这里插入图片描述即绑定any的队列收到了消息，因为我们只指定了id这一个消息头

五，死信队列

当一个队列过期，长度超过指定值就会成为死信队列。随之这个消息会自动绑定一个交换器。
5.1 创建死信队列，正常队列和交换器绑定

@Configuration
public class RabbitMQConfigdead {
    //1.创建 死信交换器  专门转发死信消息
    @Bean("dead")
    public DirectExchange createDLX(){
        return new DirectExchange("deadex");
    }
    //2.创建队列
    //队列 生成死信 1.没有消费者 2.有效期 3.设置死信和死信匹配关键字
    @Bean
    public Queue createQ10() {
        Map<String, Object> param = new HashMap<>();
        //设置死信交换器
        param.put("x-dead-letter-exchange", "deadex");
        //设置死信交换器 匹配的路由
        param.put("x-dead-letter-routing-key", "test1");
        //设置队列中消息的有效期 8秒
        param.put("x-message-ttl", 8000);   

        return QueueBuilder.durable("queue10").withArguments(param).build();
    }

    @Bean
    public Queue createQ11(){
        return new Queue("queue11");
    }
    //3.绑定
    @Bean
    public Binding createBd8(@Qualifier("dead") DirectExchange dead){
        return BindingBuilder.bind(createQ11()).to(dead).with("test1");
    }
}

这里queue10消息队列，在8s后会过期，成为死信队列

然后创建监听器，监听queue11这个正常队列的消息

@Component
@RabbitListener(queues = "queue11")
public class MqListenerDead {
    @RabbitHandler
    public void handler(String msg){
        System.err.println("（MqListenerDead）监听器消费消息："+msg+"--->"+ LocalTime.now());
    }
}

然后创建接口，向queue这个死信队列发送消息

  @GetMapping("/api/mq/test6")
    public String sendMsg06(String msg) {
        System.out.println("向8s后会成为死信队列的队列发送消息--->"+LocalTime.now());
        template.convertAndSend("", "queue10", msg);
        return "OK";
    }

这里启动可能会报冲突，应为前面有一个注册bean同样注册了DirectExchange类型，我们加个注解，使之通过名称指定(正常启动请忽略)，
修改后的direct交换器配置类

@Configuration
public class RabbitMQConfig02 {
    /**
     * 创建交换器*/
    @Bean("direct")
    public DirectExchange createDe(){
        return new DirectExchange("direct");
    }
    /**
     * 创建队列*/
    @Bean
    public Queue createQ4(){
        return new Queue("queue04");
    }
    @Bean
    public Queue createQ5(){
        return new Queue("queue05");
    }
    /**
     * 创建绑定关系*/
    @Bean
    public Binding createBq4(@Qualifier("direct") DirectExchange de){
        return BindingBuilder.bind(createQ4()).to(de).with("info");
    }
    @Bean
    public Binding createBq5(@Qualifier("direct") DirectExchange de){
        return BindingBuilder.bind(createQ5()).to(de).with("error");
    }
}

在这里插入图片描述可以看到，监听queue11的监听器收到了消息，也就是说我们发送到queue10的消息被交换器转发了。

当然，如果有监听器监听queue10，是之在过期之前被消费掉，他也就不会成为死信队列被转发到queue11.

CodingHao
关注
rabbitmq死信队列详解与使用
congge
08-28 14万+
什么是死信队列 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列； 以上是个人的通俗解释，专业术语解释的比...
rabbitmq延时队列和四种交换机模式下队列的简单实现
08-06
rabbitmq延时队列和四种交换机模式下队列的简单实现，需要自己配置一下属性文件。
RabbitMQ的交换机与队列
m0_74356429的博客
04-07 1464
首先先介绍一个简单的一个消息推送到接收的流程，提供一个简单的图黄色的圈圈就是我们的消息推送服务，将消息推送到 中间方框里面也就是 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终右边的蓝色圈圈消费者获取对应监听的消息。
RabbitMQ交换机与队列
Anolzo
01-23 1821
当这样做的时候，我们需要明白一点，在AMQP 0-9-1中，消息的负载均衡是发生在消费者（consumer）之间的，而不是队列（queue）之间。延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。（7）x-dead-letter-routing-key：死信消息路由键，在消息发送到死信交换器时会使用该路由键，如果不设置，则使用消息的原来的路由键值。
RabbitMQ 核心概念(交换机、队列、路由键)，队列类型等介绍
日常记录
12-29 4043
RabbitMQ 是一个开源的消息代理（Message Broker），用于在应用程序之间传递消息。它实现了高级消息队列协议（AMQP），提供了可靠的消息传递和消息路由机制，以支持分布式系统的开发。AMQP：AMQP（Advanced Message Queuing Protocol）是一种协议，用于定义消息传递的规范。RabbitMQ是AMQP协议的一个流行实现之一，它允许不同的应用程序之间通过消息进行通信。生产者：生产者是消息的发送方。它们创建消息并将其发布到 RabbitMQ 的交换机上。
MQ中的交换机与队列
最新发布
0
04-09 958
首先先介绍一个简单的一个消息推送到接收的流程，提供一个简单的图黄色的圈圈就是我们的消息推送服务，将消息推送到 中间方框里面也就是 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终右边的蓝色圈圈消费者获取对应监听的消息。
RabbitMQ死信队列应用1
08-03
RabbitMQ死信队列（Dead Letter Exchange, DLX）是一种高级特性，用于处理那些无法正常处理或过期的消息。当消息在业务队列中处理失败，如因异常导致重试次数达到上限，就会变为死信。DLX允许将这些死信重新发布到另...
Rabbitmq的死信队列和延时队列
fxbar的博客
02-26 810
Rabbitmq的死信队列和延时队列 一、死信队列 死信队列其实和普通的队列没啥大的区别，都需要创建自己的Queue、Exchange,然后通过RoutingKey绑定到Exchange上去，只不过死信队列的RoutingKey和Exchange要作为参数，绑定到正常的队列上去，一种应用场景是正常队列里面的消息被basicNack或者reject时，消息就会被路由到正常队列绑定的死信队列中，还有一种还有常用的场景就是开启了自动签收，然后消费者消费消息时出现异常，超过了重试次数，那么这条消息也会进入死信队列，
Spring Boot整合RabbitMQ——死信队列
灵波微布
02-04 933
文章目录
rabbitmq-死信交换机和死信队列
02-07 1278
如果使用消息拒绝机制，同时 requeue 参数设置为 false时，消息丢失了，这点作为程序员我们不能忍。所以 RabbitMQ作为一个高级消息中间件，提出了死信交换器的概念，死信，意思就是死了的信息。这种交换器专门处理死了的信息（被拒绝可以重新投递的信息不能算死的）。 死信交换器是 RabbitMQ 对 AMQP 规范的一个扩展，往往用在对问题消息的诊断上（主要针对消费者），还有延时队列的功能。 消息变成死信一般是以下三种情况： 消息被拒绝，并且设置 requeue 参数为 false 消息过期
Rabbitmq---队列和交换机
YeahToYeah的博客
07-16 2302
队列 ​ Queue：队列，是Rabbitmq的内部对象，用于存储消息。 ​ 多个消费者可以订阅同一个队列，这时队列中的消息会被平均分摊（Round-Robin，即轮询） Queue中的消息会被Consumer1和Consumer2轮番消费。 交换机 交换机：即生产者把消息发送到队列的桥梁。 交换机常用的交换机类型有fanout、direct、topic、headers四种。 fanout：会把所有发送到交换机信息都路由到与该交换机绑定的队列中。 direct：会根据消息的RoutingKey，完
RabbitMQ之Exchange、Queue参数详解
热门推荐
dh554112075的博客
05-13 1万+
1.先来介绍RabbitMQ中的成员 Producer(生产者)： 将消息发送到Exchange Exchange(交换器)：将从生产者接收到的消息路由到Queue Queue(队列)：存放供消费者消费的消息 BindingKey(绑定键)：建立Exchange与Queue之间的关系（个人看作是一种规则，也就是Exchange将什么样的消息路由到Queue） RoutingKey(路由键)：Pr...
RabbitMQ--交换器类型/队列模式--使用/教程/详解
IT利刃出鞘的博客
11-16 5100
本文介绍RabbitMQ的交换器类型和队列模式。 本内容也是Java后端面试常见的问题。
RabbitMQ队列及交换机的使用
qi341500的博客
10-21 3533
一、简单模型 1、首先控制台创建一个队列 2、父工程导入依赖 3、生产者配置文件 4、写测试类 5、消费者配置文件 6、消费者接收消息 二、WorkQueues模型 1、在控制台创建一个新的队列 2、生产者生产消息 3、创建两个消费者接收消息 4、能者多劳充分利用每一个消费者的能力 三、交换机 四、Fanout交换机 1、 声明队列 2、创建交换机 ​编辑3、绑定交换机 4、示例 五、Diect交换机 1、 声明队列 2、创建交换机 3、绑定交换机
RabbitMQ——交换机、死信队列
Yellow_Star的博客
01-19 1673
交换机 概念 RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产 者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这些由交换机的类型来决定。 交换机的类型 直接（direct） 主题（topic） 标题（heade
RabbitMQ交换器
寻常的博客
02-11 792
RabbitMQ交换器类型有fanout、direct、topic、headers fanout 它会把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中。 direct 类型的交换器路由规则也很简单，它会把消息路由到那些 BindingKey和RoutingKey完全匹配的队列中。 topic direct 类型的交换器路由规则是完全匹配 BindingKey和RoutingKey ,但是这种严格的匹配方式在很多情况下不能满足实际业务的需求. topic 类型的交换器在匹配规则上进行了扩展，.
RabbitMQ之交换机
m0_53151031的博客
02-27 1万+
一、RabbitMQ交换机 二、RabbitMQ交换机实例讲解
RabbitMQ延迟消息问题(含Demo工程)
一切总会归于平淡
03-05 4777
延迟队列的使用场景包括： 1、延迟发送短信。 2、用户下单，如果用户在15 分钟内未支付，则自动取消。 3、预约工作会议，20分钟后自动通知所有参会人员。
rabbitmq实现ttl和死信队列
10-11
RabbitMQ可以通过设置消息的TTL（Time-To-Live）来控制消息的有效期，在消息过期后可以将其路由到死信交换器中，从而实现死信队列功能。 具体实现步骤如下： 1. 创建两个交换器：普通交换器和死信交换器。 2. 将普通交换器绑定到队列上，并设置消息的TTL属性。 3. 将死信交换器绑定到普通交换器上，并指定死信队列的名称。 4. 在消费者端，监听死信队列并处理过期的消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值