Spring Boot中的RabbitMQ死信队列魔法：从异常到延迟，一网打尽【RabbitMQ实战 一】

已于 2023-12-15 16:34:19 修改
阅读量3.6k 收藏 3
点赞数 54
分类专栏： # RabbitMQ # springboot 文章标签： spring boot rabbitmq 死信队列
于 2023-12-04 22:39:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mrxiao_bo/article/details/134795694
版权

欢迎来到我的博客，代码的世界里，每一行都是一个故事


在这里插入图片描述

Spring Boot中的RabbitMQ死信队列魔法：从异常到延迟，一网打尽

前言

在编写现代应用时，我们经常需要处理异步消息。而当这些消息发生异常或者需要延迟处理时，RabbitMQ的死信队列就像一把神奇的钥匙，为我们打开了新的可能性。本文将带你踏入Spring Boot和RabbitMQ的奇妙世界，揭示死信队列的神秘面纱。

第一：基础整合实现

在Spring Boot中整合RabbitMQ并处理消息消费异常，可以通过使用死信队列（Dead Letter Queue）来捕获异常消息。以下是一个简单的Spring Boot应用程序，演示如何实现这个需求：

首先，确保你的项目中引入了Spring Boot和RabbitMQ的依赖。在pom.xml文件中添加如下依赖：

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <!-- Spring Boot Starter AMQP -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
</dependencies>

接下来，创建一个配置类用于配置RabbitMQ连接和声明死信队列。例如，创建一个名为RabbitMQConfig的类：

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    // 定义普通队列
    @Bean
    public Queue normalQueue() {
        return new Queue("normal.queue");
    }

    // 定义死信队列
    @Bean
    public Queue deadLetterQueue() {
        return QueueBuilder.durable("dead-letter.queue")
                .deadLetterExchange("")
                .deadLetterRoutingKey("dead-letter.queue")
                .build();
    }

    // 定义交换机
    @Bean
    public DirectExchange exchange() {
        return new DirectExchange("exchange");
    }

    // 绑定普通队列到交换机
    @Bean
    public Binding binding(Queue normalQueue, DirectExchange exchange) {
        return BindingBuilder.bind(normalQueue).to(exchange).with("normal.queue");
    }

    // 绑定死信队列到交换机
    @Bean
    public Binding deadLetterBinding(Queue deadLetterQueue, DirectExchange exchange) {
        return BindingBuilder.bind(deadLetterQueue).to(exchange).with("dead-letter.queue");
    }
}

第二：处理消息消费异常

接下来，创建一个消息消费者，同时在消费者中处理异常，将异常消息发送到死信队列。例如，创建一个名为MessageConsumer的类：

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

@Component
public class MessageConsumer {

    @RabbitListener(queues = "normal.queue")
    public void consumeMessage(@Payload String message) {
        try {
            // 处理消息的业务逻辑
            // 如果发生异常，将消息发送到死信队列
            throw new RuntimeException("Simulating an exception during message processing");
        } catch (Exception e) {
            // 发送消息到死信队列
            // 可以在这里记录日志或执行其他操作
            // 注意：此处是简化的示例，实际情况可能需要根据业务需求进行更复杂的处理
            // 这里使用默认的交换机和路由键，发送到死信队列
            // 实际应用中，可能需要根据具体情况进行定制化处理
            // 可以在RabbitTemplate的convertAndSend方法中指定交换机和路由键
            // 例如：rabbitTemplate.convertAndSend("exchange", "dead-letter.queue", message);
        }
    }
}

以上示例演示了如何在消息消费过程中模拟一个异常，并在异常发生时将消息发送到死信队列。实际应用中，你可能需要根据业务需求进行更复杂的异常处理和日志记录。

请注意，这里使用了默认的交换机和路由键将异常消息发送到死信队列。在实际应用中，你可能需要根据具体情况进行更多的定制化处理。

第三：实现延迟消息处理

要实现消息的延迟投递，可以使用RabbitMQ的TTL（Time-To-Live）和死信队列来实现。下面是一个简单的Spring Boot示例，演示如何配置消息的TTL以实现延迟效果：

首先，在RabbitMQConfig配置类中添加一个用于设置消息TTL的MessagePostProcessor：

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    // ... 其他配置 ...

    // 定义消息的 TTL
    @Bean
    public MessagePostProcessor messagePostProcessor() {
        return message -> {
            // 设置消息的 TTL（单位：毫秒）
            message.getMessageProperties().setExpiration("5000"); // 5000毫秒即5秒
            return message;
        };
    }
}

在上述配置中，messagePostProcessor方法返回一个MessagePostProcessor实例，该实例用于设置消息的TTL。在这个例子中，消息的TTL被设置为5000毫秒（即5秒）。

接下来，在消息的生产者中使用RabbitTemplate发送消息时，通过convertAndSend方法添加MessagePostProcessor：

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

@Component
public class MessageProducer {

    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public MessageProducer(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String message) {
        // 发送消息，并添加 MessagePostProcessor 设置 TTL
        rabbitTemplate.convertAndSend("exchange", "normal.queue", message, messagePostProcessor());
    }
}

在上述例子中，通过convertAndSend方法发送消息时，使用messagePostProcessor方法返回的MessagePostProcessor实例来设置消息的TTL。

最后，在MessageConsumer中监听死信队列，处理延迟消息：

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

@Component
public class MessageConsumer {

    @RabbitListener(queues = "dead-letter.queue")
    public void consumeDelayedMessage(@Payload String message) {
        // 处理延迟消息的业务逻辑
        System.out.println("Received delayed message: " + message);
    }
}

在这个例子中，MessageConsumer通过@RabbitListener监听死信队列，一旦有延迟消息到达，就会触发consumeDelayedMessage方法来处理延迟消息的业务逻辑。

这样，通过配置消息的TTL和死信队列，你就实现了延迟消息处理的效果。在实际应用中，可以根据具体需求调整消息的TTL值和处理逻辑。

第四：优雅的消息重试机制

设计可靠的消息重试机制是确保系统在面对消息处理失败时能够自动重试，提高消息的可靠性。以下是一个简单的消息重试机制的实现，利用死信队列进行消息重试。

首先，在RabbitMQConfig配置类中添加一个用于设置消息重试次数的MessagePostProcessor：

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    // ... 其他配置 ...

    // 定义消息的最大重试次数
    private static final int MAX_RETRY_COUNT = 3;

    // 定义消息的 TTL
    @Bean
    public MessagePostProcessor messagePostProcessor() {
        return message -> {
            // 设置消息的 TTL（单位：毫秒）
            message.getMessageProperties().setExpiration("5000"); // 5000毫秒即5秒
            // 设置消息的最大重试次数
            message.getMessageProperties().setHeader("x-max-retry-count", MAX_RETRY_COUNT);
            return message;
        };
    }
}

在上述配置中，MAX_RETRY_COUNT定义了消息的最大重试次数。在messagePostProcessor方法中，通过setHeader设置了消息的最大重试次数。

接下来，在消息的消费者中，通过捕获异常来进行消息的重试。当发生异常时，检查消息的重试次数，如果小于最大重试次数，则将消息重新发送到原队列，否则将消息发送到死信队列：

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

@Component
public class MessageConsumer {

    @RabbitListener(queues = "normal.queue")
    public void consumeMessage(@Payload String message, Message rabbitMessage) {
        try {
            // 处理消息的业务逻辑
            // 如果发生异常，将消息重试
            throw new RuntimeException("Simulating an exception during message processing");
        } catch (Exception e) {
            handleRetry(message, rabbitMessage);
        }
    }

    private void handleRetry(String message, Message rabbitMessage) {
        // 获取消息的重试次数
        Integer retryCount = rabbitMessage.getMessageProperties().getHeader("x-death-retry-count");

        // 如果重试次数小于最大重试次数，则将消息重新发送到原队列
        if (retryCount != null && retryCount < getMaxRetryCount()) {
            System.out.println("Retrying message: " + message);
            // 在实际应用中，可能需要根据业务需求进行更复杂的重试逻辑
            // 这里使用默认的交换机和路由键，发送到原队列
            // 实际应用中，可能需要根据具体情况进行定制化处理
            rabbitTemplate.convertAndSend("exchange", "normal.queue", message, messagePostProcessor());
        } else {
            // 超过最大重试次数，将消息发送到死信队列
            System.out.println("Max retry count reached. Sending message to dead-letter.queue: " + message);
            rabbitTemplate.convertAndSend("exchange", "dead-letter.queue", message, messagePostProcessor());
        }
    }

    private int getMaxRetryCount() {
        // 从配置或其他地方获取最大重试次数
        return RabbitMQConfig.MAX_RETRY_COUNT;
    }
}

在上述例子中，consumeMessage方法模拟了消息处理时的异常。在异常发生时，调用handleRetry方法进行消息的重试。handleRetry方法获取消息的重试次数，如果小于最大重试次数，则将消息重新发送到原队列，否则将消息发送到死信队列。

这样，通过设置消息的TTL和利用死信队列，结合消息重试机制，你可以实现一个优雅的消息重试策略，提高系统的可靠性。在实际应用中，你可能需要根据具体需求调整消息的TTL、最大重试次数和处理逻辑。

第五：异步处理超时消息

处理长时间运行的任务时，通常需要考虑超时机制，以避免无限等待。在消息队列中，可以使用死信队列来处理超时消息。以下是一个简单的示例，演示如何使用死信队列处理异步处理超时的消息。

首先，在RabbitMQConfig配置类中添加一个用于设置消息的TTL和超时队列的配置：

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    // ... 其他配置 ...

    // 定义消息的 TTL
    private static final long MESSAGE_TTL = 10000; // 10秒

    // 定义超时队列
    @Bean
    public Queue timeoutQueue() {
        return QueueBuilder.durable("timeout.queue")
                .deadLetterExchange("")
                .deadLetterRoutingKey("timeout.queue.dead-letter")
                .ttl(MESSAGE_TTL)
                .build();
    }

    // 定义交换机
    @Bean
    public DirectExchange exchange() {
        return new DirectExchange("exchange");
    }

    // 绑定超时队列到交换机
    @Bean
    public Binding timeoutBinding(Queue timeoutQueue, DirectExchange exchange) {
        return BindingBuilder.bind(timeoutQueue).to(exchange).with("timeout.queue");
    }
}

在上述配置中，MESSAGE_TTL定义了消息的TTL，这里设置为10秒。timeoutQueue方法定义了超时队列，并通过ttl方法设置了队列的TTL。

接下来，在消息的生产者中，使用RabbitTemplate发送消息时，发送到超时队列：

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

@Component
public class MessageProducer {

    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public MessageProducer(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendTimeoutMessage(String message) {
        // 发送消息到超时队列
        rabbitTemplate.convertAndSend("exchange", "timeout.queue", message);
    }
}

在上述例子中，通过convertAndSend方法将消息发送到超时队列。

最后，在消息的消费者中监听死信队列，处理超时消息：

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

@Component
public class MessageConsumer {

    @RabbitListener(queues = "timeout.queue.dead-letter")
    public void handleTimeoutMessage(@Payload String message) {
        // 处理超时消息的业务逻辑
        System.out.println("Received timeout message: " + message);
    }
}

在这个例子中，MessageConsumer通过@RabbitListener监听死信队列，一旦有超时消息到达，就会触发handleTimeoutMessage方法来处理超时消息的业务逻辑。

通过配置消息的TTL和死信队列，结合异步处理，你可以实现一个可靠的超时处理机制。在实际应用中，你可能需要根据具体需求调整消息的TTL值和处理逻辑。

第六：广泛的实际应用场景

在实际应用中，消息队列和异步消息处理在许多场景中都是非常有用的。以下是一些广泛的实际应用场景：

  1. 订单支付状态更新：

    • 当用户发起支付请求后，可以使用消息队列来异步处理支付状态的更新。
    • 消息队列可以将支付成功或失败的消息发送给订单服务，订单服务异步处理并更新订单状态。
    • 这种方式可以提高系统的响应速度，避免在支付过程中用户长时间等待。

  2. 用户通知和提醒：

    • 当有新的消息、通知或提醒需要发送给用户时，可以使用消息队列来异步处理。
    • 例如，用户注册成功后，系统可以通过消息队列异步发送欢迎邮件或短信给用户。
    • 这样可以降低用户注册的响应时间，提升用户体验。

  3. 邮件发送和异步任务：

    • 邮件发送是一个常见的异步任务，可以使用消息队列来处理邮件发送请求。
    • 用户触发的某些操作（如密码重置、订单确认等）可能需要发送邮件通知，通过消息队列异步发送邮件可以提高系统的吞吐量。
    • 异步任务的其他场景包括数据处理、生成报告等耗时的操作。

  4. 系统解耦和微服务通信：

    • 在微服务架构中，不同服务之间的通信可以通过消息队列来实现解耦。
    • 服务之间通过消息队列发送事件，其他服务订阅并响应这些事件，从而实现松耦合的微服务通信。

  5. 日志收集和分析：

    • 将系统产生的日志异步发送到消息队列，以便后续进行集中的日志收集和分析。
    • 这有助于监控系统的运行状况、发现问题和进行性能分析。

  6. 批量处理和数据同步：

    • 在需要进行批量处理或数据同步的场景，消息队列可以用于异步触发这些任务。
    • 例如，定时异步同步用户数据、商品库存更新等。

这些场景中，消息队列提供了一种解耦和异步处理的机制，有助于提高系统的可伸缩性、稳定性和性能。选择适当的消息队列服务和合适的消息处理策略对于不同场景非常重要。

总结

通过学习本文，你将深入了解如何在Spring Boot应用中高效、灵活地应用RabbitMQ死信队列。实际的代码实现将为你打开处理异步消息的新视角，让你在项目中更加从容地面对各种消息场景。死信队列不再是未知的领域，而是成为你解决异步消息难题的得力助手。开始你的RabbitMQ死信队列之旅吧！

结语

深深感谢你阅读完整篇文章，希望你从中获得了些许收获。如果觉得有价值，欢迎点赞、收藏，并关注我的更新，期待与你共同分享更多技术与思考。

在这里插入图片描述

一只牛博
关注
  • 54
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Spring Boot与RabbitMQ结合实现延迟队列的示例
08-28
本篇文章主要介绍了Spring Boot与RabbitMQ结合实现延迟队列的示例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring Boot整合RabbitMQ开发实战详解
08-28
主要介绍了Spring Boot整合RabbitMQ开发实战，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot基于RabbitMQ实现消息延迟队列方案
“ 春风若有怜花意，能否许我再少年。”
04-15 7441
在此之前，简单说明下基于RabbitMQ实现延时队列的相关知识及说明下延时队列的使用场景。
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种支持。下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
RabbitMQ死信队列应用1
08-03
1、什么是死信队列 2、死信队列应用场景 3、延迟消息概念 4、死信队列使用流程图 5、死信队列应用（管理控制台） 6、死信队列应用（Java代码）
Spring RabbitMQ死信机制原理实例详解
08-24
主要介绍了Spring RabbitMQ死信机制原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot整合rabbitmq传递对象时无限循环报错处理
文盲青年的博客
09-05 2504
https://www.cnblogs.com/lazio10000/p/5559999.html
Spring集成消息队列RabbitMQ(消息失败处理)
很多时候犯错都是在不知情的情况下发生的
11-30 1万+
1. RabbitMQ简介 1.1. RabbitMQ RabbitMQ是由Erlang(爱立信公司)语言开发，实现Advanced Message Queuing Protocol (AMQP高级消息队列协议)的消息中间件。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 1.2. 结构图   • Broker：消息队列服务器实体，例如
搭建消息时光机：深入探究RabbitMQ_recent_history_exchange在Spring Boot中的应用【RabbitMQ实战 二】
热门推荐
todoitbo的博客
12-13 7万+
在本文中，我们将深入探讨如何将RabbitMQ_recent_history_exchange与Spring Boot相结合，为你的消息通信提供全新的维度。通过使用recent_history_exchange，你将能够实现更灵活、高效的消息传递，解锁全新的异步通信方式。本文将提供详细的步骤和示例，帮助你快速上手，充分发挥RabbitMQ_recent_history_exchange的潜力。
分布式消息传递新时代：深入了解RabbitMQ_sharding插件的精髓【RabbitMQ 八】
todoitbo的博客
12-15 121
本文将深入研究RabbitMQ_sharding插件，探索其在分布式消息系统中的威力。通过详细的解析和实例演示，读者将对如何有效地利用该插件进行大规模消息处理有一个全面的了解。文章将介绍其设计原理、应用场景以及在实际项目中的应用方法，为你打开异步通信的新大门。
【rabbitmq】使用延时队列+死信队列实现上篇的重试操作
吾生也有涯，而知也无涯
07-13 698
首先来安装rabbitmq，我是在wsl上安装的，你可以根据自己的操作系统选择安装
RabbitMq基础及死信队列使用
qq_36382225的博客
03-02 243
交换机模式 fanout fanout类型的Exchange路由规则非常简单，它会把所有发送到该Exchange的消息路由到所有与它绑定的Queue中。 direct direct类型的Exchange路由规则也很简单，它会把消息路由到那些binding key与routing key完全匹配的Queue中。 topic 前面讲到direct类型的Exchange路由规则是完全匹配binding key与routing key，但这种严格的匹配方式在很多情况下不能满足实际业务需求。topic类型的Exch
RabbitMq死信队列及其处理方案
深圳市多克创新科技有限公司
03-20 2309
RabbitMq死信队列及其处理方案
Spring Boot与MongoDB集成指南
无远弗届
05-29 675
在深入探讨Spring Boot与MongoDB的集成之前，让我们先深入了解Spring Boot这一强大的Java框架。MongoDB是一个高性能、高可用性和高伸缩性的NoSQL数据库，它以其独特的数据模型、灵活的查询语言和强大的聚合框架而受到开发者的青睐。在深入了解如何将MongoDB与Spring Boot集成之前，让我们先全面了解MongoDB的基本概念和特性。
[AIGC] Spring Boot 2 自定义 Starter 指南
程序员三木的博客
05-29 586
Spring Boot 包含一系列的 “Starter POMs”，它们都是一些方便的依赖描述符，你可以在你的应用中导入。在一些情况下，你可能想创建自己的自定义 starter。以下是创建自己的 Spring Boot Starter 的步骤。
RabbitMQ-默认读、写方式介绍
liupenglove的专栏
05-26 935
了解rabbitmq的设计架构，对理解mq如何使用有很大的帮助。一个非常重要的点，mq中的生产者从来不是直接将消息发送到队列中的，而是将消息发送到了mq的交换机中(上图中的exchange为交换机)， 甚至生产者都不知道这条消息将被发送到哪个队列中。交换机是个怎样的设计呢，他的一侧连接生产者，从生产者接收消息，另外一侧连接队列，将消息push进队列中，将消息push进一个队列，还是多个队列，还是抛弃，这些策略是由交换机的类型决定的，对于交换机的使用，后面详细介绍。
RabbitMQ小结
javanmsl的博客
06-02 421
kafka优点：性能好，吞吐量高百万级，分布式，消息有序缺点：单机超过64分区，cpu会飙高，消费失败不支持重试 ，
RabbitMQ-直连交换机(direct)使用方法
最新发布
liupenglove的专栏
06-02 584
直连交换机，可以实现类似路由的功能，消息从交换机发送到哪个队列，直连交换机是支持配置的，他可以根据不同的routing key将消息转发到不同的队列当中。false,nil)false,nil)在上面的代码中，routing key参数，在扇形交换机是无效的，这点大家要注意。以上就是rabbitmq直连交换机的使用方式，示例代码只是做了简单的演示，对于多重绑定，各种路由规则可以自行尝试，直连交换机模式，为开发者提供了灵活的路由规则，推荐使用。
rabbitmq死信队列使用
08-24
RabbitMQ 的死信队列（Dead Letter Queue）是一种特殊的队列，用于处理无法被消费者正常处理的消息。当消息在消费者端发生异常、超时或被拒绝时，可以将这些消息发送到死信队列中，以便进行后续处理。 下面是使用 RabbitMQ 死信队列的步骤： 1. 创建主要的消息队列和死信队列： 首先，创建主要的消息队列（Main Queue），并设置相关属性，例如交换机、路由键等。然后，创建死信队列（Dead Letter Queue），通常与主要队列绑定在一起。 2. 设置消息的过期时间： 在发送消息时，为消息设置一个过期时间＊＊＊ 配置死信队列绑定： 将主要队列配置为将死信消息发送到死信队列。可以使用 RabbitMQ 的插件或者通过代码进行配置。 4. 处理死信消息： 在死信队列上设置一个消费者来处理死信消息。可以根据需要对这些消息进行额外的处理，

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只牛博

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值