package com.momo.tplusapi.rabbitmq; import org.springframework.amqp.core.; import…
- User
package com.momo.tplusapi.rabbitmq; import org.springframework.amqp.core.*; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;
import java.util.HashMap; import java.util.Map;
/**
-
@author: mo
-
@description: TODO
-
@date: 2025/6/29 14:00
-
@version: 2.0 */ @Configuration public class OrderRabbitConfig {
// ================== 常量定义:按功能分组 ==================
public static final class Exchanges { public static final String ORDER = "order.event.exchange"; public static final String DLX = "order.dlx.exchange"; public static final String DELAY = "order.delay.exchange"; public static final String XDELAYED = "order.xdelayed.exchange"; }
public static final class Queues { // 主业务队列 public static final String SALE_ORDER = "order.sale.queue"; public static final String SALE_DELIVERY = "order.delivery.queue";
// 死信队列 public static final String SALE_ORDER_DLX = "order.sale.dlx.queue"; public static final String SALE_DELIVERY_DLX = "order.delivery.dlx.queue"; // TTL延迟队列 public static final String SALE_ORDER_DELAY = "order.sale.delay.queue"; public static final String SALE_DELIVERY_DELAY = "order.delivery.delay.queue"; // 插件延迟队列 public static final String SALE_ORDER_XDELAYED = "order.sale.xdelayed.queue"; public static final String SALE_DELIVERY_XDELAYED = "order.delivery.xdelayed.queue";}
public static final class RoutingKeys { // 主业务路由 Key public static final String SALE_ORDER = "order.sale.#"; public static final String SALE_DELIVERY = "order.delivery.#";
// 死信路由 Key public static final String SALE_ORDER_DLX = "order.sale.dlx"; public static final String SALE_DELIVERY_DLX = "order.delivery.dlx"; // TTL延迟路由 Key public static final String SALE_ORDER_DELAY = "order.sale.delay"; public static final String SALE_DELIVERY_DELAY = "order.delivery.delay"; // 插件延迟路由 Key public static final String SALE_ORDER_XDELAYED = "order.sale.xdelayed"; public static final String SALE_DELIVERY_XDELAYED = "order.delivery.xdelayed";}
private int x_message_ttl = 30000; // 默认30秒
// ================== Exchange Definitions ==================
@Bean public TopicExchange orderExchange() { return new TopicExchange(Exchanges.ORDER, true, false); }
@Bean public TopicExchange dlxExchange() { return new TopicExchange(Exchanges.DLX, true, false); }
@Bean public TopicExchange orderDelayExchange() { return new TopicExchange(Exchanges.DELAY, true, false); }
@Bean public CustomExchange orderXdelayedExchange() { Map<String, Object> args = new HashMap<>(); args.put("x-delayed-type", "topic"); return new CustomExchange(Exchanges.XDELAYED, "x-delayed-message", true, false, args); }
// ================== Queue Definitions ==================
@Bean public Queue saleOrderQueue() { return new Queue(Queues.SALE_ORDER, true, false, false, Map.of( "x-dead-letter-exchange", Exchanges.DLX, "x-dead-letter-routing-key", RoutingKeys.SALE_ORDER_DLX )); }
@Bean public Queue saleDeliveryQueue() { return new Queue(Queues.SALE_DELIVERY, true, false, false, Map.of( "x-dead-letter-exchange", Exchanges.DLX, "x-dead-letter-routing-key", RoutingKeys.SALE_DELIVERY_DLX )); }
@Bean public Queue saleOrderDelayQueue() { return new Queue(Queues.SALE_ORDER_DELAY, true, false, false, Map.of( "x-dead-letter-exchange", Exchanges.ORDER, "x-dead-letter-routing-key", "order.sale.retry", "x-message-ttl", x_message_ttl )); }
@Bean public Queue saleDeliveryDelayQueue() { return new Queue(Queues.SALE_DELIVERY_DELAY, true, false, false, Map.of( "x-dead-letter-exchange", Exchanges.ORDER, "x-dead-letter-routing-key", "order.delivery.retry", "x-message-ttl", x_message_ttl )); }
@Bean public Queue saleOrderDlxQueue() { return new Queue(Queues.SALE_ORDER_DLX, true); }
@Bean public Queue saleDeliveryDlxQueue() { return new Queue(Queues.SALE_DELIVERY_DLX, true); }
@Bean public Queue saleOrderXdelayedQueue() { return new Queue(Queues.SALE_ORDER_XDELAYED, true); }
@Bean public Queue saleDeliveryXdelayedQueue() { return new Queue(Queues.SALE_DELIVERY_XDELAYED, true); }
// ================== Binding Definitions ==================
@Bean public Binding saleOrderBinding() { return BindingBuilder.bind(saleOrderQueue()).to(orderExchange()).with(RoutingKeys.SALE_ORDER); }
@Bean public Binding saleDeliveryBinding() { return BindingBuilder.bind(saleDeliveryQueue()).to(orderExchange()).with(RoutingKeys.SALE_DELIVERY); }
@Bean public Binding saleOrderDlxBinding() { return BindingBuilder.bind(saleOrderDlxQueue()).to(dlxExchange()).with(RoutingKeys.SALE_ORDER_DLX); }
@Bean public Binding saleDeliveryDlxBinding() { return BindingBuilder.bind(saleDeliveryDlxQueue()).to(dlxExchange()).with(RoutingKeys.SALE_DELIVERY_DLX); }
@Bean public Binding saleOrderDelayBinding() { return BindingBuilder.bind(saleOrderDelayQueue()).to(orderDelayExchange()).with(RoutingKeys.SALE_ORDER_DELAY); }
@Bean public Binding saleDeliveryDelayBinding() { return BindingBuilder.bind(saleDeliveryDelayQueue()).to(orderDelayExchange()).with(RoutingKeys.SALE_DELIVERY_DELAY); }
@Bean public Binding saleOrderXdelayedBinding() { return BindingBuilder.bind(saleOrderXdelayedQueue()) .to(orderXdelayedExchange()) .with(RoutingKeys.SALE_ORDER_XDELAYED) .noargs(); }
@Bean public Binding saleDeliveryXdelayedBinding() { return BindingBuilder.bind(saleDeliveryXdelayedQueue()) .to(orderXdelayedExchange()) .with(RoutingKeys.SALE_DELIVERY_XDELAYED) .noargs(); } }
这个是不是只是表示对列是durable,并不是表示消息是durable?
-
Assistant
是的,你的理解是正确的。
在 RabbitMQ 中,
durable属性是指队列(Queue)是否是持久化的。如果一个队列是持久化的,那么它将在 RabbitMQ 服务器重启后仍然存在。但是,这并不意味着消息(Message)也是持久化的。消息的持久化是通过
persistent属性来控制的,当你发送一个消息时,可以指定该消息是否是持久化的。如果一个消息是持久化的,那么它将被写入磁盘,否则它将只存在于内存中。在你的代码中,队列是通过
new Queue(Queues.SALE_ORDER, true, false, false, ...)创建的,其中true表示队列是持久化的。但是,这并不意味着发送到该队列的消息也是持久化的。要使消息持久化,你需要在发送消息时指定
MessageProperties的deliveryMode属性为2,例如:MessageProperties properties = new MessageProperties(); properties.setDeliveryMode(2); // 2 表示持久化然后,你可以使用
RabbitTemplate发送消息:RabbitTemplate template = new RabbitTemplate(); template.convertAndSend("order.sale.queue", "Hello, World!", properties);这样,消息将被持久化到磁盘中,即使 RabbitMQ 服务器重启,消息也将仍然存在。
- User
我的疑问是,如果消息不是durable的,是不是表示消息发送出去后,就算没有任何消费者,这个消息也会在对列中消失。
Assistant
如果消息不是持久化的(
deliveryMode为 1),那么当 RabbitMQ 服务器重启或队列被删除时,消息将会丢失。但是,如果消息发送出去后,没有任何消费者消费它,即使消息不是持久化的,消息也不会立即消失。消息将会留在队列中,直到以下情况发生:
- 消息被消费者消费。
- 消息过期(如果设置了 TTL)。
- 队列被删除。
- RabbitMQ 服务器重启(非持久化消息将丢失)。
所以,即使消息不是持久化的,它也不会因为没有消费者而立即消失。它将会留在队列中,直到被消费、过期、队列被删除或 RabbitMQ 服务器重启。
但需要注意的是,如果 RabbitMQ 服务器重启,非持久化消息将会丢失。如果你希望消息在服务器重启后仍然存在,你应该使用持久化消息(
deliveryMode为 2)。- User
@Test public void sendOrderMessage() throws JsonProcessingException {
String orgId="1233705141350698"; String voucherCode="SA-2025-05-30-00-020"; OrderEventType eventType=OrderEventType.SaleDelivery_Update; OrderEventMessage event = new OrderEventMessage(); event.setEventType(eventType.name()); event.setOrgId(orgId); event.setVoucherCode(voucherCode); event.setEventTime(LocalDateTime.now().toString()); rabbitTemplate.convertAndSend(OrderRabbitConfig.Exchanges.ORDER, getRoutingKey(eventType), event); }为什么我这样发送过去后,过一会,任务就消失了。
Assistant
根据你的代码,消息发送到 RabbitMQ 的
ORDER交换机中,使用了convertAndSend方法。这个方法会自动将 Java 对象转换为 JSON 格式的字符串,然后发送到 RabbitMQ 中。但是,你没有指定消息的
deliveryMode属性,这意味着消息默认为非持久化的(deliveryMode为 1)。在你的
OrderRabbitConfig类中,你定义了队列时,使用了new Queue(Queues.SALE_ORDER, true, false, false, ...),其中true表示队列是持久化的。但是,这只表示队列本身是持久化的,而不是消息。由于消息是非持久化的,当 RabbitMQ 服务器重启或队列被删除时,消息将会丢失。但是,在你的情况中,消息发送后过一会就消失了,这可能是因为消息被认为是“未确认”的(unacknowledged)。
当消息被发送到队列中,但没有被消费者确认(acknowledged)时,RabbitMQ 会认为消息是未确认的。如果队列中有未确认的消息,RabbitMQ 会在一段时间后(默认为 30 分钟)自动将这些消息从队列中删除。
为了避免这种情况,你可以在发送消息时指定
deliveryMode为 2(持久化),或者在消费者中确认消息(acknowledged)。你可以尝试修改你的发送代码为:
MessageProperties properties = new MessageProperties(); properties.setDeliveryMode(2); // 持久化 rabbitTemplate.convertAndSend(OrderRabbitConfig.Exchanges.ORDER, getRoutingKey(eventType), event, properties);或者,你可以在消费者中确认消息:
@RabbitListener(queues = OrderRabbitConfig.Queues.SALE_ORDER) public void handleOrderMessage(OrderEventMessage event, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) throws IOException { // 处理消息 channel.basicAck(deliveryTag, false); // 确认消息 }这样,消息将被持久化到队列中,即使没有被消费者确认,也不会被自动删除。
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.