RabbitMQ学习(七)交换机

一、概念

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

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

二、Fanout（扇出）交换机

将接收到的所有消息广播到它知道的所有队列中

原理图

binding 其实是 exchange 和 queue 之间的桥梁，它告诉我们 exchange 和那个队列进行了绑定关系 

1.消费者代码 

public class Consumer1 {
    public static final String EXCHANGE_NAME = "logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        //声明一个队列，临时队列
        //一旦我们断开了消费者的连接，队列将被自动删除。
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机与队列
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("Consumer01等待接收消息");

        // 推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.println("Consumer01接收到的消息："+new String(message.getBody()));
        };

        //取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消费被中断");
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

public class Consumer2 {
    public static final String EXCHANGE_NAME = "logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        //声明一个队列，临时队列
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机与队列
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("Consumer02等待接收消息");

        // 推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.println("Consumer02接收到的消息："+new String(message.getBody()));
        };

        //取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消费被中断");
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

2.生产者代码 

public class Produce {
    public static final String EXCHANGE_NAME = "logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        for (int i=0;i<10;i++){
            String message = "message----"+i;
            channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes());
        }

        System.out.println("消息发送成功");
    }
}

三、Direct （直连）交换机

消息只去到它绑定的routingKey 队列中去

默认交换机

实际上是— 个由 RabbitMQ预先声明好的名字为空字符串的直连交换机 (direct exchange) 。

它有一个特殊的属性使得它对于简单应用特别有用处 ：那就是每个新建队列 (queue)  都会自动绑定到默认交换机上，绑定的 路由键(routing key) 名称与队列名称相同。

举例：

默认交换队列会自动将其绑定到默认交换机上，绑定、（binding）的路由键名称也是为“hello”。当携带着名为“hello”的路由键的信息被发送到默认交换机的时候，此消息会被默认交换机路由至名为“hello”的队列中

类似amq.*的名称的交换机：这些是RabbitMQ默认创建的交换机。

这些队列名称被预留做RabbitMQ内部使用，不能被应用使用，否则抛出403错误

原理图

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

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

多重绑定 

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

代码 

 1.生产者代码

public class Produce {
    public static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        for (int i=0;i<5;i++){
            String message1 = "message----info"+i;
            String message2 = "message----warning"+i;
            String message3 = "message----error"+i;
            channel.basicPublish(EXCHANGE_NAME,"info",null,message1.getBytes());
            channel.basicPublish(EXCHANGE_NAME,"warning",null,message2.getBytes());
            channel.basicPublish(EXCHANGE_NAME,"error",null,message3.getBytes());
        }

        System.out.println("消息发送成功");
    }
}

 2.消费者代码

public class Consumer01 {
    public static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个队列，临时队列
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机与队列
        channel.queueBind(queueName,EXCHANGE_NAME,"info");
        channel.queueBind(queueName,EXCHANGE_NAME,"warning");
        System.out.println("Consumer01等待接收消息");

        // 推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.println("Consumer01接收到的消息："+new String(message.getBody()));
        };

        //取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消费被中断");
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

public class Consumer02 {
    public static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个队列，临时队列
        String queueName = channel.queueDeclare().getQueue();
        //绑定交换机与队列
        channel.queueBind(queueName,EXCHANGE_NAME,"error");
        System.out.println("Consumer01等待接收消息");

        // 推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.println("Consumer01接收到的消息："+new String(message.getBody()));
        };

        //取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消费被中断");
        };
        channel.basicConsume(queueName,true,deliverCallback,cancelCallback);
    }
}

 四、Topic（主题）交换机

直连交换机的缺点：

直连交换机的 routing_key方案非常简单 ，如果我们希望一 条消息发送给多个队列 ，那么这个交换机需 要绑定上非常多的 routing_key.

假设每个交换机上都绑定一堆的 routing_key连接到各个队列上。那么消息的管理 就会异常地困难。

主题交换机的特点：

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

这些单词可以是任意单词，比如说："stock.usd.nyse", "nyse.vmw","quick.orange.rabbit".这种类型的。当然这个单词列表最多不能超过 255 个字节。
在这个规则列表中，其中有两个替换符是大家需要注意的
*(星号)可以代替一个单词
#(井号)可以替代零个或多个单词

原理图 

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

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

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

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

代码

1.生产者

ublic class Produce {
    public static final String EXCHANGE_NAME = "topic_logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        Map bindingKeyMap = new HashMap<>();
        bindingKeyMap.put("quick.orange.rabbit"," 被队列 Q1Q2  接收到");
        bindingKeyMap.put("lazy.orange.elephant"," 被队列 Q1Q2  接收到");
        bindingKeyMap.put("quick.orange.fox"," 被队列 Q2  接收到");
        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 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);
        }
        System.out.println("消息发送成功");
    }
}

2.消费者

public class Consumer01 {
    public static final String EXCHANGE_NAME = "topic_logs";
    public static final String QUEUE_NAME = "Q1";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明一个队列，临时队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //绑定交换机与队列
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"*.orange.*");
        System.out.println("Consumer01等待接收消息");

        // 推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.print("Consumer01接收到的消息："+new String(message.getBody()));
            System.out.println("绑定键："+message.getEnvelope().getRoutingKey());
        };

        //取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消费被中断");
        };
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

public class Consumer02 {
    public static final String EXCHANGE_NAME = "topic_logs";
    public static final String QUEUE_NAME = "Q2";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明一个队列，临时队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //绑定交换机与队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "*.*.rabbit");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "lazy.#");
        System.out.println("Consumer02等待接收消息");

        // 推送的消息如何进行消费的接口回调
        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.print("Consumer02接收到的消息："+new String(message.getBody()));
            System.out.println("  绑定键："+message.getEnvelope().getRoutingKey());
        };

        //取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消费被中断");
        };
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}