ROCKETMQ——简单消息发送、接收示例

最新推荐文章于 2024-09-15 08:26:12 发布
最新推荐文章于 2024-09-15 08:26:12 发布
阅读量2.3k 收藏
点赞数
文章标签： python 移动开发 操作系统
原文链接：https://my.oschina.net/liangxiao/blog/3007875
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

摘要

  1. 默认消息发送超时时间为3s
  2. 默认消息发送是同步的发送模式，同步发送会发送1+重试次数，默认重试2，一共3次
  3. 消息内容不能为0，也不能超过4M
  4. 同步消息发送才会有重试机制，异步发送和oneway发送模式都只有一次发送机会。同步发送 1+重试次数（默认2）
  5. pull模式、push模式启动的时候都不会检查nameserv，pull模式在fetchqueue时没有nameserv时会报错，push模式没有nameserv不会报错

使用示例

使用的是官方的示例。

发送示例：

public class Producer {
    public static void main(String[] args) throws MQClientException, InterruptedException {

        DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
        producer.setNamesrvAddr("localhost:9876");
        producer.start();

        for (int i = 0; i < 10; i++)
            try {
                {
                    Message msg = new Message("TopicTest",
                        "TagA",
                        "OrderID188",
                        "Hello world".getBytes(RemotingHelper.DEFAULT_CHARSET));
                    SendResult sendResult = producer.send(msg);
                    System.out.printf("%s%n", sendResult);
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

        producer.shutdown();
    }
}

接收示例：

pull接收示例


public class PullConsumer {
    private static final Map<MessageQueue, Long> OFFSE_TABLE = new HashMap<MessageQueue, Long>();

    public static void main(String[] args) throws MQClientException {
    	
      DefaultMQPullConsumer consumer = new DefaultMQPullConsumer("ProducerGroupName");
      consumer.setNamesrvAddr("localhost:9876");
      
      consumer.start();
      
      // 从nameserv上拉取的topic的队列信息
      Set<MessageQueue> mqs = consumer.fetchSubscribeMessageQueues("TOPIC_TEST");
        for (MessageQueue mq : mqs) {
            System.out.printf("Consume from the queue: %s%n", mq);
            SINGLE_MQ:
            while (true) {
                try {
                	// 远程拉取消息，拉取32个
                    PullResult pullResult = consumer.pullBlockIfNotFound(mq, null, getMessageQueueOffset(mq), 32);
                    System.out.printf("%s%n", pullResult);
                    putMessageQueueOffset(mq, pullResult.getNextBeginOffset());
                    switch (pullResult.getPullStatus()) {
                        case FOUND://找到消息
                        	List<MessageExt> messageExtList = pullResult.getMsgFoundList();
                            for (MessageExt m : messageExtList) {
                            	System.out.println("msgId:"+m.getMsgId());
                                System.out.println(new String(m.getBody()));
                            }
                            break;
                        case NO_MATCHED_MSG:
                            break;
                        case NO_NEW_MSG:
                            break SINGLE_MQ;
                        case OFFSET_ILLEGAL:
                            break;
                        default:
                            break;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

//        consumer.shutdown();
    }

    private static long getMessageQueueOffset(MessageQueue mq) {
        Long offset = OFFSE_TABLE.get(mq);
        if (offset != null)
            return offset;

        return 0;
    }

    private static void putMessageQueueOffset(MessageQueue mq, long offset) {
        OFFSE_TABLE.put(mq, offset);
    }

}

push接收示例


public class PushConsumer {

    public static void main(String[] args) throws InterruptedException, MQClientException {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("PUSH_CONSUME_GROUP");
        consumer.setNamesrvAddr("localhost:9876");
        consumer.subscribe("TOPIC_TEST", "*");// topic  tag
        /**
         * 全新的消费组 才适用这些策略
         * CONSUME_FROM_LAST_OFFSET //默认策略，从该队列最尾开始消费，即跳过历史消息
		 * CONSUME_FROM_FIRST_OFFSET //从队列最开始开始消费，即历史消息（还储存在broker的）全部消费一遍
         * CONSUME_FROM_TIMESTAMP//从某个时间点开始消费，和setConsumeTimestamp()配合使用，默认是半个小时以前
         */
//        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
//        consumer.setConsumeTimestamp("20170422221800"); //时间格式 yyyyMMddHHmmss
        consumer.registerMessageListener(new MessageListenerConcurrently() {

            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                System.out.printf("%s Receive New Messages: %s %n", Thread.currentThread().getName(), msgs);
                for(MessageExt msg:msgs){
                	System.out.println("msgId:"+msg.getMsgId() + " body:" + new String(msg.getBody()));
                }
                /**
                 * CONSUME_SUCCESS 消费成功
                 * RECONSUME_LATER 重试消费，重试次数可以设置，默认是16次
                 */
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;//
            }
        });
        consumer.start();
        System.out.printf("Consumer Started.%n");
    }
}

源码阅读

消息发送

producer启动步骤

producer启动序列图

producer启动源码

public void start(final boolean startFactory) throws MQClientException {
        switch (this.serviceState) {
            case CREATE_JUST:
                this.serviceState = ServiceState.START_FAILED;
                /** 参数校验：1、group不能为空   2、group长度不能超过255  3、group名称不能为默认的“DEFAULT_PRODUCER”  4、group不能包含特殊字符  */
                this.checkConfig();
                // 设置producer实例的名称，默认设置为pid
                if (!this.defaultMQProducer.getProducerGroup().equals(MixAll.CLIENT_INNER_PRODUCER_GROUP)) {
                    this.defaultMQProducer.changeInstanceNameToPID();
                }
                //从map(factoryTable)中获取一个MQClientInstance（key为clientId，clientId为ip@PID），如果没有这创建一个，并存到map中
                this.mQClientFactory = MQClientManager.getInstance().getAndCreateMQClientInstance(this.defaultMQProducer, rpcHook);
                // 将 当前producer存放到 MQClientInstance的一个map里面，key为groupName，value为当前producer，如果一个应用里面有不能创个多个同gourpName的producer
                boolean registerOK = mQClientFactory.registerProducer(this.defaultMQProducer.getProducerGroup(), this);
                if (!registerOK) {
                    this.serviceState = ServiceState.CREATE_JUST;
                    throw new MQClientException("The producer group[" + this.defaultMQProducer.getProducerGroup()
                        + "] has been created before, specify another name please." + FAQUrl.suggestTodo(FAQUrl.GROUP_NAME_DUPLICATE_URL),
                        null);
                }
                //这一步 key=TBW102,value=
                this.topicPublishInfoTable.put(this.defaultMQProducer.getCreateTopicKey(), new TopicPublishInfo());

                if (startFactory) {//启动 MQClientInstance
                    mQClientFactory.start();
                }

                log.info("the producer [{}] start OK. sendMessageWithVIPChannel={}", this.defaultMQProducer.getProducerGroup(),
                    this.defaultMQProducer.isSendMessageWithVIPChannel());
                this.serviceState = ServiceState.RUNNING;
                break;
            case RUNNING:
            case START_FAILED:
            case SHUTDOWN_ALREADY:
                throw new MQClientException("The producer service state not OK, maybe started once, "
                    + this.serviceState
                    + FAQUrl.suggestTodo(FAQUrl.CLIENT_SERVICE_NOT_OK),
                    null);
            default:
                break;
        }
        //向所有broker发送心跳，并更新filter类型的consumer
        this.mQClientFactory.sendHeartbeatToAllBrokerWithLock();
    }

mQClientFactory.start 启动

public void start() throws MQClientException {

        synchronized (this) {
            switch (this.serviceState) {
                case CREATE_JUST:
                    this.serviceState = ServiceState.START_FAILED;
                    // If not specified,looking address from name server
                    if (null == this.clientConfig.getNamesrvAddr()) {
                        this.mQClientAPIImpl.fetchNameServerAddr();
                    }
                    // Start request-response channel
                    this.mQClientAPIImpl.start();
                    // Start various schedule tasks
                    this.startScheduledTask();
                    // Start pull service
                    this.pullMessageService.start();
                    // Start rebalance service
                    this.rebalanceService.start();
                    // Start push service
                    this.defaultMQProducer.getDefaultMQProducerImpl().start(false);
                    log.info("the client factory [{}] start OK", this.clientId);
                    this.serviceState = ServiceState.RUNNING;
                    break;
                case RUNNING:
                    break;
                case SHUTDOWN_ALREADY:
                    break;
                case START_FAILED:
                    throw new MQClientException("The Factory object[" + this.getClientId() + "] has been created before, and failed.", null);
                default:
                    break;
            }
        }
    }

producer发送步骤

producer 发送逻辑序列图

producer 发送源码阅读

方法入口

org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl.sendDefaultImpl(Message, CommunicationMode, SendCallback, long)

方法：

 private SendResult sendDefaultImpl(
        Message msg,
        final CommunicationMode communicationMode,
        final SendCallback sendCallback,
        final long timeout
    ) throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        this.makeSureStateOK();// ServiceState.RUNNING 必须是running
        Validators.checkMessage(msg, this.defaultMQProducer);

        final long invokeID = random.nextLong();
        long beginTimestampFirst = System.currentTimeMillis();
        long beginTimestampPrev = beginTimestampFirst;//记录起始时间，每次选好队列之后,真正发送之前，计算着中间耗时，超过3s，则发送超时
        long endTimestamp = beginTimestampFirst;
        TopicPublishInfo topicPublishInfo = this.tryToFindTopicPublishInfo(msg.getTopic());//根据topic获取队列信息，没有 则从远程读取
        if (topicPublishInfo != null && topicPublishInfo.ok()) {
            boolean callTimeout = false;
            MessageQueue mq = null;
            Exception exception = null;
            SendResult sendResult = null;
            int timesTotal = communicationMode == CommunicationMode.SYNC ? 1 + this.defaultMQProducer.getRetryTimesWhenSendFailed() : 1;// 不同发送，默认是3次，异步是1次；
            int times = 0;
            String[] brokersSent = new String[timesTotal];
            for (; times < timesTotal; times++) {
                String lastBrokerName = null == mq ? null : mq.getBrokerName();
                MessageQueue mqSelected = this.selectOneMessageQueue(topicPublishInfo, lastBrokerName);//根据一定的策略选取某个队列，默认是轮询，根据 topicInfo里面的threadLocalIndex=1629234617，threadLocalIndex对队列长度取模
                if (mqSelected != null) {
                    mq = mqSelected;
                    brokersSent[times] = mq.getBrokerName();
                    try {
                        beginTimestampPrev = System.currentTimeMillis();
                        long costTime = beginTimestampPrev - beginTimestampFirst;
                        if (timeout < costTime) {
                            callTimeout = true;
                            break;
                        }
                        //真正消息发送是在这里
                        sendResult = this.sendKernelImpl(msg, mq, communicationMode, sendCallback, topicPublishInfo, timeout - costTime);
                        endTimestamp = System.currentTimeMillis();
                        this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, false);
                        switch (communicationMode) {
                            case ASYNC:
                                return null;
                            case ONEWAY:
                                return null;
                            case SYNC:
                                if (sendResult.getSendStatus() != SendStatus.SEND_OK) {
                                    if (this.defaultMQProducer.isRetryAnotherBrokerWhenNotStoreOK()) {
                                        continue;
                                    }
                                }

                                return sendResult;
                            default:
                                break;
                        }
                    } catch (RemotingException e) {
                        endTimestamp = System.currentTimeMillis();
                        this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, true);
                        log.warn(String.format("sendKernelImpl exception, resend at once, InvokeID: %s, RT: %sms, Broker: %s", invokeID, endTimestamp - beginTimestampPrev, mq), e);
                        log.warn(msg.toString());
                        exception = e;
                        continue;
                    } catch (MQClientException e) {
                        endTimestamp = System.currentTimeMillis();
                        this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, true);
                        log.warn(String.format("sendKernelImpl exception, resend at once, InvokeID: %s, RT: %sms, Broker: %s", invokeID, endTimestamp - beginTimestampPrev, mq), e);
                        log.warn(msg.toString());
                        exception = e;
                        continue;
                    } catch (MQBrokerException e) {
                        endTimestamp = System.currentTimeMillis();
                        this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, true);
                        log.warn(String.format("sendKernelImpl exception, resend at once, InvokeID: %s, RT: %sms, Broker: %s", invokeID, endTimestamp - beginTimestampPrev, mq), e);
                        log.warn(msg.toString());
                        exception = e;
                        switch (e.getResponseCode()) {
                            case ResponseCode.TOPIC_NOT_EXIST:
                            case ResponseCode.SERVICE_NOT_AVAILABLE:
                            case ResponseCode.SYSTEM_ERROR:
                            case ResponseCode.NO_PERMISSION:
                            case ResponseCode.NO_BUYER_ID:
                            case ResponseCode.NOT_IN_CURRENT_UNIT:
                                continue;
                            default:
                                if (sendResult != null) {
                                    return sendResult;
                                }

                                throw e;
                        }
                    } catch (InterruptedException e) {
                        endTimestamp = System.currentTimeMillis();
                        this.updateFaultItem(mq.getBrokerName(), endTimestamp - beginTimestampPrev, false);
                        log.warn(String.format("sendKernelImpl exception, throw exception, InvokeID: %s, RT: %sms, Broker: %s", invokeID, endTimestamp - beginTimestampPrev, mq), e);
                        log.warn(msg.toString());

                        log.warn("sendKernelImpl exception", e);
                        log.warn(msg.toString());
                        throw e;
                    }
                } else {
                    break;
                }
            }

            if (sendResult != null) {
                return sendResult;
            }

            String info = String.format("Send [%d] times, still failed, cost [%d]ms, Topic: %s, BrokersSent: %s",
                times,
                System.currentTimeMillis() - beginTimestampFirst,
                msg.getTopic(),
                Arrays.toString(brokersSent));

            info += FAQUrl.suggestTodo(FAQUrl.SEND_MSG_FAILED);

            MQClientException mqClientException = new MQClientException(info, exception);
            if (callTimeout) {
                throw new RemotingTooMuchRequestException("sendDefaultImpl call timeout");
            }

            if (exception instanceof MQBrokerException) {
                mqClientException.setResponseCode(((MQBrokerException) exception).getResponseCode());
            } else if (exception instanceof RemotingConnectException) {
                mqClientException.setResponseCode(ClientErrorCode.CONNECT_BROKER_EXCEPTION);
            } else if (exception instanceof RemotingTimeoutException) {
                mqClientException.setResponseCode(ClientErrorCode.ACCESS_BROKER_TIMEOUT);
            } else if (exception instanceof MQClientException) {
                mqClientException.setResponseCode(ClientErrorCode.BROKER_NOT_EXIST_EXCEPTION);
            }

            throw mqClientException;
        }

        List<String> nsList = this.getmQClientFactory().getMQClientAPIImpl().getNameServerAddressList();
        if (null == nsList || nsList.isEmpty()) {
            throw new MQClientException(
                "No name server address, please set it." + FAQUrl.suggestTodo(FAQUrl.NAME_SERVER_ADDR_NOT_EXIST_URL), null).setResponseCode(ClientErrorCode.NO_NAME_SERVER_EXCEPTION);
        }

        throw new MQClientException("No route info of this topic, " + msg.getTopic() + FAQUrl.suggestTodo(FAQUrl.NO_TOPIC_ROUTE_INFO),
            null).setResponseCode(ClientErrorCode.NOT_FOUND_TOPIC_EXCEPTION);
    }

消息消费

pull消费步骤

  1. 当前pullConsumer设置为ServiceState.START_FAILED;
  2. 配置检查。检查group配置，跟producer一样，长度不能超过255，不能包含特殊字符，不能为空，不能为默认的DEFAULT_CONSUMER；allocateMessageQueueStrategy不能为空
  3. 复制订阅关系
  4. 将defaultMQPullConsumer的名字改成pid
  5. 根据consumer配置，创建一个MQClientInstance，创建逻辑跟producer创建一个MQClientInstance一样的

pull消费逻辑序列图

pull消费源码阅读

push消费步骤

  1. 参数注入
  2. listener实例注入
  3. 启动DefaultMQPushConsumer
    1. 参数校验。consumergroup 不能为空；名字不能是DEFAULT_CONSUMER；消费模型（集群、广播）不能为空；从哪里开始消费不能为空；消息起始时间格式必须为 yyyyMMddHHmmss；校验队列分配策略（默认是average，）消息接收必须是 orderly或者 concurrently
    2. copy订阅关系

push消费逻辑序列图

push消费源码阅读

参考文档

消息中间件—RocketMQ消息发送

转载于:https://my.oschina.net/liangxiao/blog/3007875

weixin_34203426
关注
RocketMQ 顺序消息解析——图解、源码级解析
如切如磋，如琢如磨
07-30 3315
优秀的程序员不应该只是CRUD
RocketMQ5.0--消息发送
专搞技术的小兔子
07-07 185
没有启用Broker故障延迟机制，即：sendLatencyFaultEnable为false，采用默认机制，其实现方法org.apache.rocketmq.client.impl.producer.TopicPublishInfo#selectOneMessageQueue(java.lang.String)，其代码如下。org.apache.rocketmq.broker.processor.SendMessageProcessor是Broker接收消息的实现类，其代码如下。
RocketMQ：发送消息与接收实例
weixin_42113716的博客
08-29 435
RocketMQ：发送消息与接收实例【同步消息 异步消息 单线消息 顺序消息】
RocketMQ-消费MQ消息简单示例
zym_1321的博客
07-18 512
Rocket MQ
中间件之RocketMQ
最新发布
一个老Java开发的自白
09-15 1325
RocketMQ作为一款高性能、高可靠、高可用的分布式消息队列系统，在微服务架构、大数据处理、实时计算等领域具有广泛的应用前景。其强大的功能和灵活的配置使得它能够满足不同场景下的消息传递需求。随着技术的不断发展和社区的不断壮大，RocketMQ将继续为分布式系统提供稳定可靠的消息传递服务。
RocketMQ MQClientInstance、生产者实例启动源码分析
vnjohn 博主 > 主线分享后端领域业务设计知识、源码思想、架构设计
01-06 1746
该篇博文主要介绍 MQClientInstance 客户端实例以及 TopicRouteData 主题元数据信息，结合 Dashboard 看会更加的清晰，后续介绍了生产者实例启动的一个过程，其中介绍了几个核心的地方：NettyRemotingClient Netty 客户端、MQClientInstance#startScheduledTask 涉及到的定时调度任务、PullMessageService 推送模式作用的类、RebalanceService 重平衡服务
springboot下rocketmq-client消息接收发布示例代码
apply_bomb的博客
10-25 171
就是官网稍稍复杂些，并且是脱离springboot的，对任务繁重的开发们可能不太友好，而我的示例注释比较多，可以直接复制就用。参考官方文档，大部分功能的示例代码都可以从这个地址找到。
RocketMQ（三）RocketMQ入门样例
weixiaohuai的博客
03-17 4052
目录 一、概述 二、Producer端发送同步消息 三、Producer端发送异步消息 四、Producer端单向发送消息 五、消费消息 一、概述 RocketMQ支持发送三种类型的消息：同步消息、异步消息和单向消息。其中前两种消息是可靠的，因为会有发送是否成功的应答。 接下来，我们将演示如何发送三种类型的消息，来快速熟悉RocketMQ的使用。首先需要加入RocketMQ的依赖， 因为是Maven项目，所以在pom.xml中加入如下依赖： ​ <dependency> .
RocketMQ官方教程（翻译加扩充）——简单的消息示例
gaishi_hero的博客
05-12 365
文章目录添加依赖同步地发送消息异步消息发送以单向模式发送消息消费消息 本翻译教程来自RocketMQ官方网站，中间会加上自己的理解，有错误或者不妥之处请及时指正。另外，本文所基于的版本是4.4.0 使用RocketMQ以三种方式来发送消息：可靠同步、可靠异步和单向模式 使用RocketMQ来消费消息 添加依赖 maven: <dependency> &l...
RocketMq发送消息
wanli4717的博客
02-28 5562
发送类型 Rocketmq提供三种方式可以发送普通消息：同步、异步、和单向发送。 同步：发送方发送消息后，收到服务端响应后才发送下一条消息 异步：发送一条消息后，不等服务端返回就可以继续发送消息或者后续任务处理。发送方通过回调接口接收服务端响应，并处理响应结果。 OneWay：发送方发送消息，不等待服务端返回响应且没有回调函数触发，即只发送请求不需要应答。 发送方式对比：发送吞吐量,单向>异步>同步。但单向发送可靠性差存在丢失消息可能，选型根据实际需求确定。 Demo演示 ..
RocketMQ系列4——负载均衡
xiaodigua1024的博客
03-29 1148
RocketMQ中的负载均衡主要分为Producer端发送消息时候的负载均衡和Consumer端订阅消息的负载均衡。
Python-rocketmqpython是一个基于rocketmqclientcpp封装的RocketMQPython客户端
08-10
rocketmq-python 是一个基于 rocketmq-client-cpp 封装的 RocketMQ Python 客户端
消息中间件 RocketMQ源码解析：Message发送&接收
weixin_33709590的博客
04-28 979
2019独角兽企业重金招聘Python工程师标准>>> ...
RocketMQ高手之路系列之七：RocketMQ之消息发送（四）
08-03 454
引言 前面我们介绍了`RocketMQ`在发送消息之前做了一系列的准备事项，其中包括路由选择、队列选择以及坏点`Broker`退避等等。本文将开始阐述`RocketMQ`的消息发送过程。
源码分析之RocketMQ发送消息与接收消息
evasnowind的专栏
10-13 588
说明 本文主要是本人学习、整理的笔记，涉及的内容可能来自网上，我会尽量注明来源。 我本人阅读的rocketmq代码版本为4.7.1。 producer发送消息 有关producer生产消息，之前参考极客时间 消息队列高手课，写过一篇学习笔记，参考这里源码分析之RocketMQ Producer生产消息的实现及其设计模式分析 此处再给出一些参考图片与资料 producer发送消息总体过程 此图来自：http://www.iocoder.cn/RocketMQ/message-send-and-receive
RocketMQ 源码分析 —— Message 发送与接收
芋艿V
04-26 422
点击上方“芋道源码”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020 超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络...
RocketMQ《二》消息发送与接收样例
qq_40774600的博客
08-17 844
本文转载整理至网友整理的相关，资料整理地址：https://github.com/DillonDong/notes/blob/master/RocketMQ/RocketMQ-01.md 1、准备工作工作 导入MQ客户端依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <ve
rocketmq的生产者源码解读二（发消息）
简单，快乐，拥抱变化
03-31 394
上接生产者源码解读一
RocketMQ 发送/接受消息
程序员野蛮成长
01-09 754
新建Java项目，添加RocketMQ Client的依赖。 <dependency> <groupId>com.alibaba.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> ...
Kotlin+RocketMQ实现延时消息详解及示例
"本文主要讲解如何使用Kotlin与Apache RocketMQ结合实现延时消息功能，通过具体的示例代码，提供了一种在特定时间后发送消息的解决方案，适用于电商等需要延时处理的业务场景。" 在当今的分布式系统中，延时消息是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值