RabbitMQ学习—day5—交换机

最新推荐文章于 2025-04-03 10:10:55 发布

luckilyil

最新推荐文章于 2025-04-03 10:10:55 发布

阅读量1.1k

点赞数 15

分类专栏：消息队列文章标签： rabbitmq 学习分布式

本文链接：https://blog.youkuaiyun.com/weixin_73687229/article/details/145806343

版权

消息队列专栏收录该内容

9 篇文章

订阅专栏

1. 交换机简介

介绍

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

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

总共有以下几个类型：

直接（direct）、主题（topic）、标题（headers）、扇出（fanout）

无名交换机：

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

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


channel.basiPublish("","hello",null,message.getBytes())；

2. 临时队列

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

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

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

创建出来的队列长这样：

3. 绑定Bindings

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

4. 实战演练

Fanout（发布订阅模式）

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

实战

消费者

    /*
 * 消息接收
 * */
 public class ReceiveLogs01 {
 
     //交换机名称
     public static final String EXCHANGE_NAME = "logs";
 
     public static void main(String[] args) throws Exception{
         Channel channel = RabbitMqUtils.getChannel();

     //声明一个队列,名称随机，当消费者断开与队列的连接时，队列自动删除
     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()));
     };

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

 /*
 * 消息接收
 * */
 public class ReceiveLogs02 {
 
     //交换机名称
     public static final String EXCHANGE_NAME = "logs";
 
     public static void main(String[] args) throws Exception{
         Channel channel = RabbitMqUtils.getChannel();

     //声明一个队列,名称随机，当消费者断开与队列的连接时，队列自动删除
     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()));
     };

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

生产者

 /*
 *  发消息 交换机
 * */
 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,"fauout");

     Scanner scanner = new Scanner(System.in);
     while (scanner.hasNext()){
         String message = scanner.next();
         channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes(StandardCharsets.UTF_8));
         System.out.println("生产者发出的消息："+ message);
     }
 }
}

效果

Direct（路由模式）

与Fanout不同的是，Fanout的Routing key是相同的，实现了一方发送，多方接收

Direct通过不同的Routing key，实现给不同队列发不同消息

实战

消费者

public class ReceiveLogsDirect01 {
 public static final String EXCHANGE_NAME = "direct_logs";

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

     //声明一个队列
     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()));
     };

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

public class ReceiveLogsDirect02 {
 public static final String EXCHANGE_NAME = "direct_logs";

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

     //声明一个队列
     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()));
     };

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

生产者

public class DirectLogs {
 // 交换机的名称
 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);

     Scanner scanner = new Scanner(System.in);
     while (scanner.hasNext()){
         String message = scanner.next();
         channel.basicPublish(EXCHANGE_NAME,"info",null,message.getBytes(StandardCharsets.UTF_8));
         System.out.println("生产者发出的消息："+ message);
     }
 }
}

效果

Topics（主题模式）

通过通配符可以连接到一个队列或者多个队列

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

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

匹配案例

下图绑定关系如下：

Q1绑定的是：中间带orange的三个单词的字符串：*.orange.*

Q2绑定的是：最后一个单词是rabbit的单个单词：*.*.rabbit，第一个单词是lazy的多个单词：lazy.#

数据接收情况如下：

quick.orange.rabbit：被队列Q1Q2接收到
quick.orange.fox：被队列Q1接收到
lazy.brown.fox：被队列Q2接收到
lazy.pink.rabbit：虽然满足队列Q2的两个绑定但是只会被接收一次
quick.orange.male.rabbit：四个单词不匹配任何绑定会被丢弃

结论

当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像fanout了
如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是direct了

实战

消费者

/*
* 声明主题交换机及相关队列
* 消费者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("等待接收消息......");

        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println(new String(message.getBody()));
            System.out.println("接收队列："+ queueName + "绑定键：" + message.getEnvelope().getRoutingKey());
        };

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

/*
* 声明主题交换机及相关队列
* 消费者C2
* */
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("等待接收消息......");

        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println(new String(message.getBody()));
            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();


     HashMap<String, String> map = new HashMap<>();
     map.put("quick.orange.rabbit","被队列Q1Q2接收到");
     map.put("quick.orange.fox","被队列Q1接收到");
     map.put("lazy.brown.fox","被队列Q2接收到 ");
     map.put("lazy.pink.rabbit","虽然满足队列Q2的两个绑定但是只会被接收一次");
     map.put("quick.orange.male.rabbit","四个单词不匹配任何绑定会被丢弃");

     for (Map.Entry<String, String> bindingKeyEntry : map.entrySet()) {
         String routingKey = bindingKeyEntry.getKey();
         String message = bindingKeyEntry.getValue();

         channel.basicPublish(EXCHANGE_NAME,routingKey,null,message.getBytes(StandardCharsets.UTF_8));
         System.out.println("生产者发送消息："+ message );

     }
  }
}

效果