RabbitMQ五大常用工作模式

最新推荐文章于 2024-05-17 21:07:11 发布
最新推荐文章于 2024-05-17 21:07:11 发布
阅读量1.2k 收藏 27
点赞数 29
分类专栏： RabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76363587/article/details/136148485
版权

1.简单队列

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 消息生产者

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

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "这是一条消息！！！";
            // 发送消息
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println("Send：" + message);
        }
    }
}

  • 消息消费者（会一直监听队列）

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

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Recv：" + message);
        };
        // 自动确认消息
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
        });
    }
}

2.工作队列

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 工作队列

    • 消息生产能力大于消费能力，增加多个消费节点
    • 和简单队列类似，增加多个消费节点，处于竞争关系
    • 默认策略：round robin轮训

  • 生产者

    public class Send {

    private static final String QUEUE_NAME = "work_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 批量发送10个消息
            for (int i = 0; i < 10; i++) {
                String message = "这是一条消息！！！" + i;
                // 发送消息
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println("Send：" + message);

            }
        }
    }
}

  • 消费者1

    public class Recv1 {
    private static final String QUEUE_NAME = "work_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            // 模拟消费者缓慢
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Recv1：" + message);
            // 手工确认消息
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };
        // 关闭自动确认消息
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> {
        });
    }
}

  • 消费者2

    public class Recv2 {
    private static final String QUEUE_NAME = "work_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            // 模拟消费者缓慢
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Recv2：" + message);
            // 手工确认消息
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };
        // 关闭自动确认消息
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> {
        });
    }
}

  • 轮训策略验证

    • 先启动两个消费者，再启动生产者
    • 缺点：存在部分节点消费过快，部分节点消费慢，导致不能合理处理消息

  • 公平策略验证

    • 修改消费者策略
    • 解决消费者能力消费不足的问题，降低消费时间问题

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3.RabbitMQ的Exchange交换机

  • 生产者将消息发送到Exchange，交换机将消息路由到一个或者多个队列中，交换机有多个类型，队列和交换机是多对多的关系
  • 交换机只负责转发消息，不具备存储消息的能力，如果没有队列和交换机绑定或者没有符合的路由规则，则消息会被丢失
  • RabbitMQ有四种交换机类型，分别是Direct exchange、Fanout exchange、Topic exchange、Headers exchange，最后一种基本不用

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 交换机类型
    • Direct exchange定向
      • 将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配
      • 处理路由键
    • Fanout exchange广播
      • 只需要简单的将队列绑定到交换机上，一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息
      • Fanout交换机转发消息是最快的，用于发布订阅广播形式
      • 不处理路由键
    • Topic exchange通配符
      • 主题交换机是一种发布/订阅的模式，结合了直连交换机与扇形交换机的特点
      • 将路由键和某模式进行匹配，此时队列需要绑定在一个模式上
      • 符号"#“匹配一个或多个词，符号”*"匹配不多不少一个词
    • Headers exchange（很少用）
      • 根据发送的消息内容中的headers属性进行匹配，在绑定Queue与Exchange时指定一组键值对
      • 当消息发送到RabbitMQ时会取到该消息的headers与Exchange绑定时指定的键值对进行匹配
      • 如果完全匹配则消息会路由到该队列，否则不会路由到该队列
      • 不处理路由键

4.发布订阅模型

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 什么是RabbitMQ的发布订阅模式

    • 发布订阅模型中，消息生产者不再是直接面对队列，而是直面交换机，都需要经过交换机来进行消息的发送，所有发往同一个fanout交换机的消息都会被所有监听这个交换机的消费者接收
    • 发布订阅模型引入fanout交换机

  • 发布订阅模型应用场景

    • 微信公众号
    • 新浪微博关注

  • RabbitMQ发布订阅模型

    • 通过把消息发送给交换机，交换机转发给对应绑定的队列
    • 交换机绑定的队列是排他独占队列，自动删除

  • 发送端

    public class Send {

    private static final String EXCHANGE_NAME = "fan_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 绑定交换机，广播类型
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
            String message = "广播发送消息：这是一条消息！！！";
            // 发送消息
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println("Send：" + message);
        }
    }
}

  • 消费端（两个节点）

    public class Recv1 {
    private static final String EXCHANGE_NAME = "fan_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 绑定交换机，广播类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        // 获取队列（排它队列）
        String queueName = channel.queueDeclare().getQueue();
        // 绑定队列和交换机
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        // 回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Recv1：" + message);
        };
        // 自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

5.路由模式

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 什么是RabbitMQ的路由模式

    • 交换机类型是direct

    • 队列和交换机绑定，需要指定一个路由键（也叫binding key）

    • 消息生产者发送消息给交换机，需要指定路由键

    • 交换机根据消息的路由键，转发给对应的队列

  • 消息生产者

    public class Send {

    private static final String EXCHANGE_NAME = "direct_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 绑定交换机，直连类型
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
            String error = "我是错误日志";
            String info = "我是info日志";
            String warning = "我是warning日志";
            // 发送消息
            channel.basicPublish(EXCHANGE_NAME, "error", null, error.getBytes(StandardCharsets.UTF_8));
            channel.basicPublish(EXCHANGE_NAME, "info", null, info.getBytes(StandardCharsets.UTF_8));
            channel.basicPublish(EXCHANGE_NAME, "warning", null, warning.getBytes(StandardCharsets.UTF_8));
            System.out.println("Send：消息发送成功！");
        }
    }
}

  • 消费者一（只接收错误消息）

    public class Recv1 {
    private static final String EXCHANGE_NAME = "direct_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 绑定交换机，直连类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 获取队列
        String queueName = channel.queueDeclare().getQueue();
        // 绑定队列和交换机
        channel.queueBind(queueName, EXCHANGE_NAME, "error");
        // 回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Recv1：" + message);
        };
        // 自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

  • 消费者二（接收全部消息）

    public class Recv2 {
    private static final String EXCHANGE_NAME = "direct_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 绑定交换机，直连类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 获取队列
        String queueName = channel.queueDeclare().getQueue();
        // 绑定队列和交换机
        channel.queueBind(queueName, EXCHANGE_NAME, "error");
        channel.queueBind(queueName, EXCHANGE_NAME, "info");
        channel.queueBind(queueName, EXCHANGE_NAME, "warning");
        // 回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Recv2：" + message);
        };
        // 自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

6.主题通配符模式

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 什么是RabbitMQ的主题模式

    • 交换机是topic，可以实现发布订阅模式fanout和路由模式direct的功能，更加灵活，支持通配符匹配
    • 交换机通过通配符进行转发到对应的队列，*代表一个词，#代表1个或多个词，一般用#作为通配符居多，词与词之间使用.点进行分割
    • 注意：交换机和队列绑定时用的binding使用通配符的路由键；生产者发送消息时需要使用具体的路由键

  • 生产者

    public class Send {

    private static final String EXCHANGE_NAME = "topic_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 绑定交换机，主题类型
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
            String error = "我是错误日志";
            String info = "我是info日志";
            String warning = "我是warning日志";
            // 发送消息
            channel.basicPublish(EXCHANGE_NAME, "error", null, error.getBytes(StandardCharsets.UTF_8));
            channel.basicPublish(EXCHANGE_NAME, "info", null, info.getBytes(StandardCharsets.UTF_8));
            channel.basicPublish(EXCHANGE_NAME, "warning", null, warning.getBytes(StandardCharsets.UTF_8));
            System.out.println("Send：消息发送成功！");
        }
    }
}

  • 消费者一（只接收错误消息）

    public class Recv1 {
    private static final String EXCHANGE_NAME = "topic_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 绑定交换机，主题类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 获取队列
        String queueName = channel.queueDeclare().getQueue();
        // 绑定队列和交换机
        channel.queueBind(queueName, EXCHANGE_NAME, "error");
        // 回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Recv1：" + message);
        };
        // 自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

  • 消费者二（接收全部消息）

    public class Recv2 {
    private static final String EXCHANGE_NAME = "topic_mq";

    public static void main(String[] args) throws Exception {
        // 连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.101.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("Gen123");
        factory.setVirtualHost("/");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 绑定交换机，主题类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 获取队列
        String queueName = channel.queueDeclare().getQueue();
        // 绑定队列和交换机
        channel.queueBind(queueName, EXCHANGE_NAME, "#");
        // 回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Recv2：" + message);
        };
        // 自动确认消息
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}

7.工作模式总结

  • 简单模式

    • 一个生产者一个消费者，不用指定交换机，使用默认交换机

  • 工作队列模式

    • 一个生产者多个消费者，可以有轮训和公平策略，不用指定交换机，使用默认交换机

  • 发布订阅模式

    • fanout类型交换机，通过交换机和队列绑定，不用指定绑定路由键，生产者发送消息到交换机，fanout交换机直接进行转发，消息不用指定routingkey路由键

  • 路由模式

    • direct类型交换机，通过交换机和队列绑定，指定绑定的路由键，生产者发送消息到交换机，交换机根据消息的路由key进行转发到对应的队列，消息要指定routingkey路由键

  • 通配符模式

    • topic交换机，通过交换机和队列绑定，指定绑定的通配符路由键，生产者发送消息到交换机，交换机根据消息的路由键进行转发到对应的队列，消息要指定routingkey路由键
水宝的滚动歌词
关注
  • 29
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
RabbitMQ的五种工作模式
gaoqiandr的博客
04-23 500
本文主要是对于rabbitmq的五种常用模式做出的详细介绍
RabbitMQ六大模式
跨越时空的记忆
11-24 6528
RabbitMQ六大模式 文章目录前言一、简单模式二、Work queues工作队列模式一、Publish/Subscribe发布与订阅模式一、Routing路由模式一、Topics通配符模式 前言 RabbitMQ提供了6种模式：简单模式，work模式，Publish/Subscribe发布与订阅模式，Routing路由模式，Topics主题模式，RPC远程调用模式（远程调用，不太算MQ；暂不作介绍）。 一、简单模式 在上图的模型中，有以下概念： P：生产者，也就是要发送消息的程序。 C：消费者：.
MQ的快速入门及RabbitMQ的五种工作模式
weixin_64133130的博客
08-11 2334
Mq消息中间件的基础知识，rabbitmq的工作模式，springboot集成rabbitmq
RabbitMQ的核心组件和五种常用模式
weixin_44623190的博客
04-20 1386
1，简单模式 生产者Producer: package com.lp.test; import com.rabbitmq.client.AMQP; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import java.io.IOException; import java.util.concurrent.Co
RabbitMQ的五种常用消息模型
我能在河边钓一整天的鱼
02-20 3602
目录 五种消息模型 基本消息模型 work消息模型 订阅模型-Fanout(广播) 订阅模型-Direct(路由) 订阅模型-Topic(通配符) 持久化 五种消息模型 RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ。其中3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。 基本消息模型 原理 P...
rabbitmq五种模式
weixin_49307896的博客
12-21 7337
rabbitmq五种模式 1.简单模式 2.争抢模式（工作模式，工作争抢模式） 3.路由模式 route 4.发布订阅模式 fanout 5.主题模式 topic 6. RPC异步调用模式（不常用） 1.简单模式 当生产端发送消息到交换机,交换机根据消息属性发送到队列,消费者监听绑定队列实现消息的接收和消费逻辑编写.简单模式下,强调的一个队列queue只被一个消费者监听消费. 1.1 结构 生产者：生成消息,发送到交换机 交换机：根据消息属性,将消息发送给队列 消费者：监听这个队列,发现消息后,
SpringBoot 集成 RabbitMq 实现五种常用消息模型
wxw1997a的博客
08-09 520
一个简单的 Demo ，实现五种消息模型，快速上手
SpringAMQP整合RabbitMQ-五种工作模式Demo
Henrik-Yao的博客
11-21 5465
一.MQ基本概念 1.概述 MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器，是存储消息的中间件 分布式系统通信有两种方式，一种是直接远程调用，一种是借助类似于rabbitmq的第三方中间件完成间接通信 2.MQ的优势 应用解耦：提高系统容错性和可维护性 异步提速：提升用户体验和系统吞吐量 削峰填谷：提高系统稳定性 二.RabbitMQ 1.AMQP AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用
RabbitMq (一）理论篇部分 MQ作用是什么 MQ的优缺点 RabbitMQ的基础架构 RabbitMQ 五种常用工作模式 RabbitMQ消息确认机制
热门推荐
T_Antry
08-31 1万+
本次的内容是rabbitmq，写这个专题的目的是为了更好的巩固和自我总结，因为暂时工作中是用不到的，所以也是希望自己下次在使用时，也能够借助文章轻松回顾，更快地着手应用。因为个人是第一次提及mq相关的内容，因此也会简单地介绍mq的相关特点。
RabbitMQ 最常用的三大模式实例解析
08-25
主要介绍了RabbitMQ 最常用的三大模式实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java课程实验 RabbitMQ 常用的工作模式
07-07
以下是RabbitMQ中常用的工作模式： 1. 简单模式（Simple Mode）： - 简单模式是最基本的消息传递模式，也是最简单的模式。生产者将消息发送到队列，消费者从队列中接收并处理消息。这是一对一的方式。 2. 工作队列...
beego - rabbitmq简单模式和工作模式
03-10
beego - rabbitmq简单模式和工作模式 demo
rabbitmq常用三种模式的配置
03-16
rabbitmq包含多种模式，主要是fanout，direct，topic，本代码主要针对这三种模式进行相关的配置，配置文件单独放置在不同的文件夹里，以便学习。
rabbitmq交换机，死信队列的简单例子
weixin_43970625的博客
05-14 551
假设我们有一个场景，生产者有消息发到某个直连交换机，这个交换机上有两个队列分别存储两种类型的消息，但是与这两个队列相连的消费者太不争气了，处理消息有点慢，我们想5秒钟这个消息在队列中还没有被消费的话，就给它丢进死信队列里得了，后续再处理，但是这俩队列明显存储的消息不一样，我们又不好意思将它都扔到同一个死信队列里去，如果我们想要俩死信队列分别装这两个消费者漏掉的消息，那我们怎么做呢？：我们先创建一个工具类用来连接rabbitmq，注意你需要去创建对应的虚拟主机，以及对应的登录账号和密码。
Rabbitmq报unauthorized异常
qq_32590535的博客
05-14 324
处理rabbitmq的unauthorized 异常。Caused by: java.lang.SecurityException: Attempt to deserialize unauthorized class java.util.HashMap;
RabbitMQ的基本组件有哪些？
yuanlaile的博客
05-15 302
RabbitMQ的基本组件介绍，RabbitMQ不生产消息，他是消息的搬运工。
RabbitMQ---交换机-Fanout-Direct
最新发布
m0_72410274的博客
05-17 1044
rabbitmq 交换机
rabbitmq的五种工作模式
06-09
RabbitMQ支持以下五种工作模式： 1. 简单模式（Simple Mode）：一个生产者向一个队列发送消息，一个消费者从队列中接收消息。 2. 工作模式（Work Mode）：一个生产者向一个队列发送消息，多个消费者从队列中接收...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

水宝的滚动歌词

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

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

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

打赏作者

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

抵扣说明：

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

余额充值