springboot集成rabbitmq死信队列的延时队列使用

最新推荐文章于 2024-06-28 09:57:49 发布
最新推荐文章于 2024-06-28 09:57:49 发布
阅读量230 收藏
点赞数
分类专栏： java 文章标签： rabbitmq spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqtbqq/article/details/118415480
版权

目录

        1、自动分列延时队列

        2、应答失败自动转储延时再通知机制

-------------------------------------------------------------------------------------------------------------------------------

一、自动分列延时队列

根据消息延时时间自动按D（天）、H（时）、M（分）、S（秒）各粒度进行自动建立队列及发送到对应的延时队列中，降低不同时间长度的延时队列做队列再延时的频率。

例如38天的延时消息会自动发送到20天时长队列（D20）中，20天后自动发送到10天时长队列（D10）中,10天后还剩8天就会自动发到1天时长队列中，一天后继续发到1天时长队列中，直到小于1天再按时、分、秒的粒度一次转发到对应的延时队列。

这样的动态粒度控制可以

1、避免粒度太小转发频率变大，队列转发损耗太大，单队列累积数量太多

2、粒度太大，最后的接收处理消息时间节点出现较大误差

当前设置的粒度为D20，D10，D1，H20，H10，H1，M40，M20，M10，S40，S20，S10，S9，S8，S7，S6，S5，S4，S3，S2，S1。可以看到这里10秒以后的延时都是每个一秒有一个对应的时长队列，主要是考虑到如果设置的延时消息是秒级，那么说明消息对延时时间敏感，那么每一次消息交换消耗的时间都是影响较大的，这里如果S10后就设置一个S1的那么如果8秒的就要转换8次，损耗太大，而有了S8那么就直接入S8等待8s后直接消费就行了。

其中的粒度可以根据实际情况自己配置。

代码如下：

1、固定队列配置类

package com.tb.app.configurer.mq.rabbit.producer;

import java.util.HashMap;
import java.util.Map;

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.amqp.core.QueueBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 延时消息队列-扩展
 * @author tangbin
 * @date 2021年6月18日
 */
@Configuration
public class RabbitmqProducerDelayExtendsConfig {
	
	/**
	 * =========中转消费队列
	 */
	public final static String DELAY_EXTENDS_XF_TRANS_QUEUE = "delay_extends_xf_trans_queue";
	public final static String DELAY_EXTENDS_XF_TRANS_EXCHANGE = "delay_extends_xf_trans_exchange";
    public final static String DELAY_EXTENDS_XF_TRANS_ROUTING = "delay_extends_xf_trans_routing";
	/**
	 * =========最终消费队列
	 */
	public final static String DELAY_EXTENDS_XF_FINAL_QUEUE = "delay_extends_xf_final_queue";
	public final static String DELAY_EXTENDS_XF_FINAL_EXCHANGE = "delay_extends_xf_final_exchange";
    public final static String DELAY_EXTENDS_XF_FINAL_ROUTING = "delay_extends_xf_final_routing";
    
	/**
	 * =========死信队列
	 */
	public final static String DELAY_EXTENDS_DEAD_QUEUE = "delay_extends_dead_queue";
	public final static String DELAY_EXTENDS_DEAD_EXCHANGE = "delay_extends_dead_exchange";
    public final static String DELAY_EXTENDS_DEAD_ROUTING = "delay_extends_dead_routing";
 
    /**
     * =========最终消费队列中应答失败消息转储队列
     */
	public final static String DELAY_EXTENDS_XF_FINAL_ACKFAIL_QUEUE = "delay_extends_xf_final_ackfail_queue";
    public final static String DELAY_EXTENDS_XF_FINAL_ACKFAIL_ROUTING = "delay_extends_xf_final_ackfail_routing";
    public final static String DELAY_EXTENDS_XF_FINAL_ACKFAIL_EXCHANGE = "delay_extends_xf_final_ackfail_exchange";
	

    /**
     * 中转消费队列
     * @return
     */
    @Bean
    public Queue xfTransQueue(){
        return new Queue(DELAY_EXTENDS_XF_TRANS_QUEUE);
    }

    /**
     * 中转消费交换机
     * @return
     */
    @Bean
    public DirectExchange xfTransExchange(){
        return new DirectExchange(DELAY_EXTENDS_XF_TRANS_EXCHANGE);
    }
 
    /**
     * 绑定 中转消费队列和交换机
     * @return
     */
    @Bean
    public Binding bindingXfTrans(){
        return BindingBuilder.bind(xfTransQueue()).to(xfTransExchange()).with(DELAY_EXTENDS_XF_TRANS_ROUTING);
    }

    //====================================================================================================================
    
    /**
     * 最终消费队列
     * 
     * 如果应答失败转储到 “最终消费应答失败转储队列”
     * 
     * @return
     */
    @Bean
    public Queue xfFinalQueue(){
    	
        Map<String,Object> args = new HashMap<>();
        //指定过期消息跳转的交换器名称
        args.put("x-dead-letter-exchange",DELAY_EXTENDS_XF_FINAL_ACKFAIL_EXCHANGE);
        //指定跳转消息携带的roting-key
        args.put("x-dead-letter-routing-key",DELAY_EXTENDS_XF_FINAL_ACKFAIL_ROUTING);
        
        return QueueBuilder.durable(DELAY_EXTENDS_XF_FINAL_QUEUE).withArguments(args).build();
    }

    /**
     * 最终消费交换机
     * @return
     */
    @Bean
    public DirectExchange xfFinalExchange(){
        return new DirectExchange(DELAY_EXTENDS_XF_FINAL_EXCHANGE);
    }
 
    /**
     * 绑定 最终消费队列和交换机
     * @return
     */
    @Bean
    public Binding bindingXfFinal(){
        return BindingBuilder.bind(xfFinalQueue()).to(xfFinalExchange()).with(DELAY_EXTENDS_XF_FINAL_ROUTING);
    }
    
    //==============================================================================================================
    
    /**
     * 最终消费应答失败转储队列
     * 
     * 超过5分钟后自动再次下发到最终消费队列进行处理
     * 
     * @return
     */
    @Bean
    public Queue xfFinalACKFailQueue(){
    	
        Map<String,Object> args = new HashMap<>();
        //指定过期时间
        args.put("x-message-ttl", 5*60*1000);
        //指定过期消息跳转的交换器名称
        args.put("x-dead-letter-exchange",DELAY_EXTENDS_XF_FINAL_EXCHANGE);
        //指定跳转消息携带的roting-key
        args.put("x-dead-letter-routing-key",DELAY_EXTENDS_XF_FINAL_ROUTING);
        
        return QueueBuilder.durable(DELAY_EXTENDS_XF_FINAL_ACKFAIL_QUEUE).withArguments(args).build();
    	
    }

    /**
     * 最终消费应答失败转储交换机
     * @return
     */
    @Bean
    public DirectExchange xfFinalACKFailExchange(){
        return new DirectExchange(DELAY_EXTENDS_XF_FINAL_ACKFAIL_EXCHANGE);
    }
 
    /**
     * 绑定 最终消费应答失败转储 队列和交换机
     * @return
     */
    @Bean
    public Binding bindingXfFinalACKFail(){
        return BindingBuilder.bind(xfFinalACKFailQueue()).to(xfFinalACKFailExchange()).with(DELAY_EXTENDS_XF_FINAL_ACKFAIL_ROUTING);
    }
}

这个类中定义了

1、中转队列（对阶段性延时队列到期做再延时中转的队列）

2、最终消费队列（最终延时结束，即到达设置的消息延时时间后的消息队列）

3、最终消费应答失败转储队列（用于应答失败消息的转储，避免消息丢失及消息堵塞）

4、动态创建死信队列（这个类只是定义了死信队列的共同名字属性，队列的创建在另一个类）

2、动态死信队列消息发送及创建类

package com.tb.app.configurer.mq.rabbit.producer;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import org.springframework.amqp.rabbit.connection.Connection;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.google.common.collect.Maps;
import com.rabbitmq.client.Channel;
import com.tb.app.common.exception.ServiceException;

import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONObject;


/**
 * 延时消息队列-扩展版
 * @author tangbin
 * @date 2021年6月18日
 */
@Component
@Slf4j
public class RabbitmqProducerDelayExtendsFactory{

	@Autowired
    RabbitTemplate rabbitTemplate;

	/**
	 * 
	 * 发送延时消息
	 * 
	 * @param sendDate 发消息的时间点的时间戳
	 * @param timeDelay 延时时间，单位毫秒，最大不能超过4294967295（49.710269618055555天）
	 * @param message 消息内容
	 * @param sendName 发送者描述
	 * @throws Exception
	 */
	public void sendDelayMessage(Long sendDateTimestamp,Long timeDelay,String sendName,JSONObject message){
		
		//计算过时时间节点
		sendDateTimestamp = Optional.ofNullable(sendDateTimestamp).orElseGet(()->new Date().getTime());
		Long endDateTime = sendDateTimestamp+timeDelay;
		
		//计算当前还剩余的过时时间
		Long newTimeDelay = endDateTime - new Date().getTime();
		/**
		 * 消费队列指定
		 */
		//默认中转消费队列
		String DEXE = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_TRANS_EXCHANGE;
		String DEXR = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_TRANS_ROUTING;
		//判断时间
		if (newTimeDelay < 10000) {
			//时间在10秒以内，指定为最终消费队列
			DEXR = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_FINAL_ROUTING;
			DEXE = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_FINAL_EXCHANGE;
		}
		
		/**
		 * 延时队列指定
		 */
		Map<String, Object> resMap = queLabel(newTimeDelay);
		String label = (String) resMap.get("label");
		Long queueDelay = (Long) resMap.get("queueDelay");
		
		String DEDE = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_DEAD_EXCHANGE+label;
		String DEDQ = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_DEAD_QUEUE+label;
		String DEDR = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_DEAD_ROUTING+label;
		
		//创建连接连接到MabbitMQ
		ConnectionFactory factory = rabbitTemplate.getConnectionFactory();
		Connection connection =factory.createConnection();
		//创建一个频道
		Channel channel = connection.createChannel(false);  
		
		//创建delay queue
		HashMap<String, Object> arguments = new HashMap<String, Object>();
		arguments.put("x-message-ttl", queueDelay);
		arguments.put("x-dead-letter-exchange", DEXE);
		arguments.put("x-dead-letter-routing-key", DEXR);   
		
		try {

			channel.exchangeDeclare(DEDE,"direct",true);
			channel.queueDeclare(DEDQ, true, false, false, arguments);
			channel.queueBind(DEDQ,DEDE,DEDR);    
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new ServiceException("队列创建失败！");
		}
		
		//往队列中发出一条消息
		String sendPath = sendName+"->"+DEDQ;
		JSONObject sendDataJsonObject = new JSONObject().element("data",message)
    			.element("timeDelay", timeDelay)
    			.element("newTimeDelay", newTimeDelay)
    			.element("endDateTime", endDateTime)
    			.element("sendDateTimestamp", sendDateTimestamp)
    			.element("sendPath", sendPath);
		log.info("发送消息  : " + sendDataJsonObject.toString());
		rabbitTemplate.convertAndSend(DEDQ, sendDataJsonObject);
		
		//关闭连接
		try {

			channel.close();
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new ServiceException("通的关闭失败！");
		}
		connection.close();
		
	}

	/**
	 * 获取队列标签
	 * @return
	 */
	private static Map<String, Object> queLabel(Long timeDelay) {
		
		Map<String, Object> resMap = Maps.newHashMap();
		
		//延时队列标签
		String label = "S1";
		//延时队列延时时间
		Long queueDelay = 1000l;
		
		if (timeDelay < 10*1000) {
			//10秒以内
			for (int i = 9; i >= 0; i--) {
				
				if (timeDelay >= i*1000) {
					//找到最小临界值
					label = "S"+i;
					queueDelay = i*1000l;
					break;
				}
				
			}
		}else if (Math.floor(timeDelay/(1*24*60*60*1000*1.0)) >= 20) {
			
			//大于20天
			label = "D"+20;
			queueDelay = 24*60*60*1000*20l;
			
		}else if (Math.floor(timeDelay/(1*24*60*60*1000*1.0)) >= 10) {
			
			//大于10天
			label = "D"+10;
			queueDelay = 24*60*60*1000*10l;
			
		}else if (Math.floor(timeDelay/(1*24*60*60*1000*1.0)) >= 1) {
			
			//大于1天
			label = "D"+1;
			queueDelay = 24*60*60*1000*1l;
			
		}else if (Math.floor(timeDelay/(60*60*1000*1.0)) >= 20) {
			
			//大于20小时
			label = "H"+20;
			queueDelay = 60*60*1000*20l;
			
		}else if (Math.floor(timeDelay/(60*60*1000*1.0)) >= 10) {
			
			//大于10小时
			label = "H"+10;
			queueDelay = 60*60*1000*10l;
			
		}else if (Math.floor(timeDelay/(60*60*1000*1.0)) >= 1) {
			
			//大于1小时
			label = "H"+1;
			queueDelay = 60*60*1000*1l;
			
		}else if (Math.floor(timeDelay/(60*1000*1.0)) >= 40) {
			
			//大于40分钟
			label = "M"+40;
			queueDelay = 60*1000*40l;
			
		}else if (Math.floor(timeDelay/(60*1000*1.0)) >= 20) {
			
			//大于20分钟
			label = "M"+20;
			queueDelay = 60*1000*20l;
			
		}else if (Math.floor(timeDelay/(60*1000*1.0)) >= 10) {
			
			//大于10分钟
			label = "M"+10;
			queueDelay = 60*1000*10l;
			
		}else if (Math.floor(timeDelay/(60*1000*1.0)) >= 1) {
			
			//大于1分钟
			label = "M"+1;
			queueDelay = 60*1000*1l;
			
		}else if (Math.floor(timeDelay/(1000*1.0)) >= 40) {
			
			//大于40秒
			label = "S"+40;
			queueDelay = 1000*40l;
			
		}else if (Math.floor(timeDelay/(1000*1.0)) >= 20) {
			
			//大于20秒
			label = "S"+20;
			queueDelay = 1000*20l;
			
		}else if (Math.floor(timeDelay/(1000*1.0)) >= 10) {
			
			//大于10秒
			label = "S"+10;
			queueDelay = 1000*10l;
			
		}
		
		resMap.put("label", label);
		resMap.put("queueDelay", queueDelay);
		
		return resMap;
	}
    
}

这个类中定义了

1、时间粒度控制方法queLabel，可以自己定义粒度

2、动态创建延时队列及动态指定转发到的再延时队列

3、消费者中转消息再延时监听类

@Component
@RabbitListener(queues = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_TRANS_QUEUE)//监听的队列名称 
@Slf4j
public class RabbitmqDelayComsumerExtendsTransComsumer {
	
	@Autowired
	RabbitmqProducerDelayExtendsFactory rabbitmqProducerDelayExtendsFactory;

	//@RabbitHandler
    public void process(JSONObject result) {
		
		log.info("消费者收到"+RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_TRANS_QUEUE+"消息  : " + result.toString());
		Long timeDelay = result.getLong("timeDelay");
		Long sendDateTimestamp = result.getLong("sendDateTimestamp");
		JSONObject data = result.getJSONObject("data");
		
		//重新发到延时队列中
		rabbitmqProducerDelayExtendsFactory.sendDelayMessage(sendDateTimestamp, timeDelay,RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_TRANS_QUEUE, data);
    }
    
	
	@RabbitHandler
    public void receiveObjectDel(Channel channel, JSONObject json, Message message){

        log.info("接收到"+RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_TRANS_QUEUE+"的消息："+json);

        //手动ACK
        //默认情况下如果一个消息被消费者所正确接收则会被从队列中移除
        //如果一个队列没被任何消费者订阅，那么这个队列中的消息会被 Cache（缓存），
        //当有消费者订阅时则会立即发送，当消息被消费者正确接收时，就会被从队列中移除
        try {
            //手动ack应答
        	//最后一个参数是：是否重回队列
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false,false);
            process(json);
            //拒绝消息
            //channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
            //消息被丢失
            //channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
            //消息被重新发送
            //channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
            //多条消息被重新发送
            //channel.basicNack(message.getMessageProperties().getDeliveryTag(), true, true);
            //log.info("消息消费成功：id：{}",message.getMessageProperties().getDeliveryTag());
        } catch (IOException e) {
            e.printStackTrace();
            log.info("消息消费失败：id：{}",message.getMessageProperties().getDeliveryTag());
        }
    }
}

这个类是一个消费者类，主要是接收需要再延时的消息进行消息的再延时。

4、最终消费者类

import org.springframework.stereotype.Component;

import com.rabbitmq.client.Channel;
import com.tb.app.configurer.mq.rabbit.producer.RabbitmqProducerDelayExtendsConfig;

import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONObject;

@Component
@RabbitListener(queues = RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_FINAL_QUEUE)//监听的队列名称 
@Slf4j
public class RabbitmqDelayComsumerExtendsFinalComsumer {

	//@RabbitHandler
    public void process(JSONObject result) {
		log.info("消费者收到"+RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_FINAL_QUEUE+"消息  : " + result.toString());
    }
	
	@RabbitHandler
    public void receiveObjectDel(Channel channel, JSONObject json, Message message){

        log.info("接收到"+RabbitmqProducerDelayExtendsConfig.DELAY_EXTENDS_XF_FINAL_QUEUE+"的消息："+json);

        //手动ACK
        //默认情况下如果一个消息被消费者所正确接收则会被从队列中移除
        //如果一个队列没被任何消费者订阅，那么这个队列中的消息会被 Cache（缓存），
        //当有消费者订阅时则会立即发送，当消息被消费者正确接收时，就会被从队列中移除
        try {
            //手动ack应答
        	//最后一个参数是：是否重回队列
            //channel.basicNack(message.getMessageProperties().getDeliveryTag(), false,false);
            //拒绝消息
            channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
            //消息被丢失
            //channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
            //消息被重新发送
            //channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
            //多条消息被重新发送
            //channel.basicNack(message.getMessageProperties().getDeliveryTag(), true, true);
            //log.info("消息消费成功：id：{}",message.getMessageProperties().getDeliveryTag());
        } catch (IOException e) {
            e.printStackTrace();
            log.info("消息消费失败：id：{}",message.getMessageProperties().getDeliveryTag());
        }
    }
}

这个类也是一个消费者类，作为最后延时完成的消息接收及业务处理，这里设置的拒收消息channel.basicReject进行测试，要注意下

---------------------------------------------------------------------------------------------------------------------------------

二、应答失败自动延时再通知

在固定队列配置类RabbitmqProducerDelayExtendsConfig中的最终消费队列那里声明了死信交换机DELAY_EXTENDS_XF_FINAL_ACKFAIL_EXCHANGE，当应答失败时会自动将消息转发到最终消费应答失败转储队列。

而不是让消息重试，可以让后续正常消息正常处理，解决消息堵塞。转储队列设置的5分钟将消息再转发最终消息队列列尾，即是5分钟后回到正常消费队列排队进行重试。这个时间可以根据具体情况设置。

缘空如是
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot整合RabbitMQ实现延时队列
PGL2009的博客
12-12 2263
组件的版本 SpringBoot : V2.5.5 RabbitMQ: 3.9.9 延时队列 延时队列的典型应用场景，例如购买火车票，下单占座后20分钟内未支付的订单会被强制取消，避免在余票紧张的情况下，车票一直被占用，其他人无法购买。还有电商平台，客户下单后，订单进入购物车，如果购物车内的订单超过特定时间未支付，则会失效，回滚库存。 RabbitMQ实现延时队列 利用 RabbitMQ 做延时队列是比较常见的一种方式，而实际上RabbitMQ 自身并没有直接支持提供延迟队列功能，而是通过 RabbitMQ
springboot 使用RabbitMQ实现延迟队列
liyongbing1122的博客
07-26 2247
RabbitMQ延迟消息实现方式 延迟任务通过消息的TTL和Dead Letter Exchange来实现。我们需要建立2个队列，一个用于发送消息，一个用于消息过期后的转发目标队列。 生产者输出消息到Queue1，并且这个消息是设置有有效时间的，比如60s。消息会在Queue1中等待60s，如果没有消费者收掉的话，它就是被转发到Queue2，Queue2有消费者，收到，处理延迟任务。 具...
springboot、rabbitMQ 死信队列
路的尽头在哪
09-13 3208
前言 死信：无法被消费的消息，称为死信。 如果死信一直留在队列中，会导致一直被消费，却从不消费成功。 所以我们专门开辟了一个来存放死信的队列，叫死信队列（DLX，dead-letter-exchange）。 死信的几种来源： 消息 TTL 过期（time to live，存活时间，可以用在限时支付消息） 队列达到最大长度（队列满了，无法路由到该队列） 消息被拒绝（ basic.reject / basic.nack ），并且 requeue = false 环境准备配置 准备 MQ 的队列和环境
SpringBoot简单实现RabbitMq的死信队列
最新发布
Aa5107033的博客
06-28 762
死信队列是一种用于处理无法被正常消费的消息机制，当消息在队列中变成 '死信' 时，RabbitMq会自动将这些消息从新发送到另一个队列，即死信队列。那么在消息队列中，什么情况下会变成 '死信'?
SpringBoot使用RabbitMQ延时队列
lizc_lizc的博客
06-18 5983
延时队列延时队列的使用场景：1.订单业务：在电商中，用户下单后30分钟后未付款则取消订单。2.短信通知：用户下单并付款后，1分钟后发短信给用户。延时队列实现思路AMQP协议和RabbitMQ队列本身没有直接支持延迟队列功能，但是我们可以通过RabbitMQ的两个特性来曲线实现延迟队列：特性一：Time To Live(TTL)RabbitMQ可以针对Queue设置x-expires 或者 针对Me...
详细介绍Spring Boot + RabbitMQ实现延迟队列
weixin_34396902的博客
11-20 980
背景何为延迟队列？顾名思义，延迟队列就是进入该队列的消息会被延迟消费的队列。而一般的队列，消息一旦入队了之后就会被消费者马上消费。 延迟队列能做什么？延迟队列多用于需要延迟工作的场景。最常见的是以下两种场景： 延迟消费。比如： 用户生成订单之后，需要过一段时间校验订单的支付状态，如果订单仍未支付则需要及时地关闭订单。 用户注册成功之后，需要过一段时间比如一周后校验用户的使用情况，如果发现用户活跃...
SpringBoot使用RabbitMQ延迟队列
搬砖爱好者.的博客
11-02 482
消息队列中间件是分布式系统中重要的组件,主要解决应用耦合、异步消息、流量削锋等问题。实现高性能、高可用、可伸缩和最终一致性架构。是大型分布式系统不可缺少的中间件。
SpringBoot整合RabbitMQ实现死信队列
二蛋的博客
12-14 2016
消费者使用basic.reject或basic.nack（重新排队参数设置为false）对消息进行否定确认。消息到达生存时间还未被消费。队列超过长度限制，消息被丢弃。这些消息会被发送到死信交换机并路由到死信队列中（在RabbitMQ中死信交换机和死信队列就是普通的交换机和队列）。其流转过程如下图。
springboot+rabbitmq实现延时队列
08-29
本教程将详细介绍如何使用SpringBoot集成RabbitMQ来实现一个延时队列，并探讨消息发送与消费确认机制以及消费者端的策略模式应用。 首先，SpringBoot是Java开发者广泛使用的快速开发框架，它简化了Spring的配置和...
SpringBoot整合Rabbitmq之延时队列
桐花思雨
09-27 1283
目录延时队列概念使用场景延时队列实现 延时队列 概念 延时队列是存储延时消息的队列，延时消息就是生产者发送了一条消息，但是不希望该消息不要被立即消费，而是设置一个延时时间，等过了这个时间再消费消息 使用场景 订单在十分钟之内未支付则自动取消 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒 账单在一周内未支付，则自动结算 用户注册成功后，如果三天内没有登陆则进行短信提醒 用户发起退款，如果三天内没有得到处理则通知相关运营人员 这时候，延时队列就可以闪亮登场了，以上场景，正是延时队列的用武之
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程
06-28
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程，参考博客：https://blog.csdn.net/qq_29914837/article/details/93334313
SpringBoot集成RabbitMQ实现消息重试机制，消息重试3次失败后写入死信队列，消息重试3次失败后入库
hsuan_CSDN的博客
04-09 3852
yml配置 spring: rabbitmq: username: admin password: admin host: localhost port: 5672 virtual-host: / publisher-confirm: true #发布确认 开启confirms回调 Producer -> Exchange publisher-returns: true #发布返回 开启returnedMessage回调 Exchange..
springboot整合rabbitMq之延迟队列相关使用
鹏举的博客
08-27 266
springboot整合rabbitMq之延迟队列
Spring Boot+RabbitMQ 基于死信队列和插件实现延迟队列详解
huangjhai的博客
10-07 2139
延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用 RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正 确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为 单个节点挂掉导致延时队列不可用或者消息丢失。
延迟
yuanshuai1136的博客
11-22 231
背景 何为延迟队列？ 顾名思义，延迟队列就是进入该队列的消息会被延迟消费的队列。而一般的队列，消息一旦入队了之后就会被消费者马上消费。 延迟队列能做什么？ 延迟队列多用于需要延迟工作的场景。最常见的是以下两种场景： 延迟消费。比如： 用户生成订单之后，需要过一段时间校验订单的支付状态，如果订单仍未支付则需要及时地关闭订单。 用户注册成功之后，需要过一段时间比如一周后校
SpringBoot集成RabbitMQ之死信队列、限流队列、延迟队列（第四节）
qq_45518774的博客
02-06 1263
重点RabbitMQ的一大重点知识，这章节介绍了死信的队列使用场景，比如抢购商品，限流，延迟消息。 多消费者并发问题的解决方案！
SpringBoot整合RabbitMQ实现死信队列详解
"本文介绍了SpringBoot如何集成RabbitMQ并实现死信队列功能，通过具体的示例代码展示了配置和使用过程。" 在SpringBoot应用中集成RabbitMQ，可以利用其强大的消息中间件能力，提高系统的可靠性和可扩展性。死信队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值