6 RabbitMQ之死信队列

已于 2022-07-01 01:28:13 修改
阅读量1.1k 收藏 7
点赞数 2
分类专栏： rabbitmq 文章标签： rabbitmq TTL 队列最大长度 消息被拒绝 死信队列
于 2022-07-01 01:27:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010502101/article/details/125454485
版权

文章目录


死信就是无法被消费的消息成为死信。正常情况下，生产者生产的消息投递到交换机，交换机根据routingKey路由到队列中，消费者从队列中消费消息。但由于某些特定原因导致队列中消息无法被消费者正常消费后，消息就变成了死信消息，存放死信消息的队列就成为死信队列。
死信队列目的就是把未能正常消费的消息保存到死信队列中，保证消息不丢失。

造成消息死信的原因主要有以下3点：

  • 消息TTL过期，TTL指Time To Live，指消息在队列中存活的时间；
  • 队列达到最大长度，队列已经满，无法再继续添加消息；
  • 消息被拒接，消息被消费者消费后，消费者发送了basic.reject拒绝指令或者basic.nack否定指令。

下面通过代码演示三种原因下死信队列的处理，如下图所示，首先生产者生产消息投递到normal_exchange交换机，然后路由到normal_queue中，队列中消息可以被Consumer1正常消费的消息会从队列中删除掉，但由于上述三种原因导致消息不能正常被消费的消息就会被重新投递到dead_exchange死信交换机，然后被路由到dead_queue死信队列中，最后死信消息被Consumer2处理。
在这里插入图片描述

1. 案例一：消息TTL过期

首先创建一个Consumer1消费者类，Consumer1类中创建了一个normal_exchange正常交换机，一个dead_exchange死信交换机，创建了一个normal_queue正常队列，一个dead_queue死信队列，并且正常交换机通过routingKey=normal绑定了正常交换机，通过死信交换机通过routingKey=dead绑定了死信队列。然后声明normal_queue队列时还关联了私信交换机，当消息消费失败后消息会重新投递到死信交换机，然后被路由到死信队列中，最后被Consumer2消费。normal_queue队列中可正常消费的消息会被Consumer1进行消费。

public class Consumer1 {
    private static final String NORMAL_EXCHANGE = "normal_exchange";      /*正常交换机*/
    private static final String DEAD_EXCHANGE = "dead_exchange";        /*死信交换机*/
    private static final String NORMAL_QUEUE = "normal_queue";          /*正常队列*/
    private static final String DEAD_QUEUE = "dead_queue";              /*死信队列*/
    public static void main(String[] args) throws IOException, TimeoutException {
        /*获取信道*/
        Channel channel = RabbitmqUtil.getChannel();
        /*声明死信交换机和普通交换机*/
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        /*声明死信队列*/
        channel.queueDeclare(DEAD_QUEUE, false, false, false, null);
        /*死信队列绑定死信交换机*/
        channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, "dead");

        /*声明正常队列, 在声明队列前设置队列的属性*/
        Map<String, Object> parms = new HashMap<>();
        /*设置消息过期时间10s，超过10s后消息就会被投递到死信交换机，此参数可以在生产端设置*/
        //parms.put("x-message-ttl", 10000);
        /*正常队列关联死信交换机, 关联key是固定的, 关联后正常队列中消息无法被消费者消费后就会把消息投递到死信交换机*/
        parms.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        /*为正常队列设置消息失败后投递到死信交换机绑定的routingKey, 这样消息消费后就会被死信交换机通过"dead"这个routingKey路由到死信队列中*/
        parms.put("x-dead-letter-routing-key", "dead");
        channel.queueDeclare(NORMAL_QUEUE, false, false, false, parms);
        /*正常队列绑定正常交换机*/
        channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, "normal");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(message);
        };

        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消费失败");
        };

        channel.basicConsume(NORMAL_QUEUE, true, deliverCallback, cancelCallback);

    }
}

下面创建Consumer2类用于消费死信消息

import com.lzj.rabbitmq.RabbitmqUtil;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer2 {
    private static final String DEAD_QUEUE = "dead_queue";              /*死信队列*/

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitmqUtil.getChannel();
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(message);
        };

        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消费失败");
        };

        channel.basicConsume(DEAD_QUEUE, true, deliverCallback, cancelCallback);

    }
}

最后创建Producer生产者用于生产消息，并对每个消息都设置了在队列中的过期时间10s。

public class Producer {
    private static final String NORMAL_CHANGE = "normal_exchange";
    public static void main(String[] args) throws IOException, TimeoutException {
        /*获取信道*/
        Channel channel = RabbitmqUtil.getChannel();
        /*设置消息在队列中存活时间，10s后消息过期*/
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
        /*发布消息*/
        String message = null;
        for (int i=1; i<5; i++){
            message = "commodity" + i;
            channel.basicPublish(NORMAL_CHANGE, "normal", properties,  message.getBytes());
            System.out.println("生产者发布消息：" + message);
        }
    }
}

下面进行测试，首先运行Consumer1进行正常交换机、死信交换机和正常队列、死信队列的已经绑定关系的创建，运行完Consumer1后从RabbitMQ浏览器管理端可以查看交换机以及队列创建情况，其中normal_queue队列中含有两个属性DLK和DLX，DLX表示死信交换机，DLK表示死信交换机的routingKey。
在这里插入图片描述
下面启动生产者Producer，为模拟生产者生产的消息经过10s后都没有被Consumer1消费而进入死信队列，在启动生产者之前先关闭Consumer1，这样生产者生产的消息无法被Consumer1消费从而进入死信队列。运行Producer后，输出如下4个消息，表示生产者生产了下面4个消息

生产者发布消息：commodity1
生产者发布消息：commodity2
生产者发布消息：commodity3
生产者发布消息：commodity4

从浏览器管理端可以看到normal_queue队列中也正好有4条待处理的消息
在这里插入图片描述
经过10s后再看浏览器管理端，可以发现normal_queue队列中的4条消息都进到了dead_queue死信队列中
在这里插入图片描述
下面启动Consumer2消费者消费掉死信队列中消息，输出下面4条消息，从而验证此4条消息就是生产者生产的4条消息，此4条消息过期后进入的死信队列中。

commodity1
commodity2
commodity3
commodity4

2. 案例二：队列达到最大长度

设定normal_queue队列最大长度为4，当队列中消息条数达到4条时进入死信队列。
首先从浏览器管理端删除掉案例一中创建的normal_queue队列，重新创建normal_queue队列，在创建队列过程中通过x-max-length参数指定队列的最大长度

parms.put("x-max-length", 4);

修改后的Consumer1程序如下所示

public class Consumer1 {
        private static final String NORMAL_EXCHANGE = "normal_exchange";      /*正常交换机*/
        private static final String DEAD_EXCHANGE = "dead_exchange";        /*死信交换机*/
        private static final String NORMAL_QUEUE = "normal_queue";          /*正常队列*/
        private static final String DEAD_QUEUE = "dead_queue";              /*死信队列*/
        public static void main(String[] args) throws IOException, TimeoutException {
            /*获取信道*/
            Channel channel = RabbitmqUtil.getChannel();
            /*声明死信交换机和普通交换机*/
            channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
            channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
    
            /*声明死信队列*/
            channel.queueDeclare(DEAD_QUEUE, false, false, false, null);
            /*死信队列绑定死信交换机*/
            channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, "dead");
    
            /*声明正常队列, 在声明队列前设置队列的属性*/
            Map<String, Object> parms = new HashMap<>();
            /*设置消息过期时间10s，超过10s后消息就会被投递到死信交换机*/
            //parms.put("x-message-ttl", 10000);
            /*正常队列关联死信交换机, 关联key是固定的, 关联后正常队列中消息无法被消费者消费后就会把消息投递到死信交换机*/
            parms.put("x-dead-letter-exchange", DEAD_EXCHANGE);
            /*为正常队列设置消息失败后投递到死信交换机绑定的routingKey, 这样消息消费后就会被死信交换机通过"dead"这个routingKey路由到死信队列中*/
            parms.put("x-dead-letter-routing-key", "dead");
            /*设定队列的最大长度限制为4, 表示正常队列中最多同时存放4条消息,继续投递过来的消息只能进死信队列*/
            parms.put("x-max-length", 4);
            channel.queueDeclare(NORMAL_QUEUE, false, false, false, parms);
            /*正常队列绑定正常交换机*/
            channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, "normal");
    
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(message);
            };
    
            CancelCallback cancelCallback = consumerTag -> {
                System.out.println("消费失败");
            };
    
            channel.basicConsume(NORMAL_QUEUE, true, deliverCallback, cancelCallback);
    
        }
    }

Producer代码中注释掉设置的消息过期时间，并且设置发布7条消息，修改后代码如下所示

public class Producer {
    private static final String NORMAL_CHANGE = "normal_exchange";
    public static void main(String[] args) throws IOException, TimeoutException {
        /*获取信道*/
        Channel channel = RabbitmqUtil.getChannel();
        /*设置消息在队列中存活时间*/
        //AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
        /*发布消息*/
        String message = null;
        for (int i=1; i<8; i++){
            message = "commodity" + i;
            channel.basicPublish(NORMAL_CHANGE, "normal", null,  message.getBytes());
            System.out.println("生产者发布消息：" + message);
        }
    }
}

Consumer2代码无任何修改。

下面重新进行验证，首先启动Conumer1程序，主要是为先创建normal_queue队列，从浏览器管理端可以查看创建的normal_queue队列，其中该队列有3个属性，Lim表示队列设置了最大长度。
在这里插入图片描述
下面为了验证正常队列中4条消息满了后其余消息就会进入死信队列，首先关闭Consumer1，然后启动Producer，输出如下7条消息，表示生产者生产了下述7条消息

生产者发布消息：commodity1
生产者发布消息：commodity2
生产者发布消息：commodity3
生产者发布消息：commodity4
生产者发布消息：commodity5
生产者发布消息：commodity6
生产者发布消息：commodity7

查看浏览器管理端如下所示，正常队列中有4条消息，正好是正常队列的最大限度，而死信队列中是3条记录。在这里插入图片描述
下面启动Consumer2消费掉死信队列中的消息，发现是下面3条消息进入了死信队列

commodity1
commodity2
commodity3

然后再重新启动Consumer1消费掉正常队列中的消息，发现是下面4条消息进入的正常队列。

commodity4
commodity5
commodity6
commodity7

3. 案例三：消息被拒

还是以上图所示案例，当生产者生产的消息被Consumer1拒绝消费时，被拒绝的消息就会投递到死信队列中。
假设生产者生产commodity1~commodity7之间的消息，但只有commodity3被拒绝消费。

下面修改Consumer1代码，只需要在添加一句向RabbitMQ服务器发送basicReject的拒绝指令即可，修改后代码如下

public class Consumer1 {
    private static final String NORMAL_EXCHANGE = "normal_exchange";      /*正常交换机*/
    private static final String DEAD_EXCHANGE = "dead_exchange";        /*死信交换机*/
    private static final String NORMAL_QUEUE = "normal_queue";          /*正常队列*/
    private static final String DEAD_QUEUE = "dead_queue";              /*死信队列*/
    public static void main(String[] args) throws IOException, TimeoutException {
        /*获取信道*/
        Channel channel = RabbitmqUtil.getChannel();
        /*声明死信交换机和普通交换机*/
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        /*声明死信队列*/
        channel.queueDeclare(DEAD_QUEUE, false, false, false, null);
        /*死信队列绑定死信交换机*/
        channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, "dead");

        /*声明正常队列, 在声明队列前设置队列的属性*/
        Map<String, Object> parms = new HashMap<>();
        /*设置消息过期时间10s，超过10s后消息就会被投递到死信交换机*/
        //parms.put("x-message-ttl", 10000);
        /*正常队列关联死信交换机, 关联key是固定的, 关联后正常队列中消息无法被消费者消费后就会把消息投递到死信交换机*/
        parms.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        /*为正常队列设置消息失败后投递到死信交换机绑定的routingKey, 这样消息消费后就会被死信交换机通过"dead"这个routingKey路由到死信队列中*/
        parms.put("x-dead-letter-routing-key", "dead");
        /*设定队列的最大长度限制为4, 表示正常队列中最多同时存放4条消息,继续投递过来的消息只能进死信队列*/
        //parms.put("x-max-length", 4);
        channel.queueDeclare(NORMAL_QUEUE, false, false, false, parms);
        /*正常队列绑定正常交换机*/
        channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, "normal");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            if (message.equals("commodity3")){
                System.out.println("Consumer1拒绝处理消息：" + message);
                channel.basicReject(delivery.getEnvelope().getDeliveryTag(), false); //false表示被拒绝的消息不再放入队列中
            }else {
                System.out.println(message + "消费成功");
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            }
        };

        CancelCallback cancelCallback = consumerTag -> {
            System.out.println("消费失败");
        };

        channel.basicConsume(NORMAL_QUEUE, false, deliverCallback, cancelCallback);

    }
}

Producer类和Consumer2类继续采用案例二中的

下面进行测试，在进行测试前首先删除normal_queue队列，然后重新启动Consumer1类，然后再启动Producer进行生产消息，生产者输出如下，表示生产了7条消息

生产者发布消息：commodity1
生产者发布消息：commodity2
生产者发布消息：commodity3
生产者发布消息：commodity4
生产者发布消息：commodity5
生产者发布消息：commodity6
生产者发布消息：commodity7

再看Consumer1的输出如下所示，表示除了commodity3消息被拒绝处理，其他6个消息都被正常消费了

ommodity1消费成功
commodity2消费成功
Consumer1拒绝处理消息：commodity3
commodity4消费成功
commodity5消费成功
commodity6消费成功
commodity7消费成功

再看我们监控端，显示有一个消息被投递到了dead_queue死信队列中
在这里插入图片描述
为了确定死信队列中的一个消息是否是被拒绝的commodity3消息，下面启动Consumer2消费死信队列中消息，输出如下所示，表示死信队列中的消息正是被Consumer1拒绝处理的commodity3消息。

commodity3
苍鹰蛟龙
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合Rabbitmq之死信队列
桐花思雨
09-25 2935
目录死信队列死信从何而来 死信队列 死信：无法被消费方消费掉的消息，称为死信。如果死信一直留在队列中，会导致一直被消费，却从不消费成功。所以 rabbitmq 专门开辟了一个来存放死信的队列，叫死信队列（DLX，dead-letter-exchange） 死信从何而来 消息被拒绝（调用 basicNack() 或 basicReject()，并且参数 requeue = false） 消息过期，过了 TTL 存活时间 队列设置了 x-max-length 最大消息数量且当前队列中的消息已经达到了这个数量，
springboot整合rabbitmq使用死信队列
11-06
在这个场景中，我们将重点讨论如何在Spring Boot中整合RabbitMQ，并利用死信队列（Dead-Letter Queue，DLQ）来处理异常消息。 首先，我们需要在Spring Boot项目中引入RabbitMQ的相关依赖。在`pom.xml`文件中，添加...
RabbitMQ 之 死信队列
weixin_73616913的博客
05-27 1228
但是发生了上面所说的三种情况中的一种，成为了死信，然后被转换到死信交换机中，这个死信交换机也是 direct 类型，它们之间的 routingKey 是 "lisi",然后就进入了死信队列，死信队列由 C2 消费。生产者正常情况下走的是普通的交换机，这个交换机的类型是 direct ，它和普通队列之间的关系是一个叫 "zhangsan" 的路由 key， 正常情况下会被 C1 消费。应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息。，字面意思可以这样理。
RabbitMQ--死信队列
DreamDlee的博客
05-13 1938
死信顾名思义就是没办法被消费的消息；
RabbitMQ：死信队列
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-12 8549
队列中不能被消费的消息称为死信队列有时候因为特殊原因，可能导致队列中的某些信息无法被消费，而队列中这些不能被消费的消息在后期没有进行处理，就会变成死信队列，死信队列中的消息称为死信。应用场景:未来保证订单业务的消息数据不丢失，我们需要使用到RabbitMQ的死信队列机制，当消息消费发生异常的时候，我们就把消息投入到死信队列中，比如说用户买东西，下单成功后去支付，但是没有在指定时间支付的时候就会自动失效。死信队列，英文缩写：DLX。
RabbitMQ之死信队列解读
一个菜鸡的博客
10-12 548
什么是死信交换机在定义业务队列的时候，要考虑指定一个死信交换机，死信交换机可以和任何一个普通的队列进行绑定，然后在业务队列出现死信的时候就会将数据发送到死信队列。什么是死信队列死信队列实际上就是一个普通的队列，只是这个队列跟死信交换机进行了绑定，用来存放死信而已RabbitMQ 中有一种交换器叫 DLX，全称为 Dead-Letter-Exchange，可以称之为死信交换器。
RabbitMQ之死信队列
冲出仁川，走出马德里，故事还会再继续
12-23 1195
死信队列1、死信队列的概念2、死信的来源3、死信实战3.1 代码架构图3.2 1、死信队列的概念 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使
rabbitMQ引入死信队列
2301_78149288的博客
01-06 1330
指的是，从队列当中取出来的消息，到达消费方后，因为某些原因导致消息并没有被正常消费掉，这些没有被后续处理的消息就是“死信”，而保存死信的队列，就是死信队列。
RabbitMQ的死信队列
一江溪水
11-13 6832
什么是死信 在 RabbitMQ 中充当主角的就是消息，在不同场景下，消息会有不同地表现。 死信就是消息在特定场景下的一种表现形式，这些场景包括： 消息被拒绝访问，即 RabbitMQ返回 nack 的信号时 消息的 TTL 过期时 消息队列达到最大长度 消息不能入队时。 上述场景经常产生死信，即消息在这些场景中时，被称为死信。 什么是死信队列 死信队列就是用于储存死信的消息队列，在死信队列中，有且只有死信构成，不会存在其余类型的消息。 死信队列在 RabbitMQ 中并不会单独存在，往往死信队列都会绑
RabbitMq之死信队列
qq_46127735的博客
10-09 441
死信队列 1. 死信的概念 死信，顾名思义就是死掉的信息（无法被消费的信息），一般来说，就是生产者将消息发送给broker（exchange+queue），但由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有被处理，就形成了死信，有死信自然就有死信队列，来存放死信。 2. 死信的来源 1.消息TTL时间过期 2.队列达到最大长度（无法再接收消息） 3.消息被拒绝 (比如 ： basic.reject 或 basic.nack)并且 requeue=false 3. 应用场景 为了保证订单
RabbitMQ创建死信队列
一个头发贼多的小火鸡
05-27 946
RabbitMQ创建死信队列示例
Spring RabbitMQ死信机制原理实例详解
08-24
在 Spring RabbitMQ 中，可以通过配置死信队列和死信交换机来实现死信机制。例如： ```java @Bean public Queue deadQueue() { return new Queue(DEAD_QUEUE_NAME, true); } @Bean public DirectExchange ...
RabbitMQ死信队列应用1
08-03
RabbitMQ死信队列（Dead Letter Exchange, DLX）是一种高级特性，用于处理那些无法正常处理或过期的消息。当消息在业务队列中处理失败，如因异常导致重试次数达到上限，就会变为死信。DLX允许将这些死信重新发布到另...
rabbitMQ 死信队列 完整例子
03-19
**RabbitMQ死信队列完整实例解析** 在分布式系统中，消息队列扮演着重要的角色，它能够帮助处理高并发、异步任务以及解耦系统组件。RabbitMQ作为一款广泛使用的开源消息代理和队列服务器，其提供的死信队列（Dead ...
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
SpringBoot集成RabbitMQ的方法(死信队列) SpringBoot集成RabbitMQ的方法是指使用SpringBoot框架集成RabbitMQ消息队列的方法，RabbitMQ是一种基于AMQP协议的开源消息队列软件。该方法可以实现消息的异步处理，提高...
RabbitMQ+redis+Redisson分布式锁+seata实现订单服务
架构师小吴的博客
07-22 807
（相关解释直接在代码注释上了）
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
rabbitmq使用死信队列
07-10
RabbitMQ中的死信队列是一种特殊类型的队列，它用于处理那些无法正常路由或者消费的消息。当消息满足某些特定条件时，比如超时未被消费、消费者取消订阅、或者是由于异常导致无法处理，RabbitMQ会将这些消息移动到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值