RabbitMQ-交换机

已于 2024-04-17 21:38:51 修改
阅读量1k 收藏 14
点赞数 8
分类专栏： 智能BI 消息队列 文章标签： rabbitmq 分布式
于 2024-04-17 15:13:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74870396/article/details/137874281
版权

文章目录

交换机

**交换机 **是消息队列中的一个组件，其作用类似于网络路由器。它负责将我们发送的消息转发到相应的目标，就像快递站将快递发送到对应的站点，或者网络路由器将网络请求转发到相应的服务器或客户端一样。交换机的主要功能是提供转发消息的能力，根据消息的路由规则将消息投递到合适的队列或绑定的消费者。
我们可以理解为，如果说一个快递站已经承受不了那么多的快递了，就建多个快递站。

fanout

扇出，广播
特点：消息会被转发到所有绑定到该交换机的队列
场景:很适用于发布订阅的场景，比如写日志，可以多个系统间共享

示例场景：
image.png
生产者代码：

package com.yupi.springbootinit.mq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.util.Scanner;

public class FanoutProducer {
  // 交换机名字
  private static final String EXCHANGE_NAME = "fanout-exchange";

  public static void main(String[] argv) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    try (Connection connection = factory.newConnection();
         Channel channel = connection.createChannel()) {
        // 创建交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String message = scanner.nextLine();
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
  }
}

消费者代码：

package com.yupi.springbootinit.mq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class FanoutConsumer {
  //交换机名字
  private static final String EXCHANGE_NAME = "fanout-exchange";

  public static void main(String[] argv) throws Exception {
    //建立连接
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    //创建频道
    Channel channel1 = connection.createChannel();
    // 声明交换机
    channel1.exchangeDeclare(EXCHANGE_NAME, "fanout");
    // 创建队列1，连接到交换机上
    String queueName = "xiaowang_queue";
    channel1.queueDeclare(queueName, true, false, false, null);
    channel1.queueBind(queueName, EXCHANGE_NAME, "");
    // 创建队列2,连接到交换机上
    String queueName2 = "xiaoli_queue";
    channel1.queueDeclare(queueName2, true, false, false, null);
    channel1.queueBind(queueName2, EXCHANGE_NAME, "");
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
    // 创建交付回调函数1
    DeliverCallback deliverCallback1 = (consumerTag, delivery) -> {
        String message = new String(delivery.getBody(), "UTF-8");
        System.out.println(" [小王] Received '" + message + "'");
    };
    // 创建交付回调函数2
    DeliverCallback deliverCallback2 = (consumerTag, delivery) -> {
      String message = new String(delivery.getBody(), "UTF-8");
      System.out.println(" [小李] Received '" + message + "'");
    };
    // 开始消费消息队列1
    channel1.basicConsume(queueName, true, deliverCallback1, consumerTag -> { });
    // 开始消费消息队列2
    channel1.basicConsume(queueName2, true, deliverCallback2, consumerTag -> { });
  }
}

Direct

官方教程：https://www.rabbitmq.com/tutorials/tutorial-four-java.html
特点：消息会根据路由键转发到指定的队列
场景：特定的消息只交给特定的系统（程序）来处理

注意：不同队列可以绑定相同的路由键

示例场景：
老板在发送消息同时会带上路由键，根据路由键找对应的队列来发送
image.png
生产者代码：

package com.yupi.springbootinit.mq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.util.Scanner;

public class DirectProducer {

  private static final String EXCHANGE_NAME = "direct-exchange";

  public static void main(String[] argv) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    try (Connection connection = factory.newConnection();
         Channel channel = connection.createChannel()) {
        //声明交换机是direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //输入消息 和 路由键
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String userInput = scanner.nextLine();
            String[] strings = userInput.split(" ");
            if (strings.length < 1) {
                continue;
            }
            String message = strings[0];
            String routingKey = strings[1];
            //发布消息的时候注意指定路由键
            channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + " with routing:" + routingKey + "'");
        }

    }
  }
}

消费者代码：

package com.yupi.springbootinit.mq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class DirectConsumer {

    private static final String EXCHANGE_NAME = "direct-exchange";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明交换机，不过生成者已经声明过了，消费者声不声明都可以
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");

        // 创建队列
        String queueName = "xiaoyu_queue";
        channel.queueDeclare(queueName, true, false, false, null);
        channel.queueBind(queueName, EXCHANGE_NAME, "xiaoyu"); //指定2交换机和路由键

        // 创建队列，随机分配一个队列名称
        String queueName2 = "xiaopi_queue";
        channel.queueDeclare(queueName2, true, false, false, null);
        channel.queueBind(queueName2, EXCHANGE_NAME, "xiaopi");

        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        DeliverCallback xiaoyuDeliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [xiaoyu] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };

        DeliverCallback xiaopiDeliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [xiaopi] Received '" +
                    delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };

        channel.basicConsume(queueName, true, xiaoyuDeliverCallback, consumerTag -> {
        });
        channel.basicConsume(queueName2, true, xiaopiDeliverCallback, consumerTag -> {
        });
    }
}

topic

官方教程：https://www.rabbitmq.com/tutorials/tutorial-five-java.html
特点：消息会根据一个模糊的路由键转发到指定的队列
场景:特定的一类消息可以交给特定的一类系统（程序）来处理
规则：

  1. :匹配一个单词，比如.orange，那么 abc.orange、ikun.orange 都能匹配
  2. #:匹配0个或多个单词，比如orange.#，那么orange，orange.abc.ikun都能匹配


应用场景：
老板要下发一个任务，让多个组来处理
image.png
生产者代码：

package com.yupi.springbootinit.mq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.util.Scanner;

public class TopicProducer {

  private static final String EXCHANGE_NAME = "topic-exchange";

  public static void main(String[] argv) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    try (Connection connection = factory.newConnection();
         Channel channel = connection.createChannel()) {

        channel.exchangeDeclare(EXCHANGE_NAME, "topic");

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String userInput = scanner.nextLine();
            String[] strings = userInput.split(" ");
            if (strings.length < 1) {
                continue;
            }
            String message = strings[0];
            String routingKey = strings[1];

            channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + " with routing:" + routingKey + "'");
        }
    }
  }
}

消费者代码：

package com.yupi.springbootinit.mq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class TopicConsumer {

  private static final String EXCHANGE_NAME = "topic-exchange";

  public static void main(String[] argv) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.exchangeDeclare(EXCHANGE_NAME, "topic");

      // 创建队列
      String queueName = "frontend_queue";
      channel.queueDeclare(queueName, true, false, false, null);
      channel.queueBind(queueName, EXCHANGE_NAME, "#.前端.#");

      // 创建队列
      String queueName2 = "backend_queue";
      channel.queueDeclare(queueName2, true, false, false, null);
      channel.queueBind(queueName2, EXCHANGE_NAME, "#.后端.#");

      // 创建队列
      String queueName3 = "product_queue";
      channel.queueDeclare(queueName3, true, false, false, null);
      channel.queueBind(queueName3, EXCHANGE_NAME, "#.产品.#");

      System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

      DeliverCallback xiaoaDeliverCallback = (consumerTag, delivery) -> {
          String message = new String(delivery.getBody(), "UTF-8");
          System.out.println(" [xiaoa] Received '" +
                  delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
      };

      DeliverCallback xiaobDeliverCallback = (consumerTag, delivery) -> {
          String message = new String(delivery.getBody(), "UTF-8");
          System.out.println(" [xiaob] Received '" +
                  delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
      };

      DeliverCallback xiaocDeliverCallback = (consumerTag, delivery) -> {
          String message = new String(delivery.getBody(), "UTF-8");
          System.out.println(" [xiaoc] Received '" +
                  delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
      };

      channel.basicConsume(queueName, true, xiaoaDeliverCallback, consumerTag -> {
      });
      channel.basicConsume(queueName2, true, xiaobDeliverCallback, consumerTag -> {
      });
      channel.basicConsume(queueName3, true, xiaocDeliverCallback, consumerTag -> {
      });
  }
}

这样生产者发消息：前端.后端
image.png
就可以匹配到前端和后端两个队列
image.png

Headers

可以根据headers中的内容来指定发送到哪个队列，由于性能差，比较复杂，一般不推荐使用

RPC

支持用消息队列来模拟RPC的调用，但是一般没必要，直接用 Dubbo、GRPC 等 RPC 框架就好了。

诨号无敌鸭
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
RabbitMQ--交换机
lu__lala的博客
06-25 792
RabbitMQ--交换机详解，全代码示例
RabbitMQ --- 死信交换机
乌云的博客
05-07 874
什么样的消息会成为死信？消息被消费者reject或者返回nack消息超时未消费队列满了死信交换机的使用场景是什么？如果队列绑定了死信交换机，死信会投递到死信交换机；可以利用死信交换机收集所有消费者处理失败的消息（死信），交由人工处理，进一步提高消息队列的可靠性。消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机。
RabbitMQ-交换机类型
TaoXiaoLi的博客
12-15 1400
RabbitMQ的交换机类型
springboot整合rabbitmq-交换机模式
zwjzone的博客
05-06 1082
rabbitmq交换机模式direct和topic演示
RabbitMQ --- 死信交换机(一)
Stephen GS的博客
05-18 814
何为死信, 死信交换机的使用, deadLetterExchange, ttl
Rabbitmq---队列和交换机
YeahToYeah的博客
07-16 2272
队列 ​ Queue：队列，是Rabbitmq的内部对象，用于存储消息。 ​ 多个消费者可以订阅同一个队列，这时队列中的消息会被平均分摊（Round-Robin，即轮询） Queue中的消息会被Consumer1和Consumer2轮番消费。 交换机 交换机：即生产者把消息发送到队列的桥梁。 交换机常用的交换机类型有fanout、direct、topic、headers四种。 fanout：会把所有发送到交换机信息都路由到与该交换机绑定的队列中。 direct：会根据消息的RoutingKey，完
RabbitMQ-交换机类型，及绑定
ywb201314的专栏
06-13 1480
交换机的类型 Directexchange（直连交换机）完全根据key进行投递 单个绑定： 多个绑定：消息会被同时路由到队列Q1和队列Q2 Fanoutexchange（扇型交换机）不需要key，它采取广播模式，一个消息进来时，投递到与该交换机绑定的所有队列 Topicexchange（主题交换机）对key进行模式匹配后进行投递，符号”#”匹配一个或多个词，符号”*”匹配正好一个词。例如”abc.#”匹配”abc.def.ghi”，”abc.*”只匹配”abc.d...
RabbitMQ--基础--03--交换机的类型
zhou920786312的博客
10-20 723
rabbitmq
RabbitMQ - 4种交换机详解
Dragon1993vsLong的博客
09-01 1596
RabbitMQ 路由 1、 Direct Exchange 把Exchange 路由 和 Queue 绑定 ———— queue 中保存了一个 路由 key 路由将指定 key 的消息发送给相应的消费者 创建信道，声明路由，插入消息 using (var connection = factory.CreateConnection()) { using (IModel channel = conn.................
RabbitMQ-常用命令
bug_null的博客
08-26 5081
rabbitmq-常用命令使用
rabbitmq-server-3.6.15-1.el7.noarch.zip
05-27
- **交换机**：在RabbitMQ中，交换机负责将消息路由到适当的队列，根据预定义的路由规则。 - **队列**：存储待处理消息的地方，消息在被消费者消费前会存储在队列中。 - **绑定**：定义了队列如何与交换机关联，...
rabbitmq-java (2).zip
01-11
总之，这个"rabbitmq-java"项目是一个使用Java语言与RabbitMQ进行通信的应用实例，涉及到了AMQP协议、Maven构建工具、IntelliJ IDEA项目配置以及RabbitMQ的核心概念，如生产者、消费者、交换机、队列和消息确认机制...
rabbitmq-server-3.7.7.exe
10-27
- 管理界面：通过Web界面可以创建、删除交换机、队列和绑定，查看节点状态等。 - 命令行工具：RabbitMQ提供了一系列命令行工具，如`rabbitmqctl`，用于管理节点、用户、权限等。 - 客户端库：RabbitMQ支持多种编程...
rabbitmq-server-generic-unix-3.6.1.tar
08-16
了解RabbitMQ的基本概念，如Exchange（交换机）、Queue（队列）、Binding（绑定）以及不同工作模式（如Direct、Fanout、Topic、Header）是非常重要的。此外，熟悉RabbitMQ的管理和监控工具，如`rabbitmqctl`和Web...
rabbitmq-server-3.6.5-1.noarch.rar
05-22
8. 为了监控和维护RabbitMQ，了解其核心概念，如交换机（exchanges）、队列（queues）、绑定（bindings）以及工作流程是非常重要的。同时，熟悉AMQP协议的基本概念和使用模式也有助于更好地利用RabbitMQ。 通过以上...
RabbitMQ+redis+Redisson分布式锁+seata实现订单服务
架构师小吴的博客
07-22 824
（相关解释直接在代码注释上了）
分布式文件存储行业解决方案和技术选型分析
zhuzhu_YT的博客
07-25 2204
上一集，我们已经完成了初始化测试报告以及判断压测类型的实战，我们在文章的末尾提到了文件上传的问题以及文件存储的问题，也说了接下来的几集中，我们会讨论分布式文件存储的内容。那么话不多说，我们就根据这一集的标题来展开分布式文件存储的讨论吧。成本：MinIO作为开源解决方案，可以节省成本，适合对存储成本有严格控制的场景。而云厂商解决方案需要付费，但通常提供更全面的服务和支持。自主性：使用MinIO等开源解决方案，企业可以拥有更高的自主性和控制权，而云服务则由服务提供商管理。集成性。
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
rabbitmq-c-0.13
08-23
它提供了发送和接收消息的功能，以及管理队列、交换机和绑定等基本操作。RabbitMQ-C库使用AMQP协议与RabbitMQ进行通信，并通过简单而直观的API提供了方便的消息传递机制。你可以通过在C项目中使用RabbitMQ-C库来与...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值