RabbitMQ 工作模式（上）

最新推荐文章于 2025-05-20 09:07:58 发布
最新推荐文章于 2025-05-20 09:07:58 发布
阅读量563 收藏 4
点赞数 21
分类专栏： RabbitMQ 文章标签： rabbitmq 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liwuqianhzc/article/details/148017384
版权

前言

在 RabbitMQ 中，一共有七种工作模式，我们也可以打开官网了解：
在这里插入图片描述

本章我们先介绍前三种工作模式

（Simple）简单模式

在这里插入图片描述

P：producer 生产者，负责发送消息
C：consumer 消费者，接收消息
Queue: 消息队列

简单模式的特点：一个生产者P，一个消费者C，消息只能被消费一次，也被称为点对点【Point-to-Point】模式

案例：上一篇文章中的快速入门RabbitMQ 就是简单模式的演示，大家可以去看一下代码的实现

Work Queue（工作队列）

在这里插入图片描述
特点：多个消费者共同消费同一条队列的消息，消息不重复
假设队列有 10 条消息，C1 消费了 4 条，C2 消费了 6 条，这就是共同消费。

生产者：

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //进行绑定
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.HOST);
        factory.setPort(Constants.PORT);
        factory.setUsername(Constants.NAME);
        factory.setPassword(Constants.PASSWORD);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        //建立连接
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //这里使用默认的交换机
        //声明队列
        channel.queueDeclare(Constants.WORK_QUEUE, true, false, false, null);
        //发送消息
        for (int i = 0; i < 10; i++) {
            String msg = "hello work queue...."+i;
            channel.basicPublish("",Constants.WORK_QUEUE, null, msg.getBytes());
        }
        System.out.println("发送消息成功");
        //资源释放
        channel.close();
        connection.close();
    }
}

消费者：

public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //进行参数绑定
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.HOST);
        factory.setPort(Constants.PORT);
        factory.setUsername(Constants.NAME);
        factory.setPassword(Constants.PASSWORD);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        //建立连接
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //使用默认的交换机
        //声明队列
        channel.queueDeclare(Constants.WORK_QUEUE, true, false, false, null);
        //消息消费
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收到的消息：" + new String(body));
            }
        };
        channel.basicConsume(Constants.WORK_QUEUE, true, consumer);
    }
}

public class Consumer2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //进行参数绑定
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.HOST);
        factory.setPort(Constants.PORT);
        factory.setUsername(Constants.NAME);
        factory.setPassword(Constants.PASSWORD);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        //建立连接
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //使用默认的交换机
        //声明队列
        channel.queueDeclare(Constants.WORK_QUEUE, true, false, false, null);
        //消息消费
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收到的消息：" + new String(body));
            }
        };
        channel.basicConsume(Constants.WORK_QUEUE, true, consumer);
    }
}

交换机概念

这里解释一下为什么上面两种工作模式流程图没有交换机的存在，因为交换机在上面两种工作模式中不起重要作用，为了简化，所以省略了交换机，实际在 RabbitMQ 中 生产者发送的消息是需要通过交换机将消息发送到对应的队列中。

在RabbitMQ 中，一共有四种类型的交换机，分别是 Fanout、Direct、Topic、Headers，不同类型的交换机有着不同的路由策略。
在 AMQP 协议中还有额外的两种类型：System 和 自定义，在RabbitMQ 中我们就不介绍这额外的两种

Fanout：广播模式，将小心发送给所有与该交换机绑定的队列中，对应下面即将讲解的 Publish / Subscribe (发布 / 订阅) 工作模式

Direct：定向，将消息发送给指定的 routing key 的队列中，对应 Routing 模式

Topic：通配符，将消息交给符合指定的 routing pattern （路由模式）的队列

Headers : 该交换机不依赖路由键的批匹配规则来路由消息，而是根据发送的消息内容中的headers 属性进行匹配，headers 类型的交换机性能很差，很少很在工作中遇到。

这里解释一下 routing key 和 binding key 的概念：

在这里插入图片描述

生产者和交换机的联系使用的是 Routing Key，交换机和队列的联系使用的是 Binding Key

在后续的代码中 我们也会将 Binding Key 当作 Routing Key

Publish / Subscribe (发布 / 订阅)

在这里插入图片描述

交换机将消息发送到不同的队列中，类似广播的作用，所有和该交换机绑定的队列都会收到一样的消息

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //设置 MQ 参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.HOST);
        factory.setPort(Constants.PORT);
        factory.setUsername(Constants.NAME);
        factory.setPassword(Constants.PASSWORD);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        //建立连接
        Connection connection = factory.newConnection();
        // 开启信道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare("publish", BuiltinExchangeType.FANOUT, true, false, null);
        //声明队列
        channel.queueDeclare("fanout1", true, false, false, null);
        channel.queueDeclare("fanout2", true, false, false, null);
        //绑定队列和交换机
        channel.queueBind("fanout1","publish","");
        channel.queueBind("fanout2","publish","");
        //发送消息
        for (int i = 0; i < 10; i++) {
            channel.basicPublish("publish", "", null, ("hello" + i).getBytes());
        }
        //关闭资源
        channel.close();
        connection.close();
    }
}

方法参数介绍：

交换机声明：

Exchange.DeclareOk exchangeDeclare(String exchange,
BuiltinExchangeType type,
boolean durable, 
boolean autoDelete,
Map<String, Object> arguments) throws IOException;

exchange：交换机的名称

BuiltinExchangeType type： 交换机的类型，点击 BuiltinExchangeType 可以查看到 这是一个枚举类，一共有四种类型的交换机：DIRECT(“direct”), FANOUT(“fanout”), TOPIC(“topic”), HEADERS(“headers”);

public enum BuiltinExchangeType {

    DIRECT("direct"), FANOUT("fanout"), TOPIC("topic"), HEADERS("headers");

    private final String type;

    BuiltinExchangeType(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

durable：是否进行持久化

autoDelete： 是否自动删除

arguments：高级特性的设置

交换机与队列的绑定：

Queue.BindOk queueBind(String queue, 
String exchange, 
String routingKey) throws IOException;

queue：队列的名称

exchange: 交换机的名称

routingKey ： 交换机和队列绑定的联系词BindingKey，这里写的RoutingKey，本质上是一样的。

消费者代码：

public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //设置 MQ 参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.HOST);
        factory.setPort(Constants.PORT);
        factory.setUsername(Constants.NAME);
        factory.setPassword(Constants.PASSWORD);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        //建立连接
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("fanout1", true, false, false, null);
        //消费消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body));
            }
        };
        channel.basicConsume("fanout1", true, consumer);
    }
}

public class Consumer2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //设置 MQ 参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.HOST);
        factory.setPort(Constants.PORT);
        factory.setUsername(Constants.NAME);
        factory.setPassword(Constants.PASSWORD);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        //建立连接
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("fanout2", true, false, false, null);
        //进行消费
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body));
            }
        };
        channel.basicConsume("fanout2", true, consumer);
    }
}
RabbitMQ消息队列的工作模式
江晓龙的博客
06-26 1万+
使用Routing路由模式时，Exchange与队列也不再进行绑定了，而是通过声明一个RoutingKey，通过这个key将消息路由到特定的队列中，因此在消息发送方发消息时，就需要指定消息的RoutingKey，Routing根据消息中的RoutingKey进行判断，当消息中的RoutingKey与队列中的RoutingKey完全一致时，消息才能正常存储到队列中，最后被消费者处理。简而言之，使用Topic模式后，可以对消息数据中的RoutingKey进行通配符匹配，将满足条件的消息数据分发到特定的队列中。
RabbitMQ工作模式详解，以及Java实现
qq_69331283的博客
07-10 1778
RabbitMQ共有六种工作模式：简单模式（Simple）、工作队列模式（Work Queue）、发布订阅模式（Publish/Subscribe）、路由模式（Routing）、通配符模式（Topics）、远程调用模式（RPC，不常用，不做讲解说明）
详解RabbitMQ工作模式之工作队列模式
热门推荐
.
04-28 1万+
详解RabbitMQ工作模式之工作队列模式。
详解RabbitMQ工作模式之路由模式
.
05-05 1万+
详解RabbitMQ工作模式之路由模式。
详解RabbitMQ工作模式之发布订阅模式
.
05-05 1万+
详解RabbitMQ工作模式之发布订阅模式
RabbitMQ 的7种工作模式
q322359的博客
12-23 2012
RabbitMQ 的7种工作模式，RabbitMQ的基本使用
RabbitMQ工作模式
Forrest Gump的博客
06-19 1341
一、工作模式介绍 RabbbitMQ提供了6种工作模式：简单模式、work queues、Publish/Subscribe发布与订阅模式、Routing路由模式、Topics主题模式、RPC远程调用模式（不太符合MQ） 1.1 简单模式 P：生产者，也就是要发送消息的程序 C：消费者，消息的接收者，会一直等待消息到来 Queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息 1.2 Work queues 工作队列模式 工作队列模式相对简单模式，
RabbitMQ简单模式和工作模式
别忘了微笑
01-25 1502
RabbitMQ 是一个消息队列中间件，用于在分布式系统中进行消息传递。在 RabbitMQ 中，有几种工作模式，其中简单模式和工作模式是其中两种基本的模式之一。在 RabbitMQ 中，简单模式和工作模式的实现通常使用一些基本的概念，包括生产者、消费者、队列和消息。生产者负责发送消息到队列，而消费者则负责从队列中接收和处理消息。下面是一个使用 RabbitMQ 和 Node.js（使用amqplib库）以及 TypeScript 实现工作模式的简单示例。在这个例子中，我们将使用amqplib。
RabbitMq的五种工作模式
代码蒋的博客
06-10 833
​ 这五种工作模式，可以归为三类：生产者，消息队列，一个消费者；生产者，消息队列，多个消费者；生产者，交换机，多个消息队列，多个消费者；
详解RabbitMQ工作模式之通配符模式
.
05-12 1万+
详解RabbitMQ工作模式之通配符模式。
【RabbitMQ】RabbitMQ 的 6 种工作模式
书山有路，学海无涯。记录成长，追逐梦想
06-14 1228
你也许会问，为什么我们接收到未知消息的时候不抛出一个错误，而是要将它忽略掉？这是为了解决服务器端有可能发生的竞争情况。尽管可能性不大，但 RPC 服务器还是有可能在已将应答发送给我们但还未将确认消息发送给请求的情况下杀掉。如果这种情况发生，RPC 在重启后会重新处理请求。这就是为什么我们必须在客户端优雅的处理重复响应，同时 RPC 也需要尽可能保持幂等性。
RabbitMQ工作模式详解
07-10
Rabbitmq简单模式消费者
beego - rabbitmq简单模式和工作模式
03-10
在RabbitMQ的简单模式中，也被称为发布/订阅模式，生产者发送消息到一个特定的交换机，这个交换机会将消息广播给所有绑定到该交换机上的队列。消费者通过绑定到交换机来接收消息。在beego应用中，我们可以使用`amqp`...
RabbitMQ-高级
2302_77423520的博客
05-19 726
本文系统讲解了RabbitMQ高可靠方案，涵盖生产者确认、持久化机制、消费者重试策略及幂等性保障，同时解析了延迟消息的两种实现方式（死信交换机和插件）。通过配置重试、ACK机制和Lazy Queue优化性能与可靠性，结合业务场景设计兜底方案，确保消息最终一致性。学习后深刻体会到消息队列在分布式系统中保障数据安全与高效传输的核心价值。
RabbitMQ-如何选择消息队列？
weixin_45226668的博客
05-19 593
RabbitMQ-如何选择消息队列？
Spring Boot中如何使用RabbitMQ？
最新发布
zhakakqns的博客
05-20 641
本文介绍了如何在SpringBoot中使用RabbitMQ，涵盖了准备工作、配置、以及四种常见的工作模式：工作队列、发布/订阅、路由和通配符。首先，需要在项目中添加spring-boot-starter-amqp依赖，并配置RabbitMQ的连接信息。接着，通过声明队列、交换机和绑定关系来配置不同的工作模式。生产者通过RabbitTemplate发送消息，消费者通过@RabbitListener注解监听队列并处理消息。与JDK原生客户端相比，SpringBoot简化了连接管理和配置，开发者只需关注业务逻辑的
disryptor和rabbitmq
2302_79637382的博客
05-19 590
用于在。
RabbitMQ详解
qq_35529931的博客
05-19 548
基于Raft一致性协议实现的一种新型的分布式消息队列，他实现了持久化，多备份的FIFO队列。Durability有两个选项，Durable和Transient，前者表示队列会将消息保存到硬盘，这样消息的安全性更高。务处理后自动进行应答，而如果消费者的业务逻辑抛出异常，RabbitMQ会将消息进行重试，这样是不会丢。会尽可能早的将消息内容保持到硬盘中，并且只有在用户请求的时候，才临时从硬盘加载到RAM内存中。这时，可以尽量多的申请机器，部署消费端应用，争取在最短的时间内消费掉积压的消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值