RabbitMQ快速入门 学习笔记

最新推荐文章于 2024-02-27 16:47:22 发布
最新推荐文章于 2024-02-27 16:47:22 发布
阅读量733 收藏 4
点赞数
分类专栏： Java学习 消息中间件 文章标签： java-rabbitmq rabbitmq 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40613029/article/details/129791923
版权

文章目录

RabbitMQ入门

一、概述

1.1 什么是MQ

MQ本质上是一个队列，FIFO先入先出原则。只不过队列中存放的内容是message而已。还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用MQ之后，消息发送上游只需要依赖MQ，不用依赖其他服务。

1.2 作用

1.2.1 流量消峰

假设订单系统最多能处理一万次订单，这个能力应付正常时段的流量戳戳有余。但是在高峰期，如果有两万次下单操作则系统是处理不了的，只能限制订单超过一万后不允许用户下单。使用消息队列做缓冲，我们就可以取消这个限制，将一秒内下的订单分散成一段时间来处理，这是有些用户可能在下单十几秒后才能收到下单成功的操作，但是比不能下单的体验更好。

1.2.2 应用解耦

电商系统为例，应用中有订单系统、库存系统、物流系统等。用户创建订单后，如果耦合调用库存系统、物流系统等，任何一个子系统出了故障，都会造成下单操作异常。当转变成基于消息队列的方式后，系统间调用的问题会减少很多。

1.2.3 异步处理

有些服务调用时异步的，假设A调用B，B需要花费很长时间执行，但是A需要知道B什么时候可以执行完，之前的方式是A过一段时间去调用B的查询API查询。或者A提供一个callback api，B执行完之后调用api通知A的服务。使用消息队列可以很方便解决这个问题。A调用B服务后，只需要监听B处理完成的消息，当B处理完成后，会发送一条消息给MQ，MQ会将此消息转发给A服务。

1.3 分类

  1. ActiveMQ
    1. 优点：单机吞吐量万级，时效性ms级，可用性高，基于主从架构实现高可用性，消息可靠性较低的概率丢失数据
    2. 缺点：官方社区维护越来越少，高吞吐量场景较少
  2. Kafka
    1. 优点：性能卓越，单机写入TPS约在百万条/秒，吞吐量高。时效性ms级可用性非常高，kafka是分布式的，一个数据多个副本，少数机器宕机，不会丢失数据，不会导致不可用，消费者采用Pull方式获取消息，消息有序，通过控制能够保证所有消息被消费且仅被消费一次。有优秀的第三方Kafka Web管理界面Kafka-Manager。在日志领域比较成熟，被多家公司和多个开源项目使用。
    2. 缺点：Kafka单机超过64个队列/分区，Load会发生明显的飙高现象，队列越多，load越高，发送消息响应时间边长，使用短轮询方式，实时性取决于轮询间隔时间，消费失败不支持重试。
  3. RocketMQ
    1. 出自阿里巴巴的开源产品，用Java语言实现，在设计时参考Kafka，并作了相应改进
    2. 优点：单机吞吐量十万级，可用性非常高，分布式架构，消息可以做到0丢失，MQ功能较为完善，扩展性好，支持10亿级别的消息堆积。
    3. 缺点：支持的客户端语言不多，目前只支持Java及C++，其中C++不成熟
  4. RabbitMQ
    1. 是一个在AMQP(高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最流行的消息中间件之一
    2. 优点：由于erlang语言的高并发特性，性能较好；吞吐量万集，MQ功能比较完备，支持多语言、健壮、稳定、易用、跨平台
    3. 缺点：商业版需要收费，学习成本较高

1.4 核心概念

  1. 生产者
    • 产生数据发送消息的程序
  2. 交换机
    • 交换机是RabbitMQ非常重要的一个组件，一方面负责接收来自生产的消息，另一方面它将消息推送给队列。交换机必须确切知道如何处理它接收到的消息，是将这些消息推送到特定队列还是推送到多个队列，亦或者是把消息丢弃。
  3. 队列
    • 队列是RabbitMQ内部使用的一种数据结构，尽管消息流经RabbitMQ和应用程序，但它们只能存储在队列中。队列仅受主机的内存和磁盘限制的约束，本质上是一个大的消息缓冲区。许多生产者可以将消息发送到一个队列中，许多消费者可以尝试从一个队列接收数据。
  4. 消费者
    • 消费者大多时候是一个等待接收消息的程序。请注意生产者、消费者和消息中间件很多时候并不在同一个机器上。同一个应用程序既可以是生产者也可以是消费者。

在这里插入图片描述

1.5 工作原理

在这里插入图片描述

  1. Broker：接收和分发消息的应用，RabbitMQ Server就是Message Broker
  2. Virtual host：出于多租户和安全因素的设计，把AMQP的基本组件划分到一个虚拟的分组中，类似于网络中的namespace的概念。
  3. Connection：publisher/consumer和Broker之间的TCP连接
  4. Channel：如果每一次访问RabbitMQ都建立一个Connection，在消息量大的时候建立TCP Connection的开销是巨大的，效率较低。Channel是在connection内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的channel进行通讯，AMQP method包含了channel id帮助客户端和message Broker识别channel，所以channel之间完全隔离
  5. Exchange：message到达Broker的第一站，根据分发规则，匹配查询表中的routing key，分发消息到queue中。常用的类型有：direct，topic and fanout

1.6 核心部分

二、快速入门

1. 简单模式

  1. 引入pom依赖

            <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.16.0</version>
        </dependency>

  2. 生产者

    public class Producer {

    private static final String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.40.128");
        factory.setUsername("admin");
        factory.setPassword("admin");
        Connection connection = factory.newConnection();
        System.out.println("开始发送消息......");
        //获取信道
        Channel channel = connection.createChannel();
        //创建队列
        //1. param1：队列名称
        //2. param2：是否持久化
        //3. param3：是否只供一个消费者消费，及消息共享
        //4. param4：是否自动删除 最后一个消费者断开连接后，该队列是否自动删除
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        // 1. param1：发送到哪个交换机
        // 2. param2：路由的Key值
        // 3. param3：其他参数信息
        // 4. param4：发送消息的消息体
        channel.basicPublish("", QUEUE_NAME, null, "hello world".getBytes());
        System.out.println("发送消息结束......");
    }
}

  3. 消费者

    public class Consumer {
    private static final String QUEUE_NAME="hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.40.128");
        factory.setUsername("admin");
        factory.setPassword("admin");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //声明 接收消息
        DeliverCallback deliverCallback=(consumerTag,message)->{
            System.out.println(new String(message.getBody()));
        };

        //取消消息时的回调
        CancelCallback cancelCallback=consumerTag->{
            System.out.println("消费消息被中断");
        };
        //消费者消费消息
        //1. param1：消费哪个队列
        //2. param2：消费成功之后是否自动应答
        //3. param3：消费者接收消息的回调
        //4. param4：消费者取消消息时的回调
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

2. 工作队列

工作队列主要思想是避免立即执行资源密集型任务，而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。

3. 消息应答机制

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务仅只完成了部分就宕机了，RabbitMQ一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续发送给该消费者的消息，因为它无法接收到。

为了保证消息不丢失，RabbitMQ引入了消息应答机制，消息应答：消费者在接收到消息并且处理该消息之后，告诉RabbitMQ它已经处理了，RabbitMQ可以把该消息删除了。

  1. 自动应答：消息发送后立即被认为已经发送成功，这种模式需要在高吞吐量和数据传输安全性方面做权衡，因为这种模式如果消息在接收到之前，消费者那边出现连接或者channel关闭，那么消息就丢失了，当然另一方面这种模式消费者那边可以传递过载消息，没有传递的消息数量进行限制，当然这样有可能使得消费者这边由于接收太多还来不及处理的消息，导致这些消息的积压，最终使得内存耗尽，最终这些消费者线程被操作系统杀死，所以这种模式仅适用在消费者可以高效并以某种速率能够处理这些消息的情况下使用。
  2. 手动应答的方法
    1. Channel.basicAck(用于肯定确认)：已知道该消息并且成功的处理消息，可以将其丢弃了
    2. Channel.basicNack(用于否定确认)
    3. Channel.basicReject(用于否定确认)
  3. 批量应答：Multiple：手动应答的好处是可以批量应答并且减少网络拥堵
3.1 消息自动重新入队

如果消费者由于某些原因失去连接（其通道已关闭，连接已关闭或TCP连接丢失），导致消息未发送ACK确认，RabbitMQ将了解到消息未完全处理，并将对其重新排队。如果此时其他消费者可以处理，它将很快将其重新分发给另一个消费者。这样，即使某个消费者偶尔死亡，也可以确保不会丢失任何消息。

3.2 手动应答
public class ConsumerWorker01 {

    private static final String QUEUE_NAME = "queue_ack";

    public static void main(String[] args) throws IOException {
        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("C1等待接收消息，处理时间为2s");
        DeliverCallback deliverCallback = (tag, mess) -> {
            try {
                //模拟该消息需要处理2s
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("接收到的消息：" + new String(mess.getBody(), StandardCharsets.UTF_8));
            //手动应答
            //1. param1：消息标记tag
            //2. param2：是否批量应答
            channel.basicAck(mess.getEnvelope().getDeliveryTag(), false);
        };

        CancelCallback cancelCallback = tag -> {
            System.out.println(tag + "接收消息被取消！");
        };
        // 采用手动应答
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, cancelCallback);
    }
}

public class ConsumerWorker02 {

    private static final String QUEUE_NAME = "queue_ack";

    public static void main(String[] args) throws IOException {
        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("C2等待接收消息，处理时间为10s");
        DeliverCallback deliverCallback = (tag, mess) -> {
            try {
                //模拟该消息需要处理10s
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("接收到的消息：" + new String(mess.getBody(), StandardCharsets.UTF_8));
            //手动应答
            //1. param1：消息标记tag
            //2. param2：是否批量应答
            channel.basicAck(mess.getEnvelope().getDeliveryTag(), false);
        };

        CancelCallback cancelCallback = tag -> {
            System.out.println(tag + "接收消息被取消！");
        };
        // 采用手动应答
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, cancelCallback);
    }
}

4. 持久化

4.1 概述

默认情况下RabbitMQ退出或由于某种原因崩溃时，它忽略队列和消息，除非告知它不要这样做。确保消息不会丢失需要做两件事：我们需要将队列和消息都标记为持久化

//队列持久化
Channel channel = RabbitMqUtils.getChannel();
//创建队列
//参数列表：durable：是否持久化
//queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
channel.queueDeclare(QUEUE_NAME, true, false, false, null);

//消息持久化
//参数列表：props：队列的属性
basicPublish(String exchange, String routingKey, AMQP.BasicProperties props, byte[] body)
//发送消息
channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes(StandardCharsets.UTF_8));
4.2 不公平分发

采用轮询分发时，如果多个消费者的响应速率有差异，例如某些消费者的响应速率比较快，此时采用该方式则不是很友好。为了避免这种情况，可以设置参数

channel.basicQos(1)
4.3 预期值

channel.basicQos(prefetch)

5. 发布确认原理

  1. 设置队列持久化

  2. 设置消息持久化

  3. 发布确认

    1. 开启发布确认方法
    //调用该方法
channel.confirmSelect();
5.1 单个确认发布

单个确认发布是一种简单的确认方式，它是一种同步确认发布的方式，也就是发布一个消息之后只有它被确认发布，后续的消息才能继续发布。缺点是发布速度特别慢

public class ProducerWorker {
    private static final String QUEUE_NAME = "queue_ack";

    public static void main(String[] args) throws IOException, InterruptedException {
        Channel channel = RabbitMqUtils.getChannel();
        //开启发布确认
        channel.confirmSelect();
        //创建队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 1000; i++) {
            String mess = i + "";
            channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, mess.getBytes(StandardCharsets.UTF_8));
            //发布确认
            boolean b = channel.waitForConfirms();
            if (b) {
                System.out.println("生产者发送消息成功：" + mess);
            }
        }
    }
}
5.2 批量确认发布

与单个确认相比，批量确认的问题是：当发生故障时我们不知道是哪条消息出现了问题，我们必须将整个批处理保存在内存中，以记录重要的消息而后重新发布消息。

public class ProducerWorker {
    private static final String QUEUE_NAME = "queue_ack";

    public static void main(String[] args) throws IOException, InterruptedException {
        Channel channel = RabbitMqUtils.getChannel();
        //开启发布确认
        channel.confirmSelect();
        //创建队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 1000; i++) {
            String mess = i + "";
            channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, mess.getBytes(StandardCharsets.UTF_8));
            //100条确认一次
            if (i % 100 == 0) {
                boolean b = channel.waitForConfirms();
            }
        }
    }
}
5.3 异步确认发布

它是利用回调函数来达到消息可靠性的传递，这个中间件也是通过函数回调来保证是否投递成功

public class ProducerWorker02 {
    private static final String QUEUE_NAME = "queue_ack";

    public static void main(String[] args{}
    /**
     * 异步发布确认
     *
     * @author yunshuaiwei
     * @date 2023/3/2 10:31
     **/
    public static void publishMessageAsync() throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //创建队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        //开启发布确认
        channel.confirmSelect();
        //线程安全有序的哈希表
        //可以将序号和消息进行关联，可以批量删除消息条目，且支持高并发
        ConcurrentSkipListMap<Long, Object> map = new ConcurrentSkipListMap<>();
        //消息确认成功后的回调
        ConfirmCallback confirmCallback = (tag, multiple) -> {
            //删除已经确认的消息
            if (multiple){//批量
                ConcurrentNavigableMap<Long, Object> confirmed = map.headMap(tag);
                confirmed.clear();
            }else{
                map.remove(tag);
            }
            System.out.println("确认成功的消息：" + tag);
        };
        //消息确认失败后的回调
        ConfirmCallback nackCallback = (tag, multiple) -> {
            Object o = map.get(tag);
            System.out.println("未确认的消息：" + o.toString());
        };
        //消息监听器
        channel.addConfirmListener(confirmCallback, nackCallback);
        for (int i = 0; i < 1000; i++) {
            String mess = i + "";
            channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, mess.getBytes(StandardCharsets.UTF_8));
            //1.记录所有要发送的消息
            map.put(channel.getNextPublishSeqNo(),mess);
        }
    }
}

三、交换机

上一部分中，每个任务恰好交付给一个消费者(工作进程)。在这一部分中，我们将消息发布给多个消费者。这种模式称为"发布/订阅"模式

RabbitMQ消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递到哪些队列中。相反，生产者只能将消息发送到交换机，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是用该把这些消息放到特定队列还是说把他们放到许多队列中，这些都由交换机来决定。

1. 交换机类型

  1. 直接(direct)
  2. 主题(topic)
  3. 标题(headers)
  4. 扇出(fanout)

2. 绑定

3. Fanout

它是将接收到的所有消息广播到它知道的所有队列中

//消费者
public class ConsumerWorker {

    private static final String EXCHANGE_NAME = "exchange01";

    public static void main(String[] args) throws IOException {
        Channel channel = RabbitMqUtils.getChannel();
        //param1：交换机名称 param2：交换机类型--扇出
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //获取一个临时队列
        String queue = channel.queueDeclare().getQueue();
        //param1：队列名称 param2：交换机名称 param3：routingKey
        channel.queueBind(queue, EXCHANGE_NAME, "");
        System.out.println("等待接收消息......");
        channel.basicConsume(queue, true, (tag, mess) -> {
            System.out.println("接收到消息：" + new String(mess.getBody(), StandardCharsets.UTF_8));
        }, tag -> {
            System.out.println("消息接收失败！");
        });
    }
}

//生产者
public class ProducerWorker {
    private static final String EXCHANGE_NAME = "exchange01";

    public static void main(String[] args) throws IOException, InterruptedException {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String mess = scanner.next();
            channel.basicPublish(EXCHANGE_NAME, "", null, mess.getBytes(StandardCharsets.UTF_8));
            System.out.println("发送消息：" + mess);
        }
    }
}

4. Direct exchange

Fanout不能给我们带来很大的灵活性，它只能进行无意识的广播，在这里我们将使用Direct这种类型进行替换，这种类型的消息只去它绑定的routingKey队列中。

5. Topics

发送到类型是Topics交换机的消息routing_key不能随意写，必须满足一定的要求，它必须是一个单词列表，以逗号隔开。

  1. Q1绑定中间带有orange带三个单词的字符串
  2. Q2绑定最后一个单词是rabbit的三个单词；第一个单词是lazy的多个单词

//消费者01
public class ConsumerWorker01 {

    private static final String EXCHANGE_NAME = "exchange01";

    public static void main(String[] args) throws IOException {
        Channel channel = RabbitMqUtils.getChannel();
        //param1：交换机名称 param2：交换机类型--扇出
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //获取一个临时队列
        String queue = channel.queueDeclare().getQueue();
        //param1：队列名称 param2：交换机名称 param3：routingKey
        channel.queueBind(queue, EXCHANGE_NAME, "*.orange.*");
        System.out.println("等待接收消息......");
        channel.basicConsume(queue, true, (tag, mess) -> {
            System.out.println("接收到消息：" + new String(mess.getBody(), StandardCharsets.UTF_8));
            System.out.println("接收队列：Q1，绑定键：" + mess.getEnvelope().getRoutingKey());
        }, tag -> {
            System.out.println("消息接收失败！");
        });
    }
}
//消费者02
public class ConsumerWorker02 {

    private static final String EXCHANGE_NAME = "exchange01";

    public static void main(String[] args) throws IOException {
        Channel channel = RabbitMqUtils.getChannel();
        //param1：交换机名称 param2：交换机类型--扇出
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //获取一个临时队列
        String queue = channel.queueDeclare().getQueue();
        //param1：队列名称 param2：交换机名称 param3：routingKey
        //绑定交换机
        channel.queueBind(queue, EXCHANGE_NAME, "*.*.rabbit");
        channel.queueBind(queue, EXCHANGE_NAME, "lazy.#");
        System.out.println("等待接收消息......");
        channel.basicConsume(queue, true, (tag, mess) -> {
            System.out.println("接收到消息：" + new String(mess.getBody(), StandardCharsets.UTF_8));
            System.out.println("接收队列：Q2，绑定键：" + mess.getEnvelope().getRoutingKey());
        }, tag -> {
            System.out.println("消息接收失败！");
        });
    }
}
//生产者
public class ProducerWorker {
    private static final String EXCHANGE_NAME = "exchange01";

    public static void main(String[] args) throws IOException, InterruptedException {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //测试代码
        HashMap<String, String> map = new HashMap<>();
        map.put("quick.orange.rabbit", "队列Q1 Q2接收");
        map.put("lazy.orange.elephant", "队列Q1 Q2接收");
        map.put("quick.orange.fox", "队列Q1接收");
        map.put("lazy.brown.fox", "队列Q2接收");
        map.put("lazy.pink.rabbit", "满足两个绑定，但是只被Q2接收一次");
        map.put("quick.brown.fox", "不匹配任何绑定不会被接收");
        for (String key : map.keySet()) {
            channel.basicPublish(EXCHANGE_NAME, key, MessageProperties.PERSISTENT_TEXT_PLAIN, map.get(key).getBytes(StandardCharsets.UTF_8));
            System.out.println("生产者发出消息：" + map.get(key));
        }
    }
}

四、死信队列

1. 概述

死信及无法被消费的消息。一般来说，producer将消息投递到broker或者直接到queue中，consumer从queue取出消息进行消费，但某些时候由于特定原因导致queue中的某些消息无法被消费，这些消息如果没有进行后续处理则会变成死信，有死信自然就有了死信队列

  1. 消息TTL过期
  2. 队列达到最大长度(队列满了，无法再添加数据到mq中)
  3. 消息被拒绝（basic.reject或basic.nack）并且requeue=false

在这里插入图片描述

2. 代码

//生产者
public class ProducerWorker {
    private static final String NORMAL_EXCHANGE = "normal_exchange";
    
    public static void main(String[] args) {
        Channel channel = RabbitMqUtils.getChannel();
        //模拟由TTL超时导致的死信
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
        for (int i = 0; i < 10; i++) {
            String mess = "info" + i;
            try {
                channel.basicPublish(NORMAL_EXCHANGE, "ZhangSan", properties, mess.getBytes(StandardCharsets.UTF_8));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
//消费者
public class ConsumerWorker {

    private static final String NORMAL_EXCHANGE = "normal_exchange";
    private static final String DEAD_EXCHANGE = "dead_exchange";
    private static final String NORMAL_QUEUE = "normal_queue";
    private static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) {
        Channel channel = RabbitMqUtils.getChannel();

        try {
            //声明交换机
            channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
            channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
            //声明队列
            Map<String, Object> map = new HashMap<>();
            //正常队列设置死信交换机
            map.put("x-dead-letter-exchange", DEAD_EXCHANGE);
            //设置路由RoutingKey
            map.put("x-dead-letter-routing-key", "lisi");
            channel.queueDeclare(NORMAL_QUEUE, false, false, false, map);
            channel.queueDeclare(DEAD_QUEUE, false, false, false, null);
            //队列和交换机进行绑定
            channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"ZhangSan");
            channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
            //发送消息
            System.out.println("等待接收消息......");
            channel.basicConsume(NORMAL_QUEUE, true, (consumerTag, mess) -> {
                System.out.println("Consumer01接收到消息："+new String(mess.getBody(), StandardCharsets.UTF_8));
            }, consumerTag -> {
                System.out.println("消息接收失败：" + consumerTag);
            });
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

五、延迟队列

延迟队列内部是有序的，最重要的特性就体现在延时属性上，延时队列中的元素是希望在指定时间到了以后或者之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。

1. 基于死信消息

//配置类
@Configuration
public class TtlQueueConfig {
    private static final String X_EXCHANGE = "X";

    private static final String Y_DEAD_LETTER_EXCHANGE = "Y";

    public static final String QUEUE_A = "QA";

    public static final String QUEUE_B = "QB";

    public static final String DEAD_LETTER_QUEUE = "QD";

    @Bean("xExchange")
    public DirectExchange xExchange() {
        return new DirectExchange(X_EXCHANGE);
    }

    @Bean("yExchange")
    public DirectExchange yExchange() {
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }


    @Bean("queueA")
    public Queue aQueue() {
        Map<String, Object> arguments = new HashMap<>(2);
        //设置死信交换机
        arguments.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        arguments.put("x-dead-letter-routing-key", "YD");
        return QueueBuilder
                .durable(QUEUE_A)
                .ttl(10000)
                .withArguments(arguments).build();
    }

    @Bean("queueB")
    public Queue bQueue() {
        Map<String, Object> arguments = new HashMap<>(2);
        //设置死信交换机
        arguments.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        arguments.put("x-dead-letter-routing-key", "YD");
        return QueueBuilder
                .durable(QUEUE_B)
                .ttl(40000)
                .withArguments(arguments).build();
    }

    @Bean("queueD")
    public Queue dQueue() {
        return QueueBuilder.durable(DEAD_LETTER_QUEUE).build();
    }

    @Bean
    public Binding queueABindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }

    @Bean
    public Binding queueBBindingX(@Qualifier("queueB") Queue queueB,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueB).to(xExchange).with("XB");
    }

    @Bean
    public Binding queueDBindingY(@Qualifier("queueD") Queue queueD,
                                  @Qualifier("yExchange") DirectExchange yExchange) {
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }
}

//生产者
@RestController
@RequestMapping("/ttl")
@Slf4j
public class SendMsg {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMsg/{message}")
    public void sendMsg(@PathVariable String message) {
        log.info("当前时间：{}，发送一条消息给两个TTL队列:{}", DateUtil.now(), message);
        //发送消息
        rabbitTemplate.convertAndSend("X", "XA", "消息来自ttl为10s的队列：" + message);
        rabbitTemplate.convertAndSend("X", "XB", "消息来自ttl为40s的队列：" + message);
    }
}
//消费者
@Slf4j
@Component
public class DeadLetterQueueConsumer {
    @RabbitListener(queues = "QD")
    public void receiveQueueD(Message message, Channel channel) {
        String msg = new String(message.getBody(), UTF_8);
        log.info("当前时间：{},收到死信队列的消息：{}", DateUtil.now(), msg);
    }
}

2. 基于插件

  1. 首先需要安装RabbitMQ延时插件
//配置类
@Configuration
public class DelayedQueueConfig {
    public static final String DELAYED_QUEUE_NAME = "delayed.queue";

    public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";


    @Bean
    public Queue delayedQueue() {
        return QueueBuilder.durable(DELAYED_QUEUE_NAME).build();
    }

    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> arguments = new HashMap<>();
        //延迟类型：直接类型
        arguments.put("x-delayed-type", "direct");
        return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false, arguments);
    }

    @Bean
    public Binding delayedQueueBinding(@Qualifier("delayedQueue") Queue delayedQueue,
                                       @Qualifier("delayedExchange") CustomExchange delayedExchange) {
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with("delayed.routingKey").noargs();
    }
}

//生产者
@RestController
@RequestMapping("/ttl")
@Slf4j
public class SendMsg {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMsg/{message}/{delayTime}")
    public void sendDelayedMsg(@PathVariable("message") String message, @PathVariable("delayTime") Integer delayTime) {
        log.info("当前时间：{}，发送一条时长为{}毫秒的信息给延时队列delayed.queue：{}", DateUtil.now(), delayTime, message);
        rabbitTemplate.convertAndSend(DelayedQueueConfig.DELAYED_EXCHANGE_NAME, "delayed.routingKey", message, msg -> {
            //设置延时时间
            msg.getMessageProperties().setDelay(delayTime);
            return msg;
        });
    }
}

//消费者
@Slf4j
@Component
public class DeadLetterQueueConsumer {
    @RabbitListener(queues = "delayed.queue")
    public void receiveQueueC(Message message,Channel channel){
        String msg=new String(message.getBody(), UTF_8);
        log.info("当前时间：{},收到延时消息：{}", DateUtil.now(), msg);
    }
}

六、参考资料

  1. 尚硅谷
ysw！不将就
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
RabbitMQ学习笔记
weixin_67268418的博客
11-30 621
RabbitMQ学习看着一片就够了,超级详细!
RabbitMQ 超详细笔记
最新发布
m0_51045361的博客
06-26 1040
​ MQ（message queue）,从字面意思上看。本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了MQ之后，消息发送上游只需要依赖MQ，不用依赖其他服务。Broker：接收和分发消息的应用，RabbitMQ Server 就是Message Broker。
rabbitmq学习笔记（史上最全，浅显易懂，生动形象）
l51541iuiui的博客
11-16 203
消息队列rabbitmq的学习
rabbitmq学习笔记和软件和插件
05-05
“尚硅谷”的学习笔记提供了关于RabbitMQ的详细教程，涵盖了基础概念、安装配置、实战案例等多个方面，是初学者入门的好资料。此外，官方文档也是深入理解RabbitMQ功能和特性的关键资源，包括了详细的API参考、插件...
rabbitMQ入门笔记的mkdown笔记和源码
08-23
rabbitMQ学习的笔记和学习过程中写的代码
RabbitMq从入门到精通
06-10
文件名"RabbitMq从入门到精通-201810314712349_6617.doc"可能是课程的讲义或笔记，包含了详细的教学步骤和实例代码。而"RabbitMq从入门到精通-201810312501052_28932.zip"可能是一个项目源码包，供学员实践操作和...
Java Springboot入门自学笔记
09-08
本入门自学笔记将带你一步步了解并掌握Spring Boot的核心概念和实践技巧。 ### 01 SpringBoot简介 #### 1.1 Spring Boot 的优势 - **简化的起步**：Spring Boot 提供了起步依赖(starter)，可以通过添加相应的Maven...
Kafka学习笔记.pdf
09-10
【Kafka学习笔记】 Kafka是由LinkedIn开发的分布式日志系统，后来成为Apache顶级开源项目。它是一个设计为高吞吐、低延迟的系统，特别适用于处理和存储大量实时数据。Kafka的主要特点包括分布式、分区、多副本以及...
RabbitMQ入门学习笔记
热爱编程、热爱生活、热爱探索
06-20 2799
本文是笔者学习RabbitMQ的笔记，如果对你有所帮助，欢迎三连（点赞👍+收藏⭐+关注💖）   在现代的分布式系统中，消息传递变得愈发重要，而RabbitMQ作为一种高性能、可靠且灵活的消息队列解决方案备受青睐。作为开源软件，RabbitMQ提供了一个可靠的、可扩展的平台，用于在应用程序之间传递消息，无论是在单个应用程序内部还是跨多个应用程序之间。   本文将介绍RabbitMQ以及与其相关的学习内容。首先，我们将学习RabbitMQ中的相关核心概念，接下来，我
非常强悍的 RabbitMQ 总结，细节写得真好
05-15 1840
rabbitMQ是基于AMQP协议的，通过使用通用协议就可以做到在不同语言之间传递。 AMQP协议 核心概念 server：又称broker，接受客户端连接，实现AMQP实体服务。 connection：连接和具体broker网络连接。 channel：网络信道，几乎所有操作都在channel中进行，channel是消息读写的通道。客户端可以建立多个channel，每个channel表示一个会话任务。 message：消息，服务器和应用程序之间传递的数据，由properties和body组成.
Rabbitmq学习笔记（超详细）
努力做知识干货分享，即开即用，感谢关注
08-05 207
死信交换机：专门给死信队列转发消息的交换机（注意，它就是一个普通交换机，只不过是专门给死信队列发消息而已，理解为这个交换机的名称就叫“死信交换机”)。注意，这里的匹配和MySQL的k的%不一样，只能按照单词来匹配，每个'.分隔单词，如果是'#.'，其实可以忽略，匹配0个词也ok。死信队列：专门处理死信的队列（注意，它就是一个普通队列，只不过是专门用来处理死信的，你甚至可以理解这个队列的名称叫“死信队列”)queueName:消息队列名称（注意，同名称的消息队列，只能用同样的参数创建一次）
RabbitMQ 简介
weixin_34068198的博客
02-23 191
为什么80%的码农都做不了架构师？>>> ...
RabbitMQ 学习笔记
低吟不作语的博客
02-27 923
具体操作可以通过路由键来实现：创建三个队列，每个队列都对应不同的路由键，每个消息可以根据 id 设置不同的路由键（例如用 id 对路由键的数量取模），消费者通过绑定指定的队列和路由键来接收消息，这样每个消费者只会接收到其关注的特定路由键的消息，从而实现了消息的分区。消费者监听死信队列，实现再次消费。拉模式下，生产者发布消息到队列时，不会立即发送消息给消费者，而是等待消费者请求消息后才发送，优点：消费端可以按照自己的处理速度来消费，缺点：消息传递存在延迟，当处理速度小于发布速度时，容易造成消息堆积在队列。
rabbitmq学习笔记
weixin_42274562的博客
10-17 435
个人总结向
rabbitmq快速入门
03-11
你好，关于rabbitmq快速入门，我可以为您提供一些基本的信息和指导。首先，RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP）标准，可以用于实现异步消息传递和解耦。如果您想快速入门，可以先...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ysw！不将就

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值