RabbitMQ延迟队列简单示例

最新推荐文章于 2022-12-24 16:08:36 发布
最新推荐文章于 2022-12-24 16:08:36 发布
阅读量228 收藏 1
点赞数
文章标签： 大数据 java
原文链接：http://www.cnblogs.com/gjb724332682/p/11407296.html
版权
简介
延迟队列存储的消息是不希望被消费者立刻拿到的，而是等待特定时间后，消费者才能拿到这个消息进行消费。使用场景比较多，例如订单限时30分钟内支付，否则取消，再如分布式环境中每隔一段时间重复执行某操作。
下面举一个简单的例子，例子大概意思是分别在首次发送消息后的10秒、40秒、100秒后重新读取到消息。为了直观，不使用RabbitMQ其他多余的特性。
 
准备工作
在Centos7下安装RabbitMQ，版本为3.6.12单机版本（非集群），IP是127.0.0.1，端口是15672，使用web管理页面或者rabbitmqctl提前准备好相关的用户、exchange和queue。
用户有producer（密码同用户名）、consumer（密码同用户名）。
Default exchange是RabbitMQ预定义的，名称为空字符串，自动绑定到每个queue，类型为direct， routingKey等于queue的名称。
三个死信交换器（队列中的消息过期后会被发送到该队列的死信交换器）10sDeadLetterExchange、30sDeadLetterExchange、60sDeadLetterExchange。
三个死信队列，10sDeadLetterQueue、30sDeadLetterQueue、60sDeadLetterQueue分别与三个死信交换器绑定。
三个队列，10sDelayQueue、30sDelayQueue、60sDelayQueue，分别设置过期时间为10秒、30秒、60秒，并设置对应的死信交换器。
 
示例
使用java代码创建一个生产者和三个消费者。生产者往Default exchange发送消息， routingKey为10sDelayQueue。三个消费者分别订阅三个死信队列。先启动三个消费者，再启动生产者。消费者会持续订阅死信队列，需要手动关闭连接。
 
RabbitMQ10sDeadLetterQueueConsumer消费者代码如下：
import com.rabbitmq.client.*;
 
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeoutException;
 
public class RabbitMQ10sDeadLetterQueueConsumer {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("consumer");
connectionFactory.setPassword("consumer");
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(15672);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
channel.basicQos(64);
channel.basicConsume("10sDeadLetterQueue", false, UUID.randomUUID().toString(),
new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("第一次重试时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
System.out.println("consumerTag:" + consumerTag);
System.out.println("envelope:" + envelope.toString());
System.out.println("basicProperties:" + properties.toString());
System.out.println("message:" + new String(body, "utf-8"));
channel.basicAck(envelope.getDeliveryTag(), false);
 
channel.basicPublish("", "30sDelayQueue",
new AMQP.BasicProperties().builder().deliveryMode(2).build(),
body);
}
});
}
}
 
RabbitMQ30sDeadLetterQueueConsumer消费者代码如下：
import com.rabbitmq.client.*;
 
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeoutException;
 
public class RabbitMQ30sDeadLetterQueueConsumer {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("consumer");
connectionFactory.setPassword("consumer");
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(15672);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
channel.basicQos(64);
channel.basicConsume("30sDeadLetterQueue", false, UUID.randomUUID().toString(),
new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("第二次重试时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
System.out.println("consumerTag:" + consumerTag);
System.out.println("envelope:" + envelope.toString());
System.out.println("basicProperties:" + properties.toString());
System.out.println("message:" + new String(body, "utf-8"));
channel.basicAck(envelope.getDeliveryTag(), false);
 
channel.basicPublish("", "60sDelayQueue",
new AMQP.BasicProperties().builder().deliveryMode(2).build(),
body);
}
});
}
}
 
RabbitMQ60sDeadLetterQueueConsumer消费者代码如下：
import com.rabbitmq.client.*;
 
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeoutException;
 
public class RabbitMQ60sDeadLetterQueueConsumer {
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("consumer");
connectionFactory.setPassword("consumer");
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(15672);
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
channel.basicQos(64);
channel.basicConsume("60sDeadLetterQueue", false, UUID.randomUUID().toString(),
new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("第三次重试时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
System.out.println("consumerTag:" + consumerTag);
System.out.println("envelope:" + envelope.toString());
System.out.println("basicProperties:" + properties.toString());
System.out.println("message:" + new String(body, "utf-8"));
channel.basicAck(envelope.getDeliveryTag(), false);
System.out.println("执行完成");
}
});
}
}
 
生产者代码如下：
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
 
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeoutException;
 
public class RabbitMQDelayQueueProducer {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = null;
Channel channel = null;
try {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("producer");
connectionFactory.setPassword("producer");
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(15672);
connection = connectionFactory.newConnection();
channel = connection.createChannel();
channel.basicPublish("", "10sDelayQueue",
new AMQP.BasicProperties().builder().deliveryMode(2).build(),
("测试延迟队列" + UUID.randomUUID().toString()).getBytes("utf-8"));
System.out.println("发送时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
} finally {
if (channel != null) {
channel.close();
}
if (connection != null) {
connection.close();
}
}
}
}
 
生产者打印：
发送时间：2019-08-25 10:08:29
 
RabbitMQ10sDeadLetterQueueConsumer消费者打印：
第一次重试时间：2019-08-25 10:08:39
consumerTag:83787685-28a9-4ae8-b2bc-b89b90f14b68
envelope:Envelope(deliveryTag=1, redeliver=false, exchange=10sDeadLetterExchange, routingKey=10sDelayQueue)
basicProperties:#contentHeader<basic>(content-type=null, content-encoding=null, headers={x-death=[{reason=expired, count=1, exchange=, time=Sun Aug 25 10:08:37 CST 2019, routing-keys=[10sDelayQueue], queue=10sDelayQueue}]}, delivery-mode=2, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=null, timestamp=null, type=null, user-id=null, app-id=null, cluster-id=null)
message:测试延迟队列f862c616-a99a-4b65-9482-d74d5aee0814
 
RabbitMQ30sDeadLetterQueueConsumer消费者打印：
第二次重试时间：2019-08-25 10:09:09
consumerTag:27bb0e0e-07fe-49b6-8c0f-06fbc32cd784
envelope:Envelope(deliveryTag=1, redeliver=false, exchange=30sDeadLetterExchange, routingKey=30sDelayQueue)
basicProperties:#contentHeader<basic>(content-type=null, content-encoding=null, headers={x-death=[{reason=expired, count=1, exchange=, time=Sun Aug 25 10:09:07 CST 2019, routing-keys=[30sDelayQueue], queue=30sDelayQueue}]}, delivery-mode=2, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=null, timestamp=null, type=null, user-id=null, app-id=null, cluster-id=null)
message:测试延迟队列f862c616-a99a-4b65-9482-d74d5aee0814
 
RabbitMQ60sDeadLetterQueueConsumer消费者打印：
第三次重试时间：2019-08-25 10:10:09
consumerTag:8bfdc795-443d-4940-bf88-1e6f14e7b530
envelope:Envelope(deliveryTag=1, redeliver=false, exchange=60sDeadLetterExchange, routingKey=60sDelayQueue)
basicProperties:#contentHeader<basic>(content-type=null, content-encoding=null, headers={x-death=[{reason=expired, count=1, exchange=, time=Sun Aug 25 10:10:07 CST 2019, routing-keys=[60sDelayQueue], queue=60sDelayQueue}]}, delivery-mode=2, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=null, timestamp=null, type=null, user-id=null, app-id=null, cluster-id=null)
message:测试延迟队列f862c616-a99a-4b65-9482-d74d5aee0814
执行完成

转载于:https://www.cnblogs.com/gjb724332682/p/11407296.html

weixin_30295091
关注
Spring Boot与RabbitMQ结合实现延迟队列的示例
08-28
Spring Boot与RabbitMQ结合实现延迟队列的示例 本资源摘要信息主要介绍了如何使用Spring Boot与RabbitMQ结合实现延迟队列的示例，包括延迟队列的定义、应用场景、实现思路、流程图、代码实现等方面的内容。 延迟...
RabbitMQ延时消息队列
小羊的博客
06-11 5646
RabbitMQ延时消息队列
rabbitmq延迟队列案例
weixin_45608102的博客
09-24 422
rabbitmq延迟队列
rabbitmq延时队列示例
赵树祥的博客
06-30 365
rabbitmq 本身不支持延迟队列，但提供了实现延迟队列的必备条件。 原理 queue可以通过x-message-ttl参数设置过期时间，到了过期时间的消息就会被标记为dead letter状态。 过期的消息可以通过x-dead-letter-exchange和x-dead-letter-routing-key参数转发到另一个exchange中去。 在management 中测试延迟队列 docker 部署测试rabbitmq 如果已经有现成的rabbitmq，本小节跳过。 ...
RabbitMq——延迟队列（基于延迟交换机实现）
weixin_50616848的博客
03-19 3312
延迟队列可以通过设置生产者发送设置有ttl时间的信息给队列来实现，但这种方式中的消息可能不会按时成为死信，而且rabbitmq每次只能检测第一个消息是否过期，如果过期就丢入死信队列，第一个消息延迟时间很长，第二个消息延迟时间很短，第二个消息并不会先执行。 如：若先发一个ttl为40s的消息，然后发一个ttl为10s的消息，ttl为10s的消息并不会先被执行，而是要等ttl为40s的消息消费完后，再消费ttl为10s的消息。 延迟交换机：类型为：x-delayed-message，消息发送给延迟交换机，交
【RabbitMq04】延迟队列
weixin_40964170的博客
07-29 2248
一、延迟队列理解 1、延迟队列概念 延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列 延迟队列，就是死信队列中，TTL消息过期的一种 举例 如死信队列文章中所讲，消费者1启动后，在rabbitmq控制台生成正常队列和死信队列后就又关闭了，然后开启生产者给消费者1发送消息，因为消费者1中设置了TTL消息过期机制，所以等了10秒种消息就自动进入到死信队列了，消息被消费者2接
rabbitMQ延迟队列
03-15
RabbitMQ延迟队列是一种特殊类型的队列，它允许消息在特定时间后才被消费者处理，而不是立即处理。这种功能在某些业务场景下非常有用，例如订单超时处理、定时发送邮件或短信通知等。在RabbitMQ中，实现延迟队列通常...
C#实现rabbitmq 延迟队列功能实例代码
08-30
RabbitMQ 延迟队列功能实例代码 本文将介绍如何使用 C# 实现 RabbitMQ 延迟队列功能，利用 RabbitMQ 的 TTL（Time To Live）和 DLX（Dead Letter Exchanges）特性来实现延迟队列。延迟队列是指消息在队列中的存活...
RabbitMQ简单队列实例及原理解析
08-25
RabbitMQ 简单队列实例及原理解析 RabbitMQ 是一个消息代理系统，它接受并转发消息。在这个系统中，队列起着非常重要的角色，队列可以存储消息，并将其传递给消费者。生产者将消息发送给队列，而消费者则从队列中...
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
RabbitMQ——延迟队列
weixin_67465673的博客
12-24 2297
采取定时任务轮训数据库订单，并且批量处理。其弊端也是显而易见的；对服务器、数据库性会有很大的要求，并且当处理大量订单起来会很力不从心,而且实时性也不是特别好。当然传统的手法还可以再优化一下，即存入订单的时候就算出订单的过期时间插入数据库，设置定时任务查询数据库的时候就只需要查询过期了的订单，然后再做其他的业务操作。
rabbitMq实现延迟队列
zhiyikeji的博客
12-07 9366
业务场景： 1.生成订单30分钟未支付，则自动取消，我们该怎么实现呢？ 2.生成订单60秒后,给用户发短信 1 安装rabbitMq windows安装 ubuntu中安装 2 添加maven依赖 <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-amqp --> <dependency> <groupId&
RabbitMQ学习笔记：RabbitMQ延迟队列(DLX、TTL及rabbitmq_delayed_message_exchange插件)
热门推荐
OceanSky的专栏
01-03 1万+
延迟队列存储的对象是对应的延迟消息，所谓的延迟消息是指当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费。 延迟消息使用的场景有很多，比如： 在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行异常处理，这时候就可以使用延迟队列来处理这些订单了。 用户希望通过手机远程遥控家里的智能设备在指定...
RabbitMQ自学之路（九）——RabbitMQ实现延时队列的两种方式
互联网叫兽
06-29 9250
一、什么是延时队列 延时队列顾名思义，即放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。 二、延时队列应用于什么场景 场景一：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行一场处理。这是就可以使用延时队列将订单信息发送到延时队列。 场景二：用户希望通过手机远程遥控家里的智能设备在指定的时间进行工作。这时候就可以将...
实战：SpringBoot集成rabbitmq并实现延时队列
快速成长的小菜鸟
07-06 1461
集成rabbitmq 前言 消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题 实现高性能，高可用，可伸缩和最终一致性架构。RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息，具有较高的系统吞吐量、可靠性、消息持久化、免费等优点，在软件项目中具有非常广泛的应用。 项目介绍 本项目以springboot集成rabbitmq,引导如何设计和优雅地集成rabbitmq相关的组件，并实现用死信队列实现延迟消息队列。 项目设计与实战 配置 maven依赖 <pare
RabbitMQ实现延时队列
Er_vel的博客
01-24 3644
       首先我先介绍一下延时队列的应用场景，延迟队列存储的对象是对应的延迟消息，所谓"延迟消息"是指当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费。        延迟队列的使用场景有很多，比如:              在订单系统中， 个用户下单之后通常有 分钟的时间进行支付，如果 30 分钟之内没有支付成功，那么这个订单将进行异常处...
RabbitMQ实现延时队列Demo
weixin_43794897的博客
04-26 1065
本Demo的原理就是：将死信队列倒着用，然后实现延时队列 简单的配置文件： spring: rabbitmq: virtual-host: / addresses: localhost username: guest password: guest port: 5672 application: name: consumer-01 配置Ra...
RabbitMQ延迟队列实现
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
07-11 1296
1) 生产者生产一条延迟消息，根据延迟时间的不同，利用不同的routing-key将消息路由到不同的延迟队列，每个队列都设置了不同的 TTL 属性 ( TTL ( Time To Live ) 生存时间 )，并绑定到同一个死信交换机中。 2) 消息过期后，根据routing-key的不同，又会被死信交换机路由到不同的死信队列中，消费者只需要监听对应的死信队列进行消费即可。......
rabbitmq延迟队列定时发送
最新发布
04-04
RabbitMQ延迟队列可以用于定时发送消息。在RabbitMQ中，延迟队列是通过设置消息的过期时间来实现的。在发送消息时，可以指定消息的过期时间，当消息过期时，RabbitMQ会将消息发送到指定的队列。 以下是设置RabbitMQ延迟队列定时发送消息的步骤： 1. 创建一个普通队列，用于存储延迟消息。 2. 创建一个交换机，用于将延迟消息发送到延迟队列中。 3. 创建一个延迟队列，将其绑定到交换机上。 4. 发送消息时，设置消息的过期时间，并将消息发送到交换机。 5. 当消息过期时，RabbitMQ会将消息发送到延迟队列中。 6. 消费延迟队列中的消息。 以下是使用Java代码设置RabbitMQ延迟队列定时发送消息的示例： ``` ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); // 创建普通队列 channel.queueDeclare("my-queue", false, false, false, null); // 创建交换机 channel.exchangeDeclare("my-exchange", "direct"); // 创建延迟队列 Map<String, Object> args = new HashMap<>(); args.put("x-message-ttl", 10000); // 设置延迟时间为10秒 args.put("x-dead-letter-exchange", "my-exchange"); // 设置延迟消息发送到的交换机 channel.queueDeclare("my-delay-queue", false, false, false, args); // 将延迟队列绑定到交换机上 channel.queueBind("my-delay-queue", "my-exchange", ""); // 发送消息并设置过期时间 String message = "Hello, RabbitMQ!"; AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder() .expiration("10000") // 设置过期时间为10秒 .build(); channel.basicPublish("my-exchange", "", properties, message.getBytes()); // 消费延迟队列中的消息 channel.basicConsume("my-delay-queue", true, new DefaultConsumer(channel) { @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { String message = new String(body, "UTF-8"); System.out.println("Received message: " + message); } }); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值