RabbitMQ:交换机

Tin

2022-6-18

RabbitMQ

Exchanges

Exchanges 概念

RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。

生产者只能将消息发送到交换机(exchange)

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

Exchanges 的类型

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

无名exchangs

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

临时队列

之前写的程序都有特定的队列名称，比如得 hello 和 ack_queue.

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

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

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

绑定(bindings)

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

Fanout

Fanout 介绍

将接受到的所有消息广播到他知道的所有队列中

Fanout实战

消费者 ReceiveLogs01

public class ReceiveLog01 {
    //交换机的名称
    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("等待接收消息，把接收到的消息打印在屏幕上.........");
        //接收消息
        DeliverCallback deliverCallback = (consumerTag , message) ->{
            System.out.println("ReceiveLog01控制台打印接收到的消息:"+new String(message.getBody()));
        };
        //消费者取消消息时回调接口
        channel.basicConsume(queueName,true,deliverCallback,consumerTag->{});
    }
}

消费者 ReceiveLog02

public class ReceiveLog02 {
    //交换机的名称
    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("等待接收消息，把接收到的消息打印在屏幕上.........");
        //接收消息
        DeliverCallback deliverCallback = (consumerTag , message) ->{
            System.out.println("ReceiveLog02控制台打印接收到的消息:"+new String(message.getBody()));
        };
        //消费者取消消息时回调接口
        channel.basicConsume(queueName,true,deliverCallback,consumerTag->{});
    }
}

生产者 EmitLog

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());
            System.out.println("生产者成功发送："+message);
        }
    }
}

Direct exchange

fanout是广播，发给所有消费者，无意识的广播

direct就是消息只去到它绑定的 routingKey 队列中去。

使用

生产者发布到交换机和 routingKey

channel.basicPublish(EXCHANGE_NAME,"routingKey",null,message.getBytes("UTF-8"));

消费者绑定交换机与routingKey

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

这样生产者发送消息到交换机，绑定键为routingKey的消息，会发布到绑定此routingKey的消费者

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

多重绑定

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

实战

解决问题:如我们希
望将日志消息写入磁盘的程序仅接收严重错误(errros)，而不存储哪些警告(warning)或信息(info)日志消息避免浪费磁盘空间。

ReceiveLogsDirect01 routingKey为error

public class ReceiveLogsDirect01 {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        String queueName = "disk";
        channel.queueDeclare(queueName,false,false,false,null);
        channel.queueBind(queueName,EXCHANGE_NAME,"error");
        System.out.println("等待接收消息....");
        DeliverCallback deliverCallback = (consumerTag,delivery) ->{
            String message = new String(delivery.getBody());
            message="接收绑定建:"+delivery.getEnvelope().getRoutingKey()+",消息:"+message;
            System.out.println("绑定的Routing Key:error-接收到消息:"+message);
        };
channel.basicConsume(queueName,true,deliverCallback,consumerTag->{});
    }
}

ReceiveLogsDirect01 routingKey为warning与info

public class ReceiveLogsDirect02 {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        String queueName = "disk";
        channel.queueDeclare(queueName,false,false,false,null);
        channel.queueBind(queueName,EXCHANGE_NAME,"warning");
        channel.queueBind(queueName,EXCHANGE_NAME,"info");
        System.out.println("等待接收消息....");
        DeliverCallback deliverCallback = (consumerTag,delivery) ->{
            String message = new String(delivery.getBody());
            message="接收绑定建:"+delivery.getEnvelope().getRoutingKey()+",消息:"+message;
            System.out.println("绑定的Routing Key:warning+info-接收到消息:"+message);
        };
        channel.basicConsume(queueName,true,deliverCallback,consumerTag->{});
    }
}

生产者：EmitLogDirect

public class EmitLogDirect {
    private static  final  String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //创建多个bindingkey
        Map<String,String> bindingKeyMap = new HashMap<>();
        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 bindingKey=bindingKeyEntry.getKey();
            String message = bindingKeyEntry.getValue();
            channel.basicPublish(EXCHANGE_NAME,bindingKey,null,message.getBytes("UTF-8"));
            System.out.println("生产者发出消息："+message);
        }
    }
}

Topics

介绍

使用了 direct 交换机，从而有能实现有选择性地接收日志

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

实战案例

TopicProduct

public class TopicProduct {
    public static final  String EXCHANGR_NAME = "topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGR_NAME,"topic");
        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 bindingKey = bindingKeyEntry.getKey();
            String message = bindingKeyEntry.getValue();
            channel.basicPublish(EXCHANGR_NAME,bindingKey,null,message.getBytes());
            System.out.println("消费者发出消息:"+message);
        }
    }
}

ReceiveLogsTopic01-routingKey:*.orange.*

public class ReceiveLogsTopic01 {
    public static final  String EXCHANGR_NAME = "topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGR_NAME,"topic");
        //声明Q1队列与绑定关系
        String queueName = "Q1";
        channel.queueDeclare(queueName,false,false,false,null);
        //****************************************************
        channel.queueBind(queueName,EXCHANGR_NAME,"*.orange.*");
        //****************************************************
        System.out.println("Q1接收消息中.....");
        DeliverCallback deliverCallback = (consumerTag,delivery)->{
            String message = new String(delivery.getBody());
            System.out.println("接收队列:"+queueName+"绑定键:"+delivery.getEnvelope().getRoutingKey()+"消息:"+message);
        };
        channel.basicConsume(queueName,true,deliverCallback,consumerTag->{});
    }
}

ReceiveLogsTopic01-routingKey:*.*.rabbit/

public class ReceiveLogsTopic02 {
    public static final  String EXCHANGR_NAME = "topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGR_NAME,"topic");
        //声明Q1队列与绑定关系
        String queueName = "Q2";
        channel.queueDeclare(queueName,false,false,false,null);
        //****************************************************
        channel.queueBind(queueName,EXCHANGR_NAME,"*.*.rabbit");
        channel.queueBind(queueName,EXCHANGR_NAME,"lazy.#");
        //****************************************************
        System.out.println("Q2接收消息中.....");
        DeliverCallback deliverCallback = (consumerTag,delivery)->{
            String message = new String(delivery.getBody());
            System.out.println("接收队列:"+queueName+"绑定键:"+delivery.getEnvelope().getRoutingKey()+"消息:"+message);
        };
        channel.basicConsume(queueName,true,deliverCallback,consumerTag->{});
    }
}

阅读剩余

作者：Tin

链接：http://www.tinstu.com/2023.html

文章版权归作者所有，未经允许请勿转载。

THE END