RabbitMQ之交换机

Exchanges

• 1、Exchanges
• • 1.1、Exchanges概念
  • 1.2、Exchanges的类型
  • 1.3、无名exchange
• 2、临时队列
• 3、绑定(bindings)
• 4、Fanout
• • 4.1 Fanout介绍
  • 4.2 Fanout实战
• 5 Direct exchange
• • 5.1 Direct exchange介绍
  • 5.2 多重绑定
  • 5.3 实战
• 6、Topics Exchange(重要)
• • 6.1 前面几个交换机存在的问题
  • 6.2 Topic的要求
  • 6.3 Topic匹配案例
  • 6.4 实战

1、Exchanges 1.1、Exchanges概念

  RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。
  相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。

1.2、Exchanges的类型

总共有一下类型：

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

1.3、无名exchange

  前面我们对exchange一无所知，但让然能够将消息发送到队列。之前能实现的原因是因为我们使用的是默认交换，我们通过空字符串("")进行标识。

channel.basicPublish("","hello",null,message.getBytes());

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

2、临时队列

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

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

创建出来之后：

3、绑定(bindings)

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

4、Fanout 4.1 Fanout介绍

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

4.2 Fanout实战

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

写代码之前先创建个获取信道的工具类

public class RabbitMqUtils {
   //得到一个连接的 channel
   public static Channel getChannel() throws Exception{
         //创建一个连接工厂
         ConnectionFactory factory = new ConnectionFactory();
         factory.setHost("192.168.159.33");
         factory.setUsername("admin");
         factory.setPassword("123");
         Connection connection = factory.newConnection();
         Channel channel = connection.createChannel();
         return channel;
   }
}

消费者01

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


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("等待接收消息，把接收到消息打印在屏幕上......");

        //消费消息的回调接口 
        DeliverCallback deliverCallback=(consumerTag, message) -> {
            System.out.println("ReceiveLogs01控制台打印接收到的消息："+new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {});
    }
}

消费者02：

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


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("等待接收消息，把接收到消息打印在屏幕上......");

         //消费消息的回调接口 
        DeliverCallback deliverCallback=(consumerTag, message) -> {
            System.out.println("ReceiveLogs02控制台打印接收到的消息："+new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume(queueName,true,deliverCallback,consumerTag -> {});
    }
}

生产者EmitLog发送消息给两个消费者接收

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

import java.util.Scanner;


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

}

生产者发送6条消息

可以看到两个消费者都接收到了，类似于广播的形式。

5 Direct exchange

  这里我们添加一些特别的功能，比如说是我们只让某个消费者订阅发布的部分消息。例如我们只把严重错误消息定向存储到日志文件(以节省磁盘空间)，同时仍然能够在控制台打印所有日志消息。
  回顾一下什么是bindings,绑定是交换机和队列之间的桥梁。也可以这么理解：**队列只对它绑定的交换机的消息感兴趣。**绑定用参数：routingKey来表示，也可称该参数为binding key,创建绑定我们用代码：channel.queueBind(queueName,EXCHANGE_NAME,"routingKey")绑定之后的意义由其交换类型决定。

5.1 Direct exchange介绍

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

5.2 多重绑定

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

5.3 实战

消费者1：

public class ReceiveLogsDirect01 {
    public 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);
        //声明一个队列
        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("ReceiveLogsDirect01控制台打印接收到的消息："+new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume("console",true,deliverCallback,consumerTag -> {});


    }
}

消费者2:

public class ReceiveLogsDirect02 {
    public 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);
        //声明一个队列
        channel.queueDeclare("disk",false,false,false,null);
        channel.queueBind("disk",EXCHANGE_NAME,"error");

      //消费消息的回调接口 
        DeliverCallback deliverCallback=(consumerTag, message) -> {
            System.out.println("ReceiveLogsDirect02控制台打印接收到的消息："+new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume("disk",true,deliverCallback,consumerTag -> {});
    }
}

由两个消费者对应的routingKey
消费者1的routingKey

消费者2对应的routingKey

  也就是说生产者发布消息时的routingKey如果是info或者warning，此时消息会被消费者1接收到，如果生产者的routingKey是error，此时信道中的消息会被消费者2接收到。
先用Info测试：

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

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();

        Scanner scanner=new Scanner(System.in);

        while(scanner.hasNext()){
            String message=scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"info",null,message.getBytes("UTF-8"));
            System.out.println("生产者发出消息："+message);
        }
    }
}

生产者发送消息，携带的routingKey是info

消费者1接收到：

若将生产者的routingKey改为error,那接收到消息的就是消费者2了。

6、Topics Exchange(重要) 6.1 前面几个交换机存在的问题

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

6.2 Topic的要求

  发送的类型是 topic 交换机的消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如说：“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 实战

消费者C1代码：

public class ReceiveLogsTopic01 {
    //交换机名称
    public static final String EXCHANGE_NAME="topic_logs";

    //接收消息
    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(new String(message.getBody(),"UTF-8"));
            System.out.println("接收队列："+queueName+" 绑定键:"+message.getEnvelope().getRoutingKey());
        };

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

    }
}

消费者C2代码：

package com.atguigu.rabbitmq.seven;

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


public class ReceiveLogsTopic02 {
    //交换机名称
    public static final String EXCHANGE_NAME="topic_logs";

    //接收消息
    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(new String(message.getBody(),"UTF-8"));
            System.out.println("接收队列："+queueName+" 绑定键:"+message.getEnvelope().getRoutingKey());
        };

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

    }
}

生产者代码：

public class EmitLogTopic {

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

    public static void main(String[] args) throws Exception {
        //获取信道
        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","被队列 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 bindingKeyEntry : bindingKeyMap.entrySet()) {
            String routingKey=bindingKeyEntry.getKey();
            String message=bindingKeyEntry.getValue();
            //发送
            channel.basicPublish(EXCHANGE_NAME,routingKey,null,message.getBytes("UTF-8"));
            System.out.println("生产者发出消息："+message);

        }
    }
}

生产者控制台：

消费者C1控制台：

消费者C2控制台：

  topic交换机根据routingKey和不同的队列绑定，这样消费者就可以根据不同routingKey获取不同队列的中的消息，非常方便和灵活，所以topic类型的交换机实际上包含了Fanout和Direct类型交换机的所有功能，非常强大。