RabbitMQ发布订阅模式-fanout、direct、topic

已于 2023-08-29 10:59:19 修改
阅读量256 收藏
点赞数
文章标签： java-rabbitmq rabbitmq java springboot
于 2023-08-25 17:16:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53799708/article/details/132498619
版权

发布订阅模式

RabbitMQ 支持发布-订阅模式（Publish-Subscribe Pattern），它是一种消息传递模式，用于将消息广播到多个消费者。在发布-订阅模式中，消息的发送方称为发布者（Publisher），而消息的接收方称为订阅者（Subscriber）。发布者将消息发送到交换机（Exchange），而交换机负责将消息广播到与之绑定的多个队列（Queues）。每个订阅者都可以独立地创建一个队列，并将其绑定到交换机上，以接收消息。
具体的步骤如下：

  • 发布者将消息发送到交换机，而不是直接发送到队列。消息可以具有一个特定的路由键（Routing Key）。
  • 交换机根据其类型和消息的路由键，将消息广播到与之绑定的多个队列。
  • 每个订阅者创建一个独立的队列，并将其绑定到交换机上，以接收消息。
  • 每个订阅者独立地消费队列中的消息。
    这样，每个订阅者都能够独立地接收到发布者发送的消息，实现了消息的广播和多消费者的并行处理。在这里插入图片描述

一、Fanout交换机

Fanout Exchange（扇形交换机）： 扇形交换机将消息广播到与之绑定的所有队列，无论路由键是否匹配。它是实现发布-订阅模式最常用的交换机类型。
在这里插入图片描述

package com.example.springamqp.发布订阅.fanout;

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 FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanout");
    }

    // 声明第一个队列
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    // 声明第二个队列
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    // 绑定队列1和交换机
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    // 绑定队列2和交换机
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }

}


package com.example.springamqp.发布订阅.fanout;

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

@Component
public class FanoutRabbitMQManager {
    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public FanoutRabbitMQManager(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String exchangeName, String message) {
        rabbitTemplate.convertAndSend(exchangeName, null, message);
    }
}


package com.example.springamqp.发布订阅.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class FanoutCommandLineRunner implements CommandLineRunner {
    private final FanoutRabbitMQManager rabbitMQManager;

    @Autowired
    public FanoutCommandLineRunner(FanoutRabbitMQManager rabbitMQManager) {
        this.rabbitMQManager = rabbitMQManager;
    }

    @Override
    public void run(String... args) {
        rabbitMQManager.sendMessage("fanout", "Hello, RabbitMQ!");
    }

    @RabbitListener(queues = "fanout.queue1")
    public void receiveMessage1(String message){
        System.out.println("Received1 receive fanout message: " + message);
    }

    @RabbitListener(queues = "fanout.queue2")
    public void receiveMessage2(String message){
        System.out.println("Received2 receive fanout message: " + message);
    }
}

在这里插入图片描述
在这里插入图片描述

二、direct交换机

Direct Exchange（直连交换机）： 直连交换机根据消息的路由键将消息发送到与之匹配的队列。在发布-订阅模式中，通常将直连交换机和具有相同路由键的队列一起使用，以实现消息的广播。
在这里插入图片描述

package com.example.springamqp.发布订阅.direct;

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

@Component
public class DirectRabbitMQManager {
    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public DirectRabbitMQManager(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String exchangeName, String routingKey, String message) {
        rabbitTemplate.convertAndSend(exchangeName, routingKey, message);
    }
}


package com.example.springamqp.发布订阅.direct;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class DirectCommandLineRunner implements CommandLineRunner {
    private final DirectRabbitMQManager rabbitMQManager;

    @Autowired
    public DirectCommandLineRunner(DirectRabbitMQManager rabbitMQManager) {
        this.rabbitMQManager = rabbitMQManager;
    }

    @Override
    public void run(String... args) {
        rabbitMQManager.sendMessage("direct", "yellow", "Hello, RabbitMQ!");
    }

    @RabbitListener(
        bindings = @QueueBinding(
                value = @Queue(name = "direct.queue1"),
                exchange = @Exchange(name = "direct"),
                key = {"red", "yellow"}
        ))
    public void listenDirectQueue1(String message){
        System.out.println("Received1 receive direct message: " + message);
    }

    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(name = "direct.queue2"),
                    exchange = @Exchange(name = "direct"),
                    key = {"red", "blue"}
            ))
    public void listenDirectQueue2(String message){
        System.out.println("Received2 receive direct message: " + message);
    }

}

在这里插入图片描述

在这里插入图片描述

三、topic交换机

Topic Exchange（主题交换机）： 主题交换机根据消息的主题（Topic）进行消息路由。订阅者可以使用通配符匹配来接收特定主题的消息。
在这里插入图片描述

package com.example.springamqp.发布订阅.topic;

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

@Component
public class TopicRabbitMQManager {
    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public TopicRabbitMQManager(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String exchangeName, String routingKey, String message) {
        rabbitTemplate.convertAndSend(exchangeName, routingKey, message);
    }
}


package com.example.springamqp.发布订阅.topic;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class TopicCommandLineRunner implements CommandLineRunner {
    private final TopicRabbitMQManager rabbitMQManager;

    @Autowired
    public TopicCommandLineRunner(TopicRabbitMQManager rabbitMQManager) {
        this.rabbitMQManager = rabbitMQManager;
    }

    @Override
    public void run(String... args) {
        rabbitMQManager.sendMessage("topic", "china.news", "Hello, RabbitMQ!");
    }

    @RabbitListener(
        bindings = @QueueBinding(
                value = @Queue(name = "topic.queue1"),
                exchange = @Exchange(name = "topic", type = ExchangeTypes.TOPIC),
                key = "china.#"
        ))
    public void listenTopicQueue1(String message){
        System.out.println("Received1 receive topic message: " + message);
    }

    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(name = "topic.queue2"),
                    exchange = @Exchange(name = "topic", type = ExchangeTypes.TOPIC),
                    key = "#.news"
            ))
    public void listenTopicQueue2(String message){
        System.out.println("Received2 receive topic message: " + message);
    }

}

在这里插入图片描述

    @Override
    public void run(String... args) {
        rabbitMQManager.sendMessage("topic", "America.news", "Hello, RabbitMQ!");
    }

在这里插入图片描述

    @Override
    public void run(String... args) {
        rabbitMQManager.sendMessage("topic", "America.qq", "Hello, RabbitMQ!");
    }

在这里插入图片描述

    @Override
    public void run(String... args) {
        rabbitMQManager.sendMessage("topic", "chinachina.news", "Hello, RabbitMQ!");
    }

    @RabbitListener(
        bindings = @QueueBinding(
                value = @Queue(name = "topic.queue1"),
                exchange = @Exchange(name = "topic", type = ExchangeTypes.TOPIC),
                key = "china.*"
        ))
    public void listenTopicQueue1(String message){
        System.out.println("Received1 receive topic message: " + message);
    }

    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(name = "topic.queue2"),
                    exchange = @Exchange(name = "topic", type = ExchangeTypes.TOPIC),
                    key = "*.news"
            ))
    public void listenTopicQueue2(String message){
        System.out.println("Received2 receive topic message: " + message);
    }

在这里插入图片描述
在这里插入图片描述

星辰小赞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
springboot2.1.4集成rabbitmq，三种模式：fanout direct topic的实现
05-16
springboot集成rabbitmq，三种模式：fanout direct topic的实现，入门级别
spring集成rabbitMq(基于direct、topic和fanout模式)
11-15
spring集成rabbitMq(基于direct、topic和fanout模式)，包括main方法，5种情景，一天总结运行
Springboot整合RabbitMQ(Fanout、Direct、Topic模式)、设置队列信息TTL、死信队列、RabbitMQ磁盘监控，内存控制
鸢尾_的博客
07-19 1308
Springboot整合RabbitMQ(Fanout、Direct、Topic模式)、设置队列信息TTL、死信队列、RabbitMQ磁盘监控，内存控制
RabbitMQ基本概念讲解及其三种队列模式(Direct,Fanout,Topic)的使用方法
0117
10-27 1949
1. RabbitMQ简介 消息队列分为很多种，常用的一般分为ActiveMQ,RabbitMQ,Kafka，这三个依次能处理更高数据量的任务，并且安全度也会降低，可能会出现数据丢失，但是，这三者的目的都是一致的，为了解耦，异步信息，流量削峰等问题实现高性能，高可用，可伸缩和最终一致性。 RabbitMq的主要特点如下： 可靠性：RMQ可以使用其持久化，传输确认，发布确认来保证可靠性。 灵活路由...
利用消息中间件RabbitMQ创建队列以及扇出（Fanout）、订阅（Direct）、主题（Topic）交换机来完成消息的发送和监听接收（完整版）
c_xiao_dian_dian的博客
07-10 3904
5.1交换机的作用是什么？接收publisher发送的消息、将消息按照规则路由到与之绑定的队列、不能缓存消息，路由失败，消息丢失、FanoutExchange的会将消息路由到每个绑定的队列 5.2声明队列、交换机、绑定关系的Bean是什么？Queue、FanoutExchange、Binding
RabbitMQ详解（三）：消息模式（fanout、direct、topic、work）
weixin_45181611的博客
05-10 3000
消息模式详解
【RabbitMQ四】——RabbitMQ发布订阅模式（Publish/Subscribe）
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
02-02 5402
通过本篇博客能够简单使用RabbitMQ的发布订阅模式。本篇博客主要是博主通过官网以及学习他人的博客总结出的RabbitMQ发布订阅模式。其中如果有误欢迎大家及时指正。
RabbitMQ基础（2）——发布订阅/fanout模式 & topic模式 & rabbitmq回调确认 & 延迟队列（死信）设计
Perley620的博客，专注后端领域
08-10 1739
1.rabbitmq队列方式的梳理，点对点，一对多； 2.发布订阅模式，交换机到消费者，以邮箱和手机验证码为例； 3.topic模式，根据规则决定发送给哪个队列； 4.rabbitmq回调确认，setConfirmCallback和setReturnsCallback； 5.死信队列，延迟队列，创建方法，正常---死信，设置延迟时间；
RabbitMQ交换机（Fanout、Direct、Topic）三种模式详解
热门推荐
m0_46084075的博客
07-09 1万+
一. 交换机 1.1 Exchanges 1.1.1 Exchanges概念 ​ RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产 者甚至都不知道这些消息传递传递到了哪些队列中。 ​ 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定
Rabbitmq fanout与topic区别
fwk19840301的博客
06-20 1万+
RabbitMQ服务器会根据路由键将消息从交换器路由到队列中，如何处理投递到多个队列的情况？这里不同类型的交换器起到了重要的作用。 最常用的交换机有三种：direct、topic、fanout。我分别叫他们：“直接连接交换机”，“主题路由匹配交换机”，“无路由交换机” fanout fanout类型的Exchange路由规则非常简单，它会把所有发送到该Exchange的消息路由到所有与它绑定...
java集成rabbitmq多种消费模式
06-06
该项目包括两个子工程，生产者（rabbitmqProvider），消费者（rabbitmqConsumer），采用了direct，fanout，topic三种方式发布及消费。以及持久化分批消费等。工程中rabbitMQ.xml，rabbitMQ1.xml，rabbitMQChanel.xml...
基于spring集成rabbitMq(基于direct、topic和fanout模式)源码.rar
11-07
基于spring集成rabbitMq(基于direct、topic和fanout模式)源码.rar
Go语言版本rabbitmq消息队列库：simple、worker、Fanout 模型、Direct 模型、Topic模型
07-29
Go语言版本rabbitmq消息队列库：simple、worker、Fanout 模型、Direct 模型、Topic模型。 RabbitMQ 是使用Erlang编写的一个开源的消息队列，本身支持很多的协议：AMQP，XMPP, SMTP, STOMP，也正是如此，使的它变的...
rabbitMQ 中三种常用交换机：direct、topic、fanout的使用以及区别和queue消息的Ack,Nack ,Reject 消息类型
码农崛起
08-10 3765
当消息发送到Exchange时，RabbitMQ会取到该消息的headers（也是一个键值对的形式），对比其中的键值对是否完全匹配Queue与Exchange绑定时指定的键值对；生产者将消息不是直接发送到队列，而是发送到X交换机，然后由交换机发送给两个队列，两个消费者各自监听一个队列，来消费消息。生产者，一个队列一个或多个消费者，当多个消费者同时监听一个队列时，他们并不能同时消费一条消息，而是随机消费消息，即一个队列中一条消息，只能被一个消费者消费。如果匹配请求中的值，则向程序返回该响应数据。.......
RabbitMQ:发布订阅模式
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-06 3725
P:生产者，发送消息给交换机C:消费者，接收消息X:交换机，一方面接收生产者发送的消息，另一方面知道怎么处理消息，是否应将其附加到特定队列？是否应将其附加到多个队列中？或者它应该被丢弃。其规则由交换类型定义。Queue:消息队列，接收消息，缓存消息每个消费者都监听自己的队列生产者把消息发送给broker,然后交换机把消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息。
【RabbitMQ】Fanout、Direct、Topic、消息转换器
专注于Java领域开发 关注我 带你玩转Java
02-07 820
生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息
RabbitMQ入门案例之发布订阅模式
weixin_59216829的博客
06-10 2988
RabbitMQ中的发布与订阅模式是一种消息传递的方式，用于在分布式系统中传递消息。在该模式中，发送者（发布者）通过将消息发送到一个称为Exchange（交换机）的组件，消息将被路由到一个或多个称为Queue（队列）的组件。每个队列都有一个名称和一组绑定（bindings），指定接收哪些消息。消费者（订阅者）可以在指定的队列上进行侦听，以获取消息。该模式的一个重要特点是支持多个消费者接收相同的消息，通过使用多个队列和绑定实现。
rabbitMQ 三种常用交换机：direct、topic、fanout的使用以及区别
zhangaiav的博客
12-28 2323
rabbitMQ 三种常用交换机：direct、topic、fanout的使用以及区别
Java-RabbitMQ
最新发布
sgliquangang的专栏
05-16 311
1、消息持久化会用到磁盘，此时吞吐量就会受到磁盘读写速度影响，可以通过更换高读写速度的磁盘来部分解决。集群依然可以运行，但是已经出于不可用状态了，此时不能更改任何东西，且消息也无法实现持久化了。1、与RabbitMQ服务进行连接，客户端与RabbitMQ建立tcp连接，并通过人证。2、各节点使用的erlang cookie值必须相同，此值用于各节点之间认证。2、消息推送投递模式必须设置持久化，deliveryModel设置为持久。1、各集群之间必须使用–link连接，此属性不能忽略。3、设置集群镜像模式。
rabbitmq广播和发布订阅
05-10
RabbitMQ是一个消息队列的实现，它支持一种名为“发布/订阅”的消息传递模式，也称为广播模式。在这种模式下，一个消息将被传递给多个接收者。 在RabbitMQ中，实现广播模式有两种方式： 1. 使用Exchange的Fanout...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值