RabbitMq参数含义

最新推荐文章于 2024-09-20 10:45:56 发布
最新推荐文章于 2024-09-20 10:45:56 发布
阅读量659 收藏 2
点赞数
分类专栏： RabbitMQ 文章标签： 队列
原文链接：https://blog.csdn.net/vbirdbest/article/details/78670550
版权

本节主要讨论队列声明的各个参数

这里写图片描述

 

  1. queueDeclare(String queue,

  2. boolean durable,

  3. boolean exclusive,

  4. Map<String, Object> arguments);

  • 1
  • 2
  • 3
  • 4

  • queue: 队列名称

  • durable： 是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库

  • exclusive：是否排外的，有两个作用，一：当连接关闭时connection.close()该队列是否会自动删除；二：该队列是否是私有的private，如果不是排外的，可以使用两个消费者都访问同一个队列，没有任何问题，如果是排外的，会对当前队列加锁，其他通道channel是不能访问的，如果强制访问会报异常：com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=405, reply-text=RESOURCE_LOCKED - cannot obtain exclusive access to locked queue 'queue_name' in vhost '/', class-id=50, method-id=20)一般等于true的话用于一个队列只能有一个消费者来消费的场景

  • autoDelete：是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除，可以通过RabbitMQ Management，查看某个队列的消费者数量，当consumers = 0时队列就会自动删除

  • arguments： 
    队列中的消息什么时候会自动被删除？

    • Message TTL(x-message-ttl)：设置队列中的所有消息的生存周期(统一为整个队列的所有消息设置生命周期), 也可以在发布消息的时候单独为某个消息指定剩余生存时间,单位毫秒, 类似于redis中的ttl，生存时间到了，消息会被从队里中删除，注意是消息被删除，而不是队列被删除， 特性Features=TTL, 单独为某条消息设置过期时间AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties().builder().expiration(“6000”); 
      channel.basicPublish(EXCHANGE_NAME, “”, properties.build(), message.getBytes(“UTF-8”));

    • Auto Expire(x-expires): 当队列在指定的时间没有被访问(consume, basicGet, queueDeclare…)就会被删除,Features=Exp

    • Max Length(x-max-length): 限定队列的消息的最大值长度，超过指定长度将会把最早的几条删除掉， 类似于mongodb中的固定集合，例如保存最新的100条消息, Feature=Lim

    • Max Length Bytes(x-max-length-bytes): 限定队列最大占用的空间大小， 一般受限于内存、磁盘的大小, Features=Lim B

    • Dead letter exchange(x-dead-letter-exchange)： 当队列消息长度大于最大长度、或者过期的等，将从队列中删除的消息推送到指定的交换机中去而不是丢弃掉,Features=DLX

    • Dead letter routing key(x-dead-letter-routing-key)：将删除的消息推送到指定交换机的指定路由键的队列中去, Feature=DLK

    • Maximum priority(x-max-priority)：优先级队列，声明队列时先定义最大优先级值(定义最大值一般不要太大)，在发布消息的时候指定该消息的优先级， 优先级更高（数值更大的）的消息先被消费,

    • Lazy mode(x-queue-mode=lazy)： Lazy Queues: 先将消息保存到磁盘上，不放在内存中，当消费者开始消费的时候才加载到内存中
    • Master locator(x-queue-master-locator)

注意

关于队列的声明，如果使用同一套参数进行声明了，就不能再使用其他参数来声明，要么删除该队列重新删除，可以使用命令行删除也可以在RabbitMQ Management上删除，要么给队列重新起一个名字。

队列持久化

重启RabbitMQ服务器(可以通过rabbitmqctl stop_app关闭服务器，rabbitmqctl start_app重启服务器)，可以登录RabbitMQ Management—> Queues中可以看到之前声明的队列还存在

 

  1. boolean durable = true;

  2. channel.queueDeclare(QUEUE_NAME, durable, false, false, arguments);

  • 1
  • 2

消息持久化

设置消息持久化必须先设置队列持久化，要不然队列不持久化，消息持久化，队列都不存在了，消息存在还有什么意义。消息持久化需要将交换机持久化、队列持久化、消息持久化，才能最终达到持久化的目的

方式一：设置deliveryMode=2

 

  1. channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT, true);

  2. channel.queueDeclare(QUEUE_NAME, true, false, false, arguments);

  3. channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

  4.  

  5. String message = "Hello RabbitMQ: ";

  6. // 设置消息持久化

  7. AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties().builder();

  8. properties.deliveryMode(2); // 设置消息是否持久化，1： 非持久化 2：持久化

  9.  

  10. channel.basicPublish(EXCHANGE_NAME, "", properties.build(), message.getBytes("UTF-8"));

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

方式二：设置BasicProperties为MessageProperties.PERSISTENT_TEXT_PLAIN

 

  1. channel.queueDeclare(QUEUE_NAME, true, false, false, arguments);

  2. channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

  3.  

  4. String message = "Hello RabbitMQ: ";

  5. channel.basicPublish(EXCHANGE_NAME, "", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes("UTF-8"));

  • 1
  • 2
  • 3
  • 4
  • 5

Message TTL消息剩余生存时间

统一设置队列中的所有消息的过期时间，例如设置10秒，10秒后这个队列的消息清零

方式一：为该队列的所有消息统一设置相同的声明周期

 

  1. Map<String, Object> arguments = new HashMap<String, Object>();

  2. arguments.put("x-message-ttl", 10000);

  3.  

  4. // 声明队列时指定队列中的消息过期时间

  5. channel.queueDeclare(QUEUE_NAME, false, false, false, arguments);

  6. channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

方式二：单独为某条消息单独设置时间

// expiration: 设置单条消息的过期时间

 

  1. channel.queueDeclare(QUEUE_NAME, false, false, false, null);

  2. channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));

  3.  

  4. for(int i = 1; i <= 5; i++) {

  5. AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties()

  6. .builder().expiration( i * 1000 + "");

  7.  

  8. channel.basicPublish(EXCHANGE_NAME, "", properties.build(), (message + i).getBytes("UTF-8"));

  9. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

Auto Expire自动过期

x-expires用于当多长时间没有消费者访问该队列的时候，该队列会自动删除，可以设置一个延迟时间，如仅启动一个生产者，10秒之后该队列会删除，或者启动一个生产者，再启动一个消费者，消费者运行结束后10秒，队列也会被删除

 

  1. Map<String, Object> arguments = new HashMap<String, Object>();

  2. arguments.put("x-expires", 10000);

  3.  

  4. channel.queueDeclare(QUEUE_NAME, false, false, false, arguments);

  5. channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));

  • 1
  • 2
  • 3
  • 4
  • 5

Max Length最大长度

x-max-length:用于指定队列的长度，如果不指定，可以认为是无限长，例如指定队列的长度是4，当超过4条消息，前面的消息将被删除，给后面的消息腾位

 

  1. Map<String, Object> arguments = new HashMap<String, Object>();

  2. arguments.put("x-max-length", 4);

  3.  

  4. channel.queueDeclare(QUEUE_NAME, false, false, false, arguments);

  5. for(int i = 1; i <= 5; i++) {

  6. channel.basicPublish(EXCHANGE_NAME, "", MessageProperties.PERSISTENT_TEXT_PLAIN, (message + i).getBytes("UTF-8"));

  7. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Max Length Bytes代码片段

x-max-length-bytes: 用于指定队列存储消息的占用空间大小，当达到最大值是会删除之前的数据腾出空间

 

  1. Map<String, Object> arguments = new HashMap<String, Object>();

  2. rguments.put("x-max-length-bytes", 1024);

  3.  

  4. channel.queueDeclare(QUEUE_NAME, false, false, false, arguments);

  5. channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));

  • 1
  • 2
  • 3
  • 4
  • 5

Maximum priority最大优先级

x-max-priority: 设置消息的优先级，优先级值越大，越被提前消费。

正常情况下不适用优先级 
Hello RabbitMQ: 1 
Hello RabbitMQ: 2 
Hello RabbitMQ: 3 
Hello RabbitMQ: 4 
Hello RabbitMQ: 5

使用优先级顺序正好相反 
Hello RabbitMQ: 5 
Hello RabbitMQ: 4 
Hello RabbitMQ: 3 
Hello RabbitMQ: 2 
Hello RabbitMQ: 1

 

  1. Map<String, Object> arguments = new HashMap<String, Object>();

  2. arguments.put("x-max-priority", 10);

  3.  

  4. channel.queueDeclare(QUEUE_NAME, false, false, false, arguments);

  5. for(int i = 1; i <= 5; i++) {

  6. AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties()

  7. .builder().priority(i);

  8. channel.basicPublish(EXCHANGE_NAME, "", properties.build(), (message + i).getBytes("UTF-8"));

  9. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

这里写图片描述

Dead letter exchange(死亡交换机) 和 Dead letter routing key(死亡路由键)

当队列中的消息过期，或者达到最大长度而被删除，或者达到最大空间时而被删除时，可以将这些被删除的信息推送到其他交换机中，让其他消费者订阅这些被删除的消息，处理这些消息

 

  1. public void testBasicPublish() throws IOException, TimeoutException, InterruptedException {

  2. ConnectionFactory factory = new ConnectionFactory();

  3. factory.setHost("127.0.0.1");

  4. factory.setPort(AMQP.PROTOCOL.PORT);

  5. factory.setUsername("mengday");

  6. factory.setPassword("mengday");

  7.  

  8. Connection connection = factory.newConnection();

  9. Channel channel = connection.createChannel();

  10.  

  11. // 声明一个接收被删除的消息的交换机和队列

  12. String EXCHANGE_DEAD_NAME = "exchange.dead";

  13. String QUEUE_DEAD_NAME = "queue_dead";

  14. channel.exchangeDeclare(EXCHANGE_DEAD_NAME, BuiltinExchangeType.DIRECT);

  15. channel.queueDeclare(QUEUE_DEAD_NAME, false, false, false, null);

  16. channel.queueBind(QUEUE_DEAD_NAME, EXCHANGE_DEAD_NAME, "routingkey.dead");

  17.  

  18. String EXCHANGE_NAME = "exchange.fanout";

  19. String QUEUE_NAME = "queue_name";

  20. channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);

  21.  

  22. Map<String, Object> arguments = new HashMap<String, Object>();

  23. arguments.put("x-message-ttl", 15000);

  24. arguments.put("x-max-length", 4);

  25. arguments.put("x-max-length-bytes", 1024);

  26. arguments.put("x-expires", 30000);

  27.  

  28. arguments.put("x-dead-letter-exchange", "exchange.dead");

  29. arguments.put("x-dead-letter-routing-key", "routingkey.dead");

  30. channel.queueDeclare(QUEUE_NAME, true, false, false, arguments);

  31. channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

  32.  

  33. String message = "Hello RabbitMQ: ";

  34. for(int i = 1; i <= 5; i++) {

  35. channel.basicPublish(EXCHANGE_NAME, "", null, (message + i).getBytes("UTF-8"));

  36. }

  37.  
  38.  

  39. channel.close();

  40. connection.close();

  41. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

刚开始由于队列长度是4，总共发送5条消息，所以最早进入队列的消息1将被删除掉，被推送到“死亡队列”中，所以看到普通队列的消息为4条，死亡队列的消息为1条，是消息1 
这里写图片描述

随着时间的流逝，普通队列中的消息都该过期了，所以消息2、3、4、5都被推送到死亡队列，所以死亡队列消息是5条，普通队列的消息条数为0 
这里写图片描述

再随着时间的流逝，普通队列过了指定时间没有被消费者访问，这个队列自动被删除了，所以看不到普通队列了，只有死亡队列 
这里写图片描述

查看死亡队列的消息可以得知，消息一死亡的原因是maxlen达到了最大长度，消息2、3、4、5都是因为生存时间到了导致死亡的 
这里写图片描述 
这里写图片描述

一个比较杂的综合示例

关于消费者就不用代码来获取消息了，直接在RabbitMQ Management点击某个队列的名字，然后Get Message(s) 即可获取

该示例使用很多参数配置，可能实际使用不会像这样用，因为这样好像不太配套。

 

  1. public class Producer {

  2. @Test

  3. public void testBasicPublish() throws IOException, TimeoutException, InterruptedException {

  4. ConnectionFactory factory = new ConnectionFactory();

  5. factory.setHost("127.0.0.1");

  6. factory.setPort(AMQP.PROTOCOL.PORT);

  7. factory.setUsername("mengday");

  8. factory.setPassword("mengday");

  9.  

  10. Connection connection = factory.newConnection();

  11. Channel channel = connection.createChannel();

  12.  

  13. // 声明一个接收被删除的消息的交换机和队列

  14. String EXCHANGE_DEAD_NAME = "exchange.dead";

  15. String QUEUE_DEAD_NAME = "queue_dead";

  16. channel.exchangeDeclare(EXCHANGE_DEAD_NAME, BuiltinExchangeType.DIRECT);

  17. channel.queueDeclare(QUEUE_DEAD_NAME, false, false, false, null);

  18. channel.queueBind(QUEUE_DEAD_NAME, EXCHANGE_DEAD_NAME, "routingkey.dead");

  19.  

  20. String EXCHANGE_NAME = "exchange.fanout";

  21. String QUEUE_NAME = "queue_name";

  22. channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);

  23.  
  24.  

  25. Map<String, Object> arguments = new HashMap<String, Object>();

  26. // 统一设置队列中的所有消息的过期时间

  27. arguments.put("x-message-ttl", 30000);

  28. // 设置超过多少毫秒没有消费者来访问队列，就删除队列的时间

  29. arguments.put("x-expires", 20000);

  30. // 设置队列的最新的N条消息，如果超过N条，前面的消息将从队列中移除掉

  31. arguments.put("x-max-length", 4);

  32. // 设置队列的内容的最大空间，超过该阈值就删除之前的消息

  33. arguments.put("x-max-length-bytes", 1024);

  34. // 将删除的消息推送到指定的交换机，一般x-dead-letter-exchange和x-dead-letter-routing-key需要同时设置

  35. arguments.put("x-dead-letter-exchange", "exchange.dead");

  36. // 将删除的消息推送到指定的交换机对应的路由键

  37. arguments.put("x-dead-letter-routing-key", "routingkey.dead");

  38. // 设置消息的优先级，优先级大的优先被消费

  39. arguments.put("x-max-priority", 10);

  40. channel.queueDeclare(QUEUE_NAME, false, false, false, arguments);

  41. channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

  42.  
  43.  

  44. String message = "Hello RabbitMQ: ";

  45. for(int i = 1; i <= 5; i++) {

  46. // expiration: 设置单条消息的过期时间

  47. AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties().builder().priority(i).expiration( i * 1000 + "");

  48. channel.basicPublish(EXCHANGE_NAME, "", properties.build(), (message + i).getBytes("UTF-8"));

  49. }

  50.  
  51.  

  52. channel.close();

  53. connection.close();

  54. }

  55. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

运行效果

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

奥特曼VS怪兽
关注
专栏目录
RabbitMQ入门教程(十)：队列声明queueDeclare
人不风流枉少年
11-29 4万+
简介本节主要讨论队列声明的各个参数queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments); queue: 队列名称 durable： 是否持久化, 队列的声明默认是存放到内存中的，如果rabbitmq重启会丢失，如果想重启之后还存
rabbitmq配置参数解析在springboot中
天然玩家的博客
04-25 707
我在使用RabbitMQ组件的过程中，一些配置参数，如RabbitMQ连接、发布者、监听者， 这些参数均是抄过来的，并不知道真生的含义， 现打算弄清楚每个参数的含义，为后续的线上遇到问题，调参做准备。 成为调参架构师...
rabbitmq中的queueDeclare方法
诚的博客
04-16 4122
queueDeclare Queue.DeclareOk queueDeclare() throws IOException; /** * Declare a queue * @see com.rabbitmq.client.AMQP.Queue.Declare * @see com.rabbitmq.client.AMQP.Queue.DeclareOk ...
关于rabbitmq报错com.rabbitmq.client.ShutdownSignalException
Z250007275的博客
08-17 576
之前用这一套rabbitmq配置都是好好的，在另一台电脑本地运行的时候突然就报错这个异常： com.rabbitmq.client.ShutdownSignalException: connection error; protocol method: #method(reply-code=530, reply-text=NOT_ALLOWED - vhost / not found, class-id=10, method-id=40)当前配置rabbitmq默认的vho
RabbitMQ(四)：RabbitMQ-queueDeclare
weixin_40805079的博客
01-02 1111
转载地址：https://www.jianshu.com/p/5634a9c71559 声明创建队列 ConnectionFactory connectionFactory = new ConnectionFactory(); /** * 设置ip * port * 用户名 * 密码 ...
RabbitMQ实战篇4-队列(queue)
朱哲的博客
06-10 2775
队列在声明（declare）后才能被使用。如果一个队列尚不存在，声明一个队列会创建它。如果声明的队列已经存在，并且属性完全相同，那么此次声明不会对原有队列产生任何影响。如果声明中的属性与已存队列的属性存在差异，那么一个错误代码为406的通道级异常就会被抛出。队列的属性队列中存储着即将被消费掉的信息，它有如下属性：1、名称2、持久性（消息代理重启后，队列依旧存在）3、独享（只被一个连接（connec...
RabbitMq中queueDeclare()参数小结
lovekjl的博客
09-16 918
通道绑定相应的消息队列函数： queueDeclare(String queue,boolean durable,boolean exclusive,boolean autoDelete,Map<String, Object>arguments) 参数1(String queue):指定队列的名称，如果队列不存在，则会自动创建一个队列，名称为传入的queue； 参数2(booleandruable):定义队列特性是否需要持久化，如果为false，即在下一次启动mq时，队列会被删除。如果为.
RabbitMQ配置参数说明
喜欢新技术的彭英峻
02-21 1762
Spring Boot 整合RabbitMQ环境下的配置参数解释，通过官网文档和网上其他朋友一些文章参考归纳整理而得，有错误之处还请指正~ ★RabbitMQ ★Version: 1.5.13.RELEASE ★属性文件：org.springframework.boot.autoconfigure.amqp.RabbitProperties # base spring.rabbitmq.ho...
rabbitMQ multiple参数
05-16
在 RabbitMQ 中，`multiple` 参数用于批量确认或拒绝多条消息，其具体含义取决于使用该参数的具体 API。一般来说，`multiple` 参数的取值为布尔类型，表示是否确认或拒绝所有比当前消息 delivery tag 小的未确认消息...
RabbitMQ详解
qq_53263107的博客
11-15 3701
说到消息中间件，估计大伙多多少少都能讲出来一些，ActiveMQ、RabbitMQ、RocketMQ、Kafka 等等各种以及 JMS、AMQP 等各种协议，然而这些消息中间件各自都有什么特点，我们在开发中又该选择哪种呢？
rabbitmq控制面板_RabbitMQ控制台详解
weixin_31080131的博客
12-23 818
overview→Totals所有队列的阻塞情况Ready：待消费的消息总数Unacked：待应答的消息总数Total：总数 Ready+UnackedPublish：producter pub消息的速率。Publisher confirm：broker确认pub消息的速率。Deliver(manual ack)：customer手动确认的速率。Deliver( auto ack)：custome...
用两个栈实现一个队列&用两个队列实现一个栈
大鹏小站的博客
07-16 388
思路：栈：先进后出，队列：先进先出 如果转化： 1.将内容先push进一个栈inStack， 2.判断outStack是否为空，空：将栈inStack中的元素pop（删除并返回数组的最后一个元素）并push进outStack，非空：直接出栈 3.出栈时，先push进inStack先从outStack出来，即：实现了先进先出 Stack<Integer> stack1 = new Stack<Integer>(); Stack<Integer> stack2 =
RabbitMQ（十）队列的声明方式
ACGkaka的博客
01-08 1797
RabbitMQ（十）队列的声明方式
RabbitMq学习(2) queueDeclare()/ basicPublish() API详解
IlickCat的博客
06-16 4823
一、queueDeclare(…) queueDeclare()用于实现通道与队列的绑定。它包含5个参数。 String queue: 被绑定的消息队列名，当该消息队列不存在时，将新建该消息队列 Boolean durable: 是否持久化消息队列， 该参数持久化的仅为队列，而不包含队列中的消息 Boolean exclusive: 该通道是否独占该队列 Boolean autoDelete: 消费完成时是否删除队列， 该删除操作在消费者彻底断开连接之后进行。 Map<String, Object&
RabbitMQ管理页面各种属性详解
热门推荐
坑里水库的博客
04-25 4万+
转载：https://www.jianshu.com/p/5413766fa9c5 1 简介 rabbitmq-management是RabbitMq web管理端，用的是erlang的cowboy框架进行开发。web页面包括Overview(概述)、Connections(连接)、Channels(通道)、Exchanges(交换器)、Queues(队列)、Admin(用户管理)。 2 O...
springCloud使用rabbitMq
czm179885的博客
10-13 2968
一.安装rabbitMq 安装rabbitMq(需要安装延时插件)。 二.rabbitMq 使用 1.导入maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2.在application.yml配置文件中加入Ra
php使用rabbitmq声明队列$channel-＞queue_declare($config[‘queue_name‘], false, true, false, false)；中各参数的含义
最新发布
wutao1993的博客
09-20 435
这里设置为 `false`，意味着队列是非持久化的，RabbitMQ 服务重启后队列将会丢失。如果设置为 `true`，则不会创建队列，而是检查队列是否存在。总结起来，这段代码的意义是声明一个非持久化、排他性的队列，该队列不会因为消费者取消订阅而自动删除，并且如果队列不存在则会创建它。如果设置为 `true`，则队列只允许当前连接访问，并且在连接关闭时会自动删除队列。- `false` (auto_delete): 第四个参数表示当最后一个消费者取消订阅时，队列是否应该自动删除。
消息中间件入门篇之 RabbitMQ 的 queue详解
李昊轩的博客
07-23 1002
queueDeclare queueDeclare 有两个重载方法 Queue.DeclareOk queueDec1are() throws IOException; 第一种不带任何参数的queueDeclare 方法默认创建一个由RabbitMQ 命名的(类似这种amq.gen-LhQzlgv3GhDOv8PIDabOXA 名称，这种队列也称之为匿名队列〉、排他的、自动删除的、非持久化的队列。 Queue.DeclareOk queueDeclare (String queue , boolea
学习RabbitMQ（三）
weixin_51966377的博客
03-05 2015
1、交换机 假设工作队列背后，每个任务都恰好交付给一个消费者（工作进程）。在这一部分，我们将消息传达给多个消费者。这种模式称为“发布/订阅模式”。 1.1、Exchanges 1.1.1、Exchanges概念 RabbitMQ 消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递到了哪些队列中。 相反，生产者只能将消息发送到交换机（exchange），交换机工作的内容非常简单，一方面它接收来自生产者的消息，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值