RabbitMQ.交换机

最新推荐文章于 2024-10-06 19:15:22 发布
最新推荐文章于 2024-10-06 19:15:22 发布
阅读量1.4k 收藏
点赞数
分类专栏： rabbitmq 文章标签： rabbitmq 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Cat_Jay_Fish/article/details/123149185
版权
本文介绍了RabbitMQ中的交换机类型，包括直连交换机、主题交换机和扇形交换机。详细阐述了各自的特性和使用场景，并提供了Java实现的生产者和消费者示例，帮助读者理解如何配置和使用这些交换机。

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

交换机（Exchange）

 

 交换机的属性

Name：交换机名称

Type：交换机类型，direct,topic,fanout,headers

 Durability:是否需要持久化，如果持久性，则RabbitMQ重启后，交换机还存在

Auto Delet：当最后一个绑定到Exchange的队列删除后，自动删除改Exchange

Internal：当前Exchange是否用于RabbitMQ内部使用，默认为False

Arguments：扩展参数，用于扩展AMQP协议定制化使用

一、直连交换机

1、生产者

①、application.yml

server:
    port: 8081
spring:
    application:
        name: provider
    rabbitmq:
        host: 192.168.211.128
        password: 123456
        port: 5672
        username: springboot
        virtual-host: my_vhost

 ②、DirectConfig：

package com.example.provider.mq;


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
@SuppressWarnings("all")
public class DirectConfig {

    /**
     * 创建队列
     * @return
     */
    @Bean
    public Queue directQueueA(){
        return new Queue("directQueueA",true);
    }
    @Bean
    public Queue directQueueB(){
        return new Queue("directQueueB",true);
    }
    @Bean
    public Queue directQueueC(){
        return new Queue("directQueueC",true);
    }

    /**
     * 创建交换机
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("directExchange");
    }

    /**
     * 进行交换机和队列的绑定，设置bindingkey
     */
    @Bean
    public Binding BindingA(){
        return BindingBuilder.bind(directQueueA()).to(directExchange()).with("AA");
    }
    @Bean
    public Binding BindingB(){
        return BindingBuilder.bind(directQueueB()).to(directExchange()).with("BB");
    }
    @Bean
    public Binding BindingC(){
        return BindingBuilder.bind(directQueueC()).to(directExchange()).with("CC");
    }

}

③、ProviderController

package com.example.provider;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@SuppressWarnings("all")
public class ProviderController {

    @Autowired
    private RabbitTemplate template;

    @RequestMapping("/directSend")
    public String directSend(String routingKey){
        template.convertAndSend("directExchange",routingKey,"hello world");
        return "yes";
    }

}

 ④、消费者application.yml文件

server:
    port: 8082
spring:
    application:
        name: consumer
    rabbitmq:
        host: 192.168.211.128
        password: 123456
        port: 5672
        username: springboot
        virtual-host: my_vhost

⑤、运行测试

 

 此时RabbitMQ队列中就有了三个消息队列

2、消费者 

 ①、DirectReceiverA

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="directQueueA")
@Slf4j
public class DirectReceiverA {

    @RabbitHandler
    public void process(String message){
        log.info("A接到"+message);
    }

}

②、DirectReceiverB 

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="directQueueB")
@Slf4j
public class DirectReceiverB {

    @RabbitHandler
    public void process(String message){
        log.info("B接到"+message);
    }

}

③、DirectReceiverC 

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="directQueueC")
@Slf4j
public class DirectReceiverC {

    @RabbitHandler
    public void process(String message){
        log.info("C接到"+message);
    }

}

运行测试

 二、主题交换机

1、生产者

①、TopicConfig 

package com.example.provider.mq;


import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@SuppressWarnings("all")
public class TopicConfig {
    
    public final static String KEY_A="*.orange.*";
    public final static String KEY_B="*.*.rabbit";
    public final static String KEY_C="lazy.#";

    /**
     * 创建队列
     * @return
     */
    @Bean
    public Queue topicQueueA(){
        return new Queue("topicQueueA",true);
    }
    @Bean
    public Queue topicQueueB(){
        return new Queue("topicQueueB",true);
    }
    @Bean
    public Queue topicQueueC(){
        return new Queue("topicQueueC",true);
    }

    /**
     * 创建交换机
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }

    /**
     * 进行交换机和队列的绑定，设置bindingkey
     */
    @Bean
    public Binding topicBindingA(){
        return BindingBuilder.bind(topicQueueA()).to(topicExchange()).with(KEY_A);
    }
    @Bean
    public Binding topicBindingB(){
        return BindingBuilder.bind(topicQueueB()).to(topicExchange()).with(KEY_B);
    }
    @Bean
    public Binding topicBindingC(){
        return BindingBuilder.bind(topicQueueC()).to(topicExchange()).with(KEY_C);
    }

}

②、ProviderController

 @RequestMapping("/topicSend")
    public String toipcSend(String routingKey){
        template.convertAndSend("topicExchange",routingKey,"hello world");
        return "yes";
    }

③、运行测试

符合TopicConfig 中的规则就会增加队列

2、消费者

①、TopicReceiverA 

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="topicQueueA")
@Slf4j
public class TopicReceiverA {

    @RabbitHandler
    public void process(String message){
        log.warn("A接到"+message);
    }

}

②、TopicReceiverB

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="topicQueueB")
@Slf4j
public class TopicReceiverB {

    @RabbitHandler
    public void process(String message){
        log.warn("B接到"+message);
    }

}

③、TopicReceiverC 

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="topicQueueC")
@Slf4j
public class TopicReceiverC {

    @RabbitHandler
    public void process(String message){
        log.warn("C接到"+message);
    }

}

三、扇形交换机 

1、生产者

①、FanoutConfig 

package com.example.provider.mq;


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
@SuppressWarnings("all")
public class FanoutConfig {

    /**
     * 创建队列
     * @return
     */
    @Bean
    public Queue fanoutQueueA(){
        return new Queue("fanoutQueueA",true);
    }
    @Bean
    public Queue fanoutQueueB(){
        return new Queue("fanoutQueueB",true);
    }
    @Bean
    public Queue fanoutQueueC(){
        return new Queue("fanoutQueueC",true);
    }

    /**
     * 创建交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanoutExchange");
    }

    /**
     * 进行交换机和队列的绑定，设置bindingkey
     */
    @Bean
    public Binding fanoutBindingA(){
        return BindingBuilder.bind(fanoutQueueA()).to(fanoutExchange());
    }
    @Bean
    public Binding fanoutBindingB(){
        return BindingBuilder.bind(fanoutQueueB()).to(fanoutExchange());
    }
    @Bean
    public Binding fanoutBindingC(){
        return BindingBuilder.bind(fanoutQueueC()).to(fanoutExchange());
    }

}

②、ProviderController

 @RequestMapping("/fanoutSend")
    public String fanoutSend(){
        template.convertAndSend("fanoutExchange",null,"hello world");
        return "yes";
    }

2、消费者

①、FanoutReceiverA 

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="fanoutQueueA")
@Slf4j
public class FanoutReceiverA {

    @RabbitHandler
    public void process(String message){
        log.error("A接到"+message);
    }

}

 ②、FanoutReceiverB 

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="fanoutQueueB")
@Slf4j
public class FanoutReceiverB {

    @RabbitHandler
    public void process(String message){
        log.error("B接到"+message);
    }

}

③、FanoutReceiverC 

package com.example.consumer.mq;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@SuppressWarnings("all")
@RabbitListener(queues="fanoutQueueC")
@Slf4j
public class FanoutReceiverC {

    @RabbitHandler
    public void process(String message){
        log.error("C接到"+message);
    }

}

运行测试 

本篇博客有大量的代码重复，大家在测试时要注意细小的细节，比如方法名重复或者调用重复方法，大量重复代码只是为了给大家进行演示，希望能帮到你们

bye~

Rabbitmq交换机详解
小小鱼儿小小林的博客
07-26 2134
rabbitmq交换机 1.作用: 接受生产者的消息，然后根据路由键routingKey把消息投递到跟交换机绑定的对应的队列上 2.属性 Name: 交换机的名称 Type: 交换机的类型,direct,topic,fanout,headers Durability :是否需要持久化 autodelete:假如 没有队列绑定到该交换机，那么该交换机会自动删除 Internal: 当前交换机是否用户rabbitmq内部使用不常用,默认为false Argurements: 扩展参数,用户扩展AM.
RabbitMQ交换机
xieminglu的博客
12-22 520
RabbitMQ交换机 交换机属性： Name：交换机名称 Type：交换机类型 direct、topic、fanout、headers Durability：是否需要持久化，true为持久化 Auto Delete：当最后一个绑定到Exchange上的队列删除后，自动删除该Exchange Internal：当前Exchange是否用于RabbitMQ内部使用，默认为False Argumen...
MQ消息队列（六）RabbitMQ如何创建交换机如何创建队列_rabbitmq手动创建交换机
2401_84166327的博客
04-13 217
【代码】MQ消息队列（六）RabbitMQ如何创建交换机如何创建队列_rabbitmq手动创建交换机。
RabbitMQ学习（五）-- 交换机学习（第三个部分：发布-订阅模式）
行无所至，学无所尽。
07-24 265
RabbitMQ交换机学习 在之前的学习中，我们是创建了一个工资队列。我们假设的是在工作队列背后，每个人物都恰好交付给一个确认的消费者（工作进程）。在本节的学习中，我们将做一些不同的事情：将消息传递给多个消费者。这种模式被称为发布/订阅模式； 为了说明这种模式，我们将构建一个简单的日志系统，由两个程序组成： 第一个程序将发出日志消息； 第二个程序是消费者； 届时将启动两个消费者，其中一个消费者接收到消息之后将日志存储在磁盘中，另外一个消费者接收到消息之后打印在屏幕上，相当于是第一个程序发出的日志消息将广播
RabbitMQ
weixin_62735525的博客
12-22 1095
带你快速了解RabbitMQ
RabbitMQ入门5—exchange参数之durability
最新发布
小诸葛的博客
10-06 647
在 RabbitMQ 中，durability参数不仅可以应用于队列，也可以应用于交换机（Exchange）。durability参数决定了在 RabbitMQ 服务器重启后是否仍然存在。durability。
RabbitMqHelper.cs+RabbitMQ.Client.dll
10-26
RabbitMQ是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，被广泛用于分布式系统中的可靠消息传递。在.NET环境中，我们通常使用RabbitMQ.Client.dll这个库来与RabbitMQ...
RabbitMQ.tar.gz
04-12
安装完成后，用户可以使用RabbitMQ的命令行工具进行管理操作，如创建虚拟主机、定义交换机和队列、绑定队列等。 4. 配套安装：为了确保RabbitMQ的正常运行，还需要安装必要的依赖和配置防火墙规则。例如，可能需要...
RabbitMQ.Client.5.2.0.rar
09-30
4. **交换机（Exchange）**：交换机是RabbitMQ中的核心组件，它根据预设的路由规则（binding key）接收消息，并将其分发到适当的队列。RabbitMQ.Client提供了创建、删除交换机以及指定交换机类型（如Direct、Fanout...
RabbitMQ.docx
09-05
3. 创建RabbitTemplate实例，配置交换机、队列和绑定规则。 4. 实现消息生产者和消费者：生产者调用RabbitTemplate发送消息，消费者监听队列接收消息。 在SpringBoot中整合RabbitMQ的典型应用场景包括模拟用户下单...
RabbitMQ-交换机
m0_60301012的博客
07-09 1300
描述下Direct交换机与Fanout交换机的差异？
RabbitMQ简介与springboot整合
2401_84048161的博客
04-04 707
在面试前我整理归纳了一些面试学习资料，文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！大家看完有什么不懂的可以在下方留言讨论也可以关注。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！美团滴滴这类大厂的资料及案例[外链图片转存中…(img-zDh1tnZK-1712184541133)]
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4969
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
RabbitMq中的durable
热门推荐
Lvlht的博客
04-18 1万+
RabbitMq对交换器，队列，消息都可以声明持久化属性，交换器和队列持久化属性为durable（其属性值为false代表不持久化，属性值为true代表持久化），消息持久化属性为deliveryMode（其属性值为1代表不持久化，属性值为2代表持久化）。 在说明durable之前，需要指出的是： 1，RabbitMq实例以broker表示，当broker重启时，所有未申明durable的交换器和队...
RabbitMQ之交换机
Kobe Bryant
12-24 360
交换机 交换机属性： Name：交换机名称 Type：交换机类型 direct、topic、fanout、headers Durability：是否需要持久化，true为持久化 Auto Delete：当最后一个绑定到Exchange上的队列删除后，自动删除该Exchange Internal：当前Exchange是否用于RabbitMQ内部使用，默认为False Arguments：扩展参数，用...
（十五）springboot实战rabbitmq --- Fanout模式
QingFeng-Li的博客
09-27 3366
前几篇文章介绍了rabbitmq的原理介绍，springboot整合rabbitmq的direct模式和topic模式这篇文章我们来介绍一下Fanout广播模式 rabbitmq的其他内容我就不介绍了，如果有直接使用广播模式的小伙伴建议读下前面的原理和其他模式的介绍这样能加深你的理解。没有理解原理的技术应用只是行尸走肉。 其中的pom配置和application.properties配置相同。 F...
Spring Boot 整合 RabbitMQ 之 Fanout Exchange模式 (三)
https://gitee.com/micai-code
11-06 9427
摘要：那前面已经介绍过了Direct模式 (一)Topic转发模式 (二)，这次介绍下Fanout Exchange形式又叫广播形式,因此我们发送到路由器的消息会使得绑定到该路由器的每一个Queue接收到消息,这个时候就算指定了Key,或者规则(即上文中convertAndSend方法的参数2),也会被忽略!那么直接上代码,发送端配置如下: package com.micai.sprin
springboot整合RabbitMq实现fanout交换机（1）
ls_call520的专栏
08-06 265
1、pom依赖 2、yml配置文件 3、属性配置类 @Component public class FanoutExchangeConfig { /** * 短信队列 */ public static final String FANOUT_SMS_QUEUE="fanout_sms_queue"; /** * 邮件队列 */ public static final String FANOUT_EMAIL_QUEUE="fano..
RabbitMq 如何使用Fanout方式进行广播
m0_37637141的博客
08-14 1688
今天小编说的是前两天在工作中遇到的问题： 在项目中使用rabbitmq 发送消息和接收消息，如果项目在一台机器上部署则使用Direct方式即可，但是如果把项目部署到n台机器上，发送一条消息，则n台机器都能同时接收消息，则需要使用Fanout方式来实现，而且需要创建n个队列进行接收消息.这样就实现了一条消息被多个消费者同时消费。 首先，配置FanoutExchange为一个bean @Bea...
python rabbitmq rabbitmq.conf
04-10
Python RabbitMQ是一个用于与RabbitMQ消息队列进行交互的Python客户端库。RabbitMQ是一个开源的消息代理，它实现了高级消息队列协议（AMQP），用于在应用程序之间进行可靠的异步通信。 RabbitMQ的配置文件是rabbitmq.conf，它用于配置RabbitMQ服务器的各种参数和选项。通过修改rabbitmq.conf文件，可以对RabbitMQ进行各种自定义设置，例如网络连接、认证、队列、交换机等。 在rabbitmq.conf文件中，可以设置以下一些常见的配置项： 1. 网络连接相关的配置，如监听地址、端口等。 2. 认证相关的配置，如用户名、密码等。 3. 队列和交换机相关的配置，如持久化、自动删除等。 4. 集群相关的配置，如节点名称、集群节点列表等。 5. 插件相关的配置，如启用或禁用某个插件。 需要注意的是，修改rabbitmq.conf文件后需要重启RabbitMQ服务器才能生效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值