RabbitMQ：四种ExChange用法

最新推荐文章于 2025-05-14 14:17:51 发布
最新推荐文章于 2025-05-14 14:17:51 发布
阅读量162 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 大数据
原文链接：https://yq.aliyun.com/articles/175876
本文介绍了RabbitMQ中四种类型的交换机：fanout、direct、topic和headers的工作原理及使用示例。fanout交换机会将消息广播到所有绑定的队列；direct交换机根据路由键分发消息；topic交换机支持模糊匹配路由键；headers交换机则根据消息头属性进行路由。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

RabbitMQ发送消息时，都是先把消息发送给ExChange（交换机），然后再分发给有相应RoutingKey（路由）关系的Queue（队列）。
ExChange和Queue之前是多对多的关系。
RabbitMQ 3.0之后创建ExChange时，有四种类型可选“fanout、direct、topic、headers”。

一、fanout
当向一个fanout发送一个消息时，RoutingKey的设置不起作用。
消息会被发送给同一个交换机下的所有队列，每个队列接收到的消息是一样的；
一个队列内有所有消费者（包含那些并没有相应RoutingKey的消费者），将平分队列接收到的消息。

----------------消息生产者----------------
ConnectionFactory factory = new ConnectionFactory();
factory.setHost(S_RabbitMQ.QUEUE_IP);// MQ主机
factory.setPort(S_RabbitMQ.QUEUE_PORT);// MQ端口
factory.setUsername(S_RabbitMQ.QUEUE_USER);// MQ用户名
factory.setPassword(S_RabbitMQ.QUEUE_PWD);// MQ密码

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

// 声明路由名字和类型
channel.exchangeDeclare(EXCHANGE_NAME, "fanout", true, false, null);
String message = "hello world! ";

for(int i=0;i<100;i++)
{
channel.basicPublish(EXCHANGE_NAME, "", null, (message+i).getBytes());
}

System.out.println("Sent msg finish");

channel.close();
connection.close();

----------------消息消费者----------------
ConnectionFactory factory = new ConnectionFactory();

factory.setHost(S_RabbitMQ.QUEUE_IP);// MQ主机
factory.setPort(S_RabbitMQ.QUEUE_PORT);// MQ端口
factory.setUsername(S_RabbitMQ.QUEUE_USER);// MQ用户名
factory.setPassword(S_RabbitMQ.QUEUE_PWD);// MQ密码

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

//声明路由名字和类型
channel.exchangeDeclare(EXCHANGE_NAME, "fanout", true, false, null);
//声明队列
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//绑定路由和队列
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "routkey2", null);

System.out.println(" Waiting for msg....");
Consumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope,  AMQP.BasicProperties properties, byte[] body) {
String message = "";
try
{
message = new String(body, "UTF-8");
}
catch (UnsupportedEncodingException e)
{
e.printStackTrace();
}
catch (Throwable ex)
{
ex.printStackTrace();
}

System.out.println("Received msg='" + message + "'");
}
};
channel.basicConsume(QUEUE_NAME, true, consumer);

二、direct
当向一个direct发送一个消息时，消息会被发送给同一个交换机下的拥有相应RoutingKey的队列，每个队列接收到的消息是一样的；
一个队列内拥有相应RoutingKey的消费者，将平分队列接收到的消息。

----------------消息生产者----------------
ConnectionFactory factory = new ConnectionFactory();

factory.setHost(S_RabbitMQ.QUEUE_IP);// MQ主机
factory.setPort(S_RabbitMQ.QUEUE_PORT);// MQ端口
factory.setUsername(S_RabbitMQ.QUEUE_USER);// MQ用户名
factory.setPassword(S_RabbitMQ.QUEUE_PWD);// MQ密码

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

// 声明路由名字和类型
channel.exchangeDeclare(EXCHANGE_NAME, "direct", true, false, null);
String message = "hello world! ";

for(int i=0;i<100;i++)
{
channel.basicPublish(EXCHANGE_NAME, "routingkey1", null, (message+i).getBytes());
}

System.out.println("Sent msg is '" + message + "'");

channel.close();
connection.close();

----------------消息消费者----------------
ConnectionFactory factory = new ConnectionFactory();

factory.setHost(S_RabbitMQ.QUEUE_IP);// MQ主机
factory.setPort(S_RabbitMQ.QUEUE_PORT);// MQ端口
factory.setUsername(S_RabbitMQ.QUEUE_USER);// MQ用户名
factory.setPassword(S_RabbitMQ.QUEUE_PWD);// MQ密码

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

//声明路由名字和类型
channel.exchangeDeclare(EXCHANGE_NAME, "direct", true, false, null);
//声明队列
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//绑定路由和队列
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "routingkey1", null);

System.out.println(" Waiting for msg....");
Consumer consumer = new DefaultConsumer(channel)
{
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
byte[] body)
{
String message = "";
try
{
message = new String(body, "UTF-8");
}
catch (UnsupportedEncodingException e)
{
e.printStackTrace();
}
catch (Throwable ex)
{
ex.printStackTrace();
}

System.out.println("1 Received msg='" + message + "'");
}
};

channel.basicConsume(QUEUE_NAME, true, consumer);

三、topic
当向一个topic发送一个消息时，消息会被发送给同一个交换机下的拥有相应RoutingKey的队列，每个队列接收到的消息是一样的；
一个队列内有所有消费者（包含那些并没有相应RoutingKey的消费者），将平分队列接收到的消息。

----------------消息生产者----------------
ConnectionFactory factory = new ConnectionFactory();

factory.setHost(S_RabbitMQ.QUEUE_IP);// MQ主机
factory.setPort(S_RabbitMQ.QUEUE_PORT);// MQ端口
factory.setUsername(S_RabbitMQ.QUEUE_USER);// MQ用户名
factory.setPassword(S_RabbitMQ.QUEUE_PWD);// MQ密码

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

// 声明路由名字和类型
channel.exchangeDeclare(EXCHANGE_NAME, "topic", true, false, null);
String message = "hello world! ";

// int i=101;
for (int i = 0; i < 100; i++)
{
channel.basicPublish(EXCHANGE_NAME, "routingkey1", null, (message + i).getBytes());
}

System.out.println("Sent msg is '" + message + "'");

channel.close();
connection.close();

----------------消息消费者----------------
ConnectionFactory factory = new ConnectionFactory();

factory.setHost(S_RabbitMQ.QUEUE_IP);// MQ主机
factory.setPort(S_RabbitMQ.QUEUE_PORT);// MQ端口
factory.setUsername(S_RabbitMQ.QUEUE_USER);// MQ用户名
factory.setPassword(S_RabbitMQ.QUEUE_PWD);// MQ密码

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

// 声明路由名字和类型
channel.exchangeDeclare(EXCHANGE_NAME, "topic", true, false, null);
//声明队列
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//绑定路由和队列// 把队列绑定到路由上并指定headers
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "routingkey1", null);

System.out.println("1 Waiting for msg....");
Consumer consumer = new DefaultConsumer(channel)
{
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
{
String message = "";
try
{
message = new String(body, "UTF-8");
}
catch (UnsupportedEncodingException e)
{
e.printStackTrace();
}
catch (Throwable ex)
{
ex.printStackTrace();
}

System.out.println("1 Received msg='" + message + "'");
}
};
channel.basicConsume(QUEUE_NAME, true, consumer);

四、headers
当向一个headers发送一个消息时，消息会被发送给同一个交换机下的拥有相应RoutingKey或者headers的队列，每个队列接收到的消息是一样的；
一个队列内有所有消费者（包含那些并没有相应RoutingKey或headers的消费者），将平分队列接收到的消息。

----------------消息生产者----------------
ConnectionFactory factory = new ConnectionFactory();

factory.setHost(S_RabbitMQ.QUEUE_IP);// MQ主机
factory.setPort(S_RabbitMQ.QUEUE_PORT);// MQ端口
factory.setUsername(S_RabbitMQ.QUEUE_USER);// MQ用户名
factory.setPassword(S_RabbitMQ.QUEUE_PWD);// MQ密码

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

// 声明路由名字和类型
channel.exchangeDeclare(EXCHANGE_NAME, "headers", true, false, null);

// 设置消息头键值对信息
Map<String, Object> headers = new Hashtable<String, Object>();
headers.put("name", "jack");
headers.put("age", 31);
Builder builder = new Builder();
builder.headers(headers);

String message = "hello world! ";

// int i=101;
for (int i = 0; i < 100; i++)
{
channel.basicPublish(EXCHANGE_NAME, "routingkey1", builder.build(), (message + i).getBytes());
}

System.out.println("Sent msg is '" + message + "'");

channel.close();
connection.close();

----------------消息消费者----------------
ConnectionFactory factory = new ConnectionFactory();

factory.setHost(S_RabbitMQ.QUEUE_IP);
factory.setPort(S_RabbitMQ.QUEUE_PORT);// MQ端口
factory.setUsername(S_RabbitMQ.QUEUE_USER);// MQ用户名
factory.setPassword(S_RabbitMQ.QUEUE_PWD);// MQ密码

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

// 声明路由名字和类型
channel.exchangeDeclare(EXCHANGE_NAME, "headers", true, false, null);
// 声明队列
channel.queueDeclare(QUEUE_NAME, true, false, false, null);

// 设置消息头键值对信息
Map<String, Object> headers = new Hashtable<String, Object>();
// 这里x-match有两种类型
// all:表示所有的键值对都匹配才能接受到消息
// any:表示只要有键值对匹配就能接受到消息
headers.put("x-match", "all");
headers.put("name", "jack");
headers.put("age", 30);

// 把队列绑定到路由上并指定headers
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "routingkey1", headers);

System.out.println(" Waiting for msg....");
Consumer consumer = new DefaultConsumer(channel)
{
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException
{

System.out.println("Received start --------------");

for (Entry<String, Object> entry : properties.getHeaders().entrySet())
{
System.out.println(entry.getKey() + "=" + entry.getValue());
}

String message = new String(body, "UTF-8");

System.out.println("msg='" + message + "'");
System.out.println("Received end --------------");
}
};
channel.basicConsume(QUEUE_NAME, true, consumer);
RabbitMQ之Exchange
xiaoyatouvsanan的专栏
06-30 1081
rabbitMQ消息模型的核心思想是生产者不会将消息直接发送给队列。生产者通常不知道消息将会被哪些消费者接收，按照刚开始里介绍的rabbitMQ中所画的，生产者不是直接将消息发送给Queue么认识会交给Exchange,所以需要定义Exchange的消息分发模型来实现消息的分发，即发布者/订阅者模式，用这种模型来实现生产者与消费者之间的解耦。 那我们之前的例子中为什么只定义了一个队列，而没有定义
（九)RabbitMQ交换机（Exchange）
小怪的博客
11-25 1282
binding 其实是 exchange 和 queue 之间的桥梁，它告诉我们 exchange 和哪个队列进行了绑定关系。到它绑定的所有队列中，也就是关于routingKey他不管。topic 交换机的消息的 routing_key 不能随意写，必须满足一定的要求，它。，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。也就是队列名称随机产生，一旦我们断开了消费者的连接，队列将被自动删除,也没有持久化。队列只对它绑定的交换机的消息感兴趣。,这里用的就是默认的交换机。
RabbitMQ之Exchange （二）
IT界的一只菜鸟
12-03 1748
RabbitMQ之Exchange RabbitMQ之ExchangeRabbitMQ之Exchange一、概念二 Exchange使用详情2.1、Direct Exchange2.2、Topic Exchange2.3、Fanout Exchange2.4、Headers Exchange2.5、JMS Queue Exchange2.6、JMS Topic Exchange2.7、x-delayed-message Exchange 一、概念 什么是Exchange Exchange是消息队列Rabbi
rabbitmq exchange详细分析
01-20
RabbitMQ中，所有生产者提交的消息都由Exchange来接受，然后Exchange按照特定的策略转发到Queue进行存储，RabbitMQ提供了四种Exchange： 1、fanout 2、direct 3、topic 4、header header模式在实际使用中较少，此处只对前三种模式进行比较。 一.Direct Exchange 任何发送到Direct Exchange的消息都会被转发到RoutingKey中指定的Queue。 1、一般情况可以使用rabbitMQ自带的Exchange：””(该Exchange的名字为空字符串，下文称其为default Exchange)。 2、
Rabbit+SpringBoot 指定自动生成exchange、routingkey和Queue对应关系
热门推荐
qq_33300570的博客
08-28 1万+
使用AmqpTemplate只能指定对列名发送，并不会存在对应exchange关系，此时只能单配置一个，还要必须从上下文配置文件指明。 经过研究发现通过使用RabbitTemplate可以自动生成exchange和routingkey之间的关系，而不用去RabbitMQ的management页面操作。具体如下：     pom.xml依赖配置： &lt;!--消息队列模块--&gt; ...
RabbitMQ学习笔记：Event Exchange Plugin（事件交换器插件）rabbitmq-event-exchange
smart_an的专栏
07-11 659
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！客户端connection、channels、queues、consumers和系统其它部分自动生成的事件。
nodejs-rabbitmq：简单的RabbitMQ发布者消费者应用程序，通过快速路由发送消息
02-19
在Node.js中，我们创建一个通道，声明一个交换机（exchange），并使用`publish()`方法将消息发布到交换机。交换机根据预设的规则（例如直接、主题、扇出或头部）将消息路由到队列。 4. **消费者（Consumer）**：...
RabbitMQ:如何防止RabbitMq消息堆积？
qq_44813449的博客
08-30 896
当遇到消息量巨大的情况，mq爆满，导致消息堆积，消费者不能及时消费。
sb-rabbitmq:Sprint Boot子Rabbitmq
05-02
总之，"sb-rabbitmq"是一个针对Java开发者的Spring Boot子项目，它演示了如何使用Spring AMQP与RabbitMQ进行集成，为构建基于消息驱动的分布式系统提供了一个起点。通过深入研究项目源码，你可以了解到如何配置...
RabbitMQ：python基础调用
我是你大爷
02-05 795
紧接上回在windows上安装了最新版的RabbitMQ，这里给出通过AI学习到的python使用方法。
RabbitMQ之Exchange（交换机）
m0_62528678的博客
12-20 3157
在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列，队列再将消息以推送或者拉取方式给消费者进行消费创建消息 路由键 pull/push生产者------------>交换机------------>队列------------>消费者交换机原理图。
RabbitMQ：交换机-Exchange
最新发布
喝醉酒的小白
05-14 1055
Exchange（交换机）是 RabbitMQ 中用于路由消息的逻辑实体，生产者将消息发布到 Exchange，Exchange 再依据配置的 Binding（绑定）规则将消息路由到相应的 Queue（队列）或其他 Exchange【(知乎专栏)】。Exchange 本身不存储消息，只管转发或丢弃。
RabbitMQ的Exchange详解；
A232222的博客
01-07 2267
一、前言 RabbitMQ的Exchange，即交换机，是用来发送消息的AMQQP实体，通常交换机拿到一个消息之后，根据路由规则，路由到一个或零个队列； 二、Exchange的类型 AMQP 0-9-1 的代理提供了四种交换机： 除交换机类型外，在声明交换机时还可以附带许多其它数据，其中比较常用的是： Name：交换机的名称 Durable：是否持久化（重启rabbitmq之后，交换机是否还存在） AutoDelete：是否自动删除（当交换机把消息发送到与之绑定的消息队列后，是否删除交换机） Di
RabbitMQ exchange
CAir2的专栏
01-06 1944
amqp exchange
rabbitmq exchange（交换机）
sinat_16493273的博客
04-05 326
内置交换机类型 Fanout fanout英文是扇形，分裂的意思。 将接受到的消息广播到所有已知队列。 Direct a message goes to the queues whose binding key exactly matches the routing key of the message. 直接模式，比fanout模式更精确。只有队列的绑定的routingKey和消息publish的时候一致，exchange才会将该消息投递到此队列。fanout类型的交换机routingKey参数就没
RabbitMQ-工作模式
BNMZY的博客
05-15 304
文章目录概述Work Queues 概述 RabbitMQ有以下几种工作模式 Work Queues 工作队列 Publish/Subscribe 发布订阅 Routing 路由 Topics 通配符 Header Header转发器 RPC 远程过程调用 Work Queues
RabbitMQ交换机（Exchanges）
qq_40277163的博客
05-26 1332
Exchanges 概念 RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。 Exchanges 的类型 总共有以下类型： 直接(dire
理解 RabbitMQ Exchange
杏仁技术站
05-22 1万+
&#13; &#13; &#13; &#13; &#13; &#13; &#13; 作者 | 乔宇    杏仁后端工程师，关注服务端技术。AMQP 简介在了解 RabbitMQ 的 E...
rabbitmq exchange- 交换机
qq_21134059的博客
05-29 169
定义 交换机是用于接受消息，并且根据路由键转发消息到所绑定的消息队列上。 工作原理 工作原理如图： 蓝色的模块：他是消息生产 者的工作流程，消息生产者负责生产消息，并将消息发送到exchange交换机上，然后exchange通过路由匹配将得到的消息存放到对应的消息队列上。 绿色模块：代表消息的消费者的工作流程，消费者通过监听队列得到队列里存放的消息，然后进行消费。 黄色模块：代表交换机匹配路由键的过程。 红色模块：代表整个rabbitmq的服务。 交换机属性 name : 代表交换机的名称 type: 交
SpringBoot与RabbitMq：消息发送实战与配置详解
本文档是关于在SpringBoot环境中使用RabbitMQ进行消息发送的教程，针对SpringBoot 2.2.1.RELEASE和RabbitMQ 3.7.5版本。主要内容分为以下几个部分： 1. **配置**： - 使用Spring Boot的spring-boot-starter-amqp ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值