RabbitMQ的几种典型使用场景

最新推荐文章于 2025-07-20 13:20:18 发布
转载 最新推荐文章于 2025-07-20 13:20:18 发布 · 4k 阅读 · 6

本文介绍RabbitMQ在不同场景下的应用实例，包括简单的单发送单接收、单发送多接收、发布订阅模式、路由模式及主题模式等。通过具体代码演示如何实现这些模式，帮助读者快速掌握RabbitMQ的使用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

RabbitMQ主页：https://www.rabbitmq.com/

学习RabbitMQ的使用场景，来自官方教程：https://www.rabbitmq.com/getstarted.html

场景1：单发送单接收

使用场景：简单的发送与接收，没有特别的处理。

Producer：


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class Send {
    
  private final static String QUEUE_NAME = "hello";

  public static void main(String[] argv) throws Exception {
                
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    String message = "Hello World!";
    channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
    System.out.println(" [x] Sent '" + message + "'");
    
    channel.close();
    connection.close();
  }
}

Consumer：


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class Recv {
    
    private final static String QUEUE_NAME = "hello";

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

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
    
    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(QUEUE_NAME, true, consumer);
    
    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());
      System.out.println(" [x] Received '" + message + "'");
    }
  }
}

场景2：单发送多接收

使用场景：一个发送端，多个接收端，如分布式的任务派发。为了保证消息发送的可靠性，不丢失消息，使消息持久化了。同时为了防止接收端在处理消息时down掉，只有在消息处理完成后才发送ack消息。

Producer：


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;

public class NewTask {
  
  private static final String TASK_QUEUE_NAME = "task_queue";

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

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
    
    channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
    
    String message = getMessage(argv);
    
    channel.basicPublish( "", TASK_QUEUE_NAME, 
                MessageProperties.PERSISTENT_TEXT_PLAIN,
                message.getBytes());
    System.out.println(" [x] Sent '" + message + "'");
    
    channel.close();
    connection.close();
  }
    
  private static String getMessage(String[] strings){
    if (strings.length < 1)
      return "Hello World!";
    return joinStrings(strings, " ");
  }  
  
  private static String joinStrings(String[] strings, String delimiter) {
    int length = strings.length;
    if (length == 0) return "";
    StringBuilder words = new StringBuilder(strings[0]);
    for (int i = 1; i < length; i++) {
      words.append(delimiter).append(strings[i]);
    }
    return words.toString();
  }
}

发送端和场景1不同点：

1、使用“task_queue”声明了另一个Queue，因为RabbitMQ不容许声明2个相同名称、配置不同的Queue

2、使"task_queue"的Queue的durable的属性为true，即使消息队列durable

3、使用MessageProperties.PERSISTENT_TEXT_PLAIN使消息durable

When RabbitMQ quits or crashes it will forget the queues and messages unless you tell it not to. Two things are required to make sure that messages aren't lost: we need to mark both the queue and messages as durable.

Consumer：

复制代码
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;
  
public class Worker {

  private static final String TASK_QUEUE_NAME = "task_queue";

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

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
    
    channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
    
    channel.basicQos(1);
    
    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(TASK_QUEUE_NAME, false, consumer);
    
    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());
      
      System.out.println(" [x] Received '" + message + "'");
      doWork(message);
      System.out.println(" [x] Done");

      channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
    }         
  }
  
  private static void doWork(String task) throws InterruptedException {
    for (char ch: task.toCharArray()) {
      if (ch == '.') Thread.sleep(1000);
    }
  }
}

接收端和场景1不同点：

1、使用“task_queue”声明消息队列，并使消息队列durable

2、在使用channel.basicConsume接收消息时使autoAck为false，即不自动会发ack，由channel.basicAck()在消息处理完成后发送消息。

3、使用了channel.basicQos(1)保证在接收端一个消息没有处理完时不会接收另一个消息，即接收端发送了ack后才会接收下一个消息。在这种情况下发送端会尝试把消息发送给下一个not busy的接收端。

注意点：

1）It's a common mistake to miss the basicAck. It's an easy error, but the consequences are serious. Messages will be redelivered when your client quits (which may look like random redelivery), but RabbitMQ will eat more and more memory as it won't be able to release any unacked messages.

2）Note on message persistence

Marking messages as persistent doesn't fully guarantee that a message won't be lost. Although it tells RabbitMQ to save the message to disk, there is still a short time window when RabbitMQ has accepted a message and hasn't saved it yet. Also, RabbitMQ doesn't do fsync(2) for every message -- it may be just saved to cache and not really written to the disk. The persistence guarantees aren't strong, but it's more than enough for our simple task queue. If you need a stronger guarantee you can wrap the publishing code in atransaction.

3）Note about queue size

If all the workers are busy, your queue can fill up. You will want to keep an eye on that, and maybe add more workers, or have some other strategy.

场景3：Publish/Subscribe

使用场景：发布、订阅模式，发送端发送广播消息，多个接收端接收。

Producer：


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class EmitLog {

  private static final String EXCHANGE_NAME = "logs";

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

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

    String message = getMessage(argv);

    channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
    System.out.println(" [x] Sent '" + message + "'");

    channel.close();
    connection.close();
  }
  
  private static String getMessage(String[] strings){
    if (strings.length < 1)
            return "info: Hello World!";
    return joinStrings(strings, " ");
  }
  
  private static String joinStrings(String[] strings, String delimiter) {
    int length = strings.length;
    if (length == 0) return "";
    StringBuilder words = new StringBuilder(strings[0]);
    for (int i = 1; i < length; i++) {
        words.append(delimiter).append(strings[i]);
    }
    return words.toString();
  }
}

发送端：

发送消息到一个名为“logs”的exchange上，使用“fanout”方式发送，即广播消息，不需要使用queue，发送端不需要关心谁接收。

Consumer：


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class ReceiveLogs {

  private static final String EXCHANGE_NAME = "logs";

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

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
    String queueName = channel.queueDeclare().getQueue();
    channel.queueBind(queueName, EXCHANGE_NAME, "");
    
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(queueName, true, consumer);

    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());

      System.out.println(" [x] Received '" + message + "'");   
    }
  }
}

接收端：

1、声明名为“logs”的exchange的，方式为"fanout"，和发送端一样。

2、channel.queueDeclare().getQueue();该语句得到一个随机名称的Queue，该queue的类型为non-durable、exclusive、auto-delete的，将该queue绑定到上面的exchange上接收消息。

3、注意binding queue的时候，channel.queueBind()的第三个参数Routing key为空，即所有的消息都接收。如果这个值不为空，在exchange type为“fanout”方式下该值被忽略！

场景4：Routing (按路线发送接收)

使用场景：发送端按routing key发送消息，不同的接收端按不同的routing key接收消息。

Producer：


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class EmitLogDirect {

  private static final String EXCHANGE_NAME = "direct_logs";

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

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.exchangeDeclare(EXCHANGE_NAME, "direct");

    String severity = getSeverity(argv);
    String message = getMessage(argv);

    channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());
    System.out.println(" [x] Sent '" + severity + "':'" + message + "'");

    channel.close();
    connection.close();
  }
  
  private static String getSeverity(String[] strings){
    if (strings.length < 1)
            return "info";
    return strings[0];
  }

  private static String getMessage(String[] strings){ 
    if (strings.length < 2)
            return "Hello World!";
    return joinStrings(strings, " ", 1);
  }
  
  private static String joinStrings(String[] strings, String delimiter, int startIndex) {
    int length = strings.length;
    if (length == 0 ) return "";
    if (length < startIndex ) return "";
    StringBuilder words = new StringBuilder(strings[startIndex]);
    for (int i = startIndex + 1; i < length; i++) {
        words.append(delimiter).append(strings[i]);
    }
    return words.toString();
  }
}

发送端和场景3的区别：

1、exchange的type为direct

2、发送消息的时候加入了routing key

Consumer：

复制代码
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class ReceiveLogsDirect {

  private static final String EXCHANGE_NAME = "direct_logs";

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

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.exchangeDeclare(EXCHANGE_NAME, "direct");
    String queueName = channel.queueDeclare().getQueue();
    
    if (argv.length < 1){
      System.err.println("Usage: ReceiveLogsDirect [info] [warning] [error]");
      System.exit(1);
    }
    
    for(String severity : argv){    
      channel.queueBind(queueName, EXCHANGE_NAME, severity);
    }
    
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(queueName, true, consumer);

    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());
      String routingKey = delivery.getEnvelope().getRoutingKey();

      System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");   
    }
  }
}
复制代码

接收端和场景3的区别：

在绑定queue和exchange的时候使用了routing key，即从该exchange上只接收routing key指定的消息。

场景5：Topics (按topic发送接收)

使用场景：发送端不只按固定的routing key发送消息，而是按字符串“匹配”发送，接收端同样如此。

Producer：


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class EmitLogTopic {

  private static final String EXCHANGE_NAME = "topic_logs";

  public static void main(String[] argv) {
    Connection connection = null;
    Channel channel = null;
    try {
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("localhost");
  
      connection = factory.newConnection();
      channel = connection.createChannel();

      channel.exchangeDeclare(EXCHANGE_NAME, "topic");

      String routingKey = getRouting(argv);
      String message = getMessage(argv);

      channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
      System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");

    }
    catch  (Exception e) {
      e.printStackTrace();
    }
    finally {
      if (connection != null) {
        try {
          connection.close();
        }
        catch (Exception ignore) {}
      }
    }
  }
  
  private static String getRouting(String[] strings){
    if (strings.length < 1)
            return "anonymous.info";
    return strings[0];
  }

  private static String getMessage(String[] strings){ 
    if (strings.length < 2)
            return "Hello World!";
    return joinStrings(strings, " ", 1);
  }
  
  private static String joinStrings(String[] strings, String delimiter, int startIndex) {
    int length = strings.length;
    if (length == 0 ) return "";
    if (length < startIndex ) return "";
    StringBuilder words = new StringBuilder(strings[startIndex]);
    for (int i = startIndex + 1; i < length; i++) {
        words.append(delimiter).append(strings[i]);
    }
    return words.toString();
  }
}

发送端和场景4的区别：

1、exchange的type为topic

2、发送消息的routing key不是固定的单词，而是匹配字符串，如"*.lu.#"，*匹配一个单词，#匹配0个或多个单词。

Consumer：


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class ReceiveLogsTopic {

  private static final String EXCHANGE_NAME = "topic_logs";

  public static void main(String[] argv) {
    Connection connection = null;
    Channel channel = null;
    try {
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("localhost");
  
      connection = factory.newConnection();
      channel = connection.createChannel();

      channel.exchangeDeclare(EXCHANGE_NAME, "topic");
      String queueName = channel.queueDeclare().getQueue();
 
      if (argv.length < 1){
        System.err.println("Usage: ReceiveLogsTopic [binding_key]...");
        System.exit(1);
      }
    
      for(String bindingKey : argv){    
        channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
      }
    
      System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

      QueueingConsumer consumer = new QueueingConsumer(channel);
      channel.basicConsume(queueName, true, consumer);

      while (true) {
        QueueingConsumer.Delivery delivery = consumer.nextDelivery();
        String message = new String(delivery.getBody());
        String routingKey = delivery.getEnvelope().getRoutingKey();

        System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");   
      }
    }
    catch  (Exception e) {
      e.printStackTrace();
    }
    finally {
      if (connection != null) {
        try {
          connection.close();
        }
        catch (Exception ignore) {}
      }
    }
  }
}

接收端和场景4的区别：

1、exchange的type为topic

2、接收消息的routing key不是固定的单词，而是匹配字符串。

注意点：

Topic exchange

Topic exchange is powerful and can behave like other exchanges. When a queue is bound with "#" (hash) binding key - it will receive all the messages, regardless of the routing key - like in fanout exchange. When special characters "*" (star) and "#" (hash) aren't used in bindings, the topic exchange will behave just like a direct one.

 

参考：https://www.rabbitmq.com/getstarted.html


SpringBoot整合RabbitMQ之 典型应用场景实战二
青松之竹_Java博客
10-09 4095
实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。上一篇博文我分享了RabbitMQ在业务服务模块解耦，异步通信与抢单系统高并发情况下限流作用等，感兴趣的童鞋可以前往阅读：https://blog.youkuaiyun.com/...
RabbitMQ 6种业务场景
weixin_33860528的博客
05-22 3418
应用场景1-“Hello Word”一个P向queue发送一个message，一个C从该queue接收message并打印。producer，连接至RabbitMQ Server，声明队列，发送message，关闭连接，退出。应用场景2-work queues工作队列（又称：任务队列——Task Queues）是为了避免等待一些占用大量资源、时间的操作。当我们把任务（Task...
Windows本地环境安装RabbitMQ
真的小白的博客
07-01 2268
Windows本地环境安装RabbitMQ安装Erlang安装RabbitMQ配置创建用户，密码，绑定角色权限设置权限相关命令为：参考 rabbitMQ是一个在AMQP协议标准基础上完整的，可服用的企业消息系统。它遵循Mozilla Public License开源协议，采用 Erlang 实现的工业级的消息队列(MQ)服务器，Rabbit MQ 是建立在Erlang OTP平台上。 安装Erlang 在安装rabbitMQ之前，需要先安装Erlang ： 使用的是otp_win64_24.0 ，需要其
消息队列2：一篇搞懂RabbitMQ
最新发布
2301_78566776的博客
07-20 740
整体上就是一个生产者消费者模型有一个交换机，消息并不是直接进队列路由键+绑定键去找队列消息可以进入一个或多个队列消费者可以订阅多个队列队列级别不支持广播——替代fanout：和生产者关联的队列都能收到消息topic类型路由规则延迟队列的实现消息的可靠性：怎么样保证我的消息不丢失呢？消息的顺序性1、RabbitMQ介绍1.1RabbitMQ简介RabbitMQ 是采用Erlang 语言实现 AMQP。
RabbitMq工作模式
@王某人
11-10 2567
rabbitMq工作模式 Work queues工作队列模式 模式说明 Work Queues 与入门程序的 简单模式 相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。 订阅模式概述 订阅模式示例图： 前面2个案例中，只有3个角色： P：生产者，也就是要发送消息的程序 C：消费者：消息的接受者，会一直等待消息到来。 queue：消息队列，图中红色部分 而在订阅模型中，多了一个exchange角色，而且过程略有变化
一、RabbitMQ入门案例
a2231476020的博客
07-09 1269
创建SpringBoot项目，引入依赖，pom.xml如下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://...
RabbitMQ的几种模式(一)
Mensonge的博客
11-30 306
RabbitMQ存在6种实现 如下图（当前只研究前5种简单demo实现） HelloWorld 简单模式 如下图 简单模式就是一个生产者通过MQ Server对应一个消费者。 对于MQ服务器来说，无论是生产者还是消费者，都相当于客户端所以我们在pom中引入amqp-client客户端依赖<dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artif
RabbitMQ 典型应用场景实战
猿码天地
03-02 9220
一、实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 二、RabbitMQ 官网拜读 首先，让我们先拜读 RabbitMQ 官网的技术开发手册以及相关的 Features，感兴趣的朋友可以耐心的阅读其中的相关介绍，相信会有一定的收获，地址可见：RabbitMQ 官网 阅读该手册过程中，我们可以得知 RabbitMQ 其实核心就
SpringBoot整合RabbitMQ之典型应用场景实战一
技术分享
11-15 1221
实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 RabbitMQ 官网拜读 首先，让我们先拜读 RabbitMQ 官网的技术开发手册以及相关的 Features，感兴趣的朋友可以耐心的阅读其中的相关介绍，相信会有一...
RabbitMQ最新面试题和 七种队列模式应用场景(2021版)
很努力的恺恺
06-27 776
RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 RabbitMQ是一款开源的，Erlang编写的，基于AMQP协议的，消息中间件；可以用它来：解耦、异步、削峰。 异步处理 - 相比于传统的串行、并行方式，提高了系统吞吐量。 应用解耦 - 系统间通过消息通信，不用关心其他系统的处理。 流量削锋
本地安装rabbitmq
weixin_43779185的博客
04-21 1100
一、由于rabbitmq是erlang语言，要先安装erlang语言开发包 官网：http://www.erlang.org/downloads 一直下一步就可以正常安装 配置变量： 检查是否安装成功 cmd 输入erl 打印出版本号 二、安装rabbitmq 直接下一步安装就好了 配置变量： 检查是否安装成功 cmd进入C:\Program Files\RabbitMQ Server\rabbitmq_server-3.6.9\sbin目录 激活 RabbitMQ’s
Linux Ubuntu安装RabbitMQ服务
Tiam_cr的博客
07-14 6586
RabbitMQ是一个在 AMQP(高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最主流的消息中间件之一。由erlang开发的AMQP（Advanced Message Queue 高级消息队列协议 ）的开源实现，由于erlang 语言的高并发特性，性能较好，本质是个队列，FIFO 先入先出，里面存放的内容是message,下面介绍通过在ubuntu+cpolar+rabbitMQ环境下，实现mq服务端远程访问。
RabbitMQ的五种常见模式
未来的博客
04-21 574
RabbitMQ的五种常见模式 在练习RabbitMQ之前，请确认自己的RabbitMQ已经安装并开启。 1、简单模式 从图上可以看到只有三个角色:   p 【product】: 生产者 发生消息的   红色[queue]: 队列。 存储消息的    C [consumer]: 消费者 消费消息 创建一个maven项目，创建一个消费者和一个生产者。 生产者代码： public class Product { public static void main(String[] args)
手把手教你，本地RabbitMQ服务搭建（windows）
战斧的博客
06-27 8891
前面已经对RabbitMQ介绍了很多内容，今天主要是交大家搭建一个可用的RabbitMQ服务端，方便后续进一步实操与细节分析。
本地部署RabbitMQ
zoro_soro的博客
02-10 655
一.下载RabbitMQ管理工具 1.windows下载地址： http://www.rabbitmq.com/install-windows.html 2.Linux，BSD, UNIX下载地址： ①：Debian and Ubuntu http://www.rabbitmq.com/install-debian.html#downloads ②：RHEL, CentOS, Fedora, openSUSE http://www.rabbitmq.com/install-rpm.html ③：Gen
本机搭建RabbitMQ
ql_gome的博客
05-15 1987
Exchange（交换机）作用：Exchange是消息的路由器。生产者将消息发送给exchange，而不是直接发送给队列。exchange根据预定义的规则（称为binding）来决定哪些消息应该路由到哪个队列类型：Exchange有多种类型，如direct（直接交换机）、fanout（广播交换机）、topic（主题交换机）和headers（基于消息头的交换机），每种类型的exchange有不同的路由策略配置：Exchange需要预先声明，指定其类型和任何其他相关配置Queue（队列）
Win 10 本地安装RabbitMQ
m0_69421714的博客
03-04 1610
安装路径我建议安装到 erlang 环境一样的路径，同样也需要全英文路径，然后next，install即可。下载的是 ： Erlang/OTP 27.2.4 的 Downlad 64-bit Installer。打开cmd 命令提示符 输入 erl ， 能看到所安装的版本号，就是安装成功了。变量名： ERLANG_HOME，变量值：erlang的安装路径。安装就直接 next , 需要自定义安装的，路径要全英文的。Path 的配置：%ERLANG_HOME%\bin。然后点击确认退出环境变量的配置。
如何在本地和线上安装和配置RabbitMQ
weixin_69912448的博客
02-18 2272
如果你想从远程服务器访问管理面板，你需要创建一个新的管理员账号，不能使用默认的 guest 账号，否则会被系统拦截，导致无法访问或登录。如果你想从远程服务器访问管理面板，你需要创建一个新的管理员账号，不能使用默认的 guest 账号，否则会被系统拦截，导致无法访问或登录。ps.里面的 5672、15672 很重要，我们的应用程序之间就是通过 5672 端口来和 RabbitMQ 做链接的，就像 redis 的6379，es 的 9200是一样的。将命令粘贴到此处，回车，显示已经启动了，并配置了一些插件。
rabbitmq有几种交换机
03-30
<think>好的，我现在要解决用户的问题：RabbitMQ有几种交换机。我需要先回忆或查找相关资料，确保回答准确。首先，RabbitMQ作为消息队列中间件，其交换机类型是关键组件，负责消息路由。根据之前的学习，常见的交换机类型有四种，但可能还有插件提供的其他类型。 首先，确认四种核心交换机类型：直连（Direct）、扇出（Fanout）、主题（Topic）和头（Headers）。每种类型有不同的路由机制。比如，Direct交换机根据路由键精确匹配，Fanout广播到所有绑定队列，Topic支持模式匹配，Headers则基于消息头而非路由键。 接下来，需要详细解释每种交换机的工作方式、适用场景以及示例。例如，Direct适用于单播路由，Fanout用于广播，Topic处理多条件匹配，Headers用于复杂的属性匹配。此外，可能需要提到默认交换机（无名交换机），它自动将队列绑定到其名称的路由键。 需要检查是否有其他类型，比如通过插件添加的，例如一致性哈希（Consistent Hash）交换机，但可能属于高级或较少用到的类型。在回答中应明确区分核心类型和扩展类型，避免混淆用户。 结构方面，按照用户要求，分点说明，结构清晰。每个类型用标题标记，解释其原理、路由规则、应用场景，可能给出使用示例或类比，帮助用户理解。 最后，确保使用中文，数学公式正确应用，但此问题可能涉及较少公式，更多是技术描述。检查LaTeX是否符合要求，例如变量用$...$，但此处可能不需要数学公式，除非举例中有涉及。 总结步骤：确认四种核心类型，补充默认交换机，检查是否有其他类型，组织内容结构，确保语言准确易懂，符合用户的中文需求，并验证信息正确性。</think>RabbitMQ的交换机（Exchange）是消息路由的核心组件，负责根据规则将消息分发到队列。以下是其主要的交换机类型及工作原理： --- ### 1. **直连交换机（Direct Exchange）** - **路由规则**： 通过精确匹配`routing key`（路由键）将消息发送到绑定队列。 *例如*：队列A绑定`routing_key="order"`，只有携带`order`的消息会被路由到队列A。 - **适用场景**： 单播（点对点）通信，如订单处理系统。 - **示例**： ```python channel.exchange_declare(exchange='direct_logs', exchange_type='direct') ``` --- ### 2. **扇出交换机（Fanout Exchange）** - **路由规则**： 忽略`routing key`，将消息**广播**到所有绑定的队列。 *类比*：类似群发通知，所有订阅者都会收到消息。 - **适用场景**： 发布/订阅模式，如新闻推送、实时广播。 - **示例**： ```python channel.exchange_declare(exchange='fanout_logs', exchange_type='fanout') ``` --- ### 3. **主题交换机（Topic Exchange）** - **路由规则**： 通过`routing key`的模式匹配（支持`*`和`#`通配符）路由消息。 - `*`匹配一个单词（如`order.*`匹配`order.new`但不匹配`order.new.paid`） - `#`匹配零或多个单词（如`order.#`匹配`order.new.paid`） - **适用场景**： 多条件动态路由，如日志分级（`error`、`info`）或分类消息（`user.notification`）。 - **示例**： ```python channel.exchange_declare(exchange='topic_logs', exchange_type='topic') ``` --- ### 4. **头交换机（Headers Exchange）** - **路由规则**： 不依赖`routing key`，而是根据消息的`headers`属性匹配绑定的键值对。 - 匹配方式：`x-match`参数设为`all`（完全匹配）或`any`（部分匹配）。 - **适用场景**： 复杂路由逻辑，如基于消息内容（如设备类型、版本号）过滤。 - **示例**： ```python headers = {'type': 'report', 'format': 'pdf', 'x-match': 'all'} channel.queue_bind(queue='queue1', exchange='headers_logs', arguments=headers) ``` --- ### 5. **默认交换机（Default Exchange）** - **特性**： 每个队列自动绑定到默认交换机（无名，用空字符串`""`标识），`routing key`默认为队列名。 - **使用场景**： 无需显式声明交换机，直接通过`routing key`指定队列名称发送消息。 --- ### 扩展类型（插件支持） - **一致性哈希交换机（Consistent Hash Exchange）** 通过哈希算法分配消息到队列，确保相同键的消息路由到同一队列（需启用插件`rabbitmq_consistent_hash_exchange`）。 --- ### 总结表格 | 交换机类型 | 路由依据 | 典型场景 | |-----------------|------------------------|----------------------------| | Direct | 精确匹配`routing key` | 点对点通信（如订单处理） | | Fanout | 无，广播所有队列 | 发布/订阅（如通知广播） | | Topic | 通配符匹配`routing key`| 多条件路由（如日志分类） | | Headers | 消息头属性 | 复杂属性过滤（如设备类型） | | Default | 队列名称 | 直接指定队列发送消息 | 合理选择交换机类型可优化消息路由效率，建议根据业务需求匹配最适方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值