一篇博客带你学会Rabbitmq（后端必知必会）

最新推荐文章于 2024-07-19 23:32:37 发布
置顶 最新推荐文章于 2024-07-19 23:32:37 发布
阅读量849 收藏 20
点赞数 28
分类专栏： 微服务 一篇带你学会系列 中间件 文章标签： rabbitmq 笔记 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cosmoshhhyyy/article/details/139426682
版权

文章目录

Rabbitmq

简单案例

目录结构

在这里插入图片描述

引入依赖：

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

生产者

publisher配置中添加：

spring:
  rabbitmq:
    host: ip # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: guest # 用户名
    password: guest # 密码

编写测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello mq!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

mq管理页面中创建一下simple.queue的队列，然后执行代码。

在这里插入图片描述

在这里插入图片描述

可以看到成功发送消息到消息队列中。

消费者

consumer中同样yaml中配置mq（与生产者同）。

然后编写消费监听类：

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：" + msg);
    }
}

启动：

在这里插入图片描述

就可以消费mq中的消息了。

WorkQueue模型

当然，一个队列，可以由多个消费者去监听。

来实现一下.

生产者：

    @Test
    public void testWorkQueue() throws InterruptedException {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, message-";
        for (int i = 0; i < 50; i++) {
            // 发送消息
            rabbitTemplate.convertAndSend(queueName, message + i);
            Thread.sleep(30); // 每次
        }
    }

消费者（这里我们弄两个）：

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息：" + msg);
    }

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage2(String msg) throws InterruptedException {
        System.out.println("消费者2接收到消息：" + msg);
    }
}

启动看一下结果：

先启动消费者，再发送大量消息：

在这里插入图片描述

这里是因为mq有预分配，一人一半，消费能力一样，所以看起来像是轮流一人执行了一次一样，其实不是，后面会说到。

先发送大量消息，再启动消费者：

在这里插入图片描述

这里是因为消费者1先启动了，2还没启动呢，就被1消费完了。

所以我们改造一下测试代码，让消费者消费能力不同，同时让消费者先都启动，然后再送大量消息：

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息：" + msg);
        Thread.sleep(20);
    }

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage2(String msg) throws InterruptedException {
        System.out.println("消费者2接收到消息：" + msg);
        Thread.sleep(200);
    }

消费者2接收到消息：hello, message-0
消费者1接收到消息：hello, message-1
消费者1接收到消息：hello, message-3
消费者1接收到消息：hello, message-5
消费者2接收到消息：hello, message-2
消费者1接收到消息：hello, message-7
消费者1接收到消息：hello, message-9
消费者1接收到消息：hello, message-11
消费者2接收到消息：hello, message-4
消费者1接收到消息：hello, message-13
消费者1接收到消息：hello, message-15
消费者1接收到消息：hello, message-17
消费者1接收到消息：hello, message-19
消费者2接收到消息：hello, message-6
消费者1接收到消息：hello, message-21
消费者1接收到消息：hello, message-23
消费者1接收到消息：hello, message-25
消费者2接收到消息：hello, message-8
消费者1接收到消息：hello, message-27
消费者1接收到消息：hello, message-29
消费者1接收到消息：hello, message-31
消费者2接收到消息：hello, message-10
消费者1接收到消息：hello, message-33
消费者1接收到消息：hello, message-35
消费者1接收到消息：hello, message-37
消费者2接收到消息：hello, message-12
消费者1接收到消息：hello, message-39
消费者1接收到消息：hello, message-41
消费者1接收到消息：hello, message-43
消费者2接收到消息：hello, message-14
消费者1接收到消息：hello, message-45
消费者1接收到消息：hello, message-47
消费者1接收到消息：hello, message-49
消费者2接收到消息：hello, message-16
消费者2接收到消息：hello, message-18
消费者2接收到消息：hello, message-20
消费者2接收到消息：hello, message-22
消费者2接收到消息：hello, message-24
消费者2接收到消息：hello, message-26
消费者2接收到消息：hello, message-28
消费者2接收到消息：hello, message-30
消费者2接收到消息：hello, message-32
消费者2接收到消息：hello, message-34
消费者2接收到消息：hello, message-36
消费者2接收到消息：hello, message-38
消费者2接收到消息：hello, message-40
消费者2接收到消息：hello, message-42
消费者2接收到消息：hello, message-44
消费者2接收到消息：hello, message-46
消费者2接收到消息：hello, message-48

可以看到，其实rabbitmq默认有预分配（预取，每个消费者和队列中有一个通道，存放预取的消息），平均分消息，然后各自独立消费，所以消费者2要比消费者1消费完25条（50/2）消息时间长。

显然是不合理的，我们可以改造一下：

控制预取消息个数

配置中prefetch设置为1，每次消费完消息才取下一个。（能力越大，责任越大，消费快的，消费越多）

spring:
  rabbitmq:
    host: ip # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: guest # 用户名
    password: guest # 密码
    listener:
      simple:
        prefetch: 1

重新试一下。

消费者2接收到消息：hello, message-0
消费者1接收到消息：hello, message-1
消费者1接收到消息：hello, message-2
消费者1接收到消息：hello, message-3
消费者1接收到消息：hello, message-4
消费者2接收到消息：hello, message-5
消费者1接收到消息：hello, message-6
消费者1接收到消息：hello, message-7
消费者1接收到消息：hello, message-8
消费者1接收到消息：hello, message-9
消费者2接收到消息：hello, message-10
消费者1接收到消息：hello, message-11
消费者1接收到消息：hello, message-12
消费者1接收到消息：hello, message-13
消费者1接收到消息：hello, message-14
消费者2接收到消息：hello, message-15
消费者1接收到消息：hello, message-16
消费者1接收到消息：hello, message-17
消费者1接收到消息：hello, message-18
消费者2接收到消息：hello, message-19
消费者1接收到消息：hello, message-20
消费者1接收到消息：hello, message-21
消费者1接收到消息：hello, message-22
消费者1接收到消息：hello, message-23
消费者2接收到消息：hello, message-24
消费者1接收到消息：hello, message-25
消费者1接收到消息：hello, message-26
消费者1接收到消息：hello, message-27
消费者1接收到消息：hello, message-28
消费者2接收到消息：hello, message-29
消费者1接收到消息：hello, message-30
消费者1接收到消息：hello, message-31
消费者1接收到消息：hello, message-32
消费者1接收到消息：hello, message-33
消费者2接收到消息：hello, message-34
消费者1接收到消息：hello, message-35
消费者1接收到消息：hello, message-36
消费者1接收到消息：hello, message-37
消费者1接收到消息：hello, message-38
消费者2接收到消息：hello, message-39
消费者1接收到消息：hello, message-40
消费者1接收到消息：hello, message-41
消费者1接收到消息：hello, message-42
消费者1接收到消息：hello, message-43
消费者2接收到消息：hello, message-44
消费者1接收到消息：hello, message-45
消费者1接收到消息：hello, message-46
消费者1接收到消息：hello, message-47
消费者1接收到消息：hello, message-48
消费者2接收到消息：hello, message-49

这样，消费能力大的（消费者1），消费的越多。

发布订阅

在这里插入图片描述

在这里插入图片描述

Fanout 交换机

Fanout 交换机会将收到的消息路由到每一个跟其绑定的queue上。

我们做一个交换机，两个队列，两个消费者分别连接两个队列。

定义交换机，队列，交换机与队列之间的连接：

/**
 * fanout交换机配置
 */
@Configuration
public class FanoutConfig {

    /**
     * 声明交换机，设置名称
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("lpy.fanout");
    }

    /**
     * 队列1
     * @return
     */
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定交换机和队列1
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {

        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }


    /**
     * 队列1
     * @return
     */
    @Bean
    public Queue fanoutQueue2() {
        return new Queue("fanout.queue2");
    }

    /**
     * 绑定交换机和队列2
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {

        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }

}

定义监听接口：

    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1(String msg) {
        System.out.println("消费者1接收到Fanout消息：" + msg);
    }

    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutQueue2(String msg) {
        System.out.println("消费者2接收到Fanout消息：" + msg);
    }

发送消息：

    @Test
    public void testFanoutExchange() {
        // 队列名称
        String exchangeName = "lpy.fanout";
        // 消息
        String message = "hello fanout!";
        rabbitTemplate.convertAndSend(exchangeName, "", message);
    }

启动，运行：

在这里插入图片描述

可以看到，我们发的一个消息，被两个消费者消费了，说明实现成功，交换机把消息路由到了每个队列。

Direct 交换机

不同的消息路由到不同的队列，根据key路由建。

在这里插入图片描述

下面来实现一下，基于注解来声明队列和交换机，这样比较方便，直接定义再接口上。

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "lpy.direct", type = ExchangeTypes.DIRECT),
            key = {"red", "blue"}
    ))
    public void listenDirectQueue1(String msg){
        System.out.println("消费者1接收到direct.queue1的消息：" + msg);
    }


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "lpy.direct", type = ExchangeTypes.DIRECT),
            key = {"red", "yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者2接收到direct.queue2的消息：" + msg);
    }

启动测试：

  1. key 为 red
 @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "lpy.direct";
        // 消息
        String message = "hello direct red";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "red", message);

        // 消息
        String message2 = "hello direct blue";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "blue", message2);

        // 消息
        String message3 = "hello direct yellow";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "yellow", message3);
    }

在这里插入图片描述

可以看到，根据key来进行了路由。

Topic 交换机

Topic 交换机与Direct相似，只不过使用了key可以使用通配符。

RoutingKey一般由一个或多个单词组成，用“.”分割。

通配符规则

# 匹配一个或多个词

* 匹配一个词

例如：

举例：

a.#   可以匹配a.b.c、a.b等

a.*   只可以匹配a.b

现在来实验一下吧：

和Direct同样的写法，只是key改为通配符的：

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "lpy.topic", type = ExchangeTypes.TOPIC),
            key = "a.*"
    ))
    public void listenTopicQueue1(String msg){
        System.out.println("消费者接收到topic.queue1的消息：" + msg);
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "lpy.topic", type = ExchangeTypes.TOPIC),
            key = "a.#"
    ))
    public void listenTopicQueue2(String msg){
        System.out.println("消费者接收到topic.queue2的消息：" + msg);
    }

发送消息：

    @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchangeName = "lpy.topic";
        // 消息
        String message = "hello topic a.b";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "a.b", message);

        // 消息
        String message1 = "hello topic a.b.c";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "a.b.c", message1);
    }

运行结果：

在这里插入图片描述

可以看到#确实可以匹配多个单词，而*只能匹配一个。

消息序列化

Spring默认会把你发送的消息通过JDK序列化为字节发送给MQ，接收消息的时候，再把字节反序列化为Java对象。

我们可以配置JSON方式来序列化，这样体积更小，可读性更高。

引入依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

添加配置类：

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}

接收和发送服务都需要添加。

发一个map消息：

    @Test
    public void testSendMap() throws InterruptedException {
        // 准备消息
        Map<String,Object> msg = new HashMap<>();
        msg.put("name", "小宇");
        msg.put("age", 18);
        // 发送消息
        rabbitTemplate.convertAndSend("simple.queue", msg);
    }
}

在这里插入图片描述

可以看到确实以json格式传输到mq了，非常不错。

Cosmoshhhyyy
关注
  • 28
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring-rabbitmq-chat:一个带有RabbitMQ后端的简单聊天应用程序
05-03
一个基于Spring Boot和RabbitMQ的简单聊天应用。 命令行界面 确保cli配置文件已打开。 您可以通过在命令行中传递不同的队列名称来生成多个聊天客户端： session1> ./gradlew -Dapp.settings.rabbit.queue=chat.Q....
RabbitMQ 必知必会
01-05
RabbitMQ是一个消息队列，我们可以使用RabbitMQ 做消息队列，消息通知的业务功能，而且根据网上的不可靠消息得出，RabbitMQ 的性能水平甚至比 activeMQ 还要好，所以也是我选择认真去学习RabbitMQ的原因，当然我也有...
中间件RabbitMQ之运维篇
01-27
【中间件RabbitMQ之运维篇】 RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）协议的开源消息中间件，适用于多种环境的企业级消息系统。它由Erlang编程语言实现，确保了高可用性和稳定性，同时遵循...
【BAT必备】rabbitMq面试题
09-25
【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题...
消息队列-RabbitMQ
Roc的博客
07-16 351
延迟队列是一种消息队列，它允许消息在被发送后延迟一定时间才被消费者处理。这意味着消息可以设定一个未来的时间点进行投递，直到达到指定的延迟时间后，消息才会被转移到另一个队列中供消费者消费。延迟队列常用于实现需要延时处理的任务，如定时任务、延迟通知等。优先级队列是一种支持按元素优先级顺序处理消息的队列。在这种队列中，每个消息被赋予一个优先级，高优先级的消息会先于低优先级的消息被消费处理，无论它们的到达顺序如何。优先级队列用于实现重要任务的优先处理等场景。
RabbitMQ介绍
weixin_57763462的博客
07-14 338
RabbitMQ 是一个开源的消息代理软件，它实现了先进消息队列协议（AMQP），提供了一个完整的消息中间件解决方案。RabbitMQ 允许应用程序通过一个中间层来交换信息，这个中间层可以确保消息的路由、存储和可靠传输。5.通道：由于TCP/IP 套接字连接昂贵，RabbitMQ 引入了通道的概念，它允许在一个连接中有多个虚拟的连接。2.生产者和消费者：在消息模型中，生产者是创建消息的源头，而消费者则是接收消息的应用。1.消息队列：RabbitMQ 使用消息队列来暂存消息，消费者可以从队列中获取消息。
rabbitmq简介与布署
Q7758521adc的博客
07-16 600
如果队列不存在会被创建 channel.queue_declare(queue='test_queue', durable=True) # 发送消息到队列中 channel.basic_publish( exchange='', routing_key='test_queue', body='Hello, RabbitMQ!从queue里取数据需要具有queue的可读权限。可登陆管理控制台(启用management plugin的情况下)，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
【Linux服务器Java环境搭建】012在linux中安装消息队列RabbitMQ，以及对RabbitMQ设置、启动、开启可视化
liuzhenhe1988的专栏
07-19 763
上一篇博客竟然用了不到半小时就写完了，那就继续吧，如果对此系列感兴趣，可以点击系列【Linux服务器Java环境搭建】进行查看哈，这一篇主要是安装和配置消息队列RabbitMQ。至此，RabbitMQ就安装完成了，在系列【Linux服务器Java环境搭建】的后续部分，将会结合实际项目对站点的发布以及部署进行讲解，到时候会详细讲解RabbitMQ对消息的处理【消息生产和消息消费】，敬请期待！
RabbitMQ 如何保证消息的可靠性
weixin_65837469的博客
07-18 434
在分布式系统中，消息队列（如 RabbitMQ）扮演着至关重要的角色，它们作为中间件，帮助系统解耦、异步处理任务、提升系统性能和可靠性。然而，在使用消息队列时，确保消息的可靠性是一个不可忽视的问题。本文将详细探讨 RabbitMQ 如何通过一系列机制来保证消息的可靠性。
【雷丰阳-谷粒商城 】【分布式高级篇-微服务架构篇】【22】【RabbitMQ】
Keep Reading Keep Writing Keep Thinking
07-15 1397
【雷丰阳-谷粒商城 】【分布式高级篇-微服务架构篇】【22】【RabbitMQ】 延时队列，可靠消息 Message Queue 消息队列 异步处理 应用解耦 流量控制 消息中间件概念 RabbitMQ概念 Message Publisher Exchange Queue Binding Connection Channel Consumer Virtual Host Broker RabbitMQ运行机制 AMQP 中的消息路由 Exchange类型 RabbitMQ整合
RabbitMQ 安装
sszdzq的博客
07-16 827
rabbitmq 管理界面无法显示，rabbitmq window 安装
记一次使用vue连接rabbitMq
weixin_50760181的博客
07-15 318
虽然都是复制粘贴 、但是也是创作不易、结尾出给个小连接、如果你得后端不会rabbitMq抓紧让他看这个、->后端端口一搬都是15670或者15672 、我们这后端就因为端口问题搞啦好久 一直以为是我的问题。就是页面想要的数据、基本上代码都在这啦 直接。之后在关闭页面时断开。
5.java操作RabbitMQ-简单队列
最新发布
卷土的博客
07-19 347
操作文件的依赖 信道channel声明队列方法详解：信道channel发送消息： 生产者发送消息成功以后：可以看出队列hello中有一个消息正准备被消费。
防御笔记第七天（时需更新）
weixin_63264424的博客
07-16 763
HRP在进行双机热备时，还有一个要求，两台热设备之间，必须拥有一条链路，用来同步信息，并且，这条链路必须是三层链路---这两条路在进行数据传输时，不受安全策略的影响，（注意，如果心跳线是直连的，则不受安全策略的影响，但是中间有中继设备，即非直连场景，则需要配置安全策略）----心跳线----VGMP发送的报文也是通过心跳线传输的。配置信息---（接口IP地址，路由地址）-----hrp不能同步基本的接口和路由信息，安全策略和NAT策略……状态信息-----会话表，server-map，黑名单和白名单等等。
node模块加载及第三方包（学习笔记）
oopsboom的博客
07-16 586
gulp是什么？ 基于node平台开发的前端构建工具 将机械化操作编写成任务, 想要执行机械化操作时执行一个命令行命令任务就能自动执行了 用机器代替手工，提高开发效率。 能做什么？ 项目上线，HTML、CSS、JS文件压缩合并 语法转换（es6、less …） 公共文件抽离 修改文件浏览器自动刷新 Gulp使用 1.使用npm install gulp下载gulp库文件 2.在项目根目录下建立gulpfile.js文件（只能是这个文件） 3.重构项目的文件夹结构 src目录放置源代码文件 dist目录放置构
NestJS笔记
m0_65519288的博客
07-16 606
概述：本篇文章是NestJS笔记，包括了Nest的基本使用、连接数据库、日志操作。
AGV栅格地图与QImage图片转换笔记
Pou光明的博客
07-15 309
最近在加班加点处理一个agv相关的任务，印象比较深的是将agv给的json数据转换为一个图片。最终的简化需求是将某坐标系下的二维点数据转换为一张图片的像素。Ok，首先的问题是如何将二维的数据映射到栅格坐标系。先看数据例子："mapType":"2D-Map","maxPos":{"x":4.51,"y":16.331},"minPos":{"x":-14.138,"y":-1.48} "resol...
cs224w笔记（p5）
m0_51118873的博客
07-19 304
它特别关注两个节点共有的邻居节点，并给予那些在网络中不太常见的共有邻居更高的权重，而对于那些更常见的共有邻居则给予较低的权重。其中，Γ(𝑢)Γ(u) 表示节点 𝑢u 的邻居节点集合，Γ(𝑣)Γ(v) 表示节点 𝑣v 的邻居节点集合，Γ(𝑢)∩Γ(𝑣)Γ(u)∩Γ(v) 表示 𝑢u 和 𝑣v 的共有邻居节点集合。其中，𝐴A 和 𝐵B 分别代表两个集合，∣𝐴∩𝐵∣∣A∩B∣ 表示集合 𝐴A 与 𝐵B 的交集元素的数量，而 ∣𝐴∪𝐵∣∣A∪B∣ 表示集合 𝐴A 与 𝐵B 的并集元素的数量。
RabbitMQ全中文详细教程: .Net/C#编程者必备
RabbitMQ是一个开源的消息代理系统，用于提供快速可靠的消息传递，使得应用程序可以分布式地进行通信和数据交换。本教程将从基本概念开始，逐步介绍如何在.NET平台上使用RabbitMQ实现消息队列和消息传递。 ## 环境...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cosmoshhhyyy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值