RabbitMQ快速上手以及RabbitMQ交换机的四种模式

已于 2023-05-06 10:38:22 修改
阅读量1.1k 收藏 3
点赞数 3
分类专栏： 中间件 文章标签： java-rabbitmq rabbitmq java
于 2022-12-06 11:28:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zyw907155124/article/details/128199513
版权

Win10安装：

​win10下安装 RabbitMQ​_柚几哥哥的博客-CSDN博客

Linux安装：

Linux下载安装 RabbitMQ​_柚几哥哥的博客-CSDN博客

一、基础使用

1、导入依赖

        <!--RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>

2、配置application.yml

spring:
  #RabbitMQ
 rabbitmq:
    #服务器地址
   host: 192.168.10.100
    #用户名
   username: guest
    #密码
   password: guest
    #虚拟主机
   virtual-host: /
    #端口
   port: 5672
   listener:
     simple:
        #消费者最小数量
       concurrency: 10
        #消费者最大数量
       max-concurrency: 10
        #限制消费者每次只处理一条消息，处理完再继续下一条消息
       prefetch: 1
        #启动时是否默认启动容器，默认true
       auto-startup: true
        #被拒绝时重新进入队列
       default-requeue-rejected: true
   template:
     retry:
        #发布重试，默认false
       enabled: true
        #重试时间 默认1000ms
       initial-interval: 1000
        #重试最大次数，默认3次
       max-attempts: 3
        #重试最大间隔时间，默认10000ms
       max-interval: 10000
        #重试间隔的乘数。比如配2.0 第一次等10s，第二次等20s，第三次等40s
       multiplier: 1.0

3、编写配置类RabbitMQConfig.java

package com.xxxx.seckill.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author zhoubin
* @since 1.0.0
*/
@Configuration
public class RabbitMQConfig {
   @Bean
   public Queue queue(){
      return new Queue("queue",true);
   }
}

4、编写发送者MQSender.java

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQSender {
   @Autowired
   private RabbitTemplate rabbitTemplate;
   public void send(Object msg) {
      log.info("发送消息："+msg);
      rabbitTemplate.convertAndSend("queue", msg);
   }
}

5、编写接收者MQReceiver.java

/**
 * @author zyw
 * @since 1.0.0
 */
@Service
@Slf4j
public class MQReceiver {


    @RabbitListener(queues = "queue")
     public void receive(Object msg) {
     log.info("接受消息：" + msg);
    }
}

6、编写测试接口UserController.java

/**
* 测试发送RabbitMQ消息
*/
@RequestMapping("/mq")
@ResponseBody
public void mq() {
   mqSender.send("Hello");
}

7、结果

 二、RabbitMQ交换机

Fanout模式

不处理路由键，只需要简单的将队里绑定到交换机上
发送到交换机的消息都会被转发到与该交换机绑定的所有队列上
Fanout 交换机转发消息是最快的

1、RabbitMQConfig.java

package com.xxxx.seckill.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author zhoubin
* @since 1.0.0
*/
@Configuration
public class RabbitMQConfig {
   private static final String QUEUE01 = "queue_fanout01";
   private static final String QUEUE02 = "queue_fanout02";
   private static final String EXCHANGE = "fanoutExchange";
   @Bean
   public Queue queue01(){
      return new Queue(QUEUE01);
   }
   @Bean
   public Queue queue02(){
      return new Queue(QUEUE02);
   }
   @Bean
   public FanoutExchange fanoutExchange(){
      return new FanoutExchange(EXCHANGE);
   }
   @Bean
   public Binding binding01(){
      return BindingBuilder.bind(queue01()).to(fanoutExchange());
   }
   @Bean
   public Binding binding02(){
      return BindingBuilder.bind(queue02()).to(fanoutExchange());
   }
}

2、MQSender.java

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQSender {
   @Autowired
   private RabbitTemplate rabbitTemplate;
   public void send(Object msg) {
      log.info("发送消息："+msg);
      rabbitTemplate.convertAndSend("fanoutExchange","",msg);
   }
}

3、MQReceiver.java

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQReceiver {
   @RabbitListener(queues = "queue_fanout01")
   public void receive01(Object msg) {
      log.info("QUEUE01接受消息：" + msg);
   }
   @RabbitListener(queues = "queue_fanout02")
   public void receive02(Object msg) {
      log.info("QUEUE02接受消息：" + msg);
   }
}

4、UserController.java

/**
* 测试发送RabbitMQ消息
*/
@RequestMapping("/mq/fanout")
@ResponseBody
public void mq() {
   mqSender.send("Hello");
}

5、测试

调用 mq/direct01 接口，消息经由交换机转发到绑定该交换机的所有队列

Direct模式

所有发送到 Direct Exchange 的消息被转发到 RouteKey 中指定的 Queue
注意： Direct 模式可以使用 RabbitMQ 自带的 Exchange ： default Exchange, 所以不需要将
Exchange 进行任何绑定 (binding) 操作，消息传递时， RouteKey 必须完全匹配才会被队列接收，否
则该消息会被抛弃。
重点： routing key 与队列 queues 的 key 保持一致，即可以路由到对应的 queue 中。

1、RabbitMQConfig.java

package com.xxxx.seckill.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author zhoubin
* @since 1.0.0
*/
@Configuration
public class RabbitMQConfig {
 private static final String QUEUE01 = "queue_direct01";
 private static final String QUEUE02 = "queue_direct02";
 private static final String EXCHANGE = "directExchange";
 private static final String ROUTINGKEY01 = "queue.red";
 private static final String ROUTINGKEY02 = "queue.green";
 @Bean
 public Queue queue01(){
 return new Queue(QUEUE01);
 }
 @Bean
 public Queue queue02(){
 return new Queue(QUEUE02);
 }
 @Bean
 public DirectExchange directExchange(){
 return new DirectExchange(EXCHANGE);
 }
 @Bean
 public Binding binding01(){
 return
BindingBuilder.bind(queue01()).to(directExchange()).with(ROUTINGKEY01);
 }
 @Bean
 public Binding binding02(){
 return
BindingBuilder.bind(queue02()).to(directExchange()).with(ROUTINGKEY02);
 }
}

2、MQSender.java

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQSender {
 @Autowired
 private RabbitTemplate rabbitTemplate;
 public void send01(Object msg) {
 log.info("发送red消息："+msg);
 rabbitTemplate.convertAndSend("directExchange","queue.red",msg);
 }
 public void send02(Object msg) {
 log.info("发送green消息："+msg);
 rabbitTemplate.convertAndSend("directExchange","queue.green",msg);
 }
}

3、MQReceiver.java

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQReceiver {
 @RabbitListener(queues = "queue_direct01")
 public void receive01(Object msg) {
 log.info("QUEUE01接受消息：" + msg);
 }
 @RabbitListener(queues = "queue_direct02")
 public void receive02(Object msg) {
 log.info("QUEUE02接受消息：" + msg);
 }
}

4、UserController.java

/**
* 测试发送RabbitMQ消息
*/
@RequestMapping("/mq/direct01")
@ResponseBody
public void mq01() {
   mqSender.send01("Hello,Red");
}
/**
* 测试发送RabbitMQ消息
*/
@RequestMapping("/mq/direct02")
@ResponseBody
public void mq02() {
   mqSender.send02("Hello,Green");
}

5、测试

调用 mq/direct01 接口，消息经由交换机绑定的 queue.red RoutingKey 转发到 queue_direct01 队
列

调用 mq/direct02 接口，消息经由交换机绑定的 queue.green RoutingKey 转发到 queue_direct02
队列

Topic模式

所有发送到 Topic Exchange 的消息被转发到所有管线 RouteKey 中指定 Topic 的 Queue 上
Exchange 将 RouteKey 和某 Topic 进行模糊匹配 , 此时队列需要绑定一个 Topic
对于 routing key 匹配模式定义规则举例如下 :
routing key 为一个句点号 . 分隔的字符串（我们将被句点号 . 分隔开的每一段独立的字符串称为
一个单词），如 “stock.usd.nyse” 、 “nyse.vmw” 、 “quick.orange.rabbit”
routing key 中可以存在两种特殊字符 * 与 # ，用于做模糊匹配，其中 * 用于匹配一个单词， # 用
于匹配多个单词（可以是零个）

1、RabbitMQConfig.java

package com.xxxx.seckill.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author zhoubin
* @since 1.0.0
*/
@Configuration
public class RabbitMQConfig {
 private static final String QUEUE01 = "queue_topic01";
 private static final String QUEUE02 = "queue_topic02";
 private static final String EXCHANGE = "topicExchange";
 private static final String ROUTINGKEY01 = "#.queue.#";
 private static final String ROUTINGKEY02 = "*.queue.#";
 @Bean
 public Queue queue01(){
 return new Queue(QUEUE01);
 }
 @Bean
 public Queue queue02(){
 return new Queue(QUEUE02);
 }
 @Bean
 public TopicExchange topicExchange(){
 return new TopicExchange(EXCHANGE);
 }
 @Bean
 public Binding binding01(){
 return
BindingBuilder.bind(queue01()).to(topicExchange()).with(ROUTINGKEY01);
 }
 @Bean
 public Binding binding02(){
 return
BindingBuilder.bind(queue02()).to(topicExchange()).with(ROUTINGKEY02);
 }
}

2、MQSender.java 

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQSender {
 @Autowired
 private RabbitTemplate rabbitTemplate;
 public void send01(Object msg) {
 log.info("发送消息(被01队列接受)："+msg);
 rabbitTemplate.convertAndSend("topicExchange","queue.red.message",msg);
 }
 public void send02(Object msg) {
 log.info("发送消息(被两个queue接受)："+msg);
 
rabbitTemplate.convertAndSend("topicExchange","message.queue.green.abc",msg);
 }
}

3、MQReceiver.java

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQReceiver {
 @RabbitListener(queues = "queue_topic01")
 public void receive01(Object msg) {
 log.info("QUEUE01接受消息：" + msg);
 }
 @RabbitListener(queues = "queue_topic02")
 public void receive02(Object msg) {
 log.info("QUEUE02接受消息：" + msg);
 }
}

4、UserController.java

/**
* 测试发送RabbitMQ消息
*/
@RequestMapping("/mq/topic01")
@ResponseBody
public void mq01() {
   mqSender.send01("Hello,Red");
}
/**
* 测试发送RabbitMQ消息
*/
@RequestMapping("/mq/topic02")
@ResponseBody
public void mq02() {
   mqSender.send02("Hello,Green");
}

5、测试

调用 mq/topic01 接口，消息经由交换机绑定的 #.queue.# RoutingKey 转发到 queue_topic01 队列

调用 mq/topic02 接口，消息经由交换机绑定的 *.queue.# 和 #.queue.# RoutingKey 转发到
queue_topic01 和 queue_topic02 队列

Headers模式

不依赖 routingkey ，使用发送消息时 basicProperties 对象中的 headers 匹配队列
headers 是一个键值对类型，键值对的值可以是任何类型
在队列绑定交换机时用 x-match 来指定， all 代表定义的多个键值对都要满足， any 则代表只要满足
一个可以了

1、RabbitMQConfig.java

package com.xxxx.seckill.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.HeadersExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
/**
* @author zhoubin
* @since 1.0.0
*/
@Configuration
public class RabbitMQConfig {
 private static final String QUEUE01 = "queue_header01";
 private static final String QUEUE02 = "queue_header02";
 private static final String EXCHANGE = "headersExchange";
 @Bean
 public Queue queue01(){
 return new Queue(QUEUE01);
 }
 @Bean
 public Queue queue02(){
 return new Queue(QUEUE02);
 }
 @Bean
 public HeadersExchange headersExchange(){
 return new HeadersExchange(EXCHANGE);
 }
 @Bean
 public Binding binding01(){
 Map<String,Object> map = new HashMap<>();
 map.put("color","red");
 map.put("speed","low");
 return
BindingBuilder.bind(queue01()).to(headersExchange()).whereAny(map).match();
 }
 @Bean
 public Binding binding02(){
 Map<String,Object> map = new HashMap<>();
 map.put("color","red");
 map.put("speed","fast");
 return
BindingBuilder.bind(queue02()).to(headersExchange()).whereAll(map).match();
 }
}

2、MQSender.java

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQSender {
 @Autowired
 private RabbitTemplate rabbitTemplate;
 public void send01(String msg) {
 log.info("发送消息(被两个queue接受)：" + msg);
 MessageProperties properties = new MessageProperties();
 properties.setHeader("color", "red");
 properties.setHeader("speed", "fast");
 Message message = new Message(msg.getBytes(), properties);
 rabbitTemplate.convertAndSend("headersExchange", "", message);
 }
 public void send02(String msg) {
 log.info("发送消息(被01队列接受)：" + msg);
 MessageProperties properties = new MessageProperties();
 properties.setHeader("color", "red");
 properties.setHeader("speed", "normal");
 Message message = new Message(msg.getBytes(), properties);
 rabbitTemplate.convertAndSend("headersExchange", "", message);
 }
}

3、MQReceiver.java

package com.xxxx.seckill.rabbitmq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
/**
* @author zhoubin
* @since 1.0.0
*/
@Service
@Slf4j
public class MQReceiver {
 @RabbitListener(queues = "queue_header01")
 public void receive01(Message message) {
 log.info("QUEUE01接受Message对象：" + message);
 log.info("QUEUE01接受消息：" + new String(message.getBody()));
 }
 @RabbitListener(queues = "queue_header02")
 public void receive02(Message message) {
 log.info("QUEUE02接受Message对象：" + message);
 log.info("QUEUE02接受消息：" + new String(message.getBody()));
 }
}

4、UserController.java

/**
* 测试发送RabbitMQ消息
*/
@RequestMapping("/mq/header01")
@ResponseBody
public void mq01() {
   mqSender.send01("Hello,header01");
}
/**
* 测试发送RabbitMQ消息
*/
@RequestMapping("/mq/header02")
@ResponseBody
public void mq02() {
   mqSender.send02("Hello,header02");
}

5、测试

queue_header01 设置 x-match 为 any ， queue_header02 设置 x-match 为 all 。因此调用 mq/header01
接口，可以匹配两个队列

调用 mq/header02 接口，只能匹配 queue_header01 队列

柚几哥哥
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
批量删除rabbitmq的队列或交换机
06-29
采用python编写的批量删除rabbitmq的队列或交换机。 1.修改rabbitmq_delete.py中rabbitmq的配置； 2.执行以下命令： 删除队列: python3 rabbitmq_delete.py -k ‘udata.climb’ -d 1 删除交换机: python3 rabbitmq_delete.py -k ‘udata.climb’ -d 2 命令说明： -k 指定队列前缀，如udata.climb，则类似udata.climb.user, udata.climb.menu这种的会被删除 -d 指定删除队列还是交换机，1表示队列，2表示交换机。
rabbitmq延时队列和四种交换机模式下队列的简单实现
08-06
rabbitmq延时队列和四种交换机模式下队列的简单实现，需要自己配置一下属性文件。
MQ消息队列（六）RabbitMQ如何创建交换机如何创建队列_rabbitmq手动创建交换机
最新发布
2401_84166497的博客
04-15 275
5.internal：是否能由客户端直接发布到该交换机，如果为True的话表示当前Exchange是RabbitMQ内部使用，我们创建的Queue不会消费该类型交换机下的消息。2.type：交换机类型（DIRECT, FANOUT, TOPIC, HEADERS）alternate-exchange：备用交换机名称（当前交换机不可用时发送至备用交换机）3.durable：是否开启持久化，开启后交换机会在服务重启后重新加载。2.durable 是否开启持久化，开启后队列会在服务重启后重新加载。
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
rabbitmq配置文件 rabbitmq.config
11-04
rabbitmq配置文件，用于rabbitmq管理
5.队列和交换机绑定
迷路人的博客
05-24 1864
交换机是由双方同时声明，队列是由接收方声明并配置绑定关系 1.先使用rabbitmq包进行开发【偏底层】，适合了解原理 目前是每两个微服务之间的通信使用一个单独的交换机： 1.订单微服务和 餐厅微服务之间的通信 ，是在订单微服务中声明，监听餐厅发送的消息 1.首先创建ConnectionFactory 2.通过ConnectionFactory创建Connection 3.通过Connection创建Channel 4.声明交换机 5.声明消息队列 【如果还需要监听其他微服务发送的消.
RabbitMq入门到精通-Config配置详解
隔壁老瓦的专栏
07-15 3224
RabbitMQ带有默认的内置设置。在某些环境（例如开发和质量检查）中，这些可能就足够了。对于所有其他情况以及生产部署调整，有一种方法可以在代理和插件中配置很多东西。 本指南涵盖了许多与配置相关的主题： 配置服务器和插件的各种设置的不同方式 配置文件：primaryRabbitmq.conf和可选的advanced.config 各种平台上的默认配置文件位置 配置故障排除：如何验证配置文件位置和有效配置 环境变量 操作系统（内核）限制 可用的核心服务器设置 可用环境变量 如何加密敏感的.
RabbitMQ详解
m0_38033199的博客
11-11 4036
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。
RabbitMQ之交换机
热门推荐
m0_53151031的博客
02-27 1万+
一、RabbitMQ交换机 二、RabbitMQ交换机实例讲解
RabbitMQ交换机
qq_62898618的博客
12-28 3448
每个消息都有一个称为路由键(routing key)的属性，它其实就是一个简单的字符串。
RabbitMQ队列及交换机的使用
qi341500的博客
10-21 2404
一、简单模型 1、首先控制台创建一个队列 2、父工程导入依赖 3、生产者配置文件 4、写测试类 5、消费者配置文件 6、消费者接收消息 二、WorkQueues模型 1、在控制台创建一个新的队列 2、生产者生产消息 3、创建两个消费者接收消息 4、能者多劳充分利用每一个消费者的能力 三、交换机 四、Fanout交换机 1、 声明队列 2、创建交换机 ​编辑3、绑定交换机 4、示例 五、Diect交换机 1、 声明队列 2、创建交换机 3、绑定交换机
消息队列RabbitMQ入门与5种模式详解
02-24
RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统；AMQP（高级消息队列协议）是一个异步消息传递所使用应用层协议规范，为面向消息中间件设计，基于此协议的客户端...
RabbitMQ 总结
Xs943的博客
11-02 1454
假如一条消息需要延迟 30 分钟执行，我们就设置这条消息的有效期为 30 分钟，同时为这条消息配置 死信交换机和死信 routing_key ，并且不为这个消息队列设置消费者，那么 30 分钟后，这条消息由 于没有被消费者消费而进入死信队列，此时我们有一个消费者就在“蹲点”这个死信队列，消息一进入死 信队列，就立马被消费了。这里的字段都很好理解，有三个我额外说下： status：表示消息的状态，有三个取值，0，1，2 分别表示消息发送中、消息发送成功以及消息发 送失败。
rabbitmq
m0_37329981的博客
10-30 556
rabbitmq
RabbitMq(四) -- 交换机（rabbitmq的工作模式）
weixin_39724194的博客
03-02 3095
1. 实现一个消息被消费2次 一个消息经过交换机之后，可以被交换机分发给2个不同的队列，不同的队列的消息被各自的消费者消费。 注意：一个队列中的消息只能被消费一次 2. 什么是交换机？ RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机 (exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息，
RabbitMQ
qq_45620075的博客
09-03 863
简单记录
RabbitMQ--交换机
lu__lala的博客
06-25 775
RabbitMQ--交换机详解，全代码示例
RabbitMq创建交换机和队列
m0_69057918的博客
05-31 1751
RabbitMq创建交换机和队列
rabbitmq基础3——配置文件、参数策略Parameter和Policy、Federation插件、联邦交换器
百慕卿君博客
12-17 4572
环境变量、配置文件、参数策略Parameter和Policy的常规用法。 联邦交换器、联邦队列和Federation插件使用
RabbitMQ四种不同交换机
08-11
RabbitMQ是一个流行的开源消息中间件，它提供了多种交换机类型以实现不同的消息路由和传递方式。下面介绍RabbitMQ中常见的四种不同的交换机类型： 1. Direct Exchange（直连交换机）： Direct Exchange是最简单的一种交换机类型。它根据消息的Routing Key与绑定的队列的Routing Key进行精确匹配，只有完全匹配的消息会被路由到对应的队列中。 2. Fanout Exchange（扇形交换机）： Fanout Exchange将所有接收到的消息广播到所有绑定到它上面的队列中。它忽略Routing Key，只需将队列绑定到Fanout Exchange即可接收到发送到该交换机的所有消息。 3. Topic Exchange（主题交换机）： Topic Exchange根据消息的Routing Key与绑定的队列的Binding Key进行模式匹配。Routing Key可以使用通配符进行匹配，其中"*"表示匹配一个单词，"#"表示匹配零个或多个单词。通过灵活配置Binding Key和Routing Key的匹配规则，可以实现更复杂的消息路由。 4. Headers Exchange（标头交换机）： Headers Exchange使用消

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柚几哥哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值