Springboot整合RabbitMQ

最新推荐文章于 2024-07-15 20:00:00 发布
最新推荐文章于 2024-07-15 20:00:00 发布
阅读量3k 收藏 5
点赞数 1
分类专栏： MQ消息中间件 文章标签： spring boot rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45698637/article/details/124221053
版权

Springboot整合RabbitMQ

docker 安装RabbitMQ

docker run -it -d -p 5672:5672 -p15672:15672 --hostname my-rabbit --name my-rabbit \
		   -v /home/docker_volume/rabbit/:/var/lib/rabbitmq \
		   -e RABBITMQ_DEFAULT_USER=admin \
		   -e RABBITMQ_DEFAULT_PASS=admin rabbitmq:3-management

启动成功后，浏览器访问 http://192.168.0.105:15672/，进入rabbitmq管理界面。

配置文件

1. pom文件，添加amqp依赖

<!-- rabbit-mq -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2. application.yml文件，配置RabbitMQ服务

server:
  port: 8080

# RabbitMQ配置
spring:
  rabbitmq:
    host: 192.168.0.105
    port: 5672
    username: admin
    password: admin
    virtual-host: /

RabbitMQ 基本使用

1. Fanout模式（发布订阅）使用

1.1 Fanout模式配置文件，配置交换机、消息队列，并进行绑定

@Configuration
public class RabbitMQConfigFanout {

    // 1.声明注册Fanout模式的交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanout-exchange");
    }
    // 2.声明队列 参数durable: true表示消息队列持久化
    @Bean
    public Queue smsQueue(){
        return new Queue("fanout-queue-sms", true);
    }
    @Bean
    public Queue emailQueue(){
        return new Queue("fanout-queue-email", true);
    }
    @Bean
    public Queue duanxinQueue(){
        return new Queue("fanout-queue-duanxin", true);
    }
    // 3.消息队列和交换机进行绑定
    @Bean
    public Binding smsBinding(){
        return BindingBuilder.bind(smsQueue()).to(fanoutExchange());
    }
    @Bean
    public Binding emailBinding(){
        return BindingBuilder.bind(emailQueue()).to(fanoutExchange());
    }
    @Bean
    public Binding duanxinBinding(){
        return BindingBuilder.bind(duanxinQueue()).to(fanoutExchange());
    }
}

1.2 生产者，发送消息到交换机，交换机会分发到所绑定消息队列

@Service
public class OrderService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void makeOrder() {
        // 1.根据商品id查询库存是否充足
        // 2.产生订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单id: " + orderId);
        // 3.RabbitMQ完成消息分发
        /**
         *  exchange: 交换机名称
         *  routingKey: 路由key/queue队列名称
         *  object: 消息内容
         */
        String exchange = "fanout-exchange";
        String routingKey = "";
        rabbitTemplate.convertAndSend(exchange, routingKey, orderId);
    }
}

1.3 消费者，三个消费者分别消费三个队列的消息

@Service
public class MQFanoutConsumer {

    @RabbitListener(queues = "fanout-queue-sms")
    public void receiveSmsMsg(String message){
        System.out.println("sms fanout 接收到了订单信息 >> : " + message);
    }
    @RabbitListener(queues = "fanout-queue-email")
    public void receiveEmailMsg(String message){
        System.out.println("email fanout 接收到了订单信息 >> : " + message);
    }
    @RabbitListener(queues = "fanout-queue-duanxin")
    public void receiveDuanxinMsg(String message){
        System.out.println("duanxin fanout 接收到了订单信息 >> : " + message);
    }
}

1.4 调用生产者方法进行测试，查看消费者控制台输出，三个消费者全部收到了消息

duanxin fanout 接收到了订单信息 >> : ff311aa8-37d0-4bb3-99f9-edb776799d69
email fanout 接收到了订单信息 >> : ff311aa8-37d0-4bb3-99f9-edb776799d69
sms fanout 接收到了订单信息 >> : ff311aa8-37d0-4bb3-99f9-edb776799d69

2. Direct模式（路由RoutingKey）使用

2.1 Direct模式配置文件，配置交换机、消息队列，并进行绑定，并绑定 routingKey

@Configuration
public class RabbitMQConfigDirect {

    // 1.声明注册Direct模式的交换机
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("direct-exchange");
    }
    // 2.声明队列 参数durable: true表示消息队列持久化
    @Bean
    public Queue smsQueueDirect(){
        return new Queue("direct-queue-sms", true);
    }
    @Bean
    public Queue emailQueueDirect(){
        return new Queue("direct-queue-email", true);
    }
    @Bean
    public Queue duanxinQueueDirect(){
        return new Queue("direct-queue-duanxin", true);
    }
    // 3.消息队列和交换机进行绑定，指定routingKey
    @Bean
    public Binding smsBindingDirect(){
        return BindingBuilder.bind(smsQueueDirect()).to(directExchange()).with("sms");
    }
    @Bean
    public Binding emailBindingDirect(){
        return BindingBuilder.bind(emailQueueDirect()).to(directExchange()).with("email");
    }
    @Bean
    public Binding duanxinBindingDirect(){
        return BindingBuilder.bind(duanxinQueueDirect()).to(directExchange()).with("duanxin");
    }
}

2.2 生产者，发送消息到交换机，并指定routingKey，交换机会分发到所绑定消息队列

public void makeOrderDirect() {
    // 1.根据商品id查询库存是否充足
    // 2.产生订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单id: " + orderId);
    // 3.RabbitMQ完成消息分发
    String exchange = "direct-exchange";
    rabbitTemplate.convertAndSend(exchange, "email", orderId);
    rabbitTemplate.convertAndSend(exchange, "sms", orderId);
}

2.3 消费者，三个消费者分别消费三个队列的消息

@Service
public class MQDirectConsumer {

    @RabbitListener(queues = "direct-queue-sms")
    public void receiveSmsMsg(String message){
        System.out.println("sms direct 接收到了订单信息 >> : " + message);
    }
    @RabbitListener(queues = "direct-queue-email")
    public void receiveEmailMsg(String message){
        System.out.println("email direct 接收到了订单信息 >> : " + message);
    }
    @RabbitListener(queues = "direct-queue-duanxin")
    public void receiveDuanxinMsg(String message){
        System.out.println("duanxin direct 接收到了订单信息 >> : " + message);
    }
}

2.4 调用生产者方法进行测试，查看消费者控制台输出，只有匹配的routingKey才收到了消息

email direct 接收到了订单信息 >> : fd718eb4-060b-451a-b600-8f8f4f7a826d
sms direct 接收到了订单信息 >> : fd718eb4-060b-451a-b600-8f8f4f7a826d

3. Topic模式（模糊路由RoutingKey）使用

3.1 Topic模式配置文件，配置交换机、消息队列，并进行绑定，并绑定 动态routingKey（模糊匹配）

@Configuration
public class RabbitMQConfigTopic {

    // 1.声明注册Topic模式的交换机
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topic-exchange");
    }
    // 2.声明队列 参数durable: true表示消息队列持久化
    @Bean
    public Queue smsQueueTopic(){
        return new Queue("topic-queue-sms", true);
    }
    @Bean
    public Queue emailQueueTopic(){
        return new Queue("topic-queue-email", true);
    }
    @Bean
    public Queue duanxinQueueTopic(){
        return new Queue("topic-queue-duanxin", true);
    }
    // 3.消息队列和交换机进行绑定，模糊匹配routingKey *表示任意一个字符，#表示0个或任意多个字符
    @Bean
    public Binding smsBindingTopic(){
        return BindingBuilder.bind(smsQueueTopic()).to(topicExchange()).with("com.#");
    }
    @Bean
    public Binding emailBindingTopic(){
        return BindingBuilder.bind(emailQueueTopic()).to(topicExchange()).with("*.email.#");
    }
    @Bean
    public Binding duanxinBindingTopic(){
        return BindingBuilder.bind(duanxinQueueTopic()).to(topicExchange()).with("#.duanxin.#");
    }
}

3.2 生产者，发送消息到交换机，并指定动态routingKey，交换机会分发到所匹配的消息队列

public void makeOrderTopic() {
    // 1.根据商品id查询库存是否充足
    // 2.产生订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单id: " + orderId);
    // 3.RabbitMQ完成消息分发
    String exchange = "topic-exchange";
    String routingKey = "com.duanxin";
    // sms动态匹配规则 com.# 
    // email动态匹配规则 *.email.#
    // duanxin动态匹配规则 #.duanxin.# 
    // *表示任意一个字符，#表示0个或任意多个字符
    rabbitTemplate.convertAndSend(exchange, routingKey, orderId);
}

3.3 消费者，三个消费者分别消费三个队列的消息

@Service
public class MQTopicConsumer {

    @RabbitListener(queues = "topic-queue-sms")
    public void receiveSmsMsg(String message){
        System.out.println("sms topic 接收到了订单信息 >> : " + message);
    }
    @RabbitListener(queues = "topic-queue-email")
    public void receiveEmailMsg(String message){
        System.out.println("email topic 接收到了订单信息 >> : " + message);
    }
    @RabbitListener(queues = "topic-queue-duanxin")
    public void receiveDuanxinMsg(String message){
        System.out.println("duanxin topic 接收到了订单信息 >> : " + message);
    }
}

3.4 调用生产者方法进行测试，查看消费者控制台输出，只有匹配的routingKey才收到了消息

sms topic 接收到了订单信息 >> : 079bc7d9-0984-4040-8d33-63a7324e428c
duanxin topic 接收到了订单信息 >> : 079bc7d9-0984-4040-8d33-63a7324e428c

4. Headers模式（参数匹配）使用

4.1 Headers模式配置文件，配置交换机、消息队列，并进行绑定，并设置匹配参数和匹配模式（whereAll全部匹配，whereAny部分匹配）

@Configuration
public class RabbitMQConfigHeaders {

    // 1.声明注册Headers模式的交换机
    @Bean
    public HeadersExchange headersExchange(){
        return new HeadersExchange("headers-exchange");
    }
    // 2.声明队列 参数durable: true表示消息队列持久化
    @Bean
    public Queue smsQueueHeaders(){
        return new Queue("headers-queue-sms", true);
    }
    @Bean
    public Queue emailQueueHeaders(){
        return new Queue("headers-queue-email", true);
    }
    @Bean
    public Queue duanxinQueueHeaders(){
        return new Queue("headers-queue-duanxin", true);
    }
    // 3.消息队列和交换机进行绑定，设置匹配模式，全部匹配和部分匹配
    @Bean
    public Binding smsBindingHeaders(){
        Map<String,Object> map = new HashMap<>();
        map.put("queueName","headers-queue-sms");
        map.put("bindType","whereAll");
        return BindingBuilder.bind(smsQueueHeaders()).to(headersExchange()).whereAll(map).match();
    }
    @Bean
    public Binding emailBindingHeaders(){
        Map<String,Object> map = new HashMap<>();
        map.put("queueName","headers-queue-email");
        map.put("bindType","whereAny");
        return BindingBuilder.bind(emailQueueHeaders()).to(headersExchange()).whereAny(map).match();
    }
    @Bean
    public Binding duanxinBindingHeaders(){
        Map<String,Object> map = new HashMap<>();
        map.put("queueName","headers-queue-duanxin");
        map.put("bindType","whereAny");
        return BindingBuilder.bind(emailQueueHeaders()).to(headersExchange()).whereAny(map).match();
    }

}

4.2 生产者

public void whereAllMatch() {
    System.out.println("===================whereAll 全部匹配=======================");
    // 1.根据商品id查询库存是否充足
    // 2.产生订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单id: " + orderId);
    // 3.RabbitMQ完成消息分发
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setHeader("queueName", "headers-queue-sms");
    messageProperties.setHeader("bindType", "whereAll");
    Message message = new Message(orderId.getBytes(), messageProperties);
    rabbitTemplate.convertAndSend("headers-exchange", "", message);
}

public void whereAnyMatch() {
    System.out.println("===================whereAny 部分匹配=======================");
    // 1.根据商品id查询库存是否充足
    // 2.产生订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单id: " + orderId);
    // 3.RabbitMQ完成消息分发
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setHeader("queueName", "headers-queue");
    messageProperties.setHeader("bindType", "whereAny");
    Message message = new Message(orderId.getBytes(), messageProperties);
    rabbitTemplate.convertAndSend("headers-exchange", "", message);
}

4.3 消费者

@Service
public class MQHeadersConsumer {

    @RabbitListener(queues = "headers-queue-sms")
    public void receiveSmsMsg(String message){
        System.out.println("sms headers 接收到了订单信息 >> : " + message);
    }
    @RabbitListener(queues = "headers-queue-email")
    public void receiveEmailMsg(String message){
        System.out.println("email headers 接收到了订单信息 >> : " + message);
    }
    @RabbitListener(queues = "headers-queue-duanxin")
    public void receiveDuanxinMsg(String message){
        System.out.println("duanxin headers 接收到了订单信息 >> : " + message);
    }
}

4.4 测试结果

===================whereAll 全部匹配=======================
订单id: 733f880d-5135-49fd-a454-781a36cc3d8e
sms headers 接收到了订单信息 >> : 733f880d-5135-49fd-a454-781a36cc3d8e

===================whereAny 部分匹配=======================
订单id: 4c5f25f3-d5d4-470e-b27e-11b405e11c51
email headers 接收到了订单信息 >> : 4c5f25f3-d5d4-470e-b27e-11b405e11c51
duanxin headers 接收到了订单信息 >> : 4c5f25f3-d5d4-470e-b27e-11b405e11c51

5. Work模式使用

  • 轮询模式的分发：一个消费者一条，按均分配；
  • 公平分发：根据消费者的消费能力进行公平分发，处理快的处理的多，处理慢的处理的少；按劳分配；

RabbitMQ 高级使用

1. ttl消息过期时间

1.1 给消息队列设置TTL过期时间x-message-ttl

@Configuration
public class RabbitMQConfigDirectTTL {

    // 1.声明注册Direct模式的交换机
    @Bean
    public DirectExchange directTTLExchange(){
        return new DirectExchange("direct-ttl-exchange");
    }
    // 2.设置消息队列的过期时间 x-message-ttl
    @Bean
    public Queue ttlQueueDirect(){
        Map<String, Object> args = new HashMap<>();
        // 设置消息队列的过期时间，单位为 ms
        args.put("x-message-ttl", 5000);
        // 设置死信交换机 和 routingKey
        args.put("x-dead-letter-exchange", "direct-dead-exchange");
        args.put("x-dead-letter-routing-key", "dead");  // fanout模式不用配置routingKey
        return new Queue("direct-queue-ttl", true, false, false, args);
    }
    // 3.消息队列和交换机进行绑定
    @Bean
    public Binding ttlBindingDirect(){
        return BindingBuilder.bind(ttlQueueDirect()).to(directTTLExchange()).with("ttl");
    }

}

生产者产生消息：

public void makeOrderTTL() {
    // 1.根据商品id查询库存是否充足
    // 2.产生订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单id: " + orderId);
    // 3.RabbitMQ完成消息分发
    rabbitTemplate.convertAndSend("direct-ttl-exchange", "ttl", orderId);
}

此种方式是给队列设置TTL，生产者产生的消息放入此队列中，5s后消息均会过期。

1.2 给消息设置TTL过期时间

public void makeOrderTTL() {
    // 1.根据商品id查询库存是否充足
    // 2.产生订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单id: " + orderId);
    // 3.RabbitMQ完成消息分发
    // 1)给消息队列设置TTL过期时间
    rabbitTemplate.convertAndSend("direct-ttl-exchange", "ttl", orderId);
    // 2)给消息设置TTL过期时间
    MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            message.getMessageProperties().setExpiration("5000"); //5s
            message.getMessageProperties().setContentEncoding("UTF-8");
            return message;
        }
    };
    rabbitTemplate.convertAndSend("direct-ttl-exchange", "ttlMessage", orderId, messagePostProcessor);
}

两种消息过期时间的区别

  • 给队列设置TTL，此队列是个过期队列(TTL标识)，过期的消息会转移到死信队列中去，需要绑定死信交换机(DLX)
  • 给消息设置过期时间，消息过期后会直接移除。

在这里插入图片描述

2. 死信队列

DLX，全称为Dead-Letter-Exchange , 可以称之为死信交换机（DLX）。当消息在一个队列中变成死信(dead message)之后，它能被重新发送到另一个交换机中，这个交换机就是DLX ，绑定DLX的队列就称之为死信队列。消息变成死信，可能是由于以下的原因：

  • 消息被拒绝
  • 消息过期
  • 队列达到最大长度

定义死信队列，绑定死信交换机

@Configuration
public class RabbitMQConfigDirectDead {

    // 1.声明注册Direct模式的交换机
    @Bean
    public DirectExchange directDeadExchange(){
        return new DirectExchange("direct-dead-exchange");
    }
    // 2.声明队列 参数durable: true表示消息队列持久化
    @Bean
    public Queue deadQueueDirect(){
        return new Queue("direct-queue-dead", true);
    }
    // 3.消息队列和交换机进行绑定
    @Bean
    public Binding deadBindingDirect(){
        return BindingBuilder.bind(deadQueueDirect()).to(directDeadExchange()).with("dead");
    }
    
}
Buckletime
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
spring boot整合RabbitMq
weixin_44105305的博客
03-29 184
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。（但是关于rabbitMq的安装，就不介绍了）在安装完rabbitMq后，输入http://ip:15672/ ，是可以看到一个简单后台管理界面的。可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 9196
SpringBoot 集成 RabbitMQ
SpringBoot集成RabbitMQ
abc_138的博客
07-02 1638
RabbitMQ官方提供的Java 客户端编码相对复杂，一般生产环境下我们更多会结合Spring 来使用。而Spring 的官方刚好基于RabbitMQ 提供了这样一套消息收发的模板工具SpringAMQP。
Springboot 整合RabbitMq
GSON的博客
08-21 4603
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
Spring Boot中使用RabbitMQ
JavaAlliance
07-08 4406
Message Broker与AMQP简介 Message Broker是一种消息验证、传输、路由的架构模式，其设计目标主要应用于下面这些场景： 消息路由到一个或多个目的地 消息转化为其他的表现方式 执行消息的聚集、消息的分解，并将结果发送到他们的目的地，然后重新组合成相应的结果返回给消息用户 调用Web服务来检索数据 响应事件或错误 使用发布-订阅模式来提供内容或基于主题的消息路由 AMQP...
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
Springboot整合RabbitMQ简单demo
01-22
本文将详细讲解如何在Spring Boot项目中整合RabbitMQ，并通过一个简单的示例来展示其实现过程。 首先，我们需要了解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理和队列服务器，遵循AMQP（Advanced Message ...
springboot整合rabbitmq
09-14
SpringBoot整合RabbitMQ是将高可用的消息中间件RabbitMQ与SpringBoot框架结合，以实现应用程序间的异步通信和解耦。RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）协议的消息队列，而SpringBoot则为...
Spring Boot 集成 RabbitMQ
最新发布
空明的博客
07-15 1429
Spring Boot 集成 RabbitMQ ,记录一些交换器类型、消息投递及消息确认方式的使用。
spring boot 整合RabbitMq
dupengcheng1的博客
08-27 515
RabbitMq的介绍和基本的认识在上一篇中讲过，不再赘述。直接上代码，整合springboot RabbitMq Maven中引入RabbitMq依赖 &lt;dependency&gt; &lt;groupId&gt;repository.org.springframework.amqp&lt;/groupId&gt; &lt;arti...
SpringBoot整合RabbitMQ
weixin_44088051的博客
11-15 305
一、SpringBoot整合RabbitMQ的五种工作模式 五种工作模式的作用场景这里就不一一叙述了，可以参考上一篇RabbitMQ入门与五种工作模式，链接地址：https://blog.csdn.net/weixin_44088051/article/details/121160214 项目结构： 在pom.xml加入 <dependencies> <dependency> <groupId>org.springframew
Spring Boot 整合 RabbitMQ
MoYu's Blog
09-26 172
Spring Boot 整合 RabbitMQ 简介 在Spring项目中，可以使用Spring-Rabbit去操作RabbitMQ 尤其是在spring boot项目中只需要引入对应的amqp启动器依赖即可，方便的使用RabbitTemplate发送消息，使用注解接收消息。 一般在开发过程中： 生产者工程： application.yml文件配置RabbitMQ相关信息； 在生产者工程中编写配置类，用于创建交换机和队列，并进行绑定 注入RabbitTemplate对象，通过RabbitTemplate
spring boot整合RabbitMQ
qq_55648724的博客
03-08 685
无
Springboot 整合RabbitMQ (完整版)
weixin_42113716的博客
08-30 904
Springboot 整合RabbitMQ (完整版)
springboot 整合rabbitmq
09-07
- *1* [SpringBoot整合RabbitMQ](https://blog.csdn.net/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值