SpringBoot整合RabbitMQ实现死信队列

已于 2023-04-14 11:31:32 修改
阅读量1.1k 收藏 6
点赞数 2
分类专栏： rabbitmq 文章标签： java-rabbitmq rabbitmq java
于 2023-04-14 11:27:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46360888/article/details/130147674
版权

死信介绍

顾名思义就是无法被消费的消息。一般来说，Producer 将消息投递到 Broker 或者直接到 Queue 里了，Consumer 从 Queue 取出消息进行消费，但某些时候由于特定的原因导致 Queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。

应用场景

为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入到死信队列中。还有比如说：用户在商城下单成功并点击支付后再指定时间未支付时自动失效。

死信的三种情况

过期未被消费的消息

情况1
	队列设置统一消息设置过期时间导致消息过期
情况1代码测试
生产者定义队列与交换机
	/**
     * 正常队列---10s过期
     * @return
     */
    @Bean
    public Queue normalQueue(){
        //ttl(10000):队列里面的消息统一10s过期--x-message-ttl
        return QueueBuilder.durable("normal-queue").ttl(10000).
                //绑定死信交换机
                deadLetterExchange("dlx-exchange").
                //设置路由键
                deadLetterRoutingKey("error").build();
    }
    
	/**
     * 死信队列
     * @return
     */
    @Bean
    public Queue dlxQueue(){
        return QueueBuilder.durable("dlx-queue").build();
    }

    /**
     * 正常交换机
     * @return
     */
    @Bean
    public DirectExchange normalExchange(){
        return ExchangeBuilder.directExchange("normal-exchange").build();
    }

    /**
     * 死信交换机
     * @return
     */
    @Bean
    public DirectExchange dlxExchange(){
        return ExchangeBuilder.directExchange("dlx-exchange").build();
    }
    
	/**
     * 正常队列---10s过期与正常交换机绑定
     * @return
     */
    @Bean
    public Binding dlxBind(){
        return BindingBuilder.bind(normalQueue()).to(normalExchange()).with("info");
    }

    /**
     * 死信队列与死信交换机绑定
     * @return
     */
    @Bean
    public Binding dlxBind1(){
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with("error");
    }
	
	 /**
     * 项目重启时创建交换机与队列
     * @return
     */
	@Bean
    public RabbitAdmin dlxRabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin=new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        rabbitAdmin.declareExchange(dlxExchange());
        rabbitAdmin.declareExchange(normalExchange());
        rabbitAdmin.declareQueue(normalQueue());
        rabbitAdmin.declareQueue(dlxQueue());
        return rabbitAdmin;
    }
生产者发送消息
 	private static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 	
	/**
     * 组装消息
     * @param msg
     * @return
     */
    private static Map<String, Object> createMsg(Object msg) {
        String msgId = UUID.randomUUID().toString().replace("-", "").substring(0, 32);
        Map<String,Object> message= Maps.newHashMap();
        message.put("sendTime",sdf.format(new Date()));
        message.put("msg", msg);
        message.put("msgId",msgId);
        return message;
    }
    
	@GetMapping("dlx1")
    @ApiOperation("死信:队列设置统一过期时间导致消息过期测试")
    public String dlx1(@RequestParam String msg,@RequestParam String routingKey){
        Map<String, Object> map = createMsg(msg);
        rabbitTemplate.convertAndSend("normal-exchange",routingKey,map);
        return "ok";
    }
消费者监听死信队列
	/**
     * 死信队列
     * @param message 消息
     * @param c 通道
     * @param msg 消息内容
     * @throws IOException
     */
    //使用queuesToDeclare属性，如果不存在则会创建队列,注：此处声明的队列要和生产者属性保持一致
    @RabbitListener(queuesToDeclare = @Queue(value = "dlx-queue"))
    public void dlxQueue(Message message,Channel c,Map msg) throws IOException {
        MessageProperties properties = message.getMessageProperties();
        String routingKey = properties.getReceivedRoutingKey();
        log.info("死信队列收到:{},路由键:{}",msg,routingKey);
        //手动回执，不批量签收,回执后才能处理下一批消息
        long tag = properties.getDeliveryTag();
        c.basicAck(tag,false);
    }
接口测试在这里插入图片描述
结果验证

由于队列设置统一过期时间10s，此消息若10s内没有被消费，消息会变成死信进入死信队列，结果如图
在这里插入图片描述

情况2
	消息本身设置过期时间导致消息过期
情况2代码测试
生产者定义队列与交换机
	/**
     * 正常队列
     * @return
     */
    @Bean
    public Queue normalQueue2(){
        return QueueBuilder.durable("normal-queue2").
                //绑定死信交换机
                        deadLetterExchange("dlx-exchange").
                //设置路由键
                        deadLetterRoutingKey("error").build();
    }
    
 	 /**
     * 死信队列
     * @return
     */
    @Bean
    public Queue dlxQueue(){
        return QueueBuilder.durable("dlx-queue").build();
    }

    /**
     * 正常交换机
     * @return
     */
    @Bean
    public DirectExchange normalExchange(){
        return ExchangeBuilder.directExchange("normal-exchange").build();
    }

    /**
     * 死信交换机
     * @return
     */
    @Bean
    public DirectExchange dlxExchange(){
        return ExchangeBuilder.directExchange("dlx-exchange").build();
    }
	 /**
     * 死信队列与死信交换机绑定
     * @return
     */
    @Bean
    public Binding dlxBind1(){
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with("error");
    }
    
	 /**
     *  正常交换机与正常队列绑定
     * @return
     */
    @Bean
    public Binding dlxBind3(){
        return BindingBuilder.bind(normalQueue2()).to(normalExchange()).with("trace");
    }
    
    /**
     * 项目重启时创建交换机与队列
     * @return
     */
	@Bean
    public RabbitAdmin dlxRabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin=new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        rabbitAdmin.declareExchange(dlxExchange());
        rabbitAdmin.declareExchange(normalExchange());
        rabbitAdmin.declareQueue(normalQueue2());
        rabbitAdmin.declareQueue(dlxQueue());
        return rabbitAdmin;
    }
生产者发送消息
 	private static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 	
	/**
     * 组装消息
     * @param msg
     * @return
     */
    private static Map<String, Object> createMsg(Object msg) {
        String msgId = UUID.randomUUID().toString().replace("-", "").substring(0, 32);
        Map<String,Object> message= Maps.newHashMap();
        message.put("sendTime",sdf.format(new Date()));
        message.put("msg", msg);
        message.put("msgId",msgId);
        return message;
    }
    
	@GetMapping("dlx3")
    @ApiOperation("死信:消息本身设置过期导致消息过期测试")
    public String dlx3(@RequestParam String msg,@RequestParam String routingKey){
        Map<String, Object> map = createMsg(msg);
        rabbitTemplate.convertAndSend("normal-exchange", routingKey, map, message -> {
            MessageProperties properties = message.getMessageProperties();
            //设置消息10s过期,注：1.只有在消息被消费才会判断是否过期
            //2.若队列设置ttl同时消息设置过期时间，则以时间短得为主
            properties.setExpiration("10000");
            return message;
        });
        return "ok";
    }
消费者监听死信队列
	/**
     * 死信队列
     * @param message 消息
     * @param c 通道
     * @param msg 消息内容
     * @throws IOException
     */
    //使用queuesToDeclare属性，如果不存在则会创建队列,注：此处声明的队列要和生产者属性保持一致
    @RabbitListener(queuesToDeclare = @Queue(value = "dlx-queue"))
    public void dlxQueue(Message message,Channel c,Map msg) throws IOException {
        MessageProperties properties = message.getMessageProperties();
        String routingKey = properties.getReceivedRoutingKey();
        log.info("死信队列收到:{},路由键:{}",msg,routingKey);
        //手动回执，不批量签收,回执后才能处理下一批消息
        long tag = properties.getDeliveryTag();
        c.basicAck(tag,false);
    }
接口测试

在这里插入图片描述

结果验证

由于消息本身设置过期时间10s，此消息若10s内没有被消费，消息会变成死信进入死信队列，结果如图
在这里插入图片描述

注

1.消息只有在被消费时才会判断是否过期,所以ttl与死信队列实现不了真正的延迟队列，存在误差
2.若消息本身和队列都设置过期时间，以时间短的为主

达到消息队列长度限制无法进入队列的消息

生产者定义队列与交换机
	 /**
     * 正常队列---最大长度为10
     * @return
     */
    @Bean
    public Queue normalQueue1(){
        return QueueBuilder.durable("normal-queue1").maxLength(10).
                //绑定死信交换机
                        deadLetterExchange("dlx-exchange").
                //设置路由键
                        deadLetterRoutingKey("error").build();
    }
	
	 /**
     * 死信队列
     * @return
     */
    @Bean
    public Queue dlxQueue(){
        return QueueBuilder.durable("dlx-queue").build();
    }

    /**
     * 正常交换机
     * @return
     */
    @Bean
    public DirectExchange normalExchange(){
        return ExchangeBuilder.directExchange("normal-exchange").build();
    }

    /**
     * 死信交换机
     * @return
     */
    @Bean
    public DirectExchange dlxExchange(){
        return ExchangeBuilder.directExchange("dlx-exchange").build();
    }
	
	 /**
     * 死信队列与死信交换机绑定
     * @return
     */
    @Bean
    public Binding dlxBind1(){
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with("error");
    }

    /**
     * 正常队列---最大长度为10与正常交换机绑定
     * @return
     */
    @Bean
    public Binding dlxBind2(){
        return BindingBuilder.bind(normalQueue1()).to(normalExchange()).with("debug");
    }
	
	@Bean
    public RabbitAdmin dlxRabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin=new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        rabbitAdmin.declareExchange(dlxExchange());
        rabbitAdmin.declareExchange(normalExchange());
        rabbitAdmin.declareQueue(normalQueue1());
        rabbitAdmin.declareQueue(dlxQueue());
        return rabbitAdmin;
    }
生产者发送消息
 	private static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 	
	/**
     * 组装消息
     * @param msg
     * @return
     */
    private static Map<String, Object> createMsg(Object msg) {
        String msgId = UUID.randomUUID().toString().replace("-", "").substring(0, 32);
        Map<String,Object> message= Maps.newHashMap();
        message.put("sendTime",sdf.format(new Date()));
        message.put("msg", msg);
        message.put("msgId",msgId);
        return message;
    }
    
	@GetMapping("dlx2")
    @ApiOperation("死信:队列长度测试")
    public String dlx2(@RequestParam String msg,@RequestParam String routingKey){
        for (int i = 0; i < 20; i++) {
            Map<String, Object> map = createMsg(msg);
            rabbitTemplate.convertAndSend("normal-exchange",routingKey,map);
        }
        return "ok";
    }
消费者监听死信队列
	/**
     * 死信队列
     * @param message 消息
     * @param c 通道
     * @param msg 消息内容
     * @throws IOException
     */
    //使用queuesToDeclare属性，如果不存在则会创建队列,注：此处声明的队列要和生产者属性保持一致
    @RabbitListener(queuesToDeclare = @Queue(value = "dlx-queue"))
    public void dlxQueue(Message message,Channel c,Map msg) throws IOException {
        MessageProperties properties = message.getMessageProperties();
        String routingKey = properties.getReceivedRoutingKey();
        log.info("死信队列收到:{},路由键:{}",msg,routingKey);
        //手动回执，不批量签收,回执后才能处理下一批消息
        long tag = properties.getDeliveryTag();
        c.basicAck(tag,false);
    }
接口测试

在这里插入图片描述

结果验证

由于队列长度限制为10，当队列里面消息数量达到10之后，后续的消息进不了队列，消息会变成死信进入死信队列，结果如图
在这里插入图片描述

消费者拒收且不重回队列的消息

生产者定义队列与交换机
	/**
     * 正常队列
     * @return
     */
    @Bean
    public Queue normalQueue2(){
        return QueueBuilder.durable("normal-queue2").
                //绑定死信交换机
                        deadLetterExchange("dlx-exchange").
                //设置路由键
                        deadLetterRoutingKey("error").build();
    }
    
 	 /**
     * 死信队列
     * @return
     */
    @Bean
    public Queue dlxQueue(){
        return QueueBuilder.durable("dlx-queue").build();
    }

    /**
     * 正常交换机
     * @return
     */
    @Bean
    public DirectExchange normalExchange(){
        return ExchangeBuilder.directExchange("normal-exchange").build();
    }

    /**
     * 死信交换机
     * @return
     */
    @Bean
    public DirectExchange dlxExchange(){
        return ExchangeBuilder.directExchange("dlx-exchange").build();
    }
	 /**
     * 死信队列与死信交换机绑定
     * @return
     */
    @Bean
    public Binding dlxBind1(){
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with("error");
    }
    
	 /**
     *  正常交换机与正常队列绑定
     * @return
     */
    @Bean
    public Binding dlxBind3(){
        return BindingBuilder.bind(normalQueue2()).to(normalExchange()).with("trace");
    }
    
	@Bean
    public RabbitAdmin dlxRabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin=new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        rabbitAdmin.declareExchange(dlxExchange());
        rabbitAdmin.declareExchange(normalExchange());
        rabbitAdmin.declareQueue(normalQueue2());
        rabbitAdmin.declareQueue(dlxQueue());
        return rabbitAdmin;
    }
生产者发送消息
 	private static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 	
	/**
     * 组装消息
     * @param msg
     * @return
     */
    private static Map<String, Object> createMsg(Object msg) {
        String msgId = UUID.randomUUID().toString().replace("-", "").substring(0, 32);
        Map<String,Object> message= Maps.newHashMap();
        message.put("sendTime",sdf.format(new Date()));
        message.put("msg", msg);
        message.put("msgId",msgId);
        return message;
    }
    
	 @GetMapping("dlx5")
    @ApiOperation("死信:消息被拒收且不重回队列测试")
    public String dlx5(@RequestParam String msg,@RequestParam String routingKey){
        Map<String, Object> map = createMsg(msg);
        rabbitTemplate.convertAndSend("normal-exchange", routingKey, map);
        return "ok";
    }
消费者监听死信队列与拒收消息
	/**
     * 死信队列
     * @param message 消息
     * @param c 通道
     * @param msg 消息内容
     * @throws IOException
     */
    //使用queuesToDeclare属性，如果不存在则会创建队列,注：此处声明的队列要和生产者属性保持一致
    @RabbitListener(queuesToDeclare = @Queue(value = "dlx-queue"))
    public void dlxQueue(Message message,Channel c,Map msg) throws IOException {
        MessageProperties properties = message.getMessageProperties();
        String routingKey = properties.getReceivedRoutingKey();
        log.info("死信队列收到:{},路由键:{}",msg,routingKey);
        //手动回执，不批量签收,回执后才能处理下一批消息
        long tag = properties.getDeliveryTag();
        c.basicAck(tag,false);
    }
	
	/**
     * 拒收消息
     * @param message 消息
     * @param c 通道
     * @param msg 消息内容
     * @throws IOException
     */
    //使用queuesToDeclare属性，如果不存在则会创建队列,注：此处声明的队列要和生产者属性保持一致
    @RabbitListener(queuesToDeclare = @Queue(value = "normal-queue2",declare = "false"))
    public void reject(Message message,Channel c,Map msg) throws IOException {
        MessageProperties properties = message.getMessageProperties();
        String routingKey = properties.getReceivedRoutingKey();
        log.info("队列收到:{},路由键:{}",msg,routingKey);
        //手动回执，不批量签收,回执后才能处理下一批消息
        long tag = properties.getDeliveryTag();
        //设置消息拒收且不重回队列
        c.basicReject(tag,false);
        log.info("消息拒收");
    }
接口测试

在这里插入图片描述

结果验证

由于消息者拒收消息且设置消息不重回队列，死信队列则会收到此消息，结果如图

在这里插入图片描述
注：若队列设置删除自动删除的时间，到时队列会被删除，此时队列要如有消息则也会被删除，不会变成死信队列

队列删除，队列里面的消息不会变成死信

代码验证

生产者定义交换机与队列
	/**
     * 正常队列-30s后删除
     * @return
     */
    @Bean
    public Queue normalQueue3(){
        //expires(30000):队列30s内被删除--x-expires
        return QueueBuilder.durable("normal-queue3").expires(30000).
                //绑定死信交换机
                        deadLetterExchange("dlx-exchange").
                //设置路由键
                        deadLetterRoutingKey("error").build();
    }

    /**
     * 死信队列
     * @return
     */
    @Bean
    public Queue dlxQueue(){
        return QueueBuilder.durable("dlx-queue").build();
    }

    /**
     * 正常交换机
     * @return
     */
    @Bean
    public DirectExchange normalExchange(){
        return ExchangeBuilder.directExchange("normal-exchange").build();
    }

    /**
     * 死信交换机
     * @return
     */
    @Bean
    public DirectExchange dlxExchange(){
        return ExchangeBuilder.directExchange("dlx-exchange").build();
    }
    
	/**
     * 死信队列与死信交换机绑定
     * @return
     */
    @Bean
    public Binding dlxBind1(){
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with("error");
    }
    
	/**
     * 正常队列--30s后删除与正常交换机绑定
     * @return
     */
    @Bean
    public Binding dlxBind4(){
        return BindingBuilder.bind(normalQueue3()).to(normalExchange()).with("warn");
    }


    @Bean
    public RabbitAdmin dlxRabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin=new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        rabbitAdmin.declareExchange(dlxExchange());
        rabbitAdmin.declareExchange(normalExchange());
        rabbitAdmin.declareQueue(normalQueue3());
        rabbitAdmin.declareQueue(dlxQueue());
        return rabbitAdmin;
    }
生产者发送消息
 	private static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 	
	/**
     * 组装消息
     * @param msg
     * @return
     */
    private static Map<String, Object> createMsg(Object msg) {
        String msgId = UUID.randomUUID().toString().replace("-", "").substring(0, 32);
        Map<String,Object> message= Maps.newHashMap();
        message.put("sendTime",sdf.format(new Date()));
        message.put("msg", msg);
        message.put("msgId",msgId);
        return message;
    }
    
	/**
     * 不会进入死信队列
     * @param msg
     * @param routingKey
     * @return
     */
    @GetMapping("dlx4")
    @ApiOperation("死信:队列删除，消息测试")
    public String dlx4(@RequestParam String msg,@RequestParam String routingKey){
        Map<String, Object> map = createMsg(msg);
        rabbitTemplate.convertAndSend("normal-exchange", routingKey, map);
        return "ok";
    }
消费者监听死信队列与拒收消息
	/**
     * 死信队列
     * @param message 消息
     * @param c 通道
     * @param msg 消息内容
     * @throws IOException
     */
    //使用queuesToDeclare属性，如果不存在则会创建队列,注：此处声明的队列要和生产者属性保持一致
    @RabbitListener(queuesToDeclare = @Queue(value = "dlx-queue"))
    public void dlxQueue(Message message,Channel c,Map msg) throws IOException {
        MessageProperties properties = message.getMessageProperties();
        String routingKey = properties.getReceivedRoutingKey();
        log.info("死信队列收到:{},路由键:{}",msg,routingKey);
        //手动回执，不批量签收,回执后才能处理下一批消息
        long tag = properties.getDeliveryTag();
        c.basicAck(tag,false);
    }
接口测试

在这里插入图片描述
向队列里面发送一条消息
在这里插入图片描述

结果验证

结果队列30s被删除，死信队列没有此消息
在这里插入图片描述

在这里插入图片描述

shmily&&ylimhs
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
springboot整合rabbitmq死信队列
weixin_43360488的博客
08-27 665
说道死信，可能大部分观众大姥爷会有懵逼的想法，什么是死信？死信队列，俗称DLX，翻译过来的名称为Dead Letter Exchange 死信交换机。当消息限定时间内未被消费，成为 Dead Message后，可以被重新发送到另一个交换机中，发挥其应有的价值！需要测试死信队列，则需要先梳理整体的思路，如可以采取如下方式进行配置：从上面的逻辑图中，可以发现大致的思路：.1. 消息队列分为正常交换机、正常消息队列；以及死信交换机和死信队列。
SpringBoot整合Rabbitmq之死信队列
桐花思雨
09-25 2894
目录死信队列死信从何而来 死信队列 死信：无法被消费方消费掉的消息，称为死信。如果死信一直留在队列中，会导致一直被消费，却从不消费成功。所以 rabbitmq 专门开辟了一个来存放死信的队列，叫死信队列（DLX，dead-letter-exchange） 死信从何而来 消息被拒绝（调用 basicNack() 或 basicReject()，并且参数 requeue = false） 消息过期，过了 TTL 存活时间 队列设置了 x-max-length 最大消息数量且当前队列中的消息已经达到了这个数量，
RabbitMq(五) -- 死信队列和延迟队列及springboot中使用rabbitmq
weixin_39724194的博客
03-04 2878
1. 死信 1.1 死信的概念 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景： 为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，
十、RabbitMQ高级 - 死信交换机
莫等闲 白了少年头 空悲切
05-04 626
消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机将消费者监听的队列绑定到死信交换机发送消息时给消息设置超时时间为20秒。
SpringBoot基于RabbitMQ实现死信队列 (SpringBoot整合RabbitMQ实战篇)
最新发布
莫等闲 白了少年头 空悲切
04-24 1827
消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机将消费者监听的队列绑定到死信交换机发送消息时给消息设置超时时间为20秒每一项技术深挖都是一个庞大的体系，学海无涯，共勉。
spring boot 整合rabbit mq 死信队列
m0_37723564的博客
04-14 2208
前言 在电商开发中我们经常会遇到这样的一些功能需求。例如，当一个订单在30分钟后未支付就需要关闭这个订单；当一个订单7天后用户没有点击确认收货，就系统自动确认。我们可以把这类任务归纳为是一个系统事件，通过触发某个时间条件来执行该事件。我们可以先抛开rabbitmq这个中间件，思考下应该如何设计这个任务。 首先这些事件的触发不应该影响我们的主流程，比如用户生成了订单，但是即使用户不支付，他依然可以去做别的事情，比如浏览商品或者参与其它促销活动。也就是这类事件相对于我们的用户主线程它是独立的，非阻塞的，异步的。
RabbitMQ—SpringBoot中实现死信队列
shang_0122的博客
10-05 3156
RabbitMQ—SpringBoot中实现死信队列
SpringBoot RabbitMQ 死信队列
天行健，君子以自强不息；地势坤，君子以厚德载物。
04-27 1139
1. 死信定义无法被消费的消息，称为死信。如果死信一直留在队列中，会导致一直被消费，却从不消费成功，专门有一个存放死信的队列，称为死信队列(DDX, dead-letter-exchange)。死信队列DLX，Dead Letter Exchange的缩写，又死信邮箱、死信交换机。其实DLX就是一个普通的交换机，和一般的交换机没有任何区别。当消息在一个队列中变成死信（dead message）时，...
spring boot + rabbitMq整合之死信队列（DL）
阿萨的专栏
03-03 846
DXL-Dead Letter 死信队列死信，在官网中对应的单词为“Dead Letter”，可以看出翻译确实非常的简单粗暴。那么死信是个什么东西呢？消息被否定确认，使用 channel.basicNack 或 channel.basicReject ，并且此时requeue 属性被设置为false。通常来说，如果consumer如果消费出现异常，并且没有ack的话，也属于这种情况消息在队列的存活时间超过设置的生存时间（TTL)时间。消息队列的消息数量已经超过最大队列长度。
SpringBoot集成RabbitMQ之死信队列、限流队列、延迟队列（第四节）
qq_45518774的博客
02-06 872
重点RabbitMQ的一大重点知识，这章节介绍了死信的队列使用场景，比如抢购商品，限流，延迟消息。 多消费者并发问题的解决方案！
SpringBoot整合RabbitMQ实现延时队列
PGL2009的博客
12-12 2231
组件的版本 SpringBoot : V2.5.5 RabbitMQ: 3.9.9 延时队列 延时队列的典型应用场景，例如购买火车票，下单占座后20分钟内未支付的订单会被强制取消，避免在余票紧张的情况下，车票一直被占用，其他人无法购买。还有电商平台，客户下单后，订单进入购物车，如果购物车内的订单超过特定时间未支付，则会失效，回滚库存。 RabbitMQ实现延时队列 利用 RabbitMQ 做延时队列是比较常见的一种方式，而实际上RabbitMQ 自身并没有直接支持提供延迟队列功能，而是通过 RabbitMQ
springboot整合rabbitmq使用死信队列
11-06
springboot整合rabbitmq使用死信队列
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程
06-28
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程，参考博客：https://blog.csdn.net/qq_29914837/article/details/93334313
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包
07-02
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包 整合4种常用模式+高级特性死信队列 暂未整合TTL队列 博客地址:...
RabbitMQ实战视频.zip
03-19
在此，我精心录制的这一套视频教程将几乎手把手指导大家入门学习RabbitMQ并将所学的知识要点实战到实际的业务场景中，特别是在第二阶段的学习，将采用SpringBoot整合RabbitMQ的方式来实战实际的业务场景，并用来解决...
RabbitMQ的使用demo
07-02
本资源demo包括 开启手动确认模式、配置使用死信交换机、配置RabbitMQ插件实现延迟队列、配置发布确认机制等内容，通过本资源的学习能够熟练地使用SpringBoot整合RabbitMQ的API。 希望对您的学习有所帮助！
基于Springboot跟rabbitmq实现的死信队列
神尐破
09-04 186
死信队列其实并没有什么神秘的地方，不过是绑定在死信交换机上的普通队列，而死信交换机也只是一个普通的交换机，不过是用来专门处理死信的交换机。总结一下死信消息的生命周期：业务消息被投入业务队列消费者消费业务队列的消息，由于处理过程中发生异常，于是进行了nck或者reject操作被nck或reject的消息由RabbitMQ投递到死信交换机中死信交换机将消息投入相应的死信队列死信队列的消费者消费死信消息。
springboot整合rabbitmq配置死信队列
08-16
要在Spring Boot中配置死信队列（Dead Letter Queue），您可以按照以下步骤进行操作： 1. 添加RabbitMQ依赖：在您的Spring Boot项目的pom.xml文件中，添加RabbitMQ依赖。例如，使用以下Maven依赖项： ```xml ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值