微服务架构-分布式消息中间件-084：RabbitMQ实战解决方案之死信队列

最新推荐文章于 2024-07-01 16:01:37 发布
最新推荐文章于 2024-07-01 16:01:37 发布
阅读量388 收藏 1
点赞数
分类专栏： 蚂蚁课堂第6期视频笔记 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012425860/article/details/114035243
版权

084：RabbitMQ实战解决方案之死信队列

1 消息中间件产生了消息堆积如何解决

课题内容

  1. RabbitMQ消息产生了堆积如何解决
  2. RabbitMQ如何保证消息不丢失
  3. RabbitMQ实战操作死信队列
  4. RabbitMQ异步如何获取消费结果

RabbitMQ如果产生了消息堆积如何处理？
产生的背景：如果没有及时的消费者消费消息，生产者一直不断往队列服务器存放消息，最终会导致消息堆积。

两种场景：

  1. 没有消费者消费的情况下：死信队列、设置消息有效期
    相当于对消息设置有效期，在规定的时间内如果没有消费的话，自动过期，过期的时候会执行客户端回调监听的方法将消息存放到数据库记录，后期实现补偿。
  2. 有一个消费者消费的情况：应该提高消费能力，消费者实现集群

2 RabbitMQ如何保证消息不丢失

RabbitMQ如何彻底保证我们的消息不丢失？
1.MQ服务器端应该消息持久化到硬盘
2.生产者使用消息确认机制百分百能够将消息投递到MQ成功
3.消费者使用手动ack机制确认消息百分百消费成功

如果队列容量满了，再继续投递可能会丢失。解决：死信队列
死信队列：备胎队列，消息中间件队列因为某种原因拒绝存放该消息，可以转移到死信队列中存放。
死信队列产生的背景：
1.生产者投递消息到MQ中，消息过期了；
2.队列已经达到最大长度（队列存放消息满了）MQ拒绝接受存放该消息；
3.消费者多次消费该消息失败的情况，也会存放到死信队列；
在这里插入图片描述

3 RabbitMQ整合死信队列

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.RELEASE</version>
</parent>
<dependencies>

    <!-- springboot-web组件 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 添加springboot对amqp的支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
    <!--fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.49</version>
    </dependency>
</dependencies>

application.yml

spring:
  rabbitmq:
    ####连接地址
    host: 127.0.0.1
    ####端口号
    port: 5672
    ####账号
    username: guest
    ####密码
    password: guest
    ### 地址
    virtual-host: /mayikt_rabbitmq
server:
  port: 8080

###模拟演示死信队列
mayikt:
  ### 创建死信队列交换机和队列路由键
  dlx:
    exchange: mayikt_order_dlx_exchange
    queue: mayikt_order_dlx_queue
    routingKey: dlx
  ###创建订单队列交换机和队列路由键
  order:
    exchange: mayikt_order_exchange
    queue: mayikt_order_queue
    routingKey: mayikt.order

配置死信队列

@Component
public class DeadLetterMQConfig {

    /**
     * 订单交换机
     */
    @Value("${mayikt.order.exchange}")
    private String orderExchange;

    /**
     * 订单队列
     */
    @Value("${mayikt.order.queue}")
    private String orderQueue;

    /**
     * 订单路由key
     */
    @Value("${mayikt.order.routingKey}")
    private String orderRoutingKey;

    /**
     * 死信交换机
     */
    @Value("${mayikt.dlx.exchange}")
    private String dlxExchange;

    /**
     * 死信队列
     */
    @Value("${mayikt.dlx.queue}")
    private String dlxQueue;
    /**
     * 死信路由
     */
    @Value("${mayikt.dlx.routingKey}")
    private String dlxRoutingKey;

    /**
     * 声明死信交换机
     *
     * @return DirectExchange
     */
    @Bean
    public DirectExchange dlxExchange() {
        return new DirectExchange(dlxExchange);
    }

    /**
     * 声明死信队列
     *
     * @return Queue
     */
    @Bean
    public Queue dlxQueue() {
        return new Queue(dlxQueue);
    }

    /**
     * 声明订单业务交换机
     *
     * @return DirectExchange
     */
    @Bean
    public DirectExchange orderExchange() {
        return new DirectExchange(orderExchange);
    }

    /**
     * 声明订单队列
     *
     * @return Queue
     */
    @Bean
    public Queue orderQueue() {
        Map<String, Object> arguments = new HashMap<>(2);
        // 绑定死信交换机
        arguments.put("x-dead-letter-exchange", dlxExchange);
        // 绑定路由key
        arguments.put("x-dead-letter-routing-key", dlxRoutingKey);
        return new Queue(orderQueue, true, false, false, arguments);
    }

    /**
     * 绑定订单队列到订单交换机
     *
     * @return Binding
     */
    @Bean
    public Binding orderBinding() {
        return BindingBuilder.bind(orderQueue())
                .to(orderExchange())
                .with(orderRoutingKey);
    }

    /**
     * 绑定死信队列到死信交换机
     *
     * @return Binding
     */
    @Bean
    public Binding binding() {
        return BindingBuilder.bind(dlxQueue())
                .to(dlxExchange())
                .with(dlxRoutingKey);
    }
}

注意：新项目此时只有这一个配置文件创建队列和交换机失败，一定要有一个监听消费者，使springboot能够连接到rabbitmq才能创建成功。

运行结果：
在这里插入图片描述

4 RabbitMQ死信队列效果演示

@RestController
public class DeadLetterController {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    /**
     * 订单交换机
     */
    @Value("${mayikt.order.exchange}")
    private String orderExchange;

    /**
     * 订单路由key
     */
    @Value("${mayikt.order.routingKey}")
    private String orderRoutingKey;


    @RequestMapping("/sendOrderMsg")
    public String sendOrderMsg(){
        rabbitTemplate.convertAndSend(orderExchange, orderRoutingKey, "mayikt", new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setExpiration("10000");
                return message;
            }
        });
        return "success";
    }
}

@Component
public class OrderDlxConsumer {

    /**
     * 监听死信队列
     *
     * @return
     */
    @RabbitListener(queues = "mayikt_order_dlx_queue")
    public void orderConsumer(String msg) {
        System.out.println("死信队列获取消息:" + msg);
    }
}

@Component
public class OrderConsumer {
    /**
     * 监听订单队列
     *
     * @return
     */
    @RabbitListener(queues = "mayikt_order_queue")
    public void orderConsumer(String msg) {
        System.out.println("订单队列获取消息:" + msg);
    }
}

运行结果：
在这里插入图片描述
死信队列不能够和正常队列存放在同一个服务器中，应该分开服务器存放。

5 RabbitMQ如何获取消费者结果

RabbitMQ异步如何获取消费结果？
多线程+主动查询。
消费的结果根据业务来定，假设业务场景是订单消费者消费成功将订单数据存入数据库，数据库能查到结果说明消费成功。

Maven依赖增加

<!--fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.49</version>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>
<!-- mysql 依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

application.yml增加

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&&useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

核心代码

@Data
public class OrderEntity {
    private int id;
    private String orderName;
    private String orderId;

    public OrderEntity(String orderName, String orderId) {
        this.orderName = orderName;
        this.orderId = orderId;
    }

    public OrderEntity() {
    }
}

public interface OrderMapper {
    @Insert("insert order_info values (null,#{orderName},#{orderId})")
    int addOrder(OrderEntity orderEntity);

    @Select("SELECT * from order_info where orderId=#{orderId} ")
    OrderEntity getOrder(String orderId);
}

@RestController
public class DeadLetterController {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    /**
     * 订单交换机
     */
    @Value("${mayikt.order.exchange}")
    private String orderExchange;

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 订单路由key
     */
    @Value("${mayikt.order.routingKey}")
    private String orderRoutingKey;

    @RequestMapping("/sendOrderMsg")
    public String sendOrderMsg() {
        // 1.生产订单id
        String orderId = System.currentTimeMillis() + "";
        String orderName = "蚂蚁课堂第六期报名";
        OrderEntity orderEntity = new OrderEntity(orderName, orderId);
        String msg = JSONObject.toJSONString(orderEntity);
        sendMsg(msg);
        return orderId;
        // 后期客户端主动使用orderId调用服务器接口 查询该订单id是否在数据库中存在，存在说明消费成功，否则消费失败
    }

    // 如果用同步可以使用消息确认机制，必须投递成功再返回orderId，效率低
    @Async
    public void sendMsg(String msg) {
        rabbitTemplate.convertAndSend(orderExchange, orderRoutingKey, msg,
                new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        message.getMessageProperties().setExpiration("10000");
                        return message;
                    }
                });
        // 消息投递失败
    }

    /**
     * 主动查询接口
     * 先查询该订单的消息是否投递失败
     * 再查询数据库
     */
    @RequestMapping("/getOrder")
    public Object getOrder(String orderId) {
        OrderEntity orderEntity = orderMapper.getOrder(orderId);
        if (orderEntity == null) {
            return "消息正在异步的处理中";
        }
        return orderEntity;
    }
}

@Component
public class OrderConsumer {

    @Autowired
    private OrderMapper orderMapper;
    /**
     * 监听订单队列
     *
     * @return
     */
    @RabbitListener(queues = "mayikt_order_queue")
    public void orderConsumer(String msg) {
        System.out.println("订单队列获取消息:" + msg);
        OrderEntity orderEntity = JSONObject.parseObject(msg, OrderEntity.class);
        if(orderEntity == null){
            return;
        }
        orderMapper.addOrder(orderEntity);
    }
}

@SpringBootApplication
@EnableAsync
@MapperScan("com.mayikt.mapper")
public class SpringApp {
    public static void main(String[] args) {
        SpringApplication.run(SpringApp.class);
    }
}

6 主动调用接口查询消费结果

运行结果：
在这里插入图片描述

竞风之翼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud微服务 Stream集成RabbitMQ(一)
Dusty丶one的博客
04-09 1万+
前言 本小结我们将学习一下如何使用Spring Cloud Stream 来集成Rabbit MQ 并实现常规业务场景中的发布/订阅模式及其确认机制。 在学习本小结之前我假设大家已对Spring Cloud Stream 和Rabbit MQ 有实际场景应用的能力，如果暂未掌握请自行学习，这里不赘述。 通常而言，对于发布/订阅模式模式而言，消息的发送者一般只注重将消息推送到相应的Exchange ...
微服务和分布式的区别什么？有什么特点？
Aa112233aA1的博客
05-16 758
微服务是什么？ 微服务架构是团队面对互联网产品爆发式增长的最优选择，要解决的是快速迭代、高可靠和高可用等问题，把复杂度很高的产品拆分成一些较小的模块，并遵循康威定律，每一个模块用5-9个小团队来维护，这样可以减少沟通成本，提高协作效率，更好地实现快速迭代和弹性扩展。 采用微服务架构改造，引入各种复杂性，如部署工作量的增加、复杂链路的监控难题，这就是为微服务而微服务，只会得不偿失。在实施的过程中不能简单的使用某些个微服务框架或者组件一蹴而就，而是需要将业务、技术和运维有机结合起来，配合同步实施，并且在此过程中
[源码和文档分享]基于rabbitMQ的微服务架构消息组件设计与实现
12-01 258
随着互联网的高速发展，淘宝、微信、12306和各类直播平台等各种规模庞大、高频率、高峰值的应用层出不穷，而且在一些特殊节点，比如淘宝的双十一购物节、12306的春运抢票高峰等，系统的访问量更是日常流量的几万甚至千万倍。为了支撑起如此庞大的性能需求，迫切需要各种层面的配合。 传统的单体式架构，虽然易于开发、部署和扩展，但是存在很多的弊端，特别是应用变大或者团队扩大...
RabbitMQ的死信队列
最新发布
yygr的博客
07-01 100
当消息被标记为死信后，如果配置了死信队列，RabbitMQ会将该消息发送到死信交换机（Dead Letter Exchange）。可以将其从当前队列发送到另一个队列中，这个队列就是死信队列。可以观察得到，执行测试代码两秒后消费者拒签消息，三秒后查看队列，也查看不了，总共没有超过队列的存活时间，而且也没有超过队列长度，但依旧看不到，证明消费者拒签后也会变成死信队列。普通交换机和普通队列，然后在创建普通队列时让其绑定死信交换机，并且设置队列的存活时间为15s，以及最大长度为10。
RabbitMQ之死信队列
weixin_43937178的博客
01-08 4325
死信队列概念 顾名思义，（死去的消息）即无法被消费的消息，指的是消费者在消费生产者生产的消息时发生了某些特殊情况（下文会说），导致消息无法被正常消费，存放这些未被消费的消息的队列即为死信队列。 死信队列应用场景 为了保证消息不被丢失，专门存放消息 做延时，将过了过期时间的消息存放在该队列中重新消费 造成消息成为死信的三种原因 消息过了过期时间TTL（time to live） 消息队列达到了最大长度 消息被消费者拒绝（basic.reject或者basic.nack）且requeue=false 死
RabbitMQ——死信队列
风间琉璃の博客
03-09 1536
1. 死信队列 1.1 概念 死信就是无法被消费的消息，消费者从队列中取消息时，由于某些特定原因导致消息无法被消费，即没有了后续的处理，就变成了死信继而有了死信队列。 1.2 应用场景 可以保证消息不会消失，如果消费者在进行消费时发送异常，可以先放到死信队列中，等后面运行环境好了之后再进行消费。 1.3 死信来源 消息TTL过期； 队列达到最大长度； 消息被拒绝。 1.4 死信实战 架构图： 正常情况下使用normal交换机绑定给normal队列C1进行消费； 出现异常情况就转发给 dead交
消息队列--RabbitMQ 学习
xu_jin_shan的博客
04-01 2280
消息队列–RabbitMQ 学习
RabbitMQ超级详解（附带常见问题及答案、安装流程、基础知识、高级特性、实战案列）-用这一篇就够了
11-09
**RabbitMQ超级详解** RabbitMQ是一款广泛使用的开源消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议，适用于多...其易用性、灵活性以及广泛的社区支持使其成为开发者首选的消息队列解决方案之一。
rabbitmq面试题.pdf
06-05
解释RabbitMQ的消息堆积问题及解决方案。** - **问题原因：** 消费者处理能力不足。 - **解决方案：** 增加消费者数量、优化处理逻辑。 **47. 在RabbitMQ中，如何诊断和解决网络问题？** - 利用网络监控工具追踪...
商城项目实战开发系列之消息队列篇：消息队列的使用与设计
消息队列通常是一个中间件，用于解耦应用之间的通信，提高系统的可伸缩性和可靠性。 ## 1.2 消息队列的作用与优势 消息队列的作用包括解耦应用之间的关系、提高系统的可伸缩性、增加系统的稳定性和可靠性、实现...
RabbitMQ：死信队列
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-12 8780
队列中不能被消费的消息称为死信队列有时候因为特殊原因，可能导致队列中的某些信息无法被消费，而队列中这些不能被消费的消息在后期没有进行处理，就会变成死信队列，死信队列中的消息称为死信。应用场景:未来保证订单业务的消息数据不丢失，我们需要使用到RabbitMQ的死信队列机制，当消息消费发生异常的时候，我们就把消息投入到死信队列中，比如说用户买东西，下单成功后去支付，但是没有在指定时间支付的时候就会自动失效。死信队列，英文缩写：DLX。
史上最全 RabbitMQ入门教程，从零开始带你深入♂学习（十一）——死信队列
爱分享的板栗老哥
08-17 556
RabbitMQ（十一）——死信队列 死信队列简介 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息
RabbitMQ: 死信队列
qq_53374893的博客
09-08 1186
其实就是一个普通的队列，绑定号私信交换机，不给ttl，给上匹配的路由，等待交换机发送消息。
RabbitMQ-死信队列
海的那边，还是海吗
09-11 520
当涉及到处理消息队列中无法正常消费的消息时，RabbitMQ的死信队列（Dead Letter Queue，DLQ）是一个关键概念。在这篇博客中，我们将探讨RabbitMQ的死信队列是什么，以及如何使用Java代码设置和处理死信队列。我们将演示如何配置一个死信队列以及如何将无法被正常处理的消息路由到死信队列。在分布式系统中，消息队列是一种关键的通信方式，但有时消息可能因为各种原因无法被正常消费。RabbitMQ的死信队列是一种强大的机制，它可以帮助我们有效地处理这些消息，以便进一步分析和处理。
Java面试：RabbitMQ消息保障与死信队列实战
在Java消息中间件面试中，候选人被问及如何确保RabbitMQ消息的可靠性与避免重复消费。首先，他们强调了生产者确认机制，即启用publisher confirms，当消息成功发布到队列时，会等待服务器确认。若出现错误，生产者会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值