RabbitMQ 中交换机类型

喵先森爱吃鱼

已于 2022-05-28 23:03:21 修改

阅读量270

点赞数

分类专栏： rabbitmq 文章标签： rabbitmq 分布式 java

于 2022-05-28 18:03:14 首次发布

本文链接：https://blog.csdn.net/dingd1234/article/details/125014783

版权

rabbitmq 专栏收录该内容

11 篇文章 5 订阅

订阅专栏

在工作队列模式中，每个任务都恰好交付给一个消费者（工作进程）。如果需要将消息传达给多个消费者，则需要使用“发布/订阅”模式。

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

一、Exchanges

1.1 Exchanges 概念

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

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

1.2 Exchanges 类型

总共有以下几种类型：
直接（direct）、主题（topic）、标题（headers）、扇出（fanout）

1.3 无名 Exchanges

在前面的介绍中，比如简单队列模式以及工作模式，都未涉及到交换机，但仍然能够将消息发送到队列中。之所以能够实现，是因为这两种模式中使用的是默认交换机，默认交换机以空字符串（“”）来标识。
在这里插入图片描述
第一个参数是交换机的名称。空字符串表示默认或无名称交换机：如果存在RoutingKey，那么消息将通过 RoutingKey 来路由发送到指定的队列中。

二、临时队列

在之前的案例中，我们都是通过队列名称，来指定消费者去消费哪个队列的消息。

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

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

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

创建出来之后长成这样：
在这里插入图片描述

三、绑定（bindings）

Binding 是 Exchange 和 Queue 之间的桥梁，它告诉我们 Exchange 和哪个队列进行了绑定关系，比如下面这张图，交换机 X 与队列 Q1 和 Q2 进行了绑定。
在这里插入图片描述

四、Fanout

4.1 Fanout 介绍

Fanout 类型的交换机会将接收到所有消息广播到它知道的所有队列中。RabbitMQ 中默认的 Exchange 类型：
在这里插入图片描述

4.2 Fanout 实战

在这里插入图片描述
需求：生产者将日志信息发送给 Fanout 交换机，然后由 Fanout 交换机将消息路由至两个临时队列中，其中一个消费者接收到消息后把日志存储在磁盘中，另一个消费者在接收到消息后，会将消息打印到控制台上。

由于 Fanout 类型的交换机会将消息广播至所有的临时队列中，所以无需指定 BindingKey，使用默认的 BindingKey 即可，默认 BindingKey 为空字符串（“”）。

生产者：

public class FanoutProducer {
    private static String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        // 声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        System.out.println("等待输入消息：");
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
            System.out.println("消息发送完成：" + message);
        }
    }
}

消费者1：

public class FanoutConsumer1 {
    private static String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        String queueName = channel.queueDeclare().getQueue();
        // 把队列和交换机进行绑定
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println("FanoutConsumer1消费者启动，把接收到消息打印在控制台：");
        channel.basicConsume(queueName, true, (consumerTag, message) -> {
            String receivedMessage = new String(message.getBody());
            System.out.println("FanoutConsumer1消费者接收到的消息：" + receivedMessage);
        },(consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费消息");
        });
    }
}

消费者2：

public class FanoutConsumer2 {
    private static String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        String queueName = channel.queueDeclare().getQueue();
        // 把队列和交换机进行绑定
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println("FanoutConsumer2消费者启动，把接收到消息保存到磁盘：");
        channel.basicConsume(queueName, true, (consumerTag, message) -> {
            String receivedMessage = new String(message.getBody());
            File file = new File("/Users/liquanpeng/Desktop/资料/rabbitmq/log.txt");
            FileUtils.writeStringToFile(file, receivedMessage, "UTF-8",true);
            System.out.println("消息已经写入磁盘");
        },(consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费消息");
        });
    }
}

先启动生产者，由于两个消费者中未声明交换机，先启动消费者会报错。接着启动两个消费者。
在这里插入图片描述

再来看下磁盘文件：

五、Direct

绑定是交换机和队列之间的桥梁，队列只对它绑定的交换机的消息感兴趣。绑定使用 RoutingKey 来表示，也可以称该参数为 BindingKey，创建绑定使用代码：channel.queueBind(queueName, EXCHANE_NAME, "routingKey");，绑定之后的意义由其交换机类型来决定。

5.1 Direct 交换机介绍

Fanout 类型的交换机可以将我们的日志信息广播给所有的消费者，如果我们希望将日志消息写入磁盘的程序仅接收严重错误（Errors），而不存储那些警告（warning）或信息（info）类型的日志消息，避免浪费磁盘空间。Fanout 这种交换类型并不能给我们带来很大的灵活性，它只能进行无意识的广播。我们可以使用 direct 这种类型来进行替换，这种类型的工作方式是，消息只会路由到 direct 交换机绑定的 RoutingKey 队列中去。
在这里插入图片描述
在上面这张图中，交换机 X 绑定了两个队列，交换机类型为 direct。队列 Q1 绑定键为 orange，队列 Q2 绑定键有两个：一个为 black，另一个为 green。

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

5.2 多重绑定

在这里插入图片描述
如果 exchange 的绑定类型为 direct，但是如果它绑定的多个队列的 key 都相同，在这种情况下，虽然绑定类型是 direct，但是它表现的就和 fanout 有点类似了。

5.3 实战

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

public class DirectProducer {
    private static String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        // 声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 创建多个 BindingKey
        Map<String, String> bindingKeyMap = new HashMap<>(4);
        bindingKeyMap.put("info", "普通info信息");
        bindingKeyMap.put("warning", "警告warning信息");
        bindingKeyMap.put("error", "错误error信息");
        // debug由于没有消费者接收这条消息，所以就直接丢失了
        bindingKeyMap.put("debug", "调试debug信息");
        for (Map.Entry<String, String> bindingKeyEntry : bindingKeyMap.entrySet()) {
            String routingKey = bindingKeyEntry.getKey();
            String message = bindingKeyEntry.getValue();
            channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
            System.out.println("消息发送完成：" + message);
        }
    }
}

消费者1：

public class DirectConsumer1 {
    private static String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        String queueName = "console";
        channel.queueDeclare(queueName, false, false, false, null);
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 把队列和交换机进行绑定
        channel.queueBind(queueName, EXCHANGE_NAME, "info");
        channel.queueBind(queueName, EXCHANGE_NAME, "warning");
        System.out.println("C1消费者启动，把接收到消息打印在控制台：");
        channel.basicConsume(queueName, true, (consumerTag, delivery) -> {
            String routingKey = delivery.getEnvelope().getRoutingKey();
            String receivedMessage = new String(delivery.getBody());
            System.out.println("C1消费者接收路由"+routingKey+"，消息：" + receivedMessage);
        },(consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费消息");
        });
    }
}

消费者2：

public class DirectConsumer2 {
    private static String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        String queueName = "disk";
        channel.queueDeclare(queueName, false, false, false, null);
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 把队列和交换机进行绑定
        channel.queueBind(queueName, EXCHANGE_NAME, "error");
        System.out.println("C2消费者启动，把接收到消息保存到磁盘：");
        channel.basicConsume(queueName, true, (consumerTag, delivery) -> {
            String routingKey = delivery.getEnvelope().getRoutingKey();
            String receivedMessage = new String(delivery.getBody());
            receivedMessage = "C2消费者接收路由"+routingKey+"，消息：" + receivedMessage;
            File file = new File("/Users/liquanpeng/Desktop/资料/rabbitmq/directlog.txt");
            FileUtils.writeStringToFile(file, receivedMessage, "UTF-8",true);
            System.out.println(receivedMessage);
        },(consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费消息");
        });
    }
}

先启动消费者，再启动生产者

生产者：
在这里插入图片描述
消费者1：

消费者2：

debug 消息由于未绑定任何队列，所以被丢弃了。

六、Topics

6.1 之前类型的问题

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

6.2 Topic 的要求

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

在这个规则列表中，其中有两个替换符时需要注意的：

*（星号）可以代替一个单词
#（井号）可以代替零个或多个单词

6.3 Topic 匹配案例

在这里插入图片描述
上图中的绑定关系如下：
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 了。

6.4 实战

生产者

public class TopicProducer {
    private static String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        // 声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 创建多个 BindingKey
        Map<String, String> bindingKeyMap = new HashMap<>(8);
        bindingKeyMap.put("quick.orange.rabbit","被队列 Q1Q2 接收到");
        bindingKeyMap.put("lazy.orange.elephant","被队列 Q1Q2 接收到");
        bindingKeyMap.put("quick.orange.fox","被队列 Q1 接收到");
        bindingKeyMap.put("lazy.brown.fox","被队列 Q2 接收到");
        bindingKeyMap.put("lazy.pink.rabbit","虽然满足两个绑定但只被队列 Q2 接收一次");
        bindingKeyMap.put("quick.brown.fox","不匹配任何绑定不会被任何队列接收到会被丢弃");
        bindingKeyMap.put("quick.orange.male.rabbit","是四个单词不匹配任何绑定会被丢弃");
        bindingKeyMap.put("lazy.orange.male.rabbit","是四个单词但匹配 Q2");
        for (Map.Entry<String, String> bindingKeyEntry : bindingKeyMap.entrySet()) {
            String routingKey = bindingKeyEntry.getKey();
            String message = bindingKeyEntry.getValue();
            channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
            System.out.println("消息发送完成：" + message);
        }
    }
}

消费者1

public class TopicConsumer1 {
    private static String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        String queueName = "Q1";
        channel.queueDeclare(queueName, false, false, false, null);
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 把队列和交换机进行绑定
        channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.*");
        System.out.println("C1消费者启动，把接收到消息打印在控制台：");
        channel.basicConsume(queueName, true, (consumerTag, delivery) -> {
            String routingKey = delivery.getEnvelope().getRoutingKey();
            String receivedMessage = new String(delivery.getBody());
            System.out.println("C1消费者接收"+queueName+"队列，绑定键："+routingKey+"，消息：" + receivedMessage);
        },(consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费消息");
        });
    }
}

消费者2’

public class TopicConsumer2 {
    private static String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtil.getChannel();
        String queueName = "Q2";
        channel.queueDeclare(queueName, false, false, false, null);
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 把队列和交换机进行绑定
        channel.queueBind(queueName, EXCHANGE_NAME, "*.*.rabbit");
        channel.queueBind(queueName, EXCHANGE_NAME, "lazy.#");
        System.out.println("C2消费者启动，把接收到消息保存到磁盘：");
        channel.basicConsume(queueName, true, (consumerTag, delivery) -> {
            String routingKey = delivery.getEnvelope().getRoutingKey();
            String receivedMessage = new String(delivery.getBody());
            receivedMessage = "C2消费者接收"+queueName+"队列，绑定键："+routingKey+"，消息：" + receivedMessage;
            File file = new File("/Users/liquanpeng/Desktop/资料/rabbitmq/topiclog.txt");
            FileUtils.writeStringToFile(file, receivedMessage, "UTF-8",true);
            System.out.println(receivedMessage);
        },(consumerTag) -> {
            System.out.println(consumerTag + "消费者取消消费消息");
        });
    }
}

先启动两个消费者，然后再启动生产者
在这里插入图片描述

喵先森爱吃鱼

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ 中交换机类型

在工作队列模式中，每个任务都恰好交付给一个消费者（工作进程）。如果需要将消息传达给多个消费者，则需要使用“发布/订阅”模式。为了说明这种模式，我们将构建一个简单的日志系统。它将由两个程序组成：第一个程序将发出日志消息，第二个程序是消费者。我们会启动两个消费者，其中一个消费者接收到消息后把日志存储在磁盘中，另一个消费者在接收到消息后，会将消息打印到屏幕上。事实上，第一个程序发出的日志消息将会广播给所有的消费者。一、Exchanges1.1 Exchanges 概念RabbitMQ 消息传递模型的核心思
复制链接

扫一扫