RabbitMQ实战之三种交换机（Direct、Topic和Fanout）

最新推荐文章于 2024-11-24 19:55:52 发布
原创 最新推荐文章于 2024-11-24 19:55:52 发布 · 1.5k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rabbitmq #队列 #java

本文介绍了RabbitMQ中三种主要的交换机类型：DirectExchange、FanoutExchange和TopicExchange。DirectExchange基于路由键进行消息投递；FanoutExchange将消息广播到所有绑定的队列；TopicExchange则使用通配符规则进行路由。通过代码示例展示了如何在Spring Boot应用中配置和使用这些交换机，以及对应的生产者和消费者。测试结果显示了不同交换机模式下的消息传递行为。

一、消息推送到接收的流程图

首先先介绍一个简单的一个消息推送到接收的流程，提供一个简单的图：
在这里插入图片描述
黄色的圈圈就是我们的消息推送服务，将消息推送到 中间方框里面也就是 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终右边的蓝色圈圈消费者获取对应监听的消息。

常用的交换机有以下三种，因为消费者是从队列获取信息的，队列是绑定交换机的（一般），所以对应的消息推送/接收模式也会有以下几种：

1.Direct Exchange

直连型交换机，根据消息携带的路由键将消息投递给对应队列。
大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。
然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时，交换机就会根据这个路由值X去寻找绑定值也是X的队列。

2.Fanout Exchange

扇型交换机，这个交换机没有路由键概念，就算你绑了路由键也是无视的。 这个交换机在接收到消息后，会直接转发到绑定到它上面的所有队列。

3.Topic Exchange

主题交换机，这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的。
简单地介绍下规则：
*(星号) 用来表示一个单词 (必须出现的)
#(井号) 用来表示任意数量（零个或多个）单词
通配的绑定键是跟队列进行绑定的，举例如下：
队列Q1 绑定键为 .TT.
队列Q2绑定键为 TT.#
如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到；
如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到；

二、Direct Exchange

直连交换机中，每对交换机和队列之间只能通过唯一一个路由键来绑定（当然，每个交换机可绑定多个队列，每个队列也可绑定多个交换机）。

1.DirectConfig.java

package com.springboot.rabbit.demo.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class DirectConfig {
    //用@Bean注解配置好需要注册到RabbitMQ服务器的消息队列。项目启动时，这些队列就会被注册。
	//队列 起名：com.direct.queue.1
    @Bean
    public Queue directQueue1() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        // 比如return new Queue("TestDirectQueue",true,true,false);
        return new Queue("com.direct.queue.1");
    }

    @Bean
    public Queue directQueue2() {
        return new Queue("com.direct.queue.2");
    }

    @Bean
    public Queue directQueue3() {
        return new Queue("com.direct.queue.3");
    }

    //Direct交换机 起名：com.direct.exchange
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("com.direct.exchange");
    }
    
    //绑定  将队列和交换机绑定, 并设置用于匹配键：com.direct.routingKey.1
    @Bean
    public Binding bindQueue1() {
        return BindingBuilder.bind(directQueue1()).to(directExchange()).with("com.direct.routingKey.1");
    }

    @Bean
    public Binding bindQueue2() {
        return BindingBuilder.bind(directQueue2()).to(directExchange()).with("com.direct.routingKey.2");
    }

    @Bean
    public Binding bindQueue3() {
        return BindingBuilder.bind(directQueue3()).to(directExchange()).with("com.direct.routingKey.3");
    }
}

2.生产者DirectProducer.java

package com.springboot.rabbit.demo.producer;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class DirectProducer {
	
	//使用RabbitTemplate,这提供了接收/发送等等方法
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send1(String msg) {
    	//将消息携带绑定键值：com.direct.routingKey.1 发送到交换机com.direct.exchange
        rabbitTemplate.convertAndSend("com.direct.exchange", "com.direct.routingKey.1", msg);
    }

    public void send2(String msg) {
        rabbitTemplate.convertAndSend("com.direct.exchange", "com.direct.routingKey.2", msg);
    }

    public void send3(String msg) {
        rabbitTemplate.convertAndSend("com.direct.exchange", "com.direct.routingKey.3", msg);
    }
}

3.消费者DirectConsumer.java

package com.springboot.rabbit.demo.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = {"com.direct.queue.1", "com.direct.queue.2", "com.direct.queue.3"})
//监听的队列名称 com.direct.queue.1\2\3
public class DirectConsumer {
    @RabbitHandler
    public void process(String msg) {
       System.out.println(msg);
    }
}

4.业务控制层DirectController.java

package com.springboot.rabbit.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.springboot.rabbit.demo.producer.DirectProducer;
@RestController
@RequestMapping("direct")
public class DirectController {
    @Autowired
    private DirectProducer directProducer;

    @RequestMapping("1")
    public void produce1(String msg) {
        directProducer.send1(msg);
    }

    @RequestMapping("2")
    public void produce2(String msg) {
        directProducer.send2(msg);
    }

    @RequestMapping("3")
    public void produce3(String msg) {
        directProducer.send3(msg);
    }
}

5.测试结果

启动RabbitService，然后运行RabbitDemoApplication.java主类，在浏览器中访问如下链接，进行测试：
在这里插入图片描述
在这里插入图片描述
详细信息在http://localhost:15672/#/中即可查看
在这里插入图片描述

三、Fanout Exchange

扇出交换机无需绑定路由，只要是生产者发送到扇出交换机上的消息全部都会被消费者监听到并消费。所以，随意发送任意路由都可以。

1.FanoutConfig.java

package com.springboot.rabbit.demo.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FanoutConfig {

    @Bean
    public Queue fanoutQueue1() {
        return new Queue("com.fanout.queue.1");
    }

    @Bean
    public Queue fanoutQueue2() {
        return new Queue("com.fanout.queue.2");
    }

    @Bean
    public Queue fanoutQueue3() {
        return new Queue("com.fanout.queue.3");
    }

    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("com.fanout.exchange");
    }

    @Bean
    public Binding bindFanoutQueue1() {
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }

    @Bean
    public Binding bindFanoutQueue2() {
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }

    @Bean
    public Binding bindFanoutQueue3() {
        return BindingBuilder.bind(fanoutQueue3()).to(fanoutExchange());
    }
}

2.生产者FanoutProducer.java

package com.springboot.rabbit.demo.producer;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class FanoutProducer {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    public void send(String msg) {
        rabbitTemplate.convertAndSend("com.fanout.exchange", "whatever routingKey", msg);
    }
}

3.消费者FanoutConsumer.java

package com.springboot.rabbit.demo.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = {"com.fanout.queue.1", "com.fanout.queue.2", "com.fanout.queue.3"})
public class FanoutConsumer {
    @RabbitHandler
    public void process(String msg) {
    	System.out.println(msg);
    }
}

4.业务控制层FanoutController.java

package com.springboot.rabbit.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.springboot.rabbit.demo.producer.FanoutProducer;
@RestController
@RequestMapping("fanout")
public class FanoutController {
    @Autowired
    private FanoutProducer fanoutProducer;
    @RequestMapping("produce")
    public void produce(String msg) {
        fanoutProducer.send(msg);
    }
}

5.测试结果

测试结果如下：
在这里插入图片描述
在这里插入图片描述

四、Topic Exchange

Topic Exchange转发消息主要是根据通配符。在这种交换机下，队列和交换机的绑定会定义一种路由模式，那么，通配符就要在这种路由模式和路由键之间匹配后交换机才能转发消息。
在这种交换机模式下：
（1）路由键（Routing Key）命名必须为一串字符，用句号（.） 隔开，比如 jake.topic.queue。
（2）队列和交换机通过路由键绑定。

1.TopicConfig.java

package com.springboot.rabbit.demo.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class TopicConfig {

    @Bean
    public Queue topicQueueAccurate() {
        return new Queue("com.topic.queue.accurate");
    }

    @Bean
    public Queue topicQueueSingle() {
        return new Queue("com.topic.queue.single");
    }

    @Bean
    public Queue topicQueueAny() {
        return new Queue("com.topic.queue.any");
    }

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("com.topic.exchange");
    }

    @Bean
    public Binding bindWithAccurateMatcher() {
        return BindingBuilder.bind(topicQueueAccurate()).to(topicExchange()).
                with("com.topic.routingKey.accurate");
    }

    @Bean
    public Binding bindWithSingleWordMatcher() {
    	// * (星号) 用来表示一个单词 (必须出现的)
        return BindingBuilder.bind(topicQueueSingle()).to(topicExchange()).
                with("com.topic.routingKey.*");
    }

    @Bean
    public Binding bindWithAnyWordMatcher() {
    	//  # (井号) 用来表示任意数量（零个或多个）单词
        return BindingBuilder.bind(topicQueueAny()).to(topicExchange()).
                with("com.topic.#");
    }

}

2.生产者TopicProducer.java

package com.springboot.rabbit.demo.producer;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TopicProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendAccurate(String msg) {
        rabbitTemplate.convertAndSend("com.topic.exchange", "com.topic.routingKey.accurate", msg);
    }

    public void sendSingle(String msg) {
        rabbitTemplate.convertAndSend("com.topic.exchange", "com.topic.routingKey.only-one-word", msg);
    }

    public void sendAny(String msg) {
        rabbitTemplate.convertAndSend("com.topic.exchange", "com.topic.routingKey.as.much.as.you.want", msg);
    }
}

3.消费者

精确匹配TopicAccurateMatchConsumer.java

package com.springboot.rabbit.demo.consumer;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = {"com.topic.queue.accurate"})
public class TopicAccurateMatchConsumer {
    @RabbitHandler
    public void process(String msg) {
    	System.out.println(msg);
    }
}

匹配所有TopicAnyMatchConsumer.java

package com.springboot.rabbit.demo.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = {"com.topic.queue.any"})
public class TopicAnyMatchConsumer {
    @RabbitHandler
    public void process(String msg) {
    	System.out.println(msg);
    }
}

匹配单一队列TopicSingleMatchConsumer.java

package com.springboot.rabbit.demo.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = {"com.topic.queue.single"})
public class TopicSingleMatchConsumer {
    @RabbitHandler
    public void process(String msg) {
    	System.out.println(msg);
    }
}

4.业务控制层FanoutController.java

package com.springboot.rabbit.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.springboot.rabbit.demo.producer.TopicProducer;
@RestController
@RequestMapping("topic")
public class TopicController {
    @Autowired
    private TopicProducer topicProducer;

    @RequestMapping("accurate")
    public void accurate(String msg) {
        topicProducer.sendAccurate(msg);
    }

    @RequestMapping("single")
    public void single(String msg) {
        topicProducer.sendSingle(msg);
    }

    @RequestMapping("any")
    public void any(String msg) {
        topicProducer.sendAny(msg);
    }
}

5.测试结果

精确匹配测试结果：
在这里插入图片描述
在这里插入图片描述
任意匹配测试结果：
在这里插入图片描述
在这里插入图片描述
单一匹配测试结果：
在这里插入图片描述
在这里插入图片描述

五、项目结构

1.application.yml配置

目的是自由切换不同的yml配置文件，切换项目环境（dev、prod、test）等。
application.yml

spring:
  profiles:
    active: dev

application-dev.yml

server:
  port: 8086

2.项目目录结构

在这里插入图片描述
以上整体项目代码链接如下
RabbitMQ

代码思路参考了SpringBoot + RabbitMQ实战之通过代码熟悉三种交换机（Direct、Topic和Fanout）
特此对这位博主表示感谢！

参考文章
https://blog.youkuaiyun.com/qq_15329947/article/details/86528854
https://blog.youkuaiyun.com/qq_35387940/article/details/100514134

springboot2.1.4集成rabbitmq，三种模式：fanout direct topic的实现
05-16
本篇文章将深入探讨如何在Spring Boot 2.1.4版本中集成RabbitMQ，并实现三种主要的交换机类型：Fanout、Direct和Topic模式。 首先，我们需要在Spring Boot项目中添加RabbitMQ的相关依赖。在`pom.xml`文件中，引入`...
RabbitMQ入门5：交换机类型；（fanout模式，direct模式，topic模式，headers模式；）
小枯林的博客
05-10 2380
零：RabbitMQ的交换机，在前面粗浅的介绍过： ● 在【RabbitMQ入门1：RabbitMQ简介；（消息队列简介；RabbitMQ简介；）】中，简单介绍了交换机的概念； （1）Producer生产者： ● 自然，在实际项目中，生产者的数量是不受限制的，一个也可以，多个也可以； ● 生产者会生产Message消息； （2）Message消息： ● 消息会经过Exchange交换机，到达Qu...
RabbitMQ详解（三）：消息模式（fanout、direct、topic、work）
weixin_45181611的博客
05-10 4266
消息模式详解
springboot学习笔记-6 springboot整合RabbitMQ
weixin_30825581的博客
03-11 433
一 RabbitMQ的介绍　　 　　RabbitMQ是消息中间件的一种,消息中间件即分布式系统中完成消息的发送和接收的基础软件.这些软件有很多,包括ActiveMQ(apache公司的),RocketMQ(阿里巴巴公司的,现已经转让给apache). 　　消息中间件的工作过程可以用生产者消费者模型来表示.即,生产者不断的向消息队列发送信息,而消费者从消息队列中消费信息.具体过程如下: 　...
RabbitMQ中常用的三种交换机【Fanout、Direct、Topic】
LYJbao的博客
07-07 3258
此时支付服务会把支付结果发送到交换机中，而短信服务就会去监听这个交换机，但是交换机不会把所有的消息都路由给短信服务，而只把支付成功的消息路由给这个短信服务。这种情况下，就需要使用到这个Direct交换机，短信服务下的队列和这个交换机设置一个key（例如：success），支付服务发消息时，支付成功RoutingKey设为success，失败为fail，交换机就会只把key为success的消息路由给短信服务了~上图中，就是，key为blue，消费者1去消费；一个只能接到新闻，一个只能接到和中国相关的消息~
RabbitMQ 的三种类型的交换器
梅川酷紫
05-29 8434
RabbitMQ 的三种类型的交换器 RabbitMQ 使用 Exchange（交换机）和 Queue（队列）来实现消息队列。 在 RabbitMQ 中一共有三种交换机类型，每一种交换机类型都有很鲜明的特征。 基于这三种交换机类型，OpenStack 完成两种 RPC 的调用方式。首先简单介绍三种交换机。 ①广播式交换器类型（Fanout） 该类交换器不分析所接收到消息中的 Routing Key，默认将消息转发到所有与该交换器绑定的队列中去。 ②直接式交换器类型（Direct） 该类交换器需要精确匹配
rabbitMQ 中三种常用交换机：direct、topic、fanout的使用以及区别和queue消息的Ack,Nack ,Reject 消息类型
码农崛起
08-10 5029
当消息发送到Exchange时，RabbitMQ会取到该消息的headers（也是一个键值对的形式），对比其中的键值对是否完全匹配Queue与Exchange绑定时指定的键值对；生产者将消息不是直接发送到队列，而是发送到X交换机，然后由交换机发送给两个队列，两个消费者各自监听一个队列，来消费消息。生产者，一个队列一个或多个消费者，当多个消费者同时监听一个队列时，他们并不能同时消费一条消息，而是随机消费消息，即一个队列中一条消息，只能被一个消费者消费。如果匹配请求中的值，则向程序返回该响应数据。.......
RabbitMQ5：Fanout交换机、Direct交换机、Topic交换机
casually的博客
11-24 1914
Fanout 交换机（Exchange）会将接收到的消息广播到每一个跟其绑定的queue，所以也叫广播模式。第一步：在RabbitMQ控制台，创建两个队列fanout.queue1和fanout.queue2第二步：添加一台Fanout类型的交换机，名叫“hmall.fanout”第三步：给hmall.fanout交换机绑定刚才那两个队列第四步：编写代码，给hmall.fanout交换机发送一条消息第五步：编写监听代码，监听与hmall.fanout交换机绑定的两个队列。
SpringBoot整合RabbitMQ direct交换机、fanout交换机、topic交换机
熊孩子的博客
04-26 1449
SpringBoot整合RabbitMQ direct交换机、fanout交换机、topic交换机
SpringBoot整合RabbitMQ 回调函数 direct交换机、fanout交换机、topic交换机
熊孩子的博客
04-27 973
SpringBoot整合RabbitMQ 回调函数 direct交换机、fanout交换机、topic交换机
rabbitMQ 中三种常用交换机：direct、topic、fanout的使用以及区别
mlh1551799812的博客
05-30 1531
转载：https://baijiahao.baidu.com/s?id=1711677124289660825&wfr=spider&for=pc 简单模式 生产者，一个队列一个或多个消费者，当多个消费者同时监听一个队列时，他们并不能同时消费一条消息，而是随机消费消息，即一个队列中一条消息，只能被一个消费者消费。 订阅与发布模式(fanout) 生产者，一个交换机(fanoutExchange)，没有路由规则，多个队列，多个消费者。生产者将消息不是直接发送到队列，而是发送到X交换机，然后由
Springboot整合RabbitMQ实现直连模型
Anoraker的小屋
12-02 7663
引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 编辑配置文件 spring: rabbitmq: host: 106.15.73.43 port: 5672 username: admin
springboot整合rabbitmq-交换机模式
zwjzone的博客
05-06 1200
rabbitmq交换机模式direct和topic演示
rabbitmq 直连模式
zxqjava的博客
11-06 391
生产者：直连模式 package com.huixiang.rabbitmq.simple; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import java.io.IOException; import java.util.concurrent.TimeoutException; public clas
RabbitMQ-直连模型
Anoraker的小屋
12-01 7273
AMQP的架构模型 其中虚拟主机的意思类似于数据库中库的概念，设计者更希望，每一个项目独立使用一个虚拟主机。 入门案例 引入依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.7.2</version> </dependency> 先去创建虚拟主
RabbitMQ交换器类型（Direct、Topic、Fanout、Headers）与消息的发送/接收模式
pan_junbiao的博客
01-19 7533
1、RabbitMQ 交换器类型 RabbitMQ 常用的交换器类型有Direct、Topic、Fanout、Headers 这四种。AMQP 协议里还提到另外两种类型：System 和自定义，这里不予描述。对于这四种类型下面一一阐述。 1.1Direct类型 Direct类型的交换器由路由规则很简单，它会把消息路由到那些 BindingKey 和 RoutingKey 完全匹配的队列中。 Direct Exchange 是 RabbitMQ 默认的交换器模式，也是最简单的模式。它根据Ro...
RabbitMQ的三种常用交换机
weixin_44001317的博客
04-05 1086
当一个队列的绑定键为 “#”（井号） 的时候，这个队列将会无视消息的路由键，接收所有的消息。如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到；扇型交换机，这个交换机没有路由键概念，就算你绑了路由键也是无视的。如果发送的消息携带的路由键是A，那么交换机就会把该消息投送到队列1和队列3中，如果是B的话就会投送到队列2中。主题交换机，这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的。通配的绑定键是跟队列进行绑定的，举个小例子 队列Q1 绑定键为。
rabbitMQ 三种常用交换机：direct、topic、fanout的使用以及区别
zhangaiav的博客
12-28 2801
rabbitMQ 三种常用交换机：direct、topic、fanout的使用以及区别
RabbitMQ 三种交换机类型
qq_24991197的博客
06-17 209
Exchanges 概念 RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。 直接(direct), 主题(topic) ,标题(head
RabbitMQ中Direct、Topic、Fanout交换机的区别及使用场景？
最新发布
06-12
<think>我们首先需要解释三种交换机的区别，然后说明它们各自的使用场景，并给出代码示例（使用pika库）来演示如何声明和绑定这些交换机。###1.DirectExchange(直连交换机)-**工作方式**：根据消息的routingkey精确匹配队列的bindingkey。只有当routingkey完全匹配时，消息才会被路由到该队列。-**使用场景**：适用于消息的单播路由（Unicast）。例如，将不同的任务类型（如：'image.resize','video.encode'）分发到不同的处理队列。###2.TopicExchange(主题交换机)-**工作方式**：根据routingkey和bindingkey的模式匹配进行路由。bindingkey可以使用通配符：-`*`(星号)代替一个单词-`#`(井号)代替零个或多个单词-**使用场景**：适用于消息的多播路由（Multicast），且需要根据多个条件进行灵活匹配的场景。例如，日志系统根据日志级别和来源进行分发（如：'log.error.system'可以匹配到bindingkey为'log.error.*'或'log.#'的队列）。###3.FanoutExchange(扇出交换机)-**工作方式**：将消息广播到所有绑定到该交换机的队列，忽略routingkey。-**使用场景**：适用于消息的广播（Broadcast）。例如，一个用户注册后需要同时发送欢迎邮件和创建用户数据目录，这两个任务可以分别由不同的队列处理。###代码示例（使用Pythonpika库）####声明交换机```pythonimportpikaconnection=pika.BlockingConnection(pika.ConnectionParameters('localhost'))channel=connection.channel()#声明三种类型的交换机channel.exchange_declare(exchange='direct_logs',exchange_type='direct')channel.exchange_declare(exchange='topic_logs',exchange_type='topic')channel.exchange_declare(exchange='fanout_logs',exchange_type='fanout')```####绑定队列与发送消息示例#####1.DirectExchange示例```python#生产者：发送消息到direct_logs交换机，指定routing_keychannel.basic_publish(exchange='direct_logs',routing_key='error',body='Errorlogmessage')#消费者：声明队列并绑定到direct_logs交换机，指定binding_key为'error'channel.queue_declare(queue='error_logs_queue')channel.queue_bind(exchange='direct_logs',queue='error_logs_queue',routing_key='error')#只有指定routing_key为'error'的消息会被路由到error_logs_queue```#####2.TopicExchange示例```python#生产者：发送消息到topic_logs交换机，指定不同的routing_keychannel.basic_publish(exchange='topic_logs',routing_key='auth.error',body='AuthError')channel.basic_publish(exchange='topic_logs',routing_key='system.warning',body='SystemWarning')#消费者1：绑定所有error级别的日志channel.queue_declare(queue='all_error_logs')channel.queue_bind(exchange='topic_logs',queue='all_error_logs',routing_key='*.error')#该队列会收到routing_key为'auth.error'和'app.error'的消息，但不会收到'system.warning'#消费者2：绑定所有系统相关的日志channel.queue_declare(queue='system_logs')channel.queue_bind(exchange='topic_logs',queue='system_logs',routing_key='system.*')#该队列会收到routing_key为'system.warning'和'system.error'的消息```#####3.FanoutExchange示例```python#生产者：发送消息到fanout_logs交换机，routing_key被忽略channel.basic_publish(exchange='fanout_logs',routing_key='',body='Broadcastmessage')#消费者：任意绑定的队列都会收到消息channel.queue_declare(queue='mail_queue')channel.queue_bind(exchange='fanout_logs',queue='mail_queue')channel.queue_declare(queue='storage_queue')channel.queue_bind(exchange='fanout_logs',queue='storage_queue')#两个队列都会收到同样的消息```###总结对比表|交换机类型|路由规则|典型应用场景||--------------|------------------------------------|--------------------------------||Direct|精确匹配routingkey和bindingkey|单播，点对点消息（如任务分发）||Topic|通配符模式匹配|多播，多条件灵活匹配（如日志分类）||Fanout|广播，忽略routingkey|广播（如事件通知）|###相关问题§§相关问题§§:1.RabbitMQ中Headers交换机的原理和使用场景是什么？2.在RabbitMQ中如何实现消息的延迟队列？3.RabbitMQ的集群如何搭建？有哪些需要注意的配置？4.如何确保RabbitMQ在消息处理失败时进行重试？</think> ### RabbitMQ中Direct、Topic、Fanout交换机的区别及使用场景 在RabbitMQ中，交换机(exchange)是消息路由的核心组件，决定了消息如何从生产者路由到队列。以下是三种主要交换机的对比： | 交换机类型 | 路由机制 | 使用场景 | 特点 | |-----------|---------|---------|------| | **Direct** | 精确匹配routing key | 点对点精准投递 | 1:1精确路由 | | **Topic** | routing key模式匹配 | 多条件复杂路由 | 支持通配符 | | **Fanout** | 无路由逻辑 | 广播消息 | 1:N广播 | --- ### 1. Direct Exchange (直连交换机) **原理**：将消息路由到与消息的routing key**完全匹配**的队列 **适用场景**： - 精确的任务分发（如根据消息类型路由） - 需要1:1精确路由的场景 - 日志系统的不同级别处理（error/info/warn） ```python # 生产者 - 发送到指定routing key的队列 channel.exchange_declare(exchange='direct_logs', exchange_type='direct') channel.basic_publish( exchange='direct_logs', routing_key='error', # 精确匹配 body='ERROR: Something failed!' ) # 消费者 - 绑定特定key的队列 channel.queue_declare(queue='error_queue') channel.queue_bind( exchange='direct_logs', queue='error_queue', routing_key='error' # 只接收error消息 ) ``` --- ### 2. Topic Exchange (主题交换机) **原理**：使用通配符匹配模式，支持`*`(单单词)和`#`(多单词)通配符 **适用场景**： - 多维度消息路由（如地区+产品类别） - 复杂条件匹配 - 动态订阅系统 ```python # 生产者 - 发送带复杂routing key的消息 channel.exchange_declare(exchange='topic_orders', exchange_type='topic') channel.basic_publish( exchange='topic_orders', routing_key='us.electronics.order', # 可匹配*.order body='New US electronics order' ) # 消费者1 - 接收所有电子订单 channel.queue_bind( exchange='topic_orders', queue='electronics_q', routing_key='*.electronics.order' # 匹配所有地区的电子订单 ) # 消费者2 - 接收所有订单 channel.queue_bind( exchange='topic_orders', queue='all_orders_q', routing_key='#.order' # #匹配任意多级路由 ) ``` --- ### 3. Fanout Exchange (扇出交换机) **原理**：忽略routing key，将消息广播到所有绑定的队列 **适用场景**： - 事件广播（如系统配置更新） - 状态同步 - 多消费者并行处理 ```python # 生产者 - 广播消息 channel.exchange_declare(exchange='config_updates', exchange_type='fanout') channel.basic_publish( exchange='config_updates', routing_key='', # 被忽略 body='Config update: v2.0' ) # 消费者1 - 缓存服务 channel.queue_bind(exchange='config_updates', queue='cache_update_q') # 消费者2 - 日志服务 channel.queue_bind(exchange='config_updates', queue='log_update_q') ``` --- ### 交换机类型选择流程图 ``` +----------------+ | 需要广播所有队列? | +-------+--------+ | +--------------+-------------+ | | +---------v---------+ +----------v---------+ | 路由条件是否复杂匹配？ | | 使用Fanout Exchange | +---------+---------+ +---------------------+ | +---------v---------+ | 需要精确键值匹配？ | +---------+---------+ | +-----------v-----------+ | 是:Direct / 否:Topic | +-----------------------+ ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值