RabbitMQ交换机的类型

最新推荐文章于 2024-03-15 16:52:45 发布
最新推荐文章于 2024-03-15 16:52:45 发布
阅读量623 收藏 1
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq 分布式 java 中间件 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiangjunyes/article/details/121730710
版权

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

为了说明这种模式，我们将构建一个简单的日志系统。它将由两个程序组成:第一个程序将发出日志消
息，第二个程序是消费者。 其中我们会启动两个消费者，其中一个消费者接收到消息后把日志存储在磁盘，另外一个消费者接收到消息后把消息打印在屏幕上，事实上第一个程序发出的日志消息将广播给所有消费者。

Exchanges 概念

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

相反， 生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单， 一方面它接收来自生产者的消息，另一方面将它们推入队列。 交换机必须确切知道如何处理收到的消息。 是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。 这就的由交换机的类型来决定。

在这里插入图片描述

Exchanges 的类型

总共有以下类型：

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

在MQ的可视化后台管理界面中也可以看到有哪些类型
在这里插入图片描述

无名 exchange（默认）

在前面的文章对 exchange 一无所知，但仍然能够将消息发送到队列。 之前能实现的原因是因为我们使用的是默认交换，我们通过空字符串(“”)进行标识。
在这里插入图片描述
第一个参数是交换机的名称。空字符串表示默认或无名称交换机： 消息能路由发送到队列中其实是由 routingKey(bindingkey)绑定 key 指定的，如果它存在的话。

临时队列

之前的文章我使用的是具有特定名称的队列(还记得 hello 和 ack_queue 吗？ ，感兴趣的可以去查看前面的内容)。

队列的名称我们来说至关重要。我们需要指定我们的消费者去消费哪个队列的消息。每当我们连接到 RabbiMQt 时，我们都需要一个全新的空队列，为此我们可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称那就更好了。其次一旦我们断开了消费者的连接，队列将被自动删除（就是不是持久化的队列）。

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

channel.queueDeclare().getQueue();

创建出来之后长成这样:

在这里插入图片描述

绑定(bindings)

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

在这里插入图片描述
在MQ后台管理界面新建一个交换机
在这里插入图片描述
将交换机exchange1与队列one 进行绑定
在这里插入图片描述
在这里插入图片描述

一旦生产者发送消息 到达当前交换机，根据RouteingKey就找到了队列one了。

Fanout（扇出） 介绍

Fanout （也称为发布订阅模式）这种类型非常简单。正如从名称中猜到的那样，它是将接收到的所有消息广播到它知道的所有队列中。 系统中默认有些 exchange 类型

在这里插入图片描述

Fanout代码实现

创建一个交换机 exchange1 类型为fanout
创建两个消费者 注意：其实应该在生产者定义交换机就ok了
消费者代码

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.xiang.rabbitmq.util.RabbitMqUtils;

/**
 * 消费者 接收消息并输出
 */
public class Consumer {


    public static final String EXCHANGE_NAME = "exchange1";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机 ,其实在生产者已经定义了交换机，在消费者定义交换机是为了消费者在启动时，没有找到对应的交换机而报错。
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列;队列名称是随机的。当消费者断开与队列的连接，队列就会自动删除
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        // 1,队列名称  2.交换机名。3，routingKey
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("Q1等待接收消息。。。 ");

        //接收消息回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Q1接收到消息：" + new String(message.getBody(),"UTF-8"));
        };
        //取消消息回调节后
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("Q1取消接收消息:" + consumerTag);
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

第二个消费者


/**
 * 消费者 接收消息
 */
public class Consumer01 {


    public static final String EXCHANGE_NAME = "exchange1";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列;队列名称是随机的。当消费者断开与队列的连接，队列就会自动删除
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        // 1,队列名称  2.交换机名。3，routingKey
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("Q2等待接收消息。。。 ");

        //接收消息回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Q2接收到消息：" + new String(message.getBody(),"UTF-8"));
        };
        //取消消息回调节后
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("Q2取消接收消息:" + consumerTag);
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

生产者


import com.rabbitmq.client.*;
import com.xiang.rabbitmq.util.RabbitMqUtils;
import java.util.Scanner;

/**
 * 生产者
 * 测试fanout 发布订阅模式
 * 发消息给交换机
 */
public class Produce {

    public static final String EXCHANGE_NAME = "exchange1";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列;队列名称是随机的。当消费者断开与队列的连接，队列就会自动删除
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        // 1,队列名称  2.交换机名。3，routingKey
        channel.queueBind(queueName,EXCHANGE_NAME,"");

        //从控制接收要放发送的消息
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            // 声明交换机就可以了。
            channel.basicPublish(EXCHANGE_NAME,"", null,message.getBytes("UTF-8"));
            System.out.println("生产者发出消息：" + message);
        }
    }
}

启动测试发送消息
在这里插入图片描述
只发出了一条消息，查看两个消费者是否都收到了消息
在这里插入图片描述
在这里插入图片描述
测试fanout 广播成功。

Direct exchange（直连）

在上一个测试中，我们构建了一个简单发布订阅系统。我们能够向许多接收者广播消息。在次我们将向其中添加一些特别的功能-比方说我们只让某个消费者订阅发布的部分消息。例如我们只把严重错误消息定向存储到日志文件(以节省磁盘空间)，同时仍然能够在控制台上打印所有日志消息。

我们再次来回顾一下什么是 bindings，绑定是交换机和队列之间的桥梁关系。也可以这么理解：队列只对它绑定的交换机的消息感兴趣。绑定用参数： routingKey 来表示也可称该参数为 binding key，创建绑定我们用代码:channel.queueBind(queueName, EXCHANGE_NAME, “routingKey”);绑定之后的意义由其交换类型决定

Fanout 这种交换类型并不能给我们带来很大的灵活性-它只能进行无意识的广播，在这里我们将使用 direct 这种类型来进行替换，这种类型的工作方式是，消息只去到它绑定的routingKey 队列中去。

在这里插入图片描述

在上面这张图中，我们可以看到 X 绑定了两个队列，绑定类型是 direct。队列 Q1 绑定键为 orange，
队列 Q2 绑定键有两个:一个绑定键为 black，另一个绑定键为 green。

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

多重绑定

在这里插入图片描述

当然如果 exchange 的绑定类型是 direct， 但是它绑定的多个队列的 key 如果都相同，在这种情
况下虽然绑定类型是 direct 但是它表现的就和 fanout （发布订阅）有点类似了，就跟广播差不多，如上图所示。

direct代码实现

在这里插入图片描述
消费者代码

package com.xiang.rabbitmq.six;


import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.xiang.rabbitmq.util.RabbitMqUtils;

/**
 * 消费者 接收消息并输出
 */
public class Consumer {


    public static final String EXCHANGE_NAME = "direct";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机 ,其实在生产者已经定义了交换机，在消费者定义交换机是为了消费者在启动时，没有找到对应的交换机而报错。
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个临时队列;队列名称是随机的。当消费者断开与队列的连接，队列就会自动删除
        channel.queueDeclare("console",false,false,false,null);
        //绑定交换机和队列
        // 1,队列名称  2.交换机名。3，routingKey
        channel.queueBind("console",EXCHANGE_NAME,"info");
        channel.queueBind("console",EXCHANGE_NAME,"warring");
        System.out.println("Q1等待接收消息。。。 ");

        //接收消息回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Q1接收到消息：" + new String(message.getBody(),"UTF-8"));
        };
        //取消消息回调节后
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("Q1取消接收消息:" + consumerTag);
        };
        //队列明
        channel.basicConsume("console",true,deliverCallback,cancelCallback);
    }
}

第二个消费者代码

package com.xiang.rabbitmq.six;


import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.xiang.rabbitmq.util.RabbitMqUtils;

/**
 * 消费者 接收消息并输出
 */
public class Consumer01 {


    public static final String EXCHANGE_NAME = "direct";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机 ,其实在生产者已经定义了交换机，在消费者定义交换机是为了消费者在启动时，没有找到对应的交换机而报错。
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个临时队列;队列名称是随机的。当消费者断开与队列的连接，队列就会自动删除
        channel.queueDeclare("disk",false,false,false,null);
        //绑定交换机和队列
        // 1,队列名称  2.交换机名。3，routingKey
        channel.queueBind("disk",EXCHANGE_NAME,"error");
        System.out.println("Q1等待接收消息。。。 ");

        //接收消息回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Q1接收到消息：" + new String(message.getBody(),"UTF-8"));
        };
        //取消消息回调节后
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("Q1取消接收消息:" + consumerTag);
        };
        //队列明
        channel.basicConsume("disk",true,deliverCallback,cancelCallback);
    }
}

生产者代码

package com.xiang.rabbitmq.six;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.xiang.rabbitmq.util.RabbitMqUtils;

import java.util.Scanner;

/**
 * 生产者
 * 测试 direct模式
 * 发消息给交换机
 */
public class Produce {

    public static final String EXCHANGE_NAME = "direct";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个临时队列;队列名称是随机的。当消费者断开与队列的连接，队列就会自动删除
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        // 1,队列名称  2.交换机名。3，routingKey
        channel.queueBind(queueName,EXCHANGE_NAME,"");

        //从控制接收要放发送的消息
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            /**
             *   声明交换机就可以了。
             * routingKey 绑定了队列，若想要console队列收到消息，填info或者warring。
             * 若想要disk队列收到消息，填error
             */
            channel.basicPublish(EXCHANGE_NAME,"error", null,message.getBytes("UTF-8"));
            System.out.println("生产者发出消息：" + message);
        }
    }
}

启动测试 只让routingKey 为error的对类接收到消息
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

结论

消息接收和队列的routingKey 相关。

Topics模式

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

Topic 的要求

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

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

匹配案例
下图绑定关系如下
在这里插入图片描述

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

上图是一个队列绑定关系图，我们来看看他们之间数据接收情况是怎么样的
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

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

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

topics代码实现

在这里插入图片描述
生产者代码

package com.xiang.rabbitmq.seven;

import com.rabbitmq.client.Channel;
import com.xiang.rabbitmq.util.RabbitMqUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * topic 生产者
 */
public class Produce {

    public static final String exchangeName = "topic";
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        HashMap<String, String> bindKeyMap = new HashMap<>();
        bindKeyMap.put("quick.orange.rabbit","被队列 Q1Q2 接收到");
        bindKeyMap.put("lazy.orange.elephant","被队列 Q1Q2 接收到");
        bindKeyMap.put("quick.orange.fox","被队列 Q1 接收到");
        bindKeyMap.put("lazy.brown.fox","被队列 Q2 接收到");
        bindKeyMap.put("lazy.pink.rabbit","虽然满足两个绑定但只被队列 Q2 接收一次");
        bindKeyMap.put("quick.brown.fox","不匹配任何绑定不会被任何队列接收到会被丢弃");
        bindKeyMap.put("quick.orange.male.rabbit","是四个单词不匹配任何绑定会被丢弃");
        bindKeyMap.put("lazy.orange.male.rabbit","是四个单词但匹配 Q2");

        for (Map.Entry<String, String> bindingKeyEntry: bindKeyMap.entrySet()){
            String bindingKey = bindingKeyEntry.getKey();
            String message = bindingKeyEntry.getValue();
            channel.basicPublish(exchangeName,bindingKey, null,
                    message.getBytes("UTF-8"));
            System.out.println("生产者发出消息" + message);
        }

    }
}

消费者代码


```java
package com.xiang.rabbitmq.seven;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.xiang.rabbitmq.util.RabbitMqUtils;

import java.io.IOException;

/**
 * topic
 */
public class Consumer {

    public static final String exchangeName = "topic";
    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);
        //声明队列
        String queueName = "Q1";
        channel.queueDeclare(queueName,false,false,false,null);

        channel.queueBind(queueName,exchangeName,"*.orange.*");
        System.out.println("Q1等待接收消息");
        //接收消息回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            //System.out.println("Q1接收到消息：" + new String(message.getBody(),"UTF-8"));
            System.out.println("Q1接收队列到消息：" + queueName + "routingKey："+ message.getEnvelope().getRoutingKey());
        };
        //取消消息回调节后
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("Q1取消接收消息:" + consumerTag);
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

消费者代码

package com.xiang.rabbitmq.seven;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.xiang.rabbitmq.util.RabbitMqUtils;

/**
 * topic
 */
public class Consumer01 {

    public static final String exchangeName = "topic";
    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);
        //声明队列
        String queueName = "Q2";
        channel.queueDeclare(queueName,false,false,false,null);

        channel.queueBind(queueName,exchangeName,"*.*.rabbit");
        channel.queueBind(queueName,exchangeName,"lazy.#");
        System.out.println("Q2等待接收消息");
        //接收消息回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            //System.out.println("Q1接收到消息：" + new String(message.getBody(),"UTF-8"));
            System.out.println("Q2接收队列到消息：" + queueName + "routingKey："+ message.getEnvelope().getRoutingKey());
        };
        //取消消息回调节后
        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println("Q2取消接收消息:" + consumerTag);
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

启动测试
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

我叫向同学
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ 学习整理.pdf
07-02
RabbitMQ 学习整理 包括RabbitMQ 配置详解，交换机有四种类型,分别为Direct,topic,headers,Fanout，消息确认机制，多线程处理消息，消费端的限流策略，回调等。都有代码，保证代码正确性都是自己的的从工程中直接COPY出来的，其中还包括 学习的一此地址。
Spring Boot整合RabbitMQ实例（Topic模式）
08-30
Topic Exchange 转发消息主要是根据通配符。接下来通过本文给大家分享Spring Boot整合RabbitMQ实例（Topic模式），需要的朋友参考下吧
（三）丶RabbitMQ的四种类型交换机
最新发布
weixin_52466601的博客
03-15 1339
四大交换机工作原理及实战应用。
rabbitmq-server-3.7.14.txt
07-03
abbitMQ是一个被轻量级且易于部署的，它能支持多种消息协议。RabbitMQ可以部署在分散和联合配置中，从而达到高规模，高可用的需求。P 生产者 制片人 消息的发送者，可以将消息发送到交换机 C 消费者 消费者 消息的接收者，从空中中获取消息进行消费 X 开关 交换 接收生产者发送的消息，并根据路由键发送给指定大小 问 阴离子 队列 存储从交换机发来的消息 类型 交换机类型 类型 直接表示直接根据路由键（橙色/黑色）发送消息
用Jmeter测试RabbitMQ
01-03
jmeter测试Rabbitmq的方法 AMQP Publisher/Consumer  请求 介绍 Exchange(交换机):如果此处不填写，使用默认名称--(AMQP default) Exchange Type:分别是direct(单播)，fanout(广播)，topic(组播)，headers，每种类型路由的策略不同，公司用direct 和 fanout 这2种路由居多 direct：如果一个队列绑定到该交换机上，并且当前要求路由键为  X  ，只有路由键是  X  的消息才会被这个队列转发。默认交换机便是该类型。 fanout：一个发送到交换机上的消息都会被转发到与该交换机绑定的所有队列上。  Fanout  交换机发消息是最快的。 topic：将路由键和某模式进行匹配，可以理解成模糊处理(不是特别明白) Durable(持久化)：具有这个标志的队列和交换机会在重启之后重新建立，它不表示说在队列当中的消息会在重启后恢复 Redeclare(重定义)：此功能不是特别清楚 Message TTL(Time-To-Live Extensions)：消息过期时间，时间为毫秒 Exclusive(排他性队列)：创建一个只有自己可见的队列，即不允许其它用户访问，在没有消费者来消费的时候，他就会自动的删除 Expire(超期时间)：该值必须为正数(与消息 TTL 不同，该值不可以为 0)，所以如果该参数设置为 1000 ，则表示该 queue 如果在 1 秒钟之内未被使用则会被删除。 
RabbitMQ的可视化界面进行操作--交换机和队列管理
MissOfSpring的博客
04-20 643
1.创建队列 2.创建交换机 3.交换机和队列绑定
rabbitmq发布订阅
07-11
看了一天官方文档，自己写了一个发布订阅，已经用于我们的公网环境。
关于RabbitMQ交换机的理解
dengwan3818的博客
10-17 411
RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 消息(Message)由Client发送，RabbitMQ接收到消息之后通过交换机转发到对应的队列上面。Worker会从队列...
RabbitMQ交换机类型
RedStone618的博客
02-10 9202
先附加下官网文档。RabbitMQ的交换机类型共有四种，是根据其路由过程的不同而划分成的： 一、Direct Exchange（直连交换机） 直连型交换机背后的路由算法很简单——消息会传送给绑定键与消息的路由键完全匹配的那个队列。 我们用直连交换机取代了只会无脑广播的扇形交换机，并且具备了选择性接收消息的能力。 这种配置下，我们可以看到有两个队列Q1、Q2绑定到了直连交换机X上。第一个队列用的是橘色（orange）绑定键，第二个有两个绑定键，其中一个绑定键是黑色（black），另一个绑定键是绿色（gree
rabbitmq交换机类型
thebigdipperbdx的博客
09-05 529
rabbitmq官网 rabbitmq是应用最广泛的开源消息代理 - 官方网站 交换机类型 Direct exchange（直连交换机） Fanout exchange（扇型交换机）、 Topic exchange（主题交换机） Headers exchange（头交换机、 默认存在的交换机 Dead Letter Exchange（死信交换机） ...
Jemter JMeter-Rabbit-AMQP插件升级版，支持rabbitmq交换机类型“x-consistent-hash”
12-02
Jemter测试MQ的插件 JMeter-Rabbit-AMQP在github上17年便停止更新了，不支持rabbitmq的交换机类型“x-consistent-hash”，为此我更改了源码使其支持"x-consistent-hash
RabbitMQ--交换器类型/队列模式--使用/教程/详解
IT利刃出鞘的博客
11-16 4615
本文介绍RabbitMQ的交换器类型和队列模式。 本内容也是Java后端面试常见的问题。
Rabbitmq的四种类型交换机
热门推荐
weixin_43416686的博客
07-27 1万+
在绑定消息队列与交换机之前声明一个map键值对，通过这个map对象实现消息队列和交换机的绑定。直连交换机的特点是消息队列通过routingKey与交换机进行绑定，相同的routingKey会获得相同的消息。应用范围最广的交换机类型，消息队列通过消息主题与交换机绑定。一个队列可以通过多个主题与交换机绑定，多个消息队列也可以通过相同消息主题和交换机绑定。扇出交换机的特点是类似于广播，只要队列与该类型的交换机绑定，所有发送到该交换机的信息都会被转发到所有与之绑定的队列，与routingKey无关。........
RabbitMQ四种交换机类型介绍
大王的博客
08-25 640
Direct Exchange 处理路由键。需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键 “abc”，则只有被标记为“abc”的消息才被转发，不会转发abc.def，也不会转发dog.ghi，只会转发abc。 Fanout Exchange 不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。F.
RabbitMq中的交换机
weixin_30689307的博客
10-29 121
Rabbitmq的核心概念（如下图所示）：有虚拟主机、交换机、队列、绑定； 交换机可以理解成具有路由表的路由程序，仅此而已。每个消息都有一个称为路由键（routing key）的属性，就是一个简单的字符串。 最新版本的RabbitMQ有四种交换机类型，分别是Direct exchange、Fanout exchange、To...
RabbitMQ——交换机
风间琉璃の博客
03-08 2395
1. 交换机 exchange 不指定交换机直接发送到队列时，多个消费者之间存在的是竞争关系，一个消息只能被一个消费者接收，其他的消费者不能够再次接收；交换机可以绑定多个不同的队列，但是其Routingkkey是相同的，这样就可以从多个不同的队列发送相同的消息给多个消费者。 不指定交换机的情况，称为简单(工作)模式： 使用交换机的情况，称为发布、订阅模式： 在RabbitMQ中生产者不会讲消息直接发送到队列(不指定有默认交换机)；交换机接收来自生产者的消息并推送给队列。 交换机类型： dire
RabbitMQ之交换机
m0_53151031的博客
02-27 1万+
一、RabbitMQ交换机 二、RabbitMQ交换机实例讲解

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值