【RabbitMQ】消息传递模型

最新推荐文章于 2025-03-08 10:34:56 发布
原创 最新推荐文章于 2025-03-08 10:34:56 发布 · 795 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rabbitmq #java #分布式

本文详细介绍了RabbitMQ中的四种消息交换类型：fanout（广播）、direct（直连）、topic（主题）和headers（头部）。在广播模式下，消息被发送到所有绑定的队列；直连模式根据路由键将消息发送到指定队列；主题模式允许使用通配符进行路由；头部模式通过消息头的键值匹配来路由消息。通过实例代码展示了每种模式的配置和使用方法。

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

引言

生产者是发送消息的用户程序。队列是存储消息的缓冲区。使用者是接收消息的用户应用程序。RabbitMQ消息传递模型的核心思想是生产者从不直接向队列发送任何消息。实际上，很多时候生产者甚至根本不知道消息是否被传递到任何队列。
相反，生产者只能向交换器发送消息。交换是一件很简单的事情。它一边接收来自生产者的消息，另一边将消息推送到队列。交换器必须确切的知道如何处理它接收到的消息，比如是附加到一个特定的队列还是多个队列或者被丢弃。它的规则由交换类型定义。
交换类型：direct 直连，topic 主题， headers 头部信息，fanout 广播。

一、fanout 广播模式

广播模式类似发布订阅。它的消息可以被多个队列同时接收。
广播模式的特点：

  • 不会处理路由键。只是简单的将队列绑定到交换机上，所以它的处理速度是最快的。
  • 发送到交换机上的消息会被发送到多个队列上。

1.1 广播模式测试

准备几个队列和交换机，然后将队列绑定到交换机上。然后把消息发送到交换机上。消息接收者也要进行修改，监听两个队列。

/**
 * @author 47roro
 * @create 2022/5/8
 * @description: RabbitMQ配置类
 */
@Configuration
public class RabbitMQConfig {

    private static final String QUEUE01 = "queue_fanout01";
    private static final String QUEUE02 = "queue_fanout02";
    private static final String EXCHANGE = "fanoutExchange";

    @Bean
    public Queue queue(){
        return new Queue("queue", true);
    }

    @Bean
    public Queue queue01(){
        return new Queue(QUEUE01);
    }

    @Bean
    public Queue queue02(){
        return new Queue(QUEUE02);
    }

    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(EXCHANGE);
    }

    @Bean
    public Binding binding01(){
        return BindingBuilder.bind(queue01()).to(fanoutExchange());
    }

    @Bean
    public Binding binding02(){
        return BindingBuilder.bind(queue02()).to(fanoutExchange());
    }
}

/**
 * @author 47roro
 * @create 2022/5/8
 * @description: 消息发送者
 */
@Service
@Slf4j
public class MQSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(Object msg){
        log.info("发送消息：" + msg);
        rabbitTemplate.convertAndSend("fanoutExchange",  "", msg);

    }
}

/**
 * @author 47roro
 * @create 2022/5/8
 * @description: 消息消费者
 */
@Service
@Slf4j
public class MQReceiver {

    @RabbitListener(queues = "queue")
    public void receive(Object msg){
        log.info("接收消息：" + msg);
    }

    @RabbitListener(queues = "queue_fanout01")
    public void receive01(Object msg){
        log.info("QUEUE01接收消息：" + msg);
    }

    @RabbitListener(queues = "queue_fanout02")
    public void receive02(Object msg){
        log.info("QUEUE02接收消息：" + msg);
    }
}

1.2 测试结果

登录RabbitMQ远程界面，看到已经出现Exchange和两个queue。
在这里插入图片描述
在这里插入图片描述
发送消息后，两个队列均收到了数据。
在这里插入图片描述
在这里插入图片描述

二、direct 直连模式

所有发送到交换机上的消息，都会被转发到路由键中指定的队列。这个模式可以使用RabbitMQ自带的交换机。

2.1 直连模式测试

修改rabbitMQ配置类

//direct
private static final String QUEUE01 = "queue_direct01";
private static final String QUEUE02 = "queue_direct02";
private static final String EXCHANGE = "directExchange";
private static final String ROUTINGKEY01 = "queue.red";
private static final String ROUTINGKEY02 = "queue.green";

@Bean
public Queue queue01(){
    return new Queue(QUEUE01);
}

@Bean
public Queue queue02(){
    return new Queue(QUEUE02);
}
@Bean
public DirectExchange directExchange(){
    return new DirectExchange(EXCHANGE);
}

@Bean
public Binding binding01(){
    //return BindingBuilder.bind(queue01()).to(fanoutExchange());
    return BindingBuilder.bind(queue01()).to(directExchange()).with(ROUTINGKEY01);
}

@Bean
public Binding binding02(){
    //return BindingBuilder.bind(queue02()).to(fanoutExchange());
    return BindingBuilder.bind(queue02()).to(directExchange()).with(ROUTINGKEY02);
}

修改消息发送者和接收者

public void send01(Object msg){
    log.info("发送red消息：" + msg);
    rabbitTemplate.convertAndSend("directExchange", "queue.red", msg);

}

public void send02(Object msg){
    log.info("发送green消息：" + msg);
    rabbitTemplate.convertAndSend("directExchange", "queue.green", msg);

}

@RabbitListener(queues = "queue_direct01")
public void receive03(Object msg){
    log.info("QUEUE01接收消息：" + msg);
}

@RabbitListener(queues = "queue_direct02")
public void receive04(Object msg){
    log.info("QUEUE02接收消息：" + msg);
}

控制层发送逻辑

/**
 * 测试MQ direct模式发送red
 * @author 47roro
 * @date 2022/5/12
 * @param
 **/
@RequestMapping("/mq/direct01")
@ResponseBody
public void mq02(){
    mqSender.send01("hello,red");
}

/**
 * 测试MQ direct模式发送green
 * @author 47roro
 * @date 2022/5/12
 * @param
 **/
@RequestMapping("/mq/direct02")
@ResponseBody
public void mq03(){
    mqSender.send02("hello,green");
}

2.2 测试结果

管控台已经多了交换机以及绑定的队列和路由键
在这里插入图片描述
在这里插入图片描述
发送消息给red队列。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
发送给green队列也一样。

三、topic 主题模式

topic模式的路由键有通配符，较为方便。
在这里插入图片描述
* 匹配的精确的一个值.#匹配的是0个或多个。
路由键一个都匹配不上的话，会丢弃这个消息。

3.1 主题模式测试

修改RabbitMQ配置类

//topic
private static final String QUEUE01 = "queue_topic01";
private static final String QUEUE02 = "queue_topic02";
private static final String EXCHANGE = "topicExchange";
private static final String ROUTINGKEY01 = "#.queue.#";
private static final String ROUTINGKEY02 = "*.queue.#";

//topic
@Bean
public TopicExchange topicExchange(){
    return new TopicExchange(EXCHANGE);
}

@Bean
public Binding binding01(){
    //return BindingBuilder.bind(queue01()).to(fanoutExchange());
    //return BindingBuilder.bind(queue01()).to(directExchange()).with(ROUTINGKEY01);
    return BindingBuilder.bind(queue01()).to(topicExchange()).with(ROUTINGKEY01);
}

@Bean
public Binding binding02(){
    //return BindingBuilder.bind(queue02()).to(fanoutExchange());
    //return BindingBuilder.bind(queue02()).to(directExchange()).with(ROUTINGKEY02);
    return BindingBuilder.bind(queue02()).to(topicExchange()).with(ROUTINGKEY02);
    }

修改发送者、接收者

public void send03(Object msg){
    log.info("发送消息(QUEUE1)：" + msg);
    rabbitTemplate.convertAndSend("topicExchange", "queue.red.message", msg);
}

public void send04(Object msg){
    log.info("发送消息(QUEUE1,QUEUE2)：" + msg);
    rabbitTemplate.convertAndSend("topicExchange", "msg.queue.green", msg);
}

@RabbitListener(queues = "queue_topic01")
public void receive05(Object msg){
    log.info("QUEUE01接收消息：" + msg);
}

@RabbitListener(queues = "queue_topic02")
public void receive06(Object msg){
    log.info("QUEUE01,QUEUE02接收消息：" + msg);
}

修改控制层逻辑


/**
 * 测试MQ topic模式发送给QUEUE01
 * @author 47roro
 * @date 2022/5/12
 * @param
 **/
@RequestMapping("/mq/topic01")
@ResponseBody
public void mq04(){
    mqSender.send03("hello,topic01");
}

@RequestMapping("/mq/topic02")
@ResponseBody
public void mq05(){
    mqSender.send04("hello,topic02");
}

3.2 测试结果

控制台信息：
在这里插入图片描述
在这里插入图片描述
发送消息：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

四、Headers 头部信息

这种模式写起来代码比较麻烦，且效率不是很高，现在不怎么用。
项目里一般都用topic模式。

4.1 头部信息测试

修改RabbitMQ配置类

//headers
private static final String QUEUE01 = "queue_header01";
private static final String QUEUE02 = "queue_header02";
private static final String EXCHANGE = "headersExchange";

@Bean
public HeadersExchange headersExchange(){
    return new HeadersExchange(EXCHANGE);
}

@Bean
public Binding binding01(){
    //return BindingBuilder.bind(queue01()).to(fanoutExchange());
    //return BindingBuilder.bind(queue01()).to(directExchange()).with(ROUTINGKEY01);
    //return BindingBuilder.bind(queue01()).to(topicExchange()).with(ROUTINGKEY01);
    Map<String, Object> map = new HashMap<>();
    map.put("color", "red");
    map.put("speed", "slow");
    return BindingBuilder.bind(queue01()).to(headersExchange()).whereAny(map).match();
}

@Bean
public Binding binding02(){
    //return BindingBuilder.bind(queue02()).to(fanoutExchange());
    //return BindingBuilder.bind(queue02()).to(directExchange()).with(ROUTINGKEY02);
    //return BindingBuilder.bind(queue02()).to(topicExchange()).with(ROUTINGKEY02);
    Map<String, Object> map = new HashMap<>();
    map.put("color", "red");
    map.put("speed", "fast");
    return BindingBuilder.bind(queue02()).to(headersExchange()).whereAll(map).match();
}

修改发送者、接收者

public void send05(String msg){
    log.info("发送消息(QUEUE1,QUEUE2)：" + msg);
    MessageProperties properties = new MessageProperties();
    properties.setHeader("color", "red");
    properties.setHeader("speed", "fast");
    Message message = new Message(msg.getBytes(), properties);
    rabbitTemplate.convertAndSend("headersExchange", "", message);
}

public void send06(String msg){
    log.info("发送消息(QUEUE1)：" + msg);
    MessageProperties properties = new MessageProperties();
    properties.setHeader("color", "red");
    properties.setHeader("speed", "normal");
    Message message = new Message(msg.getBytes(), properties);
    rabbitTemplate.convertAndSend("headersExchange", "", message);
}

@RabbitListener(queues = "queue_header01")
public void receive07(Message msg){
    log.info("QUEUE01,QUEUE02接收Message对象：" + msg);
    log.info("QUEUE01,QUEUE02接收消息：" + new String(msg.getBody()));
}

@RabbitListener(queues = "queue_header02")
public void receive08(Message msg){
    log.info("QUEUE01接收Message对象：" + msg);
    log.info("QUEUE01接收消息：" + new String(msg.getBody()));
}

修改控制层逻辑

/**
 * 测试MQ headers模式发送给QUEUE1,QUEUE2
 * @author 47roro
 * @date 2022/5/12
 * @param
 **/
@RequestMapping("/mq/header0102")
@ResponseBody
public void mq06(){
    mqSender.send05("hello,header01,header02");
}

/**
 * 测试MQ headers模式发送给QUEUE1
 * @author 47roro
 * @date 2022/5/12
 * @param
 **/
@RequestMapping("/mq/header01")
@ResponseBody
public void mq07(){
    mqSender.send06("hello,header01");
}

4.2 测试结果

RabbitMQ控制台信息
在这里插入图片描述
在这里插入图片描述

发送消息：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

BSP编程模型（以NMF为例，试验基于消息传递的模型BSP过程）
玉心sober
07-01 4865
对于需要迭代计算的算法，MapReduce显然不可用，迭代n次的IO量太大，而基于消息的传递模型，BSP和MPI的优势就出来了。BSP的编程模型，试验过了，确实容易入门，只要将求解问题（例如，优化问题、图的最短路径问题等等）抽象成图模型（顶点Vertex、边Edge）后，再通过消息Message，来不断迭代求解即可。拿前面有篇文章，NMF的矩阵分解这个优化问题，来实验： 1）NMF的矩阵分解基本
ActiveMQ消息传送模型
weixin_33795743的博客
08-20 184
无论采用哪种JMS 组件，JMS 支持两种截然不同的消息传送模型：PTP（即点对点模型）和Pub/Sub（即发布/订阅模型），分别称作：PTP Domain 和Pub/Sub Domain。PTP（使用Queue即队列目标）消息从一个生产者传送至一个消费者。在此传送模型中，目标是一个队列。消息首先被传送至队列目标，然后根据队列传送策略，从该队列将消息传送至向此队列...
传播模型
weixin_30787531的博客
05-08 787
标准宏小区模型（城市） Lb=163+44.9log(d)-2.88Hmeff+0log(Hmeff)-13.82log(Hmeff)-6.55log(Hmeff)log(d)+kdiff*Diffraction+kclutter(clutter) 其中： Lb：市区准平滑地形电波传播损耗中值(dB) fc：工作频率（MHz） Hmeff：移动台天线有效高度（m） 其他： Hbts:基站天线有...
Kafka 消息传递模型
最新发布
u013257321的博客
03-08 974
Kafka 的消息传递模型是其核心特性之一，也是它能够高效、可靠地处理海量数据的基础。Kafka 的设计理念围绕着分布式、可扩展、容错和高吞吐量展开，借助其独特的消息传递机制，Kafka 成为许多大规模数据处理系统的中枢。
（一）JMS笔记之消息传递模型
feidegenggao888的专栏
09-28 480
一 JMS消息传递模型    1 点对点消息模型（p2p）     点对点消息模型既支持 异步“即发即弃”的消息传送方式，也支持同步的“请求响应”的消息传送方式。 点对点消息模型的特点： • 消息通过一个名为消息队列的虚拟通道来交换消息。队列即是消息生产者发送消息的目的地，也是消息消费者获取消息的消息源。 • 每一条消息只能传送给一个接受者，可能会有多个接收者在一个队列侦听，但是每个消息队列中的消...
RabbitMq的五大消息模型及Java代码演示
Aa5107033的博客
06-27 3950
主要介绍RabbitMq的五大消息模型，并通过代码实现各个订阅模型的使用
Python实现RabbitMQ6种消息模型的示例代码
09-17
在实际开发中，RabbitMQ 提供了多种消息传递模型以适应不同的业务场景需求。本文将详细介绍使用 Python 语言结合 pika 库实现的六种常见 RabbitMQ 消息模型，并提供示例代码。 #### 二、RabbitMQ 与 Redis 的对比 ...
spit:一个简单的RabbitMQ消息传递实现
04-04
【标题】"spit:一个简单的RabbitMQ消息传递实现" 在IT行业中，消息传递系统是一种常见的组件，用于在不同的应用程序之间传输数据。RabbitMQ是这样的一个系统，它是一个开源的消息代理，基于AMQP（Advanced Message ...
RabbitMQ的消息传递模型详解
RabbitMQ提供了可靠的消息传递，消息队列，消息交换，消息路由等功能，使得分布式系统中的应用程序可以更加灵活，可靠地进行通信。 ## 1.2 RabbitMQ的应用场景 RabbitMQ在各种应用场景中被广泛应用，包括但不限于...
RabbitMQ消息队列模型
02-26
### RabbitMQ 消息队列模型详解 #### 生产者与消费者模式 在 RabbitMQ 中，生产者负责创建并发送消息至交换器（Exchange），而消费者则订阅特定的队列来接收这些消息。这种架构使得生产和消费过程解耦合，提高了...
自媒体时代的消息传播数学模型
04-29
自媒体时代的消息传播问题
基于消息队列、spring boot、websocket实现的消息推送模型源代码
05-07
基于消息队列、spring boot、websocket实现的消息推送模型代码
RabbitMQ的四种消息传递模式与演示代码
jakelihua
04-07 1952
例如，用户在网站上提交了一个长时间处理的任务（如生成报表、发送邮件等），为了提高用户体验，可以将任务提交到RabbitMQ的任务队列中，然后由后台的消费者进行异步处理。通过使用Fanout模式，可以将日志消息广播到所有相关的队列中，每个消费者只需要关注自己负责处理的日志级别，从而实现了日志的分发和处理。交换机会将收到的消息广播到与其绑定的所有队列中。Fanout模式是RabbitMQ中的一种消息传递模式，它将消息广播到所有绑定到Exchange的队列中，即使在消息发布之后才创建的队列，也能接收到消息。
RabbitMQ支持的消息模型
abc_138的博客
06-05 1044
RabbitMQ提供了五种主要的消息模型，这些模型通过不同的交换机和队列的组合与绑定方式来实现。
RabbitMQ消息传递语义及模型
oneslide
08-16 785
调研RabbitMQ的消息传递模式，行为，模型。 基本模型 消息队列邮局解释： Exchange(交换器)是邮箱，Queue是目的地，Producer是寄件人。 RoutingKey是寄件人填写的源地址，BindingKey是目的地址。 队列和交换器的绑定模式有好几种，广播（fanout）,点对点（direct）,模糊匹配（topic） 拉模式与推模式----主动方划分 参考：消息模式–推模...
【kafka专栏】消息队列通用消息传递模型(带视频)
字母哥博客
04-25 2925
两种消费模型及消费者组模式讲解：Point-to-Point(P2P)，一条消息由一个消费者消费；Publish/Subscribe(Pub/Sub)，一条消息被多个消费者消费。
并发编程模型主要分为两大类：共享内存模型和消息传递模型。
靡不有初，鲜克有终
12-27 301
**内存可见性问题**：由于线程可能在不同的处理器上运行，导致它们看到的内存状态可能不一致。- **同步机制**：同步在共享内存模型中是显式进行的。- **Java中的实现**：Java采用的是共享内存模型。- **通信机制**：在共享内存模型中，线程共享同一个内存空间，它们通过读写共享变量来隐式地进行通信。- **通信机制**：在消息传递模型中，线程之间没有共享内存，它们必须通过发送和接收消息来显式地进行通信。- **同步机制**：在消息传递模型中，同步是隐式进行的。
【SpringBoot学习】13、SpringBoot 整合 RabbitMQ 实现五种消息模型案例
Tellsea
04-21 1410
SpringBoot整合RabbitMQ实现五种消息模型 RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。 simple消息模型：生产者–>队列–>消费者 work消息模型：生产者–>队列–>多个消费者共同消费 fanout消息模型：广播，将消息交给所有绑定到交换机的队列，每个消费者都会收到同一条消息 direct消...
社交网络分析——信息传播模型（附带三个模型的python实现）
热门推荐
小黄的博客
05-19 2万+
摘要：主要讲解一些基本的信息传播模型，以及IC模型、SI模型和SIR模型的python实现及可视化。 author：xiao黄 缓慢而坚定的生长 最后更新于2020.10.06
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值