RabbitMQ之Exchange、Queue参数详解

最新推荐文章于 2024-04-02 19:19:21 发布
最新推荐文章于 2024-04-02 19:19:21 发布
阅读量1.6w 收藏 47
点赞数 6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dh554112075/article/details/90182453
版权
1.先来介绍RabbitMQ中的成员
  • Producer(生产者)： 将消息发送到Exchange
  • Exchange(交换器)：将从生产者接收到的消息路由到Queue
  • Queue(队列)：存放供消费者消费的消息
  • BindingKey(绑定键)：建立Exchange与Queue之间的关系（个人看作是一种规则，也就是Exchange将什么样的消息路由到Queue）
  • RoutingKey(路由键)：Producer发送消息与路由键给Exchange，Exchange将判断RoutingKey是否符合BindingKey，如何则将该消息路由到绑定的Queue
  • Consumer(消费者)：从Queue中获取消息

下面是各个成员的作用图解

在这里插入图片描述
引入依赖

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.6.0</version>
</dependency>
2.先来介绍Exchange
这里将着重于介绍Exchange和Queue的各个参数解释

先来看看Exchange中都有哪些属性

  • exchange：名称
  • type：类型
  • durable：是否持久化，RabbitMQ关闭后，没有持久化的Exchange将被清除
  • autoDelete：是否自动删除，如果没有与之绑定的Queue，直接删除
  • internal：是否内置的，如果为true，只能通过Exchange到Exchange
  • arguments：结构化参数

type会在后面一节说到，这里不会讲

Exchange.DeclareOk exchangeDeclare(String exchange,
           String type,
           boolean durable,
           boolean autoDelete,
           boolean internal,
           Map<String, Object> arguments) throws IOException;

下面这个类用于创建一个与RabbitMQ的Connection(连接)，该Connection用于创建Channel(信道)，Channel是消息读写的通道，也就是我们的操作都会在Channel的基础之上进行

package com.dfyang.rabbitmq;

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

public class RabbitmqConnectionFactory {
    private static ConnectionFactory factory = new ConnectionFactory();

    private static String HOST = "192.168.195.123";
    private static int PORT = 5672;
    private static String USERNAME = "root";
    private static String PASSWORD = "151310";

    static {
        factory.setHost(HOST);
        factory.setPort(PORT);
        factory.setUsername(USERNAME);
        factory.setPassword(PASSWORD);
    }

    public static Connection newConnection() {
        try {
            return factory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

2.1先使用最简单的参数构建Exchange
exchangeDeclare(String exchange, String type)

package com.dfyang.rabbitmq.eq0;

import com.dfyang.rabbitmq.RabbitmqConnectionFactory;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Exchange {

    private static String EXCHANGE_NAME = "exchange.0";

    public static void main(String[] args) throws Exception {
    	//创建一个Connection连接
        Connection connection = RabbitmqConnectionFactory.newConnection();
        //开启Channel
        Channel channel = connection.createChannel();
        //创建一个Exchange，设置名称为exchange.0和类型为direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //关闭资源
        channel.close();
        connection.close();
    }
}

进入RabbitMQ可视化界面可以看到，RabbitMQ已经为我们创建了exchange.0，类型为direct
不懂如何进入可视化界面的可以点这
在这里插入图片描述
2.2接下来是三个参数，也就是加上了是否持久化，同时保留先前两个参数的exchange.0，之前我们已经创建了exchange.0，那么我们再创建一次会怎样
exchangeDeclare(String exchange, String type, boolean durable)

package com.dfyang.rabbitmq.eq0;

import com.dfyang.rabbitmq.RabbitmqConnectionFactory;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Exchange {

    private static String EXCHANGE_NAME0 = "exchange.0";
    private static String EXCHANGE_NAME1 = "exchange.1";
    private static String EXCHANGE_NAME2 = "exchange.2";

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitmqConnectionFactory.newConnection();
        Channel channel = connection.createChannel();
        //创建一个Exchange，设置名称为exchange.1和类型为direct
        channel.exchangeDeclare(EXCHANGE_NAME0, "direct");
        //创建一个Exchange，设置名称为exchange.1和类型为direct，持久化为false
        channel.exchangeDeclare(EXCHANGE_NAME1, "direct", false);
        //创建一个Exchange，设置名称为exchange.2和类型为direct，持久化为true
        channel.exchangeDeclare(EXCHANGE_NAME2, "direct", true);
        channel.close();
        connection.close();
    }
}

运行成功，并没有报错，因为只要你设置的的设置是一样的，那么就不会报错，如果设置的不一样，那么就会报错，后面会进行验证

这里我们发现exchange.2多了一个D标识，这个D是durable也就是持久化，而exchange.0没有持久化，也就是默认非持久化
在这里插入图片描述
接下来验证这个持久化有什么作用
关闭rabbitmq
rabbitmqctl stop_app
启动rabbitmq
rabbitmqctl start_app
重新进入可视化界面，Exchange就只剩下持久化的了
在这里插入图片描述
2.3接下来是五个参数的
多了两个参数，autoDelete和arguments
exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Map<String, Object> arguments)

下面创建了两个Exchange
exchange.3自动删除为false
exchange.4自动删除为true
由于这里是没有绑定Queue的，那么exchange.4将在创建后就被删除掉？

package com.dfyang.rabbitmq.eq0;

import com.dfyang.rabbitmq.RabbitmqConnectionFactory;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Exchange {

    private static String EXCHANGE_NAME0 = "exchange.3";
    private static String EXCHANGE_NAME1 = "exchange.4";

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitmqConnectionFactory.newConnection();
        Channel channel = connection.createChannel();
        //创建一个Exchange，设置名称为exchange.3和自动删除为false
        channel.exchangeDeclare(EXCHANGE_NAME1, "direct", false, false, null);
        //创建一个Exchange，设置名称为exchange.4和自动删除为true
        channel.exchangeDeclare(EXCHANGE_NAME1, "direct", false, true, null);
        channel.close();
        connection.close();
    }
}

执行上面的代码
在这里插入图片描述
exchange.4还活的好好的，这是因为我们必须在绑定Queue之后再失去绑定才会被删除，否则为什么不直接抛异常，接下来进行验证
下面直接通过可视化工具创建一个名称为queue.4的Queue
在这里插入图片描述
点击添加之后，点击queue.3进行绑定，输入exchange.3以及RoutingKey（下一节会细讲），点击bind
在这里插入图片描述
我们可以看到已经建立了Binding
在这里插入图片描述
那么我们点击Unbind，发现exchange.4没了
在这里插入图片描述
下面来看看第五个参数arguments的作用，这里依旧是使用可视化工具创建，后一节会使用很多java代码
再我们使用可视化创建Exchange时下面的Arguments提供了一个Alternate exchange，这就是一个arguments（这里只会展示这一个）
在这里插入图片描述
alternate-exchange：如下图，如果我们设置Exchange0的alternate-exchange为Exchange1，那么当Producer发送RoutingKey为test1的消息，Exchange0由于路由不到匹配的队列，会将消息发送给Exchange1进行路由
在这里插入图片描述
上面那张图我们创建了test.exchange.0，接下来创建test.exchange.1
在这里插入图片描述
然后创建test.queue.0和test.queue.1两个队列
在这里插入图片描述
将test.exchange.0绑定test.queue.0
在这里插入图片描述
将test.exchange.1绑定test.queue.1
在这里插入图片描述
点击test.exchange.0来发布一条消息，之一RoutingKey为test.1，也就是test.exchange.0路由不到匹配的Queue，将交给test.exchange.1进行路由，路由到匹配的test.queue.1
在这里插入图片描述
结果我们发现test.queue.1多了一条消息
在这里插入图片描述
2.4接下来是六个参数的
internal：是否内置的，如果为true，只能通过Exchange到Exchange
也就是该Producer无法直接将消息发送给该Exchange，只能将消息发送给一个Exchange再路由到该Exchange
在这里插入图片描述
直接使用可视化界面创建Exchange0设置internal为true
我们发现根本就没有publish这一功能，也就是我们无法通过Producer发布消息到该Exchange上
在这里插入图片描述
创建一个Queue0
在这里插入图片描述
绑定其与Exchange0的关系
在这里插入图片描述
创建一个Exchange1
在这里插入图片描述
绑定Exchange1与Exchange0的关系
在这里插入图片描述
使用Exchange1发送一条RoutingKey为test的消息，消息将被发送到Exchange0，再到Queue0
在这里插入图片描述
结果如下，至此，Exchange的6个参数全部讲解
在这里插入图片描述
2.5讲解完Exchange的参数，再来看Queue的参数，就会发现只有一个exclusive未讲
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments

exclusive：是否排他，如果未true，则只在第一次创建它的Connection中有效，当Connection关闭，该Queue也会被删除

在执行完下面代码，查看可视化界面，发现queue中并没有exclusive.queue，因为在connection关闭后，该queue也会自动删除

package com.dfyang.rabbitmq.eq1;

import com.dfyang.rabbitmq.RabbitmqConnectionFactory;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Exchange {
    private static String QUEUE_NAME0 = "exclusive.queue";

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitmqConnectionFactory.newConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME0, true, true, false, null);
        channel.close();
        connection.close();
    }
}

修改代码，让代码一直听着

package com.dfyang.rabbitmq.eq1;

import com.dfyang.rabbitmq.RabbitmqConnectionFactory;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Exchange {
    private static String QUEUE_NAME0 = "exclusive.queue";

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitmqConnectionFactory.newConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME0, true, true, false, null);
        Thread.sleep(100000);
        channel.close();
        connection.close();
    }
}

打开可视化界面，点击exclusive.queue，再点击删除
翻译为：无法获得对锁定队列“独占”的独占访问。队列’在vhost ‘/’。它可以最初在另一个连接上声明，或者独占属性值与原始声明值不匹配。
在这里插入图片描述

完！

Linux安装RabbitMQ
RabbitMQ之Exchange类型详解

DFYoung
关注
  • 6
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
RabbitMQ .NET消息队列使用详解
10-21
主要为大家详细介绍了RabbitMQ .NET消息队列使用方法,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于RabbitMQ几种Exchange 模式详解
08-28
下面小编就为大家带来一篇基于RabbitMQ几种Exchange 模式详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
RabbitMq配置参数详解
最新发布
2401_84010061的博客
04-02 311
在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）
1.6 RabbitMQ-Exchange内容详解
01-06
一、Exchange交换机的定义 交换机，接受消息，根据路由键转发消息到绑定的队列 Exchange的常用属性： Name：交换机名称 Type：交换机类型 direct、topic、fanout、headers Durability：是否需要持久化，true为持久化 Auto Delete：当最后一个绑定带Exchange上的队列删除后，自动删除该Exchange Internal：当前Exchange是否用于RabbitMQ内部使用，默认为false Argument：扩展参数，用于扩展AMQP协议自制定化使用 Exchange在流程种的示意： 二、交换机类型 2.1 Direct
Spring RabbitMQ死信机制原理实例详解
08-24
主要介绍了Spring RabbitMQ死信机制原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
rabbitmq exchange详细分析
01-20
RabbitMQ中，所有生产者提交的消息都由Exchange来接受，然后Exchange按照特定的策略转发到Queue进行存储，RabbitMQ提供了四种Exchange： 1、fanout 2、direct 3、topic 4、header header模式在实际使用中较少，此处只对前三种模式进行比较。 一.Direct Exchange 任何发送到Direct Exchange的消息都会被转发到RoutingKey中指定的Queue。 1、一般情况可以使用rabbitMQ自带的Exchange：””(该Exchange的名字为空字符串，下文称其为default Exchange)。 2、
rabbitmq延时队列和四种交换机模式下队列的简单实现
08-06
rabbitmq延时队列和四种交换机模式下队列的简单实现，需要自己配置一下属性文件。
RabbitMQ 入门：2. Exchange 和 Queue
dotNET跨平台
02-01 1015
上文RabbitMQ 入门：1. Message Broker（消息代理）提到过 RabbitMQ 实现了 AMQP 这个协议（RabbitMQ 所支持的 AMQP 的版本是 0.9.1...
rabbitmq原理介绍(转载)
weixin_34221775的博客
09-17 265
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ交换机与队列
Anolzo
01-23 1656
当这样做的时候，我们需要明白一点，在AMQP 0-9-1中，消息的负载均衡是发生在消费者（consumer）之间的，而不是队列（queue）之间。延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。（7）x-dead-letter-routing-key：死信消息路由键，在消息发送到死信交换器时会使用该路由键，如果不设置，则使用消息的原来的路由键值。
rabbitmq动态绑定exchange，routingKey，queue
08-04
关于rabbitmq的原生api和spring amqp的api的动态绑定exchange，routingKey，queue 说明文地址： http://blog.csdn.net/phantomes/article/details/47284829
RabbitMQ--交换器类型/队列模式--使用/教程/详解
IT利刃出鞘的博客
11-16 4621
本文介绍RabbitMQ的交换器类型和队列模式。 本内容也是Java后端面试常见的问题。
RabbitMQ系列（五）RabbitMQ进阶-Queue队列特性 (三) 发布/订阅 模式(1)-直连交换机
流浪的喵的博客
03-01 471
发布/订阅 模式 发布/订阅模式就是以将消息发送给不同类型的消费者。做到发布一次，消费多个。下图是（RabbitMQ）的发布/订阅模式的图，可以满足不同的业务来处理不同的消息 一个消费者将消息首先发送到交换器，交换器绑定到多个队列，然后被监听订阅该队列的消费者所接收并消费 对比 工作模式 可以看出来，我们当前的发布/订阅模式，多了 exchange 和多个队列，工作模式是1个队列绑定多个消费者，发布/订阅模式是 讲过Exchange交换机后，绑定多个队列，多个消费者 发布/订阅模式上代码 2.1 生产者
rabbitMQ 中三种常用交换机：direct、topic、fanout的使用以及区别和queue消息的Ack,Nack ,Reject 消息类型
码农崛起
08-10 3707
当消息发送到Exchange时，RabbitMQ会取到该消息的headers（也是一个键值对的形式），对比其中的键值对是否完全匹配Queue与Exchange绑定时指定的键值对；生产者将消息不是直接发送到队列，而是发送到X交换机，然后由交换机发送给两个队列，两个消费者各自监听一个队列，来消费消息。生产者，一个队列一个或多个消费者，当多个消费者同时监听一个队列时，他们并不能同时消费一条消息，而是随机消费消息，即一个队列中一条消息，只能被一个消费者消费。如果匹配请求中的值，则向程序返回该响应数据。.......
RabbitMQ 优先级队列与惰性队列
yao_wen_yu的博客
07-27 780
文章目录一、优先级队列1、使用场景2、如何添加3、实战二、惰性队列1、使用场景2、两种模式3、内存开销对比 一、优先级队列 1、使用场景 假如在我们的系统中有一个订单催付的场景，我们的客户在天猫下的订单，淘宝会及时将订单推送给我们，如果在用户设定的时间内未付款那么就会给用户推送一条短信消息提醒，但是对于淘宝来说，肯定是要分大客户和小客户的对吧，比如像苹果，小米这样大商家一年起码能给我们创 造很大的利润，所以理应当然，他们的订单必须得到优先处理，而曾经我们的后端系统是使用 redis 来存放的定时轮询，大家
RabbitMQ中 exchange、route、queue的关系
草根上的须子
05-17 2548
从AMQP协议可以看出，MessageQueue、Exchange和Binding构成了AMQP协议的核心，下面我们就围绕这三个主要组件 从应用使用的角度全面的介绍如何利用Rabbit MQ构建消息队列以及使用过程中的注意事项。 1.声明MessageQueue 在Rabbit MQ中，无论是生产者发送消息还是消费者接受消息，都首先需要声明一个MessageQueue。这就存在一个问题，是生产者声明还是消费者声明呢？要解决这个问题，首先需要明确： a)消费者是无法...
RabbitMQ Exchange(交换器) 和Queue（队列） 的属性
weixin_34407348的博客
06-30 367
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ——交换机、死信队列
Yellow_Star的博客
01-19 1612
交换机 概念 RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产 者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这些由交换机的类型来决定。 交换机的类型 直接（direct） 主题（topic） 标题（heade
rabbitmq exchange和queue
04-06
RabbitMQ是一种流行的消息中间件，它支持多种消息传递模式。其中，Exchange和Queue是两个重要的概念。 Exchange可以理解为消息的路由器，它将消息路由到与之匹配的Queue中。Exchange可以配置多种类型，例如直接交换（Direct Exchange）、主题交换（Topic Exchange）等，以满足不同场景下的需求。 Queue则是消息的容器，它存储Exchange路由过来的消息。每个Queue都可以绑定一个或多个Exchange，当Exchange将消息路由到与之绑定的Queue时，该Queue将会接收到消息。在Queue中，消息可以被多个消费者消费，但是同一条消息只能被一个消费者消费。 综上所述，Exchange和Queue是消息中间件中重要的概念，它们通过消息的路由和存储来实现消息传递和处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值