Rabbitmq 不同交换机类型如何使用，一文教会你

最新推荐文章于 2024-09-07 18:04:56 发布
最新推荐文章于 2024-09-07 18:04:56 发布
阅读量1k 收藏 23
点赞数 34
分类专栏： rabbitmq java技术 文章标签： rabbitmq 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwl2220943286/article/details/135469321
版权
1、Rabbitmq组件介绍

消息队列有三个核心要素： 消息生产者、消息队列、消息消费者；

1）、生产者（Producer）：发送消息的应用；（java程序，也可能是别的语言写的程序）

2）、消费者（Consumer）：接收消息的应用；（java程序，也可能是别的语言写的程序）

3）、代理（Broker）：就是消息服务器，RabbitMQ Server就是Message Broker；

4）、连接（Connection）：连接RabbitMQ服务器的TCP长连接；

5）、信道（Channel）：连接中的一个虚拟通道，消息队列发送或者接收消息时，都是通过信道进行的；

6）、虚拟主机（Virtual host）：一个虚拟分组，在代码中就是一个字符串，当多个不同的用户使用同一个RabbitMQ服务时，可以划分出多个Virtual host，每个用户在自己的Virtual host创建exchange/queue等；（分类比较清晰、相互隔离）

7）、交换机（Exchange）：交换机负责从生产者接收消息，并根据交换机类型分发到对应的消息队列中，起到一个路由的作用；

8）、路由键（Routing Key）：交换机根据路由键来决定消息分发到哪个队列，路由键是消息的目的地址；

9）、绑定（Binding）：绑定是队列和交换机的一个关联连接（关联关系）；

10）、队列（Queue）：存储消息的缓存；

11）、消息（Message）：由生产者通过RabbitMQ发送给消费者的信息；（消息可以任何数据，字符串、user对象，json串等等）。

2、引入依赖和添加配置（application.yml）
2.1、引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>3.1.2</version>
</dependency>
2.2、配置信息
spring:
  rabbitmq:
    host: 192.168.30.88
    port: 5672
    username: admin
    password: admin
    virtual-host: test   # 指定虚拟主机
3、交换机的类型与具体编码实现
3.1、交换机类型

1）、Fanout Exchange（扇形）
2）、Direct Exchange（直连）
3）、Topic Exchange（主题）
4）、Headers Exchange（头部） 

3.2、Fanout Exchange

         Fanout 扇形的，散开的； 扇形交换机投递消息到所有绑定的队列，不需要路由键，不需要进行路由键的匹配，相当于广播、群发。

 Fanout Exchange 配置代码实现

rabbit:
  fanout:
    exchangeName: exchange.fanout
    queueAName: queue.fanout.a
    queueBName: queue.fanout.b
@SpringBootConfiguration
@ConfigurationProperties(prefix = "rabbit.fanout")
@Data
public class RabbitConfigFanout {
    private String exchangeName;
    private String queueAName;
    private String queueBName;
    // 1、定义交换机，可以采用new的方式，也可以采用建造者模式
    @Bean
    public FanoutExchange fanoutExchange(){
        return ExchangeBuilder.fanoutExchange(exchangeName).build();
    }
    // 2、定义队列
    @Bean
    public Queue queueA(){
        return  QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB(){
        return  QueueBuilder.durable(queueBName).build();
    }
    // 3、绑定交换机和对列
    @Bean
    public Binding bindingA(FanoutExchange exchange, Queue queueA){
        return BindingBuilder.bind(queueA).to(exchange);
    }
    @Bean
    public Binding bindingB(FanoutExchange exchange, Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange);
    }
}

Fanout Exchange 生产者代码实现

@Autowired
private RabbitTemplate rabbitTemplate;
public void sendMessage(){
    String msg = "hello world!";
    Message message = new Message(msg.getBytes());
    // 向指定的交换机中发送message
    rabbitTemplate.convertAndSend("exchange.fanout", "", message);

}

Fanout Exchange 消费者代码实现

// 从两个队列中获取消息
@RabbitListener(queues = {"queue.fanout.a", "queue.fanout.b"})
public void rec(Message message){
    String msg = new String(message.getBody());
    System.out.println(msg);
}
3.3、Direct Exchange

        根据路由键精确匹配（一模一样）进行路由消息队列。  

 Direct Exchange 配置代码实现

rabbit:
  direct:
    exchangeName: exchange.direct
    queueAName: queue.direct.a
    queueBName: queue.direct.b
@SpringBootConfiguration
@ConfigurationProperties(prefix = "rabbit.direct")
@Data
public class RabbitConfigDirect {
    private String exchangeName;
    private String queueAName;
    private String queueBName;
    // 1、定义交换机
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange(exchangeName).build();
    }
    // 2、定义队列
    @Bean
    public Queue queueA(){
        return  QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB(){
        return  QueueBuilder.durable(queueBName).build();
    }
    // 3、通过精确路由key绑定交换机和对列
    @Bean
    public Binding bindingA(DirectExchange exchange, Queue queueA){
        return BindingBuilder.bind(queueA).to(exchange).with("error");
    }
    @Bean
    public Binding bindingB(DirectExchange exchange, Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange).with("info");
    }
    @Bean
    public Binding bindingC(DirectExchange exchange, Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange).with("error");
    }
    @Bean
    public Binding bindingD(DirectExchange exchange, Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange).with("warning");
    }
}

Direct Exchange 生产者代码实现

@Autowired
private RabbitTemplate template;
public void sendMsg(){
    Message message = MessageBuilder.withBody("hello long".getBytes()).build();
    // 向指定的交换机和指定路由key发送message
    template.convertAndSend("exchange.direct", "error", message);
}

Direct Exchange 消费者代码实现

// 从两个队列中获取消息
@RabbitListener(queues = {"queue.direct.a"})
public void rec(Message message){
    String msg = new String(message.getBody());
    System.out.println(msg);
}
3.4、Topic Exchange

        通配符匹配，相当于模糊匹配；

1）、# 匹配多个单词，用来表示任意数量（零个或多个）单词；

2）、* 匹配一个单词（必须有一个，而且只有一个），用 . 隔开的为一个单词。

例如：

        aaa.# == aaa.queue.abc, aaa.queue.xyz.xxx

        aaa.* == aaa.queue, aaa.xyz

 

 Topic Exchange 配置代码实现

rabbit:
  topic:
    exchangeName: exchange.topic
    queueAName: queue.topic.a
    queueBName: queue.topic.b
@SpringBootConfiguration
@ConfigurationProperties(prefix = "rabbit.topic")
@Data
public class RabbitConfigTopic {
    private String exchangeName;
    private String queueAName;
    private String queueBName;
    // 1、定义交换机
    @Bean
    public TopicExchange topicExchange(){
        return ExchangeBuilder.topicExchange(exchangeName).build();
    }
    // 2、定义队列
    @Bean
    public Queue queueA(){
        return  QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB(){
        return  QueueBuilder.durable(queueBName).build();
    }
    // 3、通过匹配路由key绑定交换机和对列
    @Bean
    public Binding bindingA(DirectExchange exchange, Queue queueA){
        return BindingBuilder.bind(queueA).to(exchange).with("*.orange.*");
    }
    @Bean
    public Binding bindingB(DirectExchange exchange, Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange).with("*.*.rabbit");
    }
    @Bean
    public Binding bindingC(DirectExchange exchange, Queue queueB){
        return BindingBuilder.bind(queueB).to(exchange).with("lazy.#");
    }
}

Topic Exchange 生产者代码实现

@Autowired
private RabbitTemplate template;
public void sendMsg(){
    Message message = MessageBuilder.withBody("hello long".getBytes()).build();
    // 向指定的交换机和指定路由key发送message
    template.convertAndSend("exchange.topic", "lazy.a.b", message);
}

Topic Exchange 消费者代码实现

// 从两个队列中获取消息
@RabbitListener(queues = {"queue.topic.a"})
public void rec(Message message){
    String msg = new String(message.getBody());
    System.out.println(msg);
}
3.5、Headers Exchange

        基于消息内容中的headers属性进行匹配。

Headers Exchange 配置代码实现

rabbit:
  headers:
    exchangeName: exchange.headers
    queueAName: queue.headers.a
    queueBName: queue.headers.b

 

@SpringBootConfiguration
@Data
@ConfigurationProperties(prefix = "rabbit.headers")
public class RabbitConfigHeaders {
    private String exchangeName;
    private String queueAName;
    private String queueBName;
    // 1、定义交换机
    @Bean
    public HeadersExchange headersExchange(){
        return ExchangeBuilder.headersExchange(exchangeName).build();
    }
    // 2、定义队列
    @Bean
    public Queue queueA(){
        return QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB(){
        return QueueBuilder.durable(queueBName).build();
    }
    // 3、绑定
    @Bean
    public Binding bindingA(HeadersExchange exchange, Queue queueA){
        Map<String, Object> headers = new HashMap<>();
        headers.put("type", "m");
        headers.put("status", 1);
        return BindingBuilder.bind(queueA).to(exchange).whereAll(headers).match();
    }
    @Bean
    public Binding bindingB(HeadersExchange exchange, Queue queueB){
        Map<String, Object> headers = new HashMap<>();
        headers.put("type", "s");
        headers.put("status", 0);
        return BindingBuilder.bind(queueB).to(exchange).whereAll(headers).match();
    }
}

Headers Exchange 生产者代码实现

@Autowired
private RabbitTemplate template;
public void sendMsg(){
    // 自定义消息属性
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setHeader("type", "m");
    messageProperties.setHeader("status", 1);
    Message message = MessageBuilder.withBody("hello long".getBytes()).andProperties(messageProperties).build();
    template.convertAndSend("exchange.headers", "", message);
}

Headers Exchange 消费者代码实现

// 从两个队列中获取消息
@RabbitListener(queues = {"queue.headers.a"})
public void rec(Message message){
    String msg = new String(message.getBody());
    System.out.println(msg);
}
4、总结

        本文详细介绍了Rabbitmq几种交换机的使用，后续更高级的用法将会在公众号上分享，关注下面微信公众号学习更多内容。

        本人是一个从小白自学计算机技术，对运维、后端、各种中间件技术、大数据等有一定的学习心得，想获取自学总结资料（pdf版本）或者希望共同学习，关注微信公众号：it自学社团。后台回复相应技术名称/技术点即可获得。（本人学习宗旨：学会了就要免费分享）

知其_所以然
关注
专栏目录
【RabbitMQ】交换机详解看这一篇就够了
万维网连五洲，二进制写尽天下事，喜欢结识新伙伴寻找志同道合的朋友，欢迎一起探讨学习
01-22 8702
交换机（Exchange）是消息队列中的一个重要概念，用于实现消息的路由和分发。交换机接收发布到它的消息，并根据特定的规则将消息发送到一个或多个队列中。 在消息队列系统中，交换机起到了消息的分发中心的作用。它接收生产者发送的消息，并根据预定义的路由规则将消息发送到符合条件的队列中，然后由消费者从队列中获取并处理消息。
RabbitMQ四种交换机类型介绍
dgush2000的博客
10-31 326
RabbitMQ 原文地址: https://baijiahao.baidu.com/s?id=1577456875919174629&wfr=spider&for=pc 最新版本的RabbitMQ有四种交换机类型，分别是Direct exchange、Fanout exchange、Topic exchange、Headers exchange。 D...
深入RabbitMQ世界：探索3种队列、4种交换机、7大工作模式及常见概念
最新发布
Apple_Boy的博客
09-07 1328
DirectExchange 的路由策略是将消息队列绑定到一个 DirectExchange 上，当一条消息到达 DirectExchange 时会被转发到与该条消息 routing key 相同的 Queue 上，例如消息队列名为 “directQueue1”，则 routingkey 为 “directQueue1” 的消息会被该消息队列接收。// Config@Bean@Bean@Bean@Bean@Bean可以发现我们可以根据routingKey控制发送到哪个队列上，
RabbitMQ的四种交换机类型
weixin_45074479的博客
03-22 483
其中RabbitMQ的四种交换机类型
RabbitMQ的交换机的四种类型
YSの陈憨憨
07-21 1090
Direct类型交换机///1.在发送消息的时候，通过Direct类型的路由转发；//要求Direct类型交换机和队列绑定；绑定需要一个标识，生产者在发送消息的时候，也需要指定一个标识，消息发送给交换机以后，交换机进行标识的匹配；知道和交换机绑定队列完全吻合的标识，只要是匹配到了，就把消息通过交换机转发给当前绑定标识吻合的这个队列中去；//Direct类型的交换机可以做点啥？//如果说有一个生产者发送了很多消息，需要把消息分类处理；//消息需要分几类，就可以定义几个队列；
关于RabbitMQ交换机的理解
dengwan3818的博客
10-17 449
RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 消息(Message)由Client发送，RabbitMQ接收到消息之后通过交换机转发到对应的队列上面。Worker会从队列...
批量删除rabbitmq的队列或交换机
06-29
采用python编写的批量删除rabbitmq的队列或交换机。 1.修改rabbitmq_delete.py中rabbitmq的配置； 2.执行以下命令： 删除队列: python3 rabbitmq_delete.py -k ‘udata.climb’ -d 1 删除交换机: python3 rabbitmq_...
浅析RabbitMQ五种交换机类型，六种队列模式
Lorie_chen的博客
10-24 1686
浅析RabbitMQ五种交换机类型，六种队列模式 五种交换机类型，六种队列模式浅析RabbitMQ五种交换机类型，六种队列模式5种交换机类型 ExchangeDirect exchange(直连交换机)Topic exchange(主题交换机)Fanout exchange(扇型交换机)Headers exchange(头交换机)System exchange(默认类型)6种队列模式hello word 模式（单点对点模式）work模式（工厂模式）Publish/Subscribe（发布-订阅者模式）rou
RabbitMQ与交换机
weixin_66202611的博客
12-18 787
直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing_key，当消息被发送的时候，需要指定一个binding_key，这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。主题交换机的routing_key需要有一定的规则，交换机和队列的binding_key需要采用*.#.*.....的格式，每个部分用.分开，其中。因此，当携带着名为”hello”的路由键的消息被发送到默认交换机的时候，此消息会被默认交换机路由至名为”hello”的队列中。
RabbitMQ交换机
Forrest Gump的博客
06-19 1022
一、交换机的属性 Name:交换机的名称 Type:交换机的类型,direct,topic,fanout,headers Durability:是否需要持久化 autodelete:假如没有队列绑定到该交换机，那么该交换机会自动删除 Internal:当前交换机是否用户rabbitmq内部使用不常用,默认为false Argurements:扩展参数,用户扩展AMQP 定制化协议 二、交换机的类型 2.1 直接交换机 direct exchange 所有发送到direct exchange的消息都会被投递到
RabbitMQ的队列、交换机类型的概念与作用
hkl_Forever的博客
11-17 847
（8）x-single-active-consumer：表示队列是否是单一活动消费者，true时，注册的消费组内只有一个消费者消费消息，其他被忽略，false时消息循环分发给所有消费者(默认false)（7）x-dead-letter-routing-key：死信消息路由键，在消息发送到死信交换器时会使用该路由键，如果不设置，则使用消息的原来的路由键值。（4）x-max-length-bytes：队列消息内容占用最大空间，受限于内存大小，超过该阈值则从队列头部开始删除消息；到底如何操作取决于交换机的类型。
RabbitMQ之交换机
热门推荐
m0_53151031的博客
02-27 1万+
一、RabbitMQ交换机 二、RabbitMQ交换机实例讲解
（三）丶RabbitMQ的四种类型交换机
weixin_52466601的博客
03-15 2112
四大交换机工作原理及实战应用。
[MQ] RabbitMQ交换机类型
浅夜
09-04 286
四种类型 Direct： 消息中的路由键（routing key）如果和 Binding 中的 binding key 一致，交换器就将消息发到对应的队列中。它是完全匹配、单播的模式。 Fanout： 每个发到 fanout 类型交换器的消息都会分到所有绑定的队列上去。很像子网广播，每台子网内的主机都获得了一份复制的消息。fanout 类型转发消息是最快的 topic： topic 交换器通过模式匹配分配消息的路由键属性，将路由键和某个模式进行匹配，此时队列需要绑定到一个模式上。它将路由键和绑定键的字符串切
RabbitMQ交换机类型
越努力越幸运。
02-02 798
发送消息时间，如果其他参数信息是{ "name":"xiaomingXX", "sex":"男" }，因为queue2的x-match是any，只需要有一个键值对匹配所以就能接收到消息，所以queue2可以接收到消息；路由键与队列名完全匹配交换机，此种类型交换机，通过RoutingKey路由键将交换机和队列进行绑定， 消息被发送到exchange时，需要根据消息的RoutingKey，来进行匹配，只将消息发送到完全匹配到此RoutingKey的队列。键"x-match"的值有2个。
RabbitMQ四种交换机类型
web13618542420的博客
08-02 912
最新版本的RabbitMQ有四种交换机类型，分别是Directexchange、Fanoutexchange、Topicexchange、Headersexchange。本文用SpringBoot工程具体介绍四种交换机的使用。
RabbitMQ的几种交换机类型
程序员阿红的博客
03-15 833
RabbitMQ的几种交换机类型
rabbitMQ的交换机类型
Zhangxi
05-11 866
1、默认交换机（default exchange）实际上是一个由消息代理预先声明好的没有名字（名字为空字符串）的直连交换机（direct exchange）。它有一个特殊的属性使得它对于简单应用特别有用处：那就是每个新建队列（queue）都会自动绑定到默认交换机上，绑定的路由键（routing key）名称与队列名称相同。 2、Direct exchange（直连交换机），(Empty st
rabbitmq交换机类型
09-23
RabbitMQ的交换机类型共有四种：Direct Exchange（直连交换机）、Fanout Exchange（扇型交换机）、Topic Exchange（主题交换机）和Headers Exchange（头交换机）。 Direct Exchange是最简单的交换机类型，它通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

知其_所以然

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

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

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

打赏作者

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

抵扣说明：

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

余额充值