• RabbitMQ-交换机（发布订阅模式/fanout/direct/topics）

    目录

    一、Exchanges

    1.1 临时队列

    1.2 绑定（bindings）

    二、fanout扇出

    三、Direct直接

    四、Topics主题

            在工作模式中，我们创建了一个工作队列。我们假设的是工作队列背后，每个任务都恰好交付给一个消费者(工作进程)。在这一部分中，我们将做一些完全不同的事情-我们将消息传达给多个消费者。这种模式称为 ”发布/订阅模式”.

     

    一、Exchanges

            RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。

             有下面几大类型：

                    直接(direct), 主题(topic) ,标题(headers) , 扇出(fanout)

            在工作模式中，我们没有使用到交换机（名字指定为 " "），但消息也能正常发送。这是因为我们使用了默认交换。消息从路由发送到队列中其实是由 routingKey(bindingkey)绑定 key 指定的（之前设置为了null）。

    1.1 临时队列

            之前我们一直使用的都是特定名称的队列，如"hello"。其实我们可以创建一个具有随机名称 的队列，或者说让服务器为我们选择一个随机队列名称。一旦我们断开了消费者的连接，队列将被自动删除。

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

    String queueName = channel.queueDeclare().getQueue();

    1.2 绑定（bindings）

            binding 其实是 exchange 和 queue 之间的桥梁，它告诉我们 exchange 和哪个队列进行了绑定关系。比如说下面这张图告诉我们的就是 X 与 Q1 和 Q2 进行了绑定：

    channel.queueBind(queueName, EXCHANGE_NAME, "routingKey");

    二、fanout扇出

             Fanout 这种类型非常简单，它是将接收到的所有消息广播到它知道的所有队列中。

            接下来就以下面的图为例进行演示：

             ReceiveLogs01：

    1. class ReceiveLogs01 implements Callable {
    2. private static final String EXCHANGE_NAME ="logs";
    3.     @Override
    4.     public Object call() throws Exception {
    5.         Channel channel = rabbitMQUtils.getChannel();
    6.         //1.声明一个交换机，参数：（交换机名，模式）
    7.         channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
    8.         //2.声明一个临时的队列
    9.         String queueName = channel.queueDeclare().getQueue();
    10.         //3.将临时队列与交换机绑定,参数：（队列名，交换机名，绑定key）
    11.         channel.queueBind(queueName,EXCHANGE_NAME,"");
    12.         System.out.println("ReceiveLogs01等待接收消息...");
    13.  
    14.         //1).成功的回调消息
    15.         DeliverCallback deliverCallback=(consumerTag, delivery)->{
    16.             String message= new String(delivery.getBody());
    17.             System.out.println("ReceiveLogs01收到了消息："+message);
    18.         };
    19.         //2).取消的回调信息
    20.         CancelCallback cancelCallback=(consumerTag)->{
    21.             System.out.println("消息消费被中断");
    22.         };
    23.         //4.等待接受消息
    24.         channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    25.         return null;
    26.     }
    27. }

             ReceiveLogs02：

    1. class ReceiveLogs02 implements Callable {
    2.     private static final String EXCHANGE_NAME ="logs";
    3.     @Override
    4.     public Object call() throws Exception {
    5.         Channel channel = rabbitMQUtils.getChannel();
    6.         //1.声明一个交换机，参数：（交换机名，模式）
    7.         channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
    8.         //2.声明一个临时的队列
    9.         String queueName = channel.queueDeclare().getQueue();
    10.         //3.将临时队列与交换机绑定,参数：（队列名，交换机名，绑定key）
    11.         channel.queueBind(queueName,EXCHANGE_NAME,"");
    12.         System.out.println("ReceiveLogs02等待接收消息...");
    13.  
    14.         //1).成功的回调消息
    15.         DeliverCallback deliverCallback=(consumerTag, delivery)->{
    16.             String message= new String(delivery.getBody());
    17.             System.out.println("ReceiveLogs02收到了消息："+message);
    18.         };
    19.         //2).取消的回调信息
    20.         CancelCallback cancelCallback=(consumerTag)->{
    21.             System.out.println("消息消费被中断");
    22.         };
    23.         //4.等待接受消息
    24.         channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    25.         return null;
    26.     }
    27. }

            EmitLog：

    1. class EmitLog implements Callable{
    2.     private static final String EXCHANGE_NAME = "logs";
    3.  
    4.     @Override
    5.     public Object call() throws Exception {
    6.         Channel channel = rabbitMQUtils.getChannel();
    7.         //1.声明一个交换机，参数：（交换机名，模式）
    8.         channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
    9.         String msg="我在测试交换机的功能！";
    10.         //2.发布消息
    11.         channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes(StandardCharsets.UTF_8));
    12.         return null;
    13.     }
    14. }

            测试：

    1. public static void main(String[] args) throws InterruptedException {
    2.         ExecutorService service= Executors.newFixedThreadPool(10);
    3.         service.submit(new ReceiveLogs01());
    4.         service.submit(new ReceiveLogs02());
    5.         Thread.sleep(1000);
    6.         service.submit(new EmitLog());
    7.     }
    8.  
    9.  
    10. //结果：
    11. ReceiveLogs01等待接收消息...
    12. ReceiveLogs02等待接收消息...
    13.  
    14. ReceiveLogs02收到了消息：我在测试交换机的功能！
    15. ReceiveLogs01收到了消息：我在测试交换机的功能！

    三、Direct直接

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

            在这种绑定情况下，生产者发布消息到 exchange 上，绑定键为 orange 的消息会被发布到队列 Q1。绑定键为 black、green 和的消息会被发布到队列 Q2，其他消息类型的消息将被丢弃。 

            演示：

            C1：

    1. class C1 implements Callable {
    2.     private static final String EXCHANGE_NAME ="direct_logs";
    3.     @Override
    4.     public Object call() throws Exception {
    5.         Channel channel = rabbitMQUtils.getChannel();
    6.         //1.声明一个交换机，参数：（交换机名，模式）
    7.         channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
    8.         //2.声明一个队列
    9.         channel.queueDeclare("Q1",false,false,false,null);
    10.         //3.将队列与交换机绑定,参数：（队列名，交换机名，绑定key）
    11.         channel.queueBind("Q1",EXCHANGE_NAME,"orange");
    12.         System.out.println("C1等待接收消息...");
    13.  
    14.         //1).成功的回调消息
    15.         DeliverCallback deliverCallback=(consumerTag, delivery)->{
    16.             String message= new String(delivery.getBody());
    17.             System.out.println("C1收到了消息："+message);
    18.         };
    19.         //2).取消的回调信息
    20.         CancelCallback cancelCallback=(consumerTag)->{
    21.             System.out.println("消息消费被中断");
    22.         };
    23.         //4.等待接受消息
    24.         channel.basicConsume("Q1",true,deliverCallback,cancelCallback);
    25.         return null;
    26.     }
    27. }

            C2：

    1. class C2 implements Callable {
    2.     private static final String EXCHANGE_NAME ="direct_logs";
    3.     @Override
    4.     public Object call() throws Exception {
    5.         Channel channel = rabbitMQUtils.getChannel();
    6.         //1.声明一个交换机，参数：（交换机名，模式）
    7.         channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
    8.         //2.声明一个队列
    9.         channel.queueDeclare("Q2",false,false,false,null);
    10.         //3.将队列与交换机绑定,参数：（队列名，交换机名，绑定key）
    11.         channel.queueBind("Q2",EXCHANGE_NAME,"black");
    12.         channel.queueBind("Q2",EXCHANGE_NAME,"green");
    13.         System.out.println("C2等待接收消息...");
    14.  
    15.         //1).成功的回调消息
    16.         DeliverCallback deliverCallback=(consumerTag, delivery)->{
    17.             String message= new String(delivery.getBody());
    18.             System.out.println("C2收到了消息："+message);
    19.         };
    20.         //2).取消的回调信息
    21.         CancelCallback cancelCallback=(consumerTag)->{
    22.             System.out.println("消息消费被中断");
    23.         };
    24.         //4.等待接受消息
    25.         channel.basicConsume("Q2",true,deliverCallback,cancelCallback);
    26.         return null;
    27.     }
    28. }

            EmitLogDirect：

    1. class EmitLogDirect implements Callable {
    2.     private static final String EXCHANGE_NAME = "direct_logs";
    3.  
    4.     @Override
    5.     public Object call() throws Exception {
    6.         Channel channel = rabbitMQUtils.getChannel();
    7.         //1.声明一个交换机，参数：（交换机名，模式）
    8.         channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT);
    9.         //2.发布消息
    10.         //用map封装三种类型的消息，对应三个bingKey的情况.发送三次
    11.         Map msgs=new HashMap<>();
    12.         msgs.put("orange","orange信息");
    13.         msgs.put("black","black信息");
    14.         msgs.put("green","green信息");
    15.         for (Map.Entry bindingKeyEntry: msgs.entrySet()) {
    16.             String bindingKey = bindingKeyEntry.getKey();
    17.             String message = bindingKeyEntry.getValue();
    18.             channel.basicPublish(EXCHANGE_NAME, bindingKey, null, message.getBytes(StandardCharsets.UTF_8));
    19.             Thread.sleep(1000);
    20.         }
    21.         return null;
    22.     }
    23. }

            测试： 

    1. public static void main(String[] args) throws InterruptedException {
    2.         ExecutorService service= Executors.newFixedThreadPool(10);
    3.         service.submit(new C1());
    4.         service.submit(new C2());
    5.         Thread.sleep(1000);
    6.         service.submit(new EmitLogDirect());
    7.     }
    8.  
    9.  
    10. //结果：
    11. C1等待接收消息...
    12. C2等待接收消息...
    13.  
    14. C1收到了消息：orange信息
    15. C2收到了消息：green信息
    16. C2收到了消息：black信息

    四、Topics主题

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

            发送到类型是 topic 交换机的消息的 routing_key（bingingKey） 不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词。

            比如："stock.usd.nyse", "nyse.vmw", "quick.orange.rabbit"。当然这个单词列表最多不能超过 255 个字节。

            其中，

                    *(星号)可以代替一个单词        

                     #(井号)可以替代零个或多个单词

            （当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像 fanout 了；

            如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是 direct 了）

             按照上面的图，若发送下面的消息，则消息的接收结果应该如下：

    quick.orange.rabbit         被队列 Q1Q2 接收到

    lazy.orange.elephant         被队列 Q1Q2 接到

    quick.orange.fox         被队列 Q1 接收到

    lazy.brown.fox         被队列 Q2 接收到

    lazy.pink.rabbit         虽然满足两个绑定但只被队列 Q2 接收一次

    quick.brown.fox         不匹配任何绑定不会被任何队列接收到会被丢弃

    quick.orange.male.rabbit         是四个单词不匹配任何绑定会被丢弃

    lazy.orange.male.rabbit         是四个单词但匹配 Q2

             C1：

    1. class C1 implements Callable {
    2.     private static final String EXCHANGE_NAME ="topic_logs";
    3.     @Override
    4.     public Object call() throws Exception {
    5.         Channel channel = rabbitMQUtils.getChannel();
    6.         //1.声明一个交换机，参数：（交换机名，模式）
    7.         channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
    8.         //2.声明一个队列
    9.         channel.queueDeclare("Q1",false,false,false,null);
    10.         //3.将队列与交换机绑定,参数：（队列名，交换机名，绑定key）
    11.         channel.queueBind("Q1",EXCHANGE_NAME,"*.orange.*");
    12.         System.out.println("C1等待接收消息...");
    13.  
    14.         //1).成功的回调消息
    15.         DeliverCallback deliverCallback=(consumerTag, delivery)->{
    16.             String message= new String(delivery.getBody());
    17.             System.out.println("C1收到了消息："+message);
    18.         };
    19.         //2).取消的回调信息
    20.         CancelCallback cancelCallback=(consumerTag)->{
    21.             System.out.println("消息消费被中断");
    22.         };
    23.         //4.等待接受消息
    24.         channel.basicConsume("Q1",true,deliverCallback,cancelCallback);
    25.         return null;
    26.     }
    27. }

            C2：

    1. class C2 implements Callable {
    2.     private static final String EXCHANGE_NAME ="topic_logs";
    3.     @Override
    4.     public Object call() throws Exception {
    5.         Channel channel = rabbitMQUtils.getChannel();
    6.         //1.声明一个交换机，参数：（交换机名，模式）
    7.         channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
    8.         //2.声明一个队列
    9.         channel.queueDeclare("Q2",false,false,false,null);
    10.         //3.将队列与交换机绑定,参数：（队列名，交换机名，绑定key）
    11.         channel.queueBind("Q2",EXCHANGE_NAME,"*.*.rabbit");
    12.         channel.queueBind("Q2",EXCHANGE_NAME,"lazy.#");
    13.         System.out.println("C2等待接收消息...");
    14.  
    15.         //1).成功的回调消息
    16.         DeliverCallback deliverCallback=(consumerTag, delivery)->{
    17.             String message= new String(delivery.getBody());
    18.             System.out.println("C2收到了消息："+message);
    19.         };
    20.         //2).取消的回调信息
    21.         CancelCallback cancelCallback=(consumerTag)->{
    22.             System.out.println("消息消费被中断");
    23.         };
    24.         //4.等待接受消息
    25.         channel.basicConsume("Q2",true,deliverCallback,cancelCallback);
    26.         return null;
    27.     }
    28. }

            EmitLogTopic：

    1. class EmitLogTopic implements Callable {
    2.     private static final String EXCHANGE_NAME = "topic_logs";
    3.  
    4.     @Override
    5.     public Object call() throws Exception {
    6.         Channel channel = rabbitMQUtils.getChannel();
    7.         //1.声明一个交换机，参数：（交换机名，模式）
    8.         channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
    9.         //2.发布消息
    10.         //用map封装不同类型的消息，对应不同bingKey的情况.发送若干次
    11.         Map msgs=new HashMap<>();
    12.         msgs.put("quick.orange.rabbit","被队列 Q1Q2 接收到");
    13.         msgs.put("lazy.orange.elephant","被队列 Q1Q2 接收到");
    14.         msgs.put("quick.orange.fox","被队列 Q1 接收到");
    15.         msgs.put("lazy.brown.fox","被队列 Q2 接收到");
    16.         msgs.put("lazy.pink.rabbit","虽然满足两个绑定但只被队列 Q2 接收一次");
    17.         msgs.put("quick.brown.fox","不匹配任何绑定不会被任何队列接收到会被丢弃");
    18.         msgs.put("quick.orange.male.rabbit","是四个单词不匹配任何绑定会被丢弃");
    19.         msgs.put("lazy.orange.male.rabbit","是四个单词但匹配 Q2");
    20.         for (Map.Entry bindingKeyEntry: msgs.entrySet()) {
    21.             String bindingKey = bindingKeyEntry.getKey();
    22.             String message = bindingKeyEntry.getValue();
    23.             channel.basicPublish(EXCHANGE_NAME, bindingKey, null, message.getBytes(StandardCharsets.UTF_8));
    24.             Thread.sleep(1000);
    25.         }
    26.         return null;
    27.     }
    28. }

            测试：

    1.  public static void main(String[] args) throws InterruptedException {
    2.         ExecutorService service= Executors.newFixedThreadPool(10);
    3.         service.submit(new C11());
    4.         service.submit(new C22());
    5.         Thread.sleep(1000);
    6.         service.submit(new EmitLogTopic());
    7.     }
    8.  
    9. //结果：
    10. C1等待接收消息...
    11. C2等待接收消息...
    12.  
    13. C2收到了消息：被队列 Q1Q2 接收到
    14. C1收到了消息：被队列 Q1Q2 接收到
    15. C2收到了消息：被队列 Q2 接收到
    16. C2收到了消息：被队列 Q1Q2 接收到
    17. C1收到了消息：被队列 Q1Q2 接收到
    18. C1收到了消息：被队列 Q1 接收到
    19. C2收到了消息：虽然满足两个绑定但只被队列 Q2 接收一次
    20. C2收到了消息：是四个单词但匹配 Q2
  • 相关阅读:
    Linux软硬链接
    信息系统项目管理师 第四版 第17章 项目干系人管理
    C++11新特性⑤ | 仿函数与lambda表达式
    SpringCloud-NacosFoundation
    linux驱动工作原理
    Spring boot easyexcel 实现复合数据导出、按模块导出
    弘辽科技：淘宝的各个级别的店铺有多少自然流量？具体解答
    LeetCode-496 下一个更大元素
    label问题排查：打不开标注好的图像
    详讲！！红黑树（最优二叉树）
  • 原文地址：https://blog.csdn.net/weixin_62427168/article/details/126323188