RabbitMQ 四种模式 简易测试

最新推荐文章于 2025-03-17 13:43:29 发布
最新推荐文章于 2025-03-17 13:43:29 发布
阅读量572 收藏
点赞数
分类专栏： 学习随记 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45189306/article/details/105234159
版权
本文介绍了RabbitMQ的三种模式：Topic、Header和fanout。在Topic模式中，生产者使用topic交换机，消费者通过Ribbon轮询机制消费信息。Header模式允许Map条件判断，适用于信息字节传输。而在fanout模式下，生产者无需指定key，消息会广播到所有绑定的队列，消费者配置相应端口接收。

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

RabbitMQ 其中三种模式的测试

Connection 连接TCP/IP 一个应用一般只会 RabbitMQ 连接一个
Channel 寄生在 Connection 和 Exchange 消息队列相关

一个Channel对应着一个消息队列
Connection一般只有一个

多个消费者，消费同一个消息队列
非常有规律的轮流消费生产者发布的信息（Ribbon轮询机制）

多个消费者，同时消费一个 Rounting key ，但队列
不同

多个消费者都可以获取到消息，不会产生轮询
生产者只要生产一次，可以通过相同的 Rounting key,不同消息队列名称都可以消费这条消息
在这里插入图片描述

1、Topic

在这里插入图片描述
在这里插入图片描述
Producer 生产者：
——config：
注册 topic 交换机

@Configuration
public class TopicConfig {

    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange("topic-exchange");
    }
}

——controller:

@RestController
@RequestMapping("/topic")
public class TopicController {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @RequestMapping("/gc/lang")
    public String sendgclang(String msg) {
        rabbitTemplate.convertAndSend("topic-exchange","gc.lang",msg);
        return "/gc.lang 发送" + msg;
    }

    @RequestMapping("/gc/lang/java")
    public String sendLangJava(String msg) {
        rabbitTemplate.convertAndSend("topic-exchange","gc.lang.java",msg);
        return "/gc/lang/java 发送" + msg;
    }

    @RequestMapping("/gc/lang/sql")
    public String sendLangsql(String msg) {
        rabbitTemplate.convertAndSend("topic-exchange","gc.lang.sql",msg);
        return "/gc/lang/sql 发送" + msg;
    }

    @RequestMapping("/gc/lang/http")
    public String sendLanghttp(String msg) {
        rabbitTemplate.convertAndSend("topic-exchange","gc.lang.http",msg);
        return "/gc/lang/http 发送" + msg;
    }

    @RequestMapping("/gc/db/socket")
    public String senddbsocket(String msg) {
        rabbitTemplate.convertAndSend("topic-exchange","gc.db.socket",msg);
        return "/gc/db/socket 发送" + msg;
    }

    @RequestMapping("/gc/db/db")
    public String senddbdb(String msg) {
        rabbitTemplate.convertAndSend("topic-exchange","gc.db.db",msg);
        return "/gc/db/db 发送" + msg;
    }
}

consumer 消费者：
——config:

@Configuration
public class TopicConfig {

    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange("topic-exchange");
    }

    @Bean
    Queue langQueue() {
        return new Queue("gclang");
    }

    @Bean
    Queue dbQueue() {
        return new Queue("gcdb");
    }

    @Bean
    Queue gcQueue() {
        return new Queue("gc");
    }

    @Bean
    Binding langBind() {
        Binding binding = BindingBuilder.bind(langQueue())
                .to(topicExchange())
                .with("gc.lang.#");
        return binding;
    }

    @Bean
    Binding dbBind() {
        Binding binding = BindingBuilder.bind(dbQueue())
                .to(topicExchange())
                .with("gc.db.#");
        return binding;
    }

    @Bean
    Binding gcBind() {
        Binding binding = BindingBuilder.bind(gcQueue())
                .to(topicExchange())
                .with("gc.#");
        return binding;
    }

}

输出结果：

//消费方收到消息做业务处理，检测敏感字符
@Service
public class Topicservices {

    @Autowired(required = false)
    private StudentDao studentDao;

    //Queue helloQ() {
    //        return new Queue("helloQ");
    //    }
    @RabbitListener(queues = "gclang")
    public void dolang(String msg) {
        System.out.println(new Date() + "gc-lang" + msg);
    }

    @RabbitListener(queues = "gcdb")
    public void dodb(String msg) {
        System.out.println(new Date() + "gc-db" + msg);
    }

    /**
     @RabbitListener(queues = "gc")
     public void dogc(String msg) {
     System.out.println(new Date() + "gc" + msg);
     }
     **/
}

2、Header(Map条件判断，信息字节传输)

生产者：
config

@Configuration
public class headerConfig {

    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange("header-exchange");
    }
}

controller:

@RestController
@RequestMapping("/head")
public class HeaderController {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @RequestMapping("/send")
    public String send(Integer id,String token,String msg) {
        System.out.println("id:" + id);
        System.out.println("token:" + token);
        System.out.println("msg:" + msg);
        MessageProperties mp = new MessageProperties();
        if (id != null) {
            mp.setHeader("id",id);
        }
        if (token != null) {
            mp.setHeader("token",token);
        }
        Message message = new Message(msg.getBytes(),mp);
        rabbitTemplate.convertAndSend("header-exchange",null,message);
        return "header send ==>id:" + id + "、token:" + token + "、msg:" + msg;
    }
}

消费者：
config
(any、all、exist、match)

@Configuration
public class headerConfig {

    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange("header-exchange");
    }

    @Bean
    Queue queue1() {
        return new Queue("q1");
    }

    @Bean
    Queue queue2() {
        return new Queue("q2");
    }

    @Bean
    Queue queue3() {
        return new Queue("q3");
    }

    @Bean
    Queue queue4() {
        return new Queue("q4");
    }

    @Bean
    Binding binding1() {    //全部存在 key
        Binding b = BindingBuilder.bind(queue1())
                .to(headersExchange()).whereAll("id","token").exist();
        return b;
    }

    @Bean
    Binding binding2() {    //任意存在
        Binding b = BindingBuilder.bind(queue2())
                .to(headersExchange()).whereAny("id","token").exist();
        return b;
    }

    @Bean
    Binding binding3() {
        Map<String,Object> map = new HashMap<>();
        map.put("id",101);
        map.put("token","t1");
        Binding b = BindingBuilder.bind(queue3())
                .to(headersExchange()).whereAll(map).match();   //value 101 t1
        return b;
    }

    @Bean
    Binding binding4() {
        Map<String,Object> map = new HashMap<>();
        map.put("id",101);
        map.put("token","t1");
        Binding b = BindingBuilder.bind(queue4())
                .to(headersExchange()).whereAny(map).match();   //value 101 t1  任一
        return b;
    }
}

service:

//消费方收到消息做业务处理，检测敏感字符
@Service
public class Hederservices {

    //Queue helloQ() {
    //        return new Queue("helloQ");
    //    }
    @RabbitListener(queues = "q1")
    public void doq1(String msg) {
        System.out.println(new Date() + "q1 id token all" + msg);
    }

    @RabbitListener(queues = "q1")
    public void doq2(String msg) {
        System.out.println(new Date() + "q1_2 id token any" + msg);
    }

    @RabbitListener(queues = "q3")
    public void doq3(String msg) {
        System.out.println(new Date() + "q3 map id=101 token=t1 all value matche" + msg);
    }

    @RabbitListener(queues = "q4")
    public void doq4(String msg) {
        System.out.println(new Date() + "q4 map id=101 token=t1 value anymatche" + msg);
    }

    @RabbitListener(queues = "q1")
    public void doTest(Message message, Channel channel) {
        System.out.println("采用Message格式来接收数据...channel---" + channel.toString());
        System.out.println("message：" + new String(message.getBody()) );
    }
}

3、fanout(广播)

生产者：
config

@Configuration
public class fanoutConfig {

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout-exchange");
    }
}

controller:
无需指定key,只需要绑定模式和端口，即可接收

@RestController
@RequestMapping("/fanout")
public class fanoutController {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @RequestMapping("/send")
    public String sendeMessage(String msg) {
        amqpTemplate.convertAndSend("fanout-exchange","",msg);
        return "/fanout/send 发送" + msg;
    }

}

消费者：
config

@Configuration
public class fanoutConfig {

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout-exchange");
    }

    @Bean
    Queue fanout_queue() {
        return new Queue("fanout_queue");
    }

    @Bean
    Binding fanoutBind() {
        Binding binding = BindingBuilder.bind(fanout_queue())
                .to(fanoutExchange());
        return binding;
    }
}

services:

//消费方收到消息做业务处理，检测敏感字符
@Service
public class fanoutservices {

    //Queue helloQ() {
    //        return new Queue("helloQ");
    //    }
    @RabbitListener(queues = "fanout_queue")
    public void do_fanout_queue(String msg) {
        System.out.println(new Date() + "fanout_queue msg:" + msg);
    }


}
rabbitmq的四种模式
weixin_46132531的博客
04-10 1647
rabbitmq的四种模式 一、Work queues 二、Publish（汉译英–帕布雷斯）/subscribe 模式 三、Routing（汉译英–ruao 挺） 路由模式 四、Topics （汉译英—汤佩克斯）模式 （原6种，常用的四种） 一、Work queues 多个消费端消费同一个队列中的消息，队列采用轮询的方式将消息是平均发送给消费者； 特点： 1、一条消息只会被一个消费端接收； 2、...
RabbitMQ基础篇
weixin_63267854的博客
01-17 1455
这篇博客深入探讨了 RabbitMQ 的核心概念和技术实现，从消息生产、消费到消息确认机制，详细解析了如何确保消息的可靠性和高效性。通过实际案例展示了如何配置和优化 RabbitMQ，解决常见的消息丢失、积压和重试问题。
rabbitmq 测试工具
02-16
rabbitmq 测试工具
MQ：通过 @RabbitListener 创建交换机、队列及绑定
最新发布
千层冷面的博客
03-17 1127
通过 @RabbitListener 的 bindings 属性，可以简洁地声明交换机、队列及其绑定关系，适合快速开发场景
RabbitMQ四种工作模式
qq_37163392的博客
03-29 383
RabbitMQ四种工作模式 创建队列 public final static String USER_LOG = "user.log"; @Bean public Queue userLogQueue() { /* durable：队列是否可持久化，默认为true。 exclusive： 队列是否具有排它性，默认为false。 autoDelete：队列没有任何订阅的消费者时是否自动删除，默认为false。 */ retur
消息队列（四）——rabbitMQ四种工作模式
SuchASilly的博客
06-19 2177
RabbitMQ工作模式 模式总结： 1、简单模式helloworld 一个生产者，一个消费者，不需要交换机（使用默认交换机） 2、工作队列模式Work Queue 一个生产者，多个消费者（竞争关系），不需要设置交换机（默认交换机） 3、发布订阅模式Publish/subscribe 需要设置类型为fanout的交换机，并且交换机和队列绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列 4、路由模式Routing 需要设置类型为direct的交换机，交换机和队列绑定，并且指定routingkey，当
RabbitMQ（四种使用模式）
Sun的个人博客
05-13 2591
/ 定义一个交换机，两个队列的名称// 创建两个队列和一个交换机// 创建队列1@Bean// 创建队列2@Bean// 创建交换机@Bean// 将队列一和交换机绑定@Bean// 将队列二和交换机绑定@Bean// ----------------- Direct模式 -----------------// 定义一个交换机，两个队列的名称// 定义两个路由分别为red和green// 创建两个队列和一个交换机// 创建队列1@Bean。
掌握SpringBoot与RabbitMQ的整合：简易教程
- **自动配置**：Spring Boot 提供了一种全新的编程模式，自动配置能力使得开发者在开发 Spring 应用时可以省去很多样板式的配置工作。 - **起步依赖**：通过在项目中引入特定的“starter”依赖，可以自动引入项目...
上传文件至云平台并通过RabbitMQ发送消息的简易Java应用
- RabbitMQ是基于AMQP协议的一个消息代理，它允许数据在应用程序之间以消息的形式异步传递。它支持不同的消息发送和接收模式，例如点对点和发布/订阅。 - **Python消费者脚本**： - Python是一种广泛使用的高级...
springmvc+rabbitmq+websocket
07-31
在本项目中，"springmvc+rabbitmq+websocket" 是一个整合了Spring MVC、RabbitMQ消息队列和WebSocket技术的简易聊天应用。这个项目旨在展示如何将这三种技术有效地结合，实现一个实时的在线交流平台。以下是这些技术...
RabbitMQ 实现简易即时通讯
空明的博客
07-15 823
利用消息队列的特性进行消息投递，实现简易即时通讯。
rabbitmqtest:使用各种用例测试 RabbitMQ
07-07
RabbitMQ测试 使用各种用例测试 RabbitMQ 从命令行使用 git clone 来签出这个项目。 做 mvn compile 来编译。
rabbitmq常用三种模式的配置
03-16
rabbitmq包含多种模式，主要是fanout，direct，topic，本代码主要针对这三种模式进行相关的配置，配置文件单独放置在不同的文件夹里，以便学习。
RabbitMQ 的四种工作模式
UchihaItachi1的博客
04-10 420
RabbitMQ 的四种工作模式 RabbitMQ 的四种工作模式 1 simple简单模式 消息产生着§将消息放入队列 消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失) 应用场景:聊天(中间有一个过度的服务器;p端,c端) 2 work工作模式(资源...
RabbitMQ的四种工作模式
你今天真好看呀
07-16 844
1. RabbitMQ的工作模式 1.1 简单模式 一个队列只有一个消费者 1.2 工厂模式 多个消费者监听同一个队列 1.3 订阅模式 一个交换机绑定多个消息队列，每个消息队列有一个消费者监听 1.4 路由模式 一个交换机绑定多个消息队列，每个消息队列都由自己唯一的key，每个消息队列有一个消费者监听 2. Spring整合RabbitMQ 创建RabbitMQ队列结构：在host1中共创建6个队列，两个交换机，其中交换机ex1连接queue3 和queue4，交换机ex2连接queue5和qu
Rabbitmq Exchange的四种模式
乐点的博客
09-04 1710
       Rabbitmq为消息队列提供了一个通用的消息发送和接受平台，且保证消息在传输过程中安全可靠。以下是消息从发送到被消费的过程。exchange有四种类型：Direct Exchange；Fanout Exchange；Topic Exchange；Headers Exchange 一、Fanout Exchange       它是最基本的交换机类型，它所能做的事情非常简单—...
java mq几种模式_RabbitMq的几种模式
weixin_34688479的博客
02-27 436
1.RabbitMq的队列的模式 2.RabbitMq的工作队列的模式 3.RabbitMq的发布订阅模式-Fanout模式 什么是发布订阅的fanout的模式？fanout模式又称广播模式即就是在交换机接收到消息后向队列中发送消息是没有任何的规则的，单纯的就是将消息交给后面的队列组进行处理即可;扇型交换机，这个交换机没有路由键概念，就算你绑了路由键也是无视的。 这个交换机在接收到消息后，会直接转...
RabbbitMq入门以及四种队列模式
怪老四的博客
03-19 3012
MQ全称为Message Queue，即消息队列。“消息队列”是在消息的传输过程中保存消息的容器。它是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。
Mac环境下RabbitMq安装与测试教程
difouyan3029的博客
05-27 153
RabbitMq安装与测试教程 Installing on Mac I. 安装 123456789 brew install rabbitmq## 进入安装目录cd /usr/local/Cellar/rabbitmq/3.7.5# 启动brew services start rabbitmq# 当前窗口启动rabbitmq-server ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值