（直连&主题&扇形）交换机

最新推荐文章于 2023-08-28 12:07:32 发布
最新推荐文章于 2023-08-28 12:07:32 发布
阅读量1.2k 收藏
点赞数
文章标签： rabbitmq 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67465673/article/details/128320904
版权

目录

一、交换机简介

1. Exchange（交换机）的作用

2.Exchange（交换机）的类型

①.直连交换机：Direct Exchange

② 主题交换机：Topic Exchange

③ 扇形交换机：Fanout Exchange

④ 首部交换机：Headers Exchange

⑤ 默认交换机

3.交换机的属性

4.综合案例：交换机的使用

二、直连交换机的使用(Direct Exchange)

① 给子模块添加依赖 

② 给消费者添加连接配置

③ 创建类 RabbitmqDirectConfig

④ 创建 SendMessageController

⑤ 运行

⑥  创建消息接收监听类 DirectReceiver

⑦ 运行 

三、主题交换机（Topic Exchange）

① 创建类 RabbitTopicConfig

② 主题交换机发送消息方法 

③ 访问 

④ 消费者监听消息 

 三、扇形交互机(Fanout Exchange)

一、交换机简介

交换机是有6种的，我们只讲常见的3种 直连交换机、主题交换机、扇形交换机。

类似amq.的名称的交换机： 

1. Exchange（交换机）的作用

在RabbitMQ中，生产者发送消息不会直接将小计投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列，队列再将消息以推送或者拉取方式给消费者进行消费

        创建消息              路由键         pull/push
   生产者------------>交换机------------>队列------------>消费者

生产者是把我们的消息投入到交换机，交换机跟队列是存在绑定关系的 

RabbitMQ交换机的作用： 

2.Exchange（交换机）的类型

①.直连交换机：Direct Exchange

直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing_key，当消息被发送的时候，需要指定一个bingding_key，这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。同样的一个binding_key也是支持应用到多个队列中的.

这样当一个交换机绑定多个队列，就会被送到对应的队列去处理。

     注1：什么是路由键 
          每个消息都有一个称为路由键(routing key)的属性，它其实就是一个简单的字符串

     注2：直连交换机适用场景
          有优先级的任务，根据任务的优先级把消息发送到对应的队列，这样可以指派更多的资源去处理高优先级的队列。

 直连交换机-单个绑定：

直连交换机-多个绑定： 

 

② 主题交换机：Topic Exchange

     直连交换机的缺点！
     直连交换机的routing_key方案非常简单，如果我们希望一条消息发送给多个队列，那么这个交换机需要绑定上非常多的routing_key，
     假设每个交换机上都绑定一堆的routing_key连接到各个队列上。那么消息的管理就会异常地困难。
     
     所以RabbitMQ提供了一种主题交换机，发送到主题交换机上的消息需要携带指定规则的routing_key，
     主题交换机会根据这个规则将数据发送到对应的(多个)队列上。

     主题交换机的routing_key需要有一定的规则，交换机和队列的binding_key需要采用*.#.*.....的格式，每个部分用.分开，其中
     *表示一个单词 
     #表示任意数量（零个或多个）单词。

 示例：
     队列Q1绑定键为 *.TT.*
     队列Q2绑定键为TT.#

     如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到 
     如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到

③ 扇形交换机：Fanout Exchange

扇形交换机是最基本的交换机类型，它所能做的事情非常简单————广播消息。

扇形交换机会把能接收到的消息全部发送给绑定在自己身上的队列。因为广播不需要"思考"，所以扇形交换机处理消息的速度也是所有的交换机类型里面最快的。

这个交换机没有路由键概念，就算你绑了路由键也是无视的。

④ 首部交换机：Headers Exchange

⑤ 默认交换机

        实际上是一个由RabbitMQ预先声明好的名字为空字符串的直连交换机（direct exchange）。它有一个特殊的属性使得它对于
     简单应用特别有用处：那就是每个新建队列（queue）都会自动绑定到默认交换机上，绑定的路由键（routing key）名称与队列名称相同。

     如：当你声明了一个名为”hello”的队列，RabbitMQ会自动将其绑定到默认交换机上，绑定（binding）的路由键名称也是为”hello”。
     因此，当携带着名为”hello”的路由键的消息被发送到默认交换机的时候，此消息会被默认交换机路由至名为”hello”的队列中
  
     类似amq.*的名称的交换机：
     这些是RabbitMQ默认创建的交换机。这些队列名称被预留做RabbitMQ内部使用，不能被应用使用，否则抛出403 (ACCESS_REFUSED)错误 

   6.Dead Letter Exchange（死信交换机）
     在默认情况，如果消息在投递到交换机时，交换机发现此消息没有匹配的队列，则这个消息将被悄悄丢弃。
     为了解决这个问题，RabbitMQ中有一种交换机叫死信交换机。当消费者不能处理接收到的消息时，将这个消息重新发布到另外一个队列中，
     等待重试或者人工干预。这个过程中的exchange和queue就是所谓的”Dead Letter Exchange 和 Queue

3.交换机的属性

除交换机类型外，在声明交换机时还可以附带许多其他的属性，其中最重要的几个分别是：
   Name：交换机名称
   Durability：是否持久化。如果持久性，则RabbitMQ重启后，交换机还存在
   Auto-delete：当所有与之绑定的消息队列都完成了对此交换机的使用后，删掉它
   Arguments：扩展参数

4.综合案例：交换机的使用

注意：当我们新建的项目时，注意要配置一下maven，它默认的是在C盘。 

     rabbitmq02                     #主模块        maven项目
     rabbitmq-provider            #生产者        springboot项目
     rabbitmq-consumer            #消费者        springboot项目

主模块： 

生产者：

消费者：

二、直连交换机的使用(Direct Exchange)

打开我们的虚拟机--->连接虚拟机连接工具

由于我们执行了开机自启动。打开浏览器访问：192.168.29.128:15672 进行登录。

① 给子模块添加依赖 

 pom.xml  生产者和消费者

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-amqp</artifactId>
     </dependency>
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <optional>true</optional>
     </dependency>

② 给消费者添加连接配置

server.port=8080
## rabbitmq config
spring.rabbitmq.host=192.168.29.128
spring.rabbitmq.port=5672
spring.rabbitmq.username=jwj
spring.rabbitmq.password=123456

## 与启动容器时虚拟主机名字一致~~~与启动容器时虚拟主机名字一致~~~与启动容器时虚拟主机名字一致~~~
spring.rabbitmq.virtual-host=my_vhost

③ 创建类 RabbitmqDirectConfig

package com.jwj.rabbitmqprovider.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 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-12-16 21:02
 *
 * 由于它是配置类所以我们要添加 @configuration
 */
@Configuration
public class RabbitmqDirectConfig {
//    直连交换机对应的队列
    @Bean
    public Queue directQueue(){
        return new Queue("jwj-direct-Queue");
    }

//    直连交换机
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("jwj-direct-Exchange");
    }

//    直连交换机与队列的绑定关系
    @Bean
    public Binding directBinding(){
        return BindingBuilder.bind(directQueue())
                .to(directExchange())
                .with("direct_routing_key");
    }
}

④ 创建 SendMessageController

关键代码：rabbitTemplate.convertAndSend("testDirectExchange", "testDirectRouting", map);
                   sendDirectMessage：进行消息推送（也可以改为定时任务，具体看需求）

package com.jwj.rabbitmqprovider.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-12-16 21:47
 */
@RestController
public class SendMessageController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RequestMapping("/sendDirect")
    public Map sendDirect(String routingKey){
        Map msg=new HashMap();
        msg.put("msg","直连交换机 jwj-direct-Exchange 发送的消息");
        msg.put("time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh-mm-ss")));

        rabbitTemplate.convertAndSend("jwj-direct-Exchange",
                routingKey,
                msg);

        Map res=new HashMap();
        res.put("code",200);
        res.put("msg","成功");
        return res;

    }
}

⑤ 运行

运行：

 如果一点没有对上就会没有。

⑥  创建消息接收监听类 DirectReceiver

 3.查看rabbitmq管理界面
       我们目前还创建消费者rabbitmq-consumer，消息没有被消费的，我们去rabbitMq管理页面看看，是否推送成功 
       Overview选项卡，可以查看到刚刚创建的消息

package com.jwj.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
		@RabbitListener(queues = {"jwj-direct-Queue"})
		public class DirectReceiver {
			// @RabbitListener(queues = {"direct-queue"})
			@RabbitHandler
			public void handler(Map msg){
				System.out.println(msg);
			}
		}
server.port=8081
spring.rabbitmq.host=192.168.29.128
spring.rabbitmq.port=5672
spring.rabbitmq.username=jwj
spring.rabbitmq.password=123456
## 与启动容器时虚拟主机名字一致~~~与启动容器时虚拟主机名字一致~~~与启动容器时虚拟主机名字一致~~~
spring.rabbitmq.virtual-host=my_vhost

 注1：新版jdk日期及格式化
          LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

     注2：rabbitTemplate和amqpTemplate有什么关系
          查看源码中会发现rabbitTemplate实现自amqpTemplate接口，两者使用起来并无区别，功能一致

     注3：不要@Configuration写成了@Configurable，这两个长得很像
          @Configuration该注解是可以用来替代XML文件。
          手动new出来的对象，正常情况下，Spring是无法依赖注入的，这个时候可以使用@Configurable注解

⑦ 运行 

三、主题交换机（Topic Exchange）

① 创建类 RabbitTopicConfig

package com.jwj.rabbitmqprovider.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-12-16 22:28
 */
@Configuration
public class RabbitTopicConfig {
//    队列
    @Bean
    public Queue topicQueueA(){
    return new Queue("jwj-topic-Queue-a");
}

    @Bean
    public Queue topicQueueB(){
        return new Queue("jwj-topic-Queue-b");
    }

    @Bean
    public Queue topicQueueC(){
        return new Queue("jwj-topic-Queue-c");
    }

//    交换机
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("jwj-topic-Queue");
    }

//    绑定关系
    @Bean
    public Binding binding1(){
        return BindingBuilder.bind(topicQueueA())
                .to(topicExchange())
                .with("jwj.person.xx");
    }

    @Bean
    public Binding binding2(){
        return BindingBuilder.bind(topicQueueB())
                .to(topicExchange())
                .with("jwj.person.yy");
    }

    @Bean
    public Binding binding3(){
        return BindingBuilder.bind(topicQueueC())
                .to(topicExchange())
                .with("jwj.person.*");
    }

}

② 主题交换机发送消息方法 

@RequestMapping("/sendTopic")
    public Map sendTopic(String routingKey){
        Map msg=new HashMap();
        msg.put("msg","主题交换机 jwj-topic-Exchange 发送的消息");
        msg.put("time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh-mm-ss")));

        rabbitTemplate.convertAndSend("jwj-topic-Exchange",
                routingKey,
                msg);

        Map res=new HashMap();
        res.put("code",200);
        res.put("msg","成功");
        return res;

    }

③ 访问 

 哪怕我们第一次访问写的不对，但它的队列也要给我们生产出来来。

 

④ 消费者监听消息 

 TopicReceiver

package com.jwj.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-12-16 22:58
 */
@Component
public class TopicReceiver {
     @RabbitListener(queues = {"jwj-topic-Queue-a"})
    @RabbitHandler
    public void handler1(Map msg){
        System.out.println("消费者订阅jwj-topic-Queue-a队列的消息为："+msg);
    }

    @RabbitListener(queues = {"jwj-topic-Queue-b"})
    @RabbitHandler
    public void handler2(Map msg){
        System.out.println("消费者订阅jwj-topic-Queue-b队列的消息为："+msg);
    }

    @RabbitListener(queues = {"jwj-topic-Queue-c"})
    @RabbitHandler
    public void handler(Map msg){
        System.out.println("消费者订阅jwj-topic-Queue-c队列的消息为："+msg);
    }
}

 三、扇形交互机(Fanout Exchange)

RabbitmqFanoutConfig

package com.jwj.rabbitmqprovider.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-12-17 0:59
 */
@Configuration
public class RabbitmqFanoutConfig {

        //    队列
        @Bean
        public Queue fanoutQueueA(){
            return new Queue("jwj-fanout-Queue-a");
        }

        @Bean
        public Queue fanoutQueueB(){
            return new Queue("jwj-fanout-Queue-b");
        }

        @Bean
        public Queue fanoutQueueC(){
            return new Queue("jwj-fanout-Queue-c");
        }

        //    交换机
        @Bean
        public FanoutExchange fanoutExchange(){
            return new FanoutExchange("jwj-fanout-Queue");
        }

        //    绑定关系
        @Bean
        public Binding bindingFanout1(){
            return BindingBuilder.bind(fanoutQueueA())
                    .to(fanoutExchange());
        }

        @Bean
        public Binding bindingFanout2(){
            return BindingBuilder.bind(fanoutQueueB())
                    .to(fanoutExchange());
        }

        @Bean
        public Binding bindingFanout3(){
            return BindingBuilder.bind(fanoutQueueC())
                    .to(fanoutExchange());
        }


}

 //因为是扇型交换机, 路由键无需配置,配置也不起作用，两处地方均未配置路由键
     BindingBuilder.bind(queueA()).to(fanoutExchange()); 
     rabbitTemplate.convertAndSend(RabbitFanoutConfig.EXCHANGE_NAME,null, map);

FanoutReceiver

package com.jwj.rabbitmqconsumer.config;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author 敢敢
 * @site www.javajwj.com
 * @company xxx公司
 * @create  2022-12-16 22:58
 */
@Component
public class FanoutReceiver {
     @RabbitListener(queues = {"jwj-fanout-Queue-a"})
    @RabbitHandler
    public void handler1(Map msg){
        System.out.println("消费者订阅jwj-fanout-Queue-a队列的消息为："+msg);
    }

    @RabbitListener(queues = {"jwj-fanout-Queue-b"})
    @RabbitHandler
    public void handler2(Map msg){
        System.out.println("消费者订阅jwj-fanout-Queue-b队列的消息为："+msg);
    }

    @RabbitListener(queues = {"jwj-fanout-Queue-c"})
    @RabbitHandler
    public void handler(Map msg){
        System.out.println("消费者订阅jwj-fanout-Queue-c队列的消息为："+msg);
    }
}
敢敢130
关注
交换机讲解，直连交换机，扇形交换机
m0_60375943的博客
02-25 2050
一，交换机 在rabbitmq中，生产者发信息不会直接将信息投递到队列中，而是先将信息投递到交换机中，在交换机转发在具体的队列，队列再将信息推送或者拉取消费者进行消费 路由键（Routingkey） 生产者将信息发送给交换机的时候 会指定Routingkey指定路由规则 绑定键（Bindingkey) 通过绑定键将交换机与队列关联起来，这样rabbtamq就知道如何正确的将信息路由到队列 二，交换机类型 直接交换机：Direct exchange 直接交换机的路.
扇形交换机
yyh821013的博客
03-31 2410
一、介绍 这章我们实现扇形模式将消息传递给多个队列，这种模式也称为“发布/订阅”， 回顾： 生产者是发送消息的用户应用程序。 队列是存储消息的缓冲区。 消费者是接收消息的用户应用程序。 RabbitMQ 消息传递模型中的核心思想是：一直不会将任何消息直接发送到队列上，而且，生产者经常不知道有没有将消息传递到任何队列。 相反，生产者只能将消息发送到交换机。交换消息是一件非常简单的事情。一方面，交换机它接收来自生产者的消息，另一方面，将它们的消息推入队列。交换机必须确切地知道如何处理接收到的消息。是
扇形交换机(Fanout Exchange)
AWildCat的博客
03-31 374
//因为是扇型交换机, 路由键无需配置,配置也不起作用，两处地方均未配置路由键 BindingBuilder.bind(queueA()).to(fanoutExchange()); rabbitTemplate.convertAndSend(RabbitFanoutConfig.EXCHANGE_NAME,null, map); 附录一：创建消息对应的模拟数据，它是一个Map集合 /** * 创建消息对应的模拟数据，它是一个Map集合 */...
RabitMQ之主题交换机（异步处理）和扇形交换机（广告）
weixin_45341195的博客
04-02 248
主题交换机(Topic Exchange) 异步处理的流程 1.队列与交换机的绑定 package com.zking.provider.config; import org.springframework.amqp.core.*; import org.springframework.context.annotation.Bean; import org.springframework.c...
RabbiMQ 学习笔记 -- 04 扇形交换机
yorsola的博客
06-11 353
一、介绍 这章我们实现扇形模式将消息传递给多个队列，这种模式也称为“发布/订阅”， 回顾： 生产者是发送消息的用户应用程序。 队列是存储消息的缓冲区。 消费者是接收消息的用户应用程序。 RabbitMQ 消息传递模型中的核心思想是：一直不会将任何消息直接发送到队列上，而且，生产者经常不知道有没有将消息传递到任何队列。 相反，生产者只能将消息发送到交换机。交换消息是一件非常简单的事情。一方面，交换机它接收来自生产者的消息，另一方面，将它们的消息推入队列。交换机必须确切地知道
RabbitMQ（02章）：RabbitMQ之交换机（直联、主题、扇形）
weixin_61024320的博客
12-12 685
在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列， 队列再将消息以推送或者拉取方式给消费者进行消费 创建消息 路由键 pull/push 生产者------------>交换机------------>队列------------>消费者
RabbitMQ消息路由模式：直连交换机
# 1. 引言 ## RabbitMQ简介 RabbitMQ是一个开源的消息中间件...在RabbitMQ中，消息路由模式由交换机（Exchange）和队列（Queue）组成。交换机负责接收生产者发送的消息，并根据路由键将消息路由到对应的队列中。 接下
RabbitMQ入坑系列（四）：扇形交换机
Fandy的博客
08-05 1206
前言 前面的系列中，我们都是通过队列发送和接收消息的，然而rabbitmq还有一个别的也是最常用的消息发送和接收机制，那就是交换机。一般来说， 消息是发送到交换机，然后由绑定到交换机中的队列来接收消息。完整的消息流程如下： 图中P是生产者，X是交换机，红色的两个队列，生产者发送消息到交换机，交换机再发送到两个队列 交换机的类型 交换机主要包括如下4种类型： Fanout exchange(扇形交换机) Direct exchange(直连交换机) Topic exchange(主题交换机) Header
RabbitMQ.交换机详解
zxy15974062965的博客
02-26 966
一.交换机 1.Exchange 在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中,在由交换机转发到具体的队列,队列再将消息以推送或者拉取方式给消费者进行消费生产者将消息发送到Exchange,由Exchange再路由到一个或多个队列中 2.路由键( Routingkey) 生产者将消息发送给交换机的时候，会指定RoutingKey指定路由规则。 3.绑定键(BindingKey) 通过绑定键将交换机与队列关联起来，这样RabbitMQ就知道如何正确地.
2-5 Tutorials with python -> Topics
idler_bm的专栏
03-03 441
为什么需要主题交换机？ （使用Python 客户端 —— pika 0.9.8） 上一篇教程里，我们改进了我们的日志系统。我们使用直连交换机替代了扇型交换机，从只能盲目的广播消息改进为有可能选择性的接收日志。 尽管直连交换机能够改善我们的系统，但是它也有它的限制 —— 没办法基于多个标准执行路由操作。 在我们的日志系统中，我们不只希望订阅基于严重程度的日志，同时还希望订阅基
RabbitMQ之直连交换机（Direct exchange）
qq_42212926的博客
04-04 1098
直连交换机 上一篇博客中讲解了扇形交换机，但是由于扇形交换机属于广播类型的交换机，如果我们需要一对一这种类型的发送接收消息，使用扇形交换机就不太合适，可以使用直连交换机。 直连交换机 直连交换机生产者代码 public class DirectLogs { //交换机的名称 public static final String EXCHANGE_NAME = "direct_logs"; public static void main(String[] args) throws E
RabbitMQ之扇形交换机
qq_42212926的博客
04-03 1155
Exchanges Exchange概念 RabbitMQ消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列中，而是发送到交换机，并且生产者都不知道这些消息 传递到了那些队列中。 交换机总共有以下几种类型： 扇形交换机（fanout），主题交换机（topic），直联交换机（direct），默认交换机（“”） 在前面博客中我们直接声明一个队列，然后交换机那块直接使用“”代替，实际上我们使用的就是默认或无名称交换机。消息能够发送到队列中是由于routingkey绑定的key指定的。 此处表示默认交换
（1）关于RabbitMq 的 Direct Exchange 直连型交换机
分享日常bug
09-27 1219
在这个界面里面我们可以做些什么？可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。以上这些管理界面的操作在这篇暂时不做扩展描述，我想着重介绍后面实例里会使用到的。根据消息携带的路由键将消息投递给对应队列。大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key。然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时交换机就会根据这个路由值X去寻找绑定值也是X的队列。
RabbitMQ交换机之直连交换机，扇形交换机，主题交换机
qq_54936371的博客
02-28 2748
一、交换机（Exchange）关系 在rabbitmq中，生产者发信息不会直接将信息投递到队列中，而是先将信息投递到交换机中，在交换机转发在具体的队列，队列再将信息推送或者拉取消费者进行消费 生产者将消息发送到Exchange，由Exchage再路由到一个或队列中 路由建（RoutingKey） 生产者将消息发送给交换机的时候，会指定RoutingKey指定路由规则 绑定键（BindingKey） 通过绑定键将交换机与队列关联起来，这样RabbbitMQ就知道如何正确地将消息路.
FanoutExchange广播(扇形)交换机
最新发布
weixin_45326523的博客
08-28 177
MQ；广播交换机；扇形交换机;rabbitMQ
RabbitMq——主题（topic）交换机
weixin_50616848的博客
03-13 2902
主题（topic）交换机：该交换机可以更好的以基于多个标准的路由发消息给指定队列。 其路由规则为：routingkey必须为单词列表，单词之间以点号分隔开，*号代表一个单词，#号可以替代零个或多个单词。 举例： 路由*.*.key1绑定队列Q1，如：red.blue.key1、black.green.key1等，通过这些路由都可以发送消息给队列Q1 路由#.key2.*绑定队列Q2，如：a.b.c.key2.red、orange.key2.blue、key2.red等，通过这些路由都可以发送消息给队
RabbitMQ之主题交换机
qq_42212926的博客
04-04 2181
RabbitMQ之主题交换机 RabbitMQ中的交换机大致分为四种，默认，直连（Direct），主题（Topic），扇形（Fanout），其中灵活性最大的应该算是Topic主题交换机了。 主题交换机中的路由键有两个替换符需要大家注意到： *（星号）可以代替一个单词 #（井号）可以代替零个或多个单词 主题交换机生产者代码 public class EmitLogTopic { public static final String EXCHANGE_NAME = "topic_logs";
(8)RabbitMQ之topic（主题）交换机
没头脑遇到不高兴
03-19 3110
本节将会介绍RabbitMQ中的topic（主题）交换机，通过在上一篇博客的基础上，利用topic形式的exchange对程序进行改进，将会变得更加灵活。 Topic exchange（主题交换机） 发送到topic交换机的消息不能具有任意的 routing_key —— 它必须是由点分隔的单词列表。单词可以是任何内容，但通常它们指定与消息相关的一些功能。一些有效的路由键示例：“ stock...
RabitMQ之直联交换机
weixin_45341195的博客
04-01 187
1.直连交换机：Direct Exchange 直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing_key，当消息被发送的时候，需要指定一个binding_key， 这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。同样的一个binding_key也是支持应用到多个队列中的。 直连交换机适用场景 有优先级的任务，根据任务的优先级把消息发...
RabbitMQ交换机
08-09
RabbitMQ提供了不同类型的交换机，包括直连交换机（direct exchange）、主题交换机（topic exchange）、头交换机（headers exchange）和扇形交换机（fanout exchange）。每种类型的交换机都有不同的路由规则和使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值