devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【初始RabbitMQ】交换机的实现_rabbitmq如何新建一个交换机

作者：2023面试高手 | 2024-04-16 02:06:58

赞

踩

rabbitmq如何新建一个交换机

交换机概念

RabbitMQ消息传递模型的核心思想就是：生产者生产的消息从不会直接发送到队列。实际上，通常生产者不知道这些消息会传递到那些队列中

相反，生产者只能将消息发送到交换机，交换机的工作内容也很简单，一方面是接受来自生产者的消息，另一方面是将它们推入到队列中。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定的队列、还是把它们放到随即队列、还是直接丢弃，这些都是由交换机来决定的

无名交换机

在本教程的前面部分我们对 exchange 一无所知，但仍然能够将消息发送到队列。之前能实现的 原因是因为我们使用的是默认交换，我们通过空字符串(“”)进行标识

 第一个参数是交换机的名称。空字符串表示默认或无名称交换机：消息能路由发送到队列中其实是由 routingKey(bindingkey)绑定 key 指定的，如果它存在的话

临时队列

之前的文章我们使用的都是具有特定名称的队列（例如hello和ack_queue），队列的名称对我们来说至关重要-我们需要指定我们的消费者去消费哪个队列的消息

每当我们连接到RabbitMQ时，我们都需要一个全新的空队列，为此我们可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称那就更好了。其次，一旦我们断开了消费者的连接，队列自动删除

创建临时队列的方式如下：

创建成功的队列如下：

绑定（bindings）

什么是binding，binding其实是交换机和队列之间的桥梁，他告诉我们交换机和那个队列进行绑定关系。比如说下面这张图告诉我们的就是 X 与 Q1 和 Q2 进行了绑定

交换机类型 

交换机重要是分为以下几种类型：直接（direct）、主题（topic）、标题（headers）、扇出（fanout）

Fanout

Fanout介绍

Fanout这种类型非常节俭但，正如名称一样，它是将接受得到的所有消息广播到它的所有队列中。系统中默认有些exchange类型：

Fanout实战

logs和临时队列的绑定关系如下： 

 ReceiveLogs01 将接收到的消息打印在控制台

  1. /**
  2.  * 消息接收
  3.  * ReceiveLogs01 将接收到的消息打印在控制台
  4.  */
  5.  
  6. public class ReceiveLogs01 {
  7.     public static final String EXCHANGE_NAME = "logs";
  8.     public static void main(String[] args) throws IOException {
  9.         Channel channel = RabbitMqUtils.getChannel();
  10.         //创建交换机
  11.         channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
  12.         /**
  13.          * 生成一个临时队列 队列名称是随机的
  14.          * 当消费者断开和该队列的链接时 队列自动删除
  15.          */
  16.         String queueName = channel.queueDeclare().getQueue();
  17.         //把该临时队列绑定我们的交换机 其中routingKey（binding key）为空字符串 这意味着队列会接收交换机发送的所有消息
  18.         channel.queueBind(queueName,EXCHANGE_NAME,"");
  19.         System.out.println("等待接收消息，把接收到的消息打印到屏幕上......");
  20.         DeliverCallback deliverCallback = (consumerTag, delivery)->{
  21.             String message = new String(delivery.getBody(), "UTF-8");
  22.             System.out.println("控制台打印接收到的消息"+message);
  23.         };
  24.         channel.basicConsume(queueName,true,deliverCallback,consumerTag->{});
  25.     }
  26. }

ReceiveLogs02 将接收到的消息存储在磁盘

  1. /**
  2.  * ReceiveLogs02 将接收到的消息存储在磁盘
  3.  */
  4. public class ReceiveLogs02 {
  5.     private static final String EXCHANGE_NAME = "logs";
  6.     public static void main(String[] args) throws IOException {
  7.         Channel channel = RabbitMqUtils.getChannel();
  8.         channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
  9.         String queueName = channel.queueDeclare().getQueue();
  10.         channel.queueBind(queueName,EXCHANGE_NAME,"");
  11.         System.out.println("等待接收消息,把接收到的消息写到文件.....");
  12.         DeliverCallback deliverCallback = (consumerTag,delivery)->{
  13.             String message = new String(delivery.getBody(), "UTF-8");
  14.             File file = new File("D:rabbitmq_info.txt");
  15.             FileUtils.writeStringToFile(file,message,"UTF-8",true);
  16.             System.out.println("数据写入文件成功"+message);
  17.         };
  18.         channel.basicConsume(queueName,true,deliverCallback, consumerTag -> { });
  19.     }
  20. }

EmitLog 发送消息给两个消费者接收

  1. /**
  2.  * EmitLog 发送消息给两个消费者接收
  3.  */
  4. public class EmitLog {
  5.     private static final String EXCHANGE_NAME = "logs";
  6.  
  7.     public static void main(String[] args) throws IOException {
  8.         Channel channel = RabbitMqUtils.getChannel();
  9.         //创建交换机 1、名称 2、类型
  10.         channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
  11.         Scanner scanner = new Scanner(System.in);
  12.         while(scanner.hasNext()){
  13.             String message = scanner.nextLine();
  14.             channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes(StandardCharsets.UTF_8));
  15.             System.out.println("生产者发出消息"+message);
  16.         }
  17.     }
  18. }

运行结果;

Direct 

Direct介绍

上一节中，我们的日志系统将所有消息广播给所有消费者，对此我们想做一些改变，例如我们希望将日志消息写入磁盘的程序仅接受严重错误（errors），而不存储那些警告（warning）或者信息（info）日志消息避免浪费磁盘空间。Fanout 这种交换类型并不能给我们带来很大的灵活性-它只能进行无意识的 广播，在这里我们将使用 direct 这种类型来进行替换，这种类型的工作方式是，消息只去到它绑定的 routingKey 队列中去

单独绑定

在上面这张图中，我们可以看到 X 绑定了两个队列，绑定类型是 direct。队列 Q1 绑定键为 orange， 队列 Q2 绑定键有两个:一个绑定键为 black，另一个绑定键为 green                                                                                                                                                                                                                在这种绑定情况下，生产者发布消息到 exchange 上，绑定键为 orange 的消息会被发布到队列 Q1。绑定键为 blackgreen 和的消息会被发布到队列 Q2，其他消息类型的消息将被丢弃

多重绑定

当交换机绑定类型是direct，但是它绑定的多个队列的key相同，这种情况下虽然绑定类型都是direct但是它的表现就和fanout类似

Direct实战

logs和临时队列的绑定关系如下： 

生产者代码如下：

  1. public class EmitLogDirect {
  2.     public static final String EXCHANGE_NAME = "direct_logs";
  3.  
  4.     public static void main(String[] args) throws IOException {
  5.         Channel channel = RabbitMqUtils.getChannel();
  6.         channel.exchangeDeclare(EXCHANGE_NAME,"direct");
  7.         //创建多个bindingKey
  8.         Map<String,String> bindingKeyMap = new HashMap<>();
  9.         bindingKeyMap.put("info","普通info信息");
  10.         bindingKeyMap.put("warning","警告warning信息");
  11.         bindingKeyMap.put("error","错误error信息");
  12.         //debug 没有消费这接收这个消息 所有就丢失了
  13.         bindingKeyMap.put("debug","调试 debug 信息");
  14.         for (Map.Entry<String, String> bindingKeyEntry: bindingKeyMap.entrySet()) {
  15.             String bindingKey = bindingKeyEntry.getKey();
  16.             String message = bindingKeyEntry.getValue();
  17.             /**
  18.              * 发送一个消息
  19.              * 1.发送到那个交换机
  20.              * 2.路由的KEY值是哪个 本次是队列的名称
  21.              * 3.其他参数信息
  22.              * 4.发送消息的消息体
  23.              */
  24.             channel.basicPublish(EXCHANGE_NAME, bindingKey, null,
  25.                     message.getBytes("UTF-8"));
  26.             System.out.println("生产者发出消息:" + message);
  27.         }
  28.     }
  29. }

 消费者1将日志保存到文件中：

  1. public class ReceiveLogsDirect01 {
  2.     public static final String EXCHANGE_NAME = "direct_logs";
  3.  
  4.     public static void main(String[] args) throws IOException {
  5.         Channel channel = RabbitMqUtils.getChannel();
  6.         channel.exchangeDeclare(EXCHANGE_NAME,"direct");
  7.         String queueName = channel.queueDeclare().getQueue();
  8.         channel.queueBind(queueName,EXCHANGE_NAME,"error");
  9.         System.out.println("等待接受消息......");
  10.  
  11.         DeliverCallback deliverCallback = (consumeTag,delivery)->{
  12.             String message = new String(delivery.getBody(),"UTF-8");
  13.             message="接收绑定键:"+delivery.getEnvelope().getRoutingKey()+",消息:"+message;
  14.             File file = new File("D:rabbitmq_info.txt");
  15.             FileUtils.writeStringToFile(file,message,"UTF-8",true);
  16.             System.out.println("数据写入文件成功"+message);
  17.         };
  18.         /**
  19.          * 消费者信息
  20.          * 1.消费哪个队列
  21.          * 2.消费成功之后是否要自动应答 true自动应答 false手动应答
  22.          * 3.消费者微车才能更改消费的回调
  23.          * 4.消费者取消消费回调
  24.          */
  25.         channel.basicConsume(queueName,true,deliverCallback, consumerTag -> {
  26.         });
  27.     }
  28. }

消费者2将日志打印到控制台： 

  1. public class ReceiveLogsDirect02 {
  2.     private static final String EXCHANGE_NAME = "direct_logs";
  3.  
  4.     public static void main(String[] args) throws IOException {
  5.         Channel channel = RabbitMqUtils.getChannel();
  6.         channel.exchangeDeclare(EXCHANGE_NAME,"direct");
  7.         String queueName = channel.queueDeclare().getQueue();
  8.         channel.queueBind(queueName, EXCHANGE_NAME, "info");
  9.         channel.queueBind(queueName, EXCHANGE_NAME, "warning");
  10.         System.out.println("等待接受消息......");
  11.         /**
  12.          * 消费者信息
  13.          * 1.消费哪个队列
  14.          * 2.消费成功之后是否要自动应答 true自动应答 false手动应答
  15.          * 3.消费者微车才能更改消费的回调
  16.          * 4.消费者取消消费回调
  17.          */
  18.         DeliverCallback deliverCallback = (consumeTag,delivery)->{
  19.             String message = new String(delivery.getBody(), "UTF-8");
  20.             System.out.println(" 接收绑定键 :"+delivery.getEnvelope().getRoutingKey()
  21.                     +", 消息:"+message);
  22.         };
  23.         channel.basicConsume(queueName,true,deliverCallback, consumerTag -> {
  24.         });
  25.     }
  26. }

运行结果： 

Topics

Topics介绍

在上一个小节中，我们改进了日志记录系统。我们没有使用只能进行随意广播的 fanout 交换机，而是 使用了 direct 交换机，从而有能实现有选择性地接收日志

 尽管使用 direct 交换机改进了我们的系统，但是它仍然存在局限性-比方说我们想接收的日志类型有 info.base 和 info.advantage，某个队列只想 info.base 的消息，那这个时候 direct 就办不到了。这个时候 就只能使用 topic 类型

Topics使用

发送到类型是 topic 交换机的消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单 词列表，以点号分隔开。这些单词可以是任意单词，比如说："stock.usd.nyse", "nyse.vmw", "quick.orange.rabbit".这种类型的。当然这个单词列表最多不能超过 255 个字节

 在这个规则列表中，其中有两个替换符：

  • *(星号)可以代替一个单词
  • #(井号)可以替代零个或多个单词

示例如下：

  1. Q1-->绑定的是
    1. 中间带 orange 带 3 个单词的字符串(*.orange.*)
  2. Q2-->绑定的是
    1. 最后一个单词是 rabbit 的 3 个单词(*.*.rabbit)
    2. 第一个单词是 lazy 的多个单词(lazy.#)

 上图是一个队列绑定关系图，我们来看看他们之间数据接收情况是怎么样的

  1. quick.orange.rabbit 被队列 Q1Q2 接收到
  2. lazy.orange.elephant 被队列 Q1Q2 接收到
  3. quick.orange.fox 被队列 Q1 接收到
  4. lazy.brown.fox 被队列 Q2 接收到
  5. lazy.pink.rabbit 虽然满足两个绑定但只被队列 Q2 接收一次
  6. quick.brown.fox 不匹配任何绑定不会被任何队列接收到会被丢弃
  7. quick.orange.male.rabbit 是四个单词不匹配任何绑定会被丢弃
  8. lazy.orange.male.rabbit 是四个单词但匹配 Q2

当队列绑定关系是下列这种情况时需要引起注意：

  • 当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像 fanout 了
  • 如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是 direct 了

Topics实战

 logs和临时队列的绑定关系如下： 

生产者代码如下：

  1. public class EmitLogTopic {
  2.     private static final String EXCHANGE_NAME = "topic_logs";
  3.  
  4.     public static void main(String[] argv) throws Exception {
  5.         Channel channel = RabbitMqUtils.getChannel();
  6.         channel.exchangeDeclare(EXCHANGE_NAME, "topic");
  7.         /**
  8.          * Q1-->绑定的是
  9.          * 中间带 orange 带 3 个单词的字符串(*.orange.*)
  10.          * Q2-->绑定的是
  11.          * 最后一个单词是 rabbit 的 3 个单词(*.*.rabbit)
  12.          * 第一个单词是 lazy 的多个单词(lazy.#)
  13.          *
  14.          */
  15.         Map<String, String> bindingKeyMap = new HashMap<>();
  16.         bindingKeyMap.put("quick.orange.rabbit", "被队列 Q1Q2 接收到");
  17.         bindingKeyMap.put("lazy.orange.elephant", "被队列 Q1Q2 接收到");
  18.         bindingKeyMap.put("quick.orange.fox", "被队列 Q1 接收到");
  19.         bindingKeyMap.put("lazy.brown.fox", "被队列 Q2 接收到");
  20.         bindingKeyMap.put("lazy.pink.rabbit", "虽然满足两个绑定但只被队列 Q2 接收一次");
  21.         bindingKeyMap.put("quick.brown.fox", "不匹配任何绑定不会被任何队列接收到会被丢弃");
  22.         bindingKeyMap.put("quick.orange.male.rabbit", "是四个单词不匹配任何绑定会被丢弃");
  23.         bindingKeyMap.put("lazy.orange.male.rabbit", "是四个单词但匹配 Q2");
  24.         for (Map.Entry<String, String> bindingKeyEntry : bindingKeyMap.entrySet()) {
  25.             String bindingKey = bindingKeyEntry.getKey();
  26.             String message = bindingKeyEntry.getValue();
  27.             channel.basicPublish(EXCHANGE_NAME, bindingKey, null,
  28.                     message.getBytes("UTF-8"));
  29.             System.out.println("生产者发出消息" + message);
  30.         }
  31.     }
  32. }

 消费者1的代码如下：

  1. public class ReceiveLogsTopic01 {
  2.     private static final String EXCHANGE_NAME = "topic_logs";
  3.     public static void main(String[] argv) throws Exception {
  4.         Channel channel = RabbitMqUtils.getChannel();
  5.         channel.exchangeDeclare(EXCHANGE_NAME, "topic");
  6.         //声明 Q1 队列与绑定关系
  7.         String queueName="Q1";
  8.         channel.queueDeclare(queueName, false, false, false, null);
  9.         channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.*");
  10.         System.out.println("等待接收消息.....");
  11.         DeliverCallback deliverCallback = (consumerTag, delivery) -> {
  12.             String message = new String(delivery.getBody(), "UTF-8");
  13.             System.out.println(" 接收队列 :"+queueName+" 绑定键:"
  14.                     +delivery.getEnvelope().getRoutingKey()+",消息:"+message);
  15.         };
  16.         channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
  17.         });
  18.     }
  19. }

消费者2代码如下：

  1. public class ReceiveLogsTopic02 {
  2.     private static final String EXCHANGE_NAME = "topic_logs";
  3.  
  4.     public static void main(String[] argv) throws Exception {
  5.         Channel channel = RabbitMqUtils.getChannel();
  6.         channel.exchangeDeclare(EXCHANGE_NAME, "topic");
  7.         //声明 Q2 队列与绑定关系
  8.         String queueName = "Q2";
  9.         channel.queueDeclare(queueName, false, false, false, null);
  10.         channel.queueBind(queueName, EXCHANGE_NAME, "*.*.rabbit");
  11.         channel.queueBind(queueName, EXCHANGE_NAME, "lazy.#");
  12.         System.out.println("等待接收消息.....");
  13.         DeliverCallback deliverCallback = (consumerTag, delivery) -> {
  14.             String message = new String(delivery.getBody(), "UTF-8");
  15.             System.out.println(" 接收队列 :" + queueName + " 绑定键:"
  16.                     + delivery.getEnvelope().getRoutingKey() + ",消息:" + message);
  17.         };
  18.         channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
  19.         });
  20.     }
  21. }

 运行结果如下：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/431667
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号