[大数据]RabbitMQ学习（五）-- 交换机学习（第三个部分：发布-订阅模式）

RabbitMQ交换机学习

在之前的学习中，我们是创建了一个工资队列。我们假设的是在工作队列背后，每个人物都恰好交付给一个确认的消费者（工作进程）。在本节的学习中，我们将做一些不同的事情：将消息传递给多个消费者。这种模式被称为发布/订阅模式；
为了说明这种模式，我们将构建一个简单的日志系统，由两个程序组成：

• 第一个程序将发出日志消息；
• 第二个程序是消费者；
  届时将启动两个消费者，其中一个消费者接收到消息之后将日志存储在磁盘中，另外一个消费者接收到消息之后打印在屏幕上，相当于是第一个程序发出的日志消息将广播给所有的消费者；

Exchange

Exchange概念

RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。
相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单：

• 一方面它接收来自生产者的消息；
• 另一方面将它们推入队列。

交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。

Exchange的类型

交换机一共有四种类型：

• 直接（direct）：路由模式；
• 主题（topic）；
• 标题（headers）：不常用；
• 扇出（fanout）：发布订阅模式；

无名exchange

在之前的学习中，我们不设置exchange仍可以将消息扔给队列，之前能实现的原因是因为我们使用的是默认交换，我们通过空字符串(“”)进行标识。

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

临时队列

之前的章节我们使用的是具有特定名称的队列(还记得 hello 和 ack_queue 吗？)。队列的名称我们来说至关重要-我们需要指定我们的消费者去消费哪个队列的消息。
每当我们连接到 Rabbit 时，我们都需要一个全新的空队列，为此我们可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称那就更好了。其次一旦我们断开了消费者的连接，队列将被自动删除。
创建临时队列的方式如下:

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

创建出来之后长成这样:

绑定

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

Fanout模式

Fanout介绍

Fanout 这种类型非常简单。正如从名称中猜到的那样，它是将接收到的所有消息广播到它知道的所有队列中。系统中默认有些 exchange 类型：

Fanout实战（发布订阅模式）

Logs与临时队列的绑定关系如下图：

代码演示：
消费者1：

package com.vleus.rabbitmq.five;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

/**
 * @author vleus
 * @date 2021年07月22日 23:34
 * 消息接收1
 */
public class ReceiveLogs01 {

    //交换机的名称
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();

        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        //声明一个队列,临时队列
        /**
         * 生成一个临时队列、队列的名称是随机的
         * 当消费者断开与队列的连接的时候 队列就自动删除
         */
        String queueName = channel.queueDeclare().getQueue();

        /**
         * 绑定交换机与队列
         */
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println("01等待接收消息，将接收到的消息打印在屏幕上....");

        //接收消息

        //消费者取消消息时触发的回调接口
        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println("01控制台打印接收到的消息:" + new String(message.getBody(),"UTF-8"));
        };

        channel.basicConsume(queueName, true, deliverCallback,consumerTag -> {});
    }

}

消费者2

package com.vleus.rabbitmq.five;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

/**
 * @author vleus
 * @date 2021年07月22日 23:34
 * 消息接收1
 */
public class ReceiveLogs02 {

    //交换机的名称
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();

        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        //声明一个队列,临时队列
        /**
         * 生成一个临时队列、队列的名称是随机的
         * 当消费者断开与队列的连接的时候 队列就自动删除
         */
        String queueName = channel.queueDeclare().getQueue();

        /**
         * 绑定交换机与队列
         */
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println("02等待接收消息，将接收到的消息打印在屏幕上....");

        //接收消息

        //消费者取消消息时触发的回调接口
        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println("02控制台打印接收到的消息:" + new String(message.getBody(),"UTF-8"));
        };

        channel.basicConsume(queueName, true, deliverCallback,consumerTag -> {});
    }

}

生产者：

package com.vleus.rabbitmq.five;

import com.rabbitmq.client.Channel;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

import java.util.Scanner;

/**
 * @author vleus
 * @date 2021年07月22日 23:46
 */
public class EmitLog {

    //交换机的名称
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();
//        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        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);

        }

    }


}

执行结果为两个消费者都能接收到消息；

Direct Exchange

回顾

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

Direct Exchange介绍

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

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

多重绑定

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

实战

生产者代码

package com.vleus.rabbitmq.direct_exchange;

import com.rabbitmq.client.Channel;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

import java.util.Scanner;

/**
 * @author vleus
 * @date 2021年07月22日 23:46
 */
public class DirectLog {

    //交换机的名称
    public static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();
//        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String message = scanner.next();
            //根据routingKey设置发送给哪个消费者
            channel.basicPublish(EXCHANGE_NAME, "error", null, message.getBytes("UTF-8"));
            System.out.println("生产者发出消息: " + message);

        }

    }
}

消费者1

package com.vleus.rabbitmq.direct_exchange;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

/**
 * @author vleus
 * @date 2021年07月24日 10:52
 */
public class ReceiveLogDirect01 {

    //设置交换机名称
    public static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();

        //声明一个Direct交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        //声明一个队列
        channel.queueDeclare("console", false, false, false, null);

        //队列与交换机绑定
        channel.queueBind("console", EXCHANGE_NAME, "info");
        channel.queueBind("console", EXCHANGE_NAME, "warning");

        //消费者取消消息时触发的回调接口
        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println("ReceiveLogDirect01控制台打印接收到的消息:" + new String(message.getBody(),"UTF-8"));
        };

        //进行消息消费
        channel.basicConsume("console", true, deliverCallback, consumerTag -> {});
    }

}

消费者2

package com.vleus.rabbitmq.direct_exchange;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

/**
 * @author vleus
 * @date 2021年07月24日 10:52
 */
public class ReceiveLogDirect02 {

    //设置交换机名称
    public static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {

        Channel channel = RabbitMqUtils.getChannel();

        //声明一个Direct交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        //声明一个队列
        channel.queueDeclare("disk", false, false, false, null);

        //队列与交换机绑定
        channel.queueBind("disk", EXCHANGE_NAME, "error");

        //消费者取消消息时触发的回调接口
        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println("ReceiveLogDirect02控制台打印接收到的消息:" + new String(message.getBody(),"UTF-8"));
        };

        //进行消息消费
        channel.basicConsume("disk", true, deliverCallback, consumerTag -> {});
    }

}

根据routingKey的不同进而可以发送给不同的消费者；

Topics

在Direct Exchange模式下，我们没有使用只能进行随意广播的 fanout 交换机，而是使用了 direct 交换机，从而有能实现有选择性地接收日志。
尽管使用 direct 交换机改进了我们的系统，但是它仍然存在局限性-比方说我们想接收的日志类型有info.base 和 info.advantage，某个队列只想 info.base 的消息，那这个时候 direct 就办不到了。这个时候就只能使用 topic 类型

Topic

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

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

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 了

实战

生产者代码

package com.vleus.rabbitmq.topics_exchange;

import com.rabbitmq.client.Channel;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * @author vleus
 * @date 2021年07月24日 12:11
 */
public class EmitLogTopic {


    //交换机名称
    public static final String EXCHANGE_NAME = "topic_log";

    public static void main(String[] args) throws Exception {

        //接收消息
        Channel channel = RabbitMqUtils.getChannel();

        /**
         * 绑定关系如下：
         * 1、 Q1-->绑定的是中间带 orange 带 3 个单词的字符串(*.orange.*)；
         * 2、 Q2-->绑定的是最后一个单词是 rabbit 的 3 个单词(*.*.rabbit)，第一个单词是 lazy 的多个单词(lazy.#)；
         */
        Map<String,String> bindingKeyMap = new HashMap<>();

        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(StandardCharsets.UTF_8));
            System.out.println("生产者成功发出消息: " + message);
        }

    }
}

消费者代码1

package com.vleus.rabbitmq.topics_exchange;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

/**
 * @author vleus
 * @date 2021年07月24日 12:01
 *  声明主题交换机及相关队列
 *
 *  消费者c1
 */
public class ReceiveLogsTopic01 {

    //交换机名称
    public static final String EXCHANGE_NAME = "topic_log";

    public static void main(String[] args) throws Exception {

        //接收消息
        Channel channel = RabbitMqUtils.getChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        //声明队列
        String queueName = "Q1";
        channel.queueDeclare(queueName, false, false, false, null);

        //队列与交换机绑定
        channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.*");

        System.out.println("C1等待接收消息");

        //消费者取消消息时触发的回调接口
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("ReceiveLogDirect01控制台打印接收到的消息:" + new String(message.getBody(),"UTF-8"));
        };

        //消费消息
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {});
    }
}

消费者代码2

package com.vleus.rabbitmq.topics_exchange;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.vleus.rabbitmq.utils.RabbitMqUtils;

/**
 * @author vleus
 * @date 2021年07月24日 12:01
 *  声明主题交换机及相关队列
 *
 *  消费者c1
 */
public class ReceiveLogsTopic02 {

    //交换机名称
    public static final String EXCHANGE_NAME = "topic_log";

    public static void main(String[] args) throws Exception {

        //接收消息
        Channel channel = RabbitMqUtils.getChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        //声明队列
        String queueName = "Q2";
        channel.queueDeclare(queueName, false, false, false, null);

        //队列与交换机绑定
        channel.queueBind(queueName, EXCHANGE_NAME, "*.*.rabbit");
        channel.queueBind(queueName, EXCHANGE_NAME, "lazy.#");

        System.out.println("C2等待接收消息");

        //消费者取消消息时触发的回调接口
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("ReceiveLogDirect01控制台打印接收到的消息:" + new String(message.getBody(),"UTF-8"));
        };

        //消费消息
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {});
    }
}