RbbitMQ自我总结与分析

最新推荐文章于 2022-04-07 14:25:36 发布
最新推荐文章于 2022-04-07 14:25:36 发布
阅读量542 收藏
点赞数 1
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46072357/article/details/106412902
版权

文章目录

一.概念

1.生产者（P-producer）：生产消息，发送消息
2.消费者（C-consumer）：消费自己已绑定队列中的消息
3.交换机(Exchanges)：类似路由器（交换机通过路由键和队列进行绑定，分发消息到绑定的消息队列，本身并没有存储功能，所以，如果交换机没有绑定队列，则生产者生产消息一到交换机就消失了），type主要由以下五种

一、简单模型（未经过交换机，一个消息只能被消费一次）
1.简单模型：P—>Q—>C 　一生一队一消
2.工作(work)消息模型： P—>Q---->多C 　一生一队多消
在这里插入图片描述
二、订阅模型（都经过交换机，由交换机进行分发，这样一个消息才能被消费多次）
3.Fanout：广播，将消息分发给所有绑定交换机的队列 （发送到所绑定有的队列）
　
4.Direct(路由模型)：定向，把消息分发给符合指定routing key 的队列 （指向性的发送到选中的绑定队列：生产者发送消息绑定routingKey(路由键)，只转发到也绑定该routingKey的队列。如：消息绑定delete路由键能够匹配routingKey为delete的队列）
　
5. Topic(通配符模型)：通配符，把消息分发给符合routing pattern的队列（Topic类型的与Direct，实质也是根据routingKey把消息路由到不同的队列。只不过Topic类型交换机可以让队列在绑定routingKey的时候使用通配符！如：消息绑定#.delete.# 能够匹配routingKey为delete.a，gg.delete.a.bc的队列）
注意： * 匹配一个词，# 匹配一个或多个词

4.消息队列(Queues)：接收，存储，转发消息----->类似家门口的邮件邮箱（消息就像一封封信件，等着消费者去消费）
5.Channel：信道，消息读写等操作在信道中进行。客户端可以建立多个信道，每个信道代表一个会话任务。在Idea操作RabbitMQ时所有Api都是通过Channel来操作（1.获取连接，2.创建信道，3.通过信道声明队列，和消费者以及相关绑定）

本质：

生产者：发送消息到交换机
交换机：接收到消息，根据type分发到绑定的消息队列
消息队列：队列接收消息，进行存储，等待消费者（C）进行消费。
消费者：启动消费者，消费者就会去其绑定的队列进行消费。
　
在这里插入图片描述

绑定：

第一，消费者与消息队列进行绑定，这样消费者才能消费该队列里的消息。
第二，消息队列与交换机进行绑定（通过路由键进行绑定，这样交换机能通过路由键确定发送到哪个绑定的队列）。
在这里插入图片描述

二、扩展：
消息确认机制（ACK）：

ACK(Acknowledge character）：即是确认字符
　　RabbitMQ有一个ACK机制。当消费者获取消息后，会向RabbitMQ发送回执ACK，告知消息已经被接收，如果消费者消费消息后没有发送ACK，则消息不会被消费

当消费者开始进行消费时，消息队列中的消息会进入Unacked状态，只有接收到消费者的ACK，那么该消息才被消费，否则状态返回Ready等待消费

在这里插入图片描述

在代码中ACK分两种情况：

  • 自动ACK：消息一旦被接收，消费者自动发送ACK（无论消费者在消费时有没有异常，都会把消息从队列中移出）
  • 手动ACK：消息接收后，不会发送ACK，需要手动调用（只有调用时发送了ACK，消息才会从队列中移出。否则消息仍然回到Ready状态）
  // 监听队列，第二个参数：是否自动进行消息确认。
     channel.basicConsume(QUEUE_NAME, true, consumer);
        // 手动进行ACK
        channel.basicAck(envelope.getDeliveryTag(), false);
能者多劳模式

BabbitMQ在多个消费者消费队列中的消息时，默认的是平均分配，BabbitMQ会将消息先平均分配给多个消费者，然后让他们自己慢慢去消费
如90个消息 a：30，b：30 ，c：30
这样就会出现资源浪费，比如a的机子比较快，处理消息能力强，应该多消费一些，这样可以提升效率

 // 设置每个消费者同时只能处理一条消息
    channel.basicQos(1);

这样设置后就可以开启能者多劳模式了

消息持久化

如何避免消息丢失？
1） 消费者的ACK机制。可以防止程序异常导致消费者丢失消息。
2） 但是，如果在消费者消费之前，MQ就宕机了，消息就没了。
是可以将消息进行持久化呢？
我们创建的交换机、队列、消息默认都是储存在内存中，所以要将消息持久化，
前提是：队列、Exchange（交换机）都持久化
在这里插入图片描述
可以看到RabbitMQ自带默认的交换机Features都有个D标志=durable持久化
而我们的direct_exchange_test则没有，消息队列同理
在这里插入图片描述
如果交换机，队列没有设置durable持久化，那么服务器一旦宕机，那么交换机和队列就会消失了，因为他们没有持久化在服务器中，那么消息是存在队列中的也自然不会持久。
所以，要将消息持久化，前提是：队列、Exchange（交换机）都持久化
交换机持久化（在生产者声明交换机时进行设置，告诉RabbitMQ我的交换机要持久化储存，durable=true）
在这里插入图片描述
消息持久化（在生产者发送消息时进行设置，告诉RabbitMQ这个消息是持久化的）
在这里插入图片描述
队列持久化（在消费者声明队列时进行设置，告诉RabbitMQ这个队列是持久化的）
在这里插入图片描述
妈妈再也不用担心我的消息会丢失了！

三、代码示例（防止忘记，多码杀秃）：

简单模型（未经过交换机，消息只可消费一次）：

简单生产者：

public class Send {
    private final static String QUEUE_NAME = "simple_queue";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 从连接中创建通道，使用通道才能完成消息相关的操作
        Channel channel = connection.createChannel();
        // 声明（创建）队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 消息内容
        String message = "Hello World!";
        // 向指定的队列中发送消息
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println(" [x] Sent '" + message + "'");
        //关闭通道和连接
        channel.close();
        connection.close();
    }

简单消费者：

public class Recv {
    private final static String QUEUE_NAME = "simple_queue";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                    byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [x] received : " + msg + "!");
            }
        };
        // 监听队列，第二个参数：是否自动进行消息确认。
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

工作（work）模型生产者：

public class Send {
    private final static String QUEUE_NAME = "test_work_queue";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 循环发布任务
        for (int i = 0; i < 50; i++) {
            // 消息内容
            String message = "task .. " + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");

            Thread.sleep(i * 2);
        }
        // 关闭通道和连接
        channel.close();
        connection.close();
    }
}

工作（work）模型消费者：

public class Recv {
    private final static String QUEUE_NAME = "test_work_queue";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        final Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 设置每个消费者同时只能处理一条消息
        channel.basicQos(1);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel  ) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                    byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [消费者1] received : " + msg + "!");
                try {
                    // 模拟完成任务的耗时：1000ms
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
                // 手动ACK
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 监听队列。
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

订阅模型（经过交换机，消息可多次消费）：

fonout类型交换机生产者：

public class Send {
    private final static String EXCHANGE_NAME = "fanout_exchange_test";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        
        // 声明exchange，指定类型为fanout
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        
        // 消息内容
        String message = "Hello everyone";
        // 发布消息到Exchange
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
        System.out.println(" [生产者] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
}

fonout消费者：

//消费者1
public class Recv {
    private final static String QUEUE_NAME = "fanout_exchange_queue_1";
    private final static String EXCHANGE_NAME = "fanout_exchange_test";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                    byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [消费者1] received : " + msg + "!");
            }
        };
        // 监听队列，自动返回完成
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

direct类型交换机生产者：

public class Send {
    private final static String EXCHANGE_NAME = "direct_exchange_test";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明exchange，指定类型为direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        // 消息内容
        String message = "商品删除了， id = 1001";
        // 发送消息，并且指定routing key 为：insert ,代表新增商品,并声明消息持久化
        channel.basicPublish(EXCHANGE_NAME, "delete", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
        System.out.println(" [商品服务：] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
}

direct消费者：

public class Recv {
    private final static String QUEUE_NAME = "direct_exchange_queue_1";
    private final static String EXCHANGE_NAME = "direct_exchange_test";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        
        // 绑定队列到交换机，同时指定需要订阅的routing key。假设此处需要update和delete消息
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "update");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "delete");
        
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
   public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                    byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [消费者1] received : " + msg + "!");
            }
        };
        // 监听队列，自动ACK
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

topic类型交换机生产者：

public class Send {
    private final static String EXCHANGE_NAME = "topic_exchange_test";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明exchange，指定类型为topic,并声明交换机持久化
        channel.exchangeDeclare(EXCHANGE_NAME, "topic",true);
        // 消息内容
        String message = "新增商品 : id = 1001";
        // 发送消息，并且指定routing key 为：insert ,代表新增商品
        channel.basicPublish(EXCHANGE_NAME, "item.insert", null, message.getBytes());
        System.out.println(" [商品服务：] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
}

topic消费者：

public class Recv {
    private final static String QUEUE_NAME = "topic_exchange_queue_1";
    private final static String EXCHANGE_NAME = "topic_exchange_test";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 获取通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        
        // 绑定队列到交换机，同时指定需要订阅的routing key。需要 update、delete
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.update");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.delete");

        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                    byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [消费者1] received : " + msg + "!");
            }
        };
        // 监听队列，自动ACK
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}
重庆爪哇头
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RbbitMQ基础知识
weixin_30599769的博客
07-22 359
MQ全称为Message Queue,消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。 ...
RabiitMQ命令使用
熊猫路人
10-24 378
$cnn = news AMQPStreamConnection(); //建立mq之间的连接 (host:ip,port:端口,user:账户,pwd:密码) $channel = $cnn->channel(); //创建一个信道 AMQP的命令都是通过信道发送出去的 $channel->exchange_declare(); //创建交换机(exchange:交换机名...
RabbiMq详解
会写Bug的攻城狮
02-07 1202
RabbitMq 1、消息队列 是在消息的传输过程中保存消息的容器。它是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 2、AMQP和JMS MQ是消息通信的模型，并发具体实现。现在实现MQ的有两种主流方式：AMQP、JMS。 两者间的区别和联系： JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式 JMS限定了
ribitmq安装在docker(详细教程)
weixin_43910372的博客
07-28 183
Docker系列之RabbitMQ安装部署教程 因为学习RabbitMQ需要，需要安装RabbitMQ，网上找资料，RabbitMQ官方提供了window版、Linux版、Docker版的管理页面，为了方便，选择了docker版本进行学习 主要介绍一下Docker版本，常用的docker镜像操作： 查询rabbitMQ镜像： management版本，不指定默认为最新版本latest docker search rabbitmq:management 拉取镜像： d.
RabbitMQ学习（三）-- 队列持久化
行无所至，学无所尽。
07-21 898
RabbitMQ持久化 概念 刚刚我们已经看到了如何处理任务不丢失的情况，但是如何保障当 RabbitMQ 服务停掉以后消息生产者发送过来的消息不丢失。默认情况下 RabbitMQ 退出或由于某种原因崩溃时，它忽视队列和消息，除非告知它不要这样做。确保消息不会丢失需要做两件事： 我们需要将队列和消息都标记为持久化； 队列如何持久化 之前我们创建的队列都是非持久化的，rabbitmq 如果重启的化，该队列就会被删除掉，如果要队列实现持久化 需要在声明队列的时候把 durable 参数设置为持久化； 但是需要
rabbitmq-server-linux
03-09
linux环境的rabbitmq安装包
embedded-rabbitmq:一个将RabbitMQ用作嵌入式服务的JVM库
05-07
嵌入式RabbitMQ 相容性 内部版本：Linux OS X 视窗 报告： 距离： 社交： 该库允许使用各种RabbitMQ版本，就好像它是可以在JVM中控制的嵌入式服务一样。 它的工作方式是从官方存储库中下载给定版本和操作系统的...
基于ARM64架构linux系统的RabbitMQ源码安装教程以及安装包.zip
08-28
ARM64架构，银河麒麟linux系统，RabbitMQ的所有离线安装包
SpringBoot开发中常用的一些组件(SpringBoot Developer Components)
06-08
service-rbbitmq-server [RbbitMQ 集成] 博客讲解1-服务器搭建 博客讲解2-代码实现 博客讲解3-踩坑 service-image-base64 [Druid+多数据源配置] 博客讲解1-代码实现 博客讲解2-踩坑 service-image-base64 [图片存储...
SpringBootDC:SpringBoot开发人员组件
05-10
service-rbbitmq-server [RbbitMQ 集成] service-image-base64 [Druid+多数据源配置] service-image-base64 [图片存储到数据库中] service-spring-data-redis [Redis集成(Jedis)] service-spring-data-neo4j [图库...
rabbitMQ的详细介绍
wang20010104的博客
04-07 7万+
rabbitMQ的详细介绍
RabbitMQ 入门介绍
qq_24991197的博客
06-17 2482
MQ 的相关概念 什么是 MQ MQ(message queue)，从字面意思上看，本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。 为什么要用 MQ 1.流量消峰 举个例子，如果订单系统最多能处理一万次订单，这个处理能力应付正常时段的下单时绰绰有余，正常时段我们下单一秒后就能返回结
RbbitMQ的几种连接方式
一个人的江湖
08-12 2113
1 简单模式Hello World 功能：一个生产者P发送消息到队列Q,一个消费者C接收 生产者实现思路： 创建连接工厂ConnectionFactory，设置服务地址，端口号，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel向队列中发送消息，关闭通道和连接。 public class RabbitMQPublishTest { public static voi
RabbitMQ基础概念详细介绍
woailuohui的专栏
08-14 9030
RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务器端用Erl...
RabbitMQ教程(安装与使用详解,Spring集成)
热门推荐
鸟哥哥的专栏
12-26 50万+
RabbitMQ教程，面试题。消息队列(MQ)，本质是个队列，队列中存放的内容是message。MQ用于不同进程Process/线程Thread之间通信。本文介绍RabbitMQ的使用。RabbitMQ实战教程。
RbbitMQ的理解
guoqinghuajj的博客
09-23 1678
技术选型：为什么要用MQ 任何技术没有绝对的好和坏，学会扬长避短。在合适的地方去运用合适的技术，对其原理，模式，运用，优缺点都要有比较熟悉的应用和理解。 MQ的缺点：系统的可用性降低（mq一旦发生故障，整个系统将会出现崩溃），复杂度提高，一致性问题 技术选型：可伸...
RabbitMQ解决大量unacked问题
请叫我杰哥
01-30 7万+
RabbitMQ解决大量unacked问题 为了快速响应用户请求，我们需要消息异步处理机制，比较简单的做法是用redis的List结构，我们项目使用更专业的RabbitMQ。关于redis和RabbitMQ队列处理的性能比较可以查看这篇文章http://blog.csdn.net/educast/article/details/34521603 这里不扯RabbitMQ的一些定义了，我们遇
RabbitMQ介绍及运用
m0_46436542的博客
08-31 1757
1.RabbitMQ 使用场景 1.1服务解耦 假如在某种情况下，有B,C,D多个服务器需要使用A服务器的数据，那么我们可以在A服务中直接调用B,C,D服务，并传入数据。 但这样做的弊端就是当我们服务器很多时，并且会不时改变需要数据服务器数量，那么A服务中调用代码的维护会极为困难。 这是由于服务之间耦合度过于紧密。 这个时候就可以考虑使用MQ消息队列 A服务只需要向消息服务器发送消息,而不用考虑谁需要这些数据;下游服务如果需要数据,自行从消息服务器订阅消息,不再需要数据时则取消订阅即可。 1.2流量削峰
RocketMQ生产者组topic和消费组的关系
love4amanda的博客
02-03 1万+
各个之间的关系其实很松散,并不是说不能操作 最佳实践 订阅关系一致 多个 Group ID 订阅了多个 Topic，并且每个 Group ID 里的多个消费者实例的订阅关系保持了一致。 消费幂等 最终一致性保证数据一致性,如果不幂等,将导致数据错乱 topic和tag的关系 topic可以是一级过滤关系 tag是二级过滤关系 使用: 业务消息往往推荐做topic 的 一级区分 tag往往用于过滤...
rbbitmq支持 arm64吗
最新发布
12-17
不过需要注意的是，由于ARM64架构的特性和市场份额有限，可能在某些方面与常见的x86架构有所不同。因此，在使用RabbitMQ时，需要根据具体情况进行适配和优化，以确保在ARM64架构上的性能和稳定性。 总结来说，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值