xxl-job源码分析

最新推荐文章于 2024-05-06 11:47:34 发布
最新推荐文章于 2024-05-06 11:47:34 发布
阅读量369 收藏 1
点赞数
文章标签： java 数据结构与算法 php
原文链接：http://www.cnblogs.com/guoyinli/p/11555035.html
版权
xxl-job源码分析

xxl-job

系统说明

安装

安装部署参考文档：分布式任务调度平台xxl-job

功能

定时调度、服务解耦、灵活控制跑批时间（停止、开启、重新设定时间、手动触发）

XXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用

概念

执行器列表：一个执行器是一个项目

任务：一个任务是一个项目中的 JobHandler

一个xxl-job服务可以有多个执行器（项目），一个项目下可以有多个任务（JobHandler），他们是如何关联的？

页面操作：

  1. 在管理平台可以新增执行器（项目）
  2. 在任务列表可以指定执行器（项目）下新增多个任务（JobHandler）

代码操作：

  1. 项目配置中增加 xxl.job.executor.appname = "执行器名称"
  2. 在实现类中增加 @JobHandler(value="xxl-job-demo") 注解，并继承 IJobHandler
架构图

1072053-20190920094456690-1804945154.png

抛出疑问

  1. 调度中心启动过程？
  2. 执行器启动过程？
  3. 执行器如何注册到调度中心？
  4. 调度中心怎么调用执行器？
  5. 集群调度时如何控制一个任务在该时刻不会重复执行
  6. 集群部署应该注意什么？

系统分析

执行器依赖jar包

com.xuxueli:xxl-job-core:2.1.0

com.xuxueli:xxl-registry-client:1.0.2

com.xuxueli:xxl-rpc-core:1.4.1

调度中心启动过程
// 1. 加载 XxlJobAdminConfig，adminConfig = this
XxlJobAdminConfig.java

// 启动过程代码
@Component
public class XxlJobScheduler implements InitializingBean, DisposableBean {
    private static final Logger logger = LoggerFactory.getLogger(XxlJobScheduler.class);

    @Override
    public void afterPropertiesSet() throws Exception {
        // init i18n
        initI18n();

        // admin registry monitor run
        // 2. 启动注册监控器（将注册到register表中的IP加载到group表）/ 30执行一次
        JobRegistryMonitorHelper.getInstance().start();

        // admin monitor run
        // 3. 启动失败日志监控器（失败重试，失败邮件发送）
        JobFailMonitorHelper.getInstance().start();

        // admin-server
        // 4. 初始化RPC服务
        initRpcProvider();

        // start-schedule
        // 5. 启动定时任务调度器（执行任务，缓存任务）
        JobScheduleHelper.getInstance().start();

        logger.info(">>>>>>>>> init xxl-job admin success.");
    }
    
    ......
}
执行器启动过程
@Override
public void start() throws Exception {

    // init JobHandler Repository
    // 将执行 JobHandler 注册到缓存中 jobHandlerRepository（ConcurrentMap）
    initJobHandlerRepository(applicationContext);

    // refresh GlueFactory
    // 刷新GLUE
    GlueFactory.refreshInstance(1);

    // super start
    // 核心启动项
    super.start();
}

public void start() throws Exception {
    // 初始化日志路径 
    // private static String logBasePath = "/data/applogs/xxl-job/jobhandler";
    XxlJobFileAppender.initLogPath(this.logPath);
    // 初始化注册中心列表 （把注册地址放到 List）
    this.initAdminBizList(this.adminAddresses, this.accessToken);
    // 启动日志文件清理线程 （一天清理一次）
    // 每天清理一次过期日志，配置参数必须大于3才有效
    JobLogFileCleanThread.getInstance().start((long)this.logRetentionDays);
    // 开启触发器回调线程
    TriggerCallbackThread.getInstance().start();
    // 指定端口
    this.port = this.port > 0 ? this.port : NetUtil.findAvailablePort(9999);
    // 指定IP
    this.ip = this.ip != null && this.ip.trim().length() > 0 ? this.ip : IpUtil.getIp();
    // 初始化RPC 将执行器注册到调度中心 30秒一次
    this.initRpcProvider(this.ip, this.port, this.appName, this.accessToken);
}
执行器注册到调度中心

执行器

// 注册执行器入口
XxlJobExecutor.java->initRpcProvider()->xxlRpcProviderFactory.start();

// 开启注册
XxlRpcProviderFactory.java->start();

// 执行注册
ExecutorRegistryThread.java->start();
// RPC 注册代码
for (AdminBiz adminBiz: XxlJobExecutor.getAdminBizList()) {
    try {
        ReturnT<String> registryResult = adminBiz.registry(registryParam);
        if (registryResult!=null && ReturnT.SUCCESS_CODE == registryResult.getCode()) {
            registryResult = ReturnT.SUCCESS;
            logger.debug(">>>>>>>>>>> xxl-job registry success, registryParam:{}, registryResult:{}", new Object[]{registryParam, registryResult});
            break;
        } else {
            logger.info(">>>>>>>>>>> xxl-job registry fail, registryParam:{}, registryResult:{}", new Object[]{registryParam, registryResult});
        }
    } catch (Exception e) {
        logger.info(">>>>>>>>>>> xxl-job registry error, registryParam:{}", registryParam, e);
    }

}

调度中心

// RPC 注册服务
AdminBizImpl.java->registry();

数据库

1072053-20190920094906422-637038043.png

1072053-20190920094851139-1515543303.png

调度中心调用执行器
/* 调度中心执行步骤 */
// 1. 调用执行器
XxlJobTrigger.java->runExecutor();

// 2. 获取执行器
XxlJobScheduler.java->getExecutorBiz();

// 3. 调用
ExecutorBizImpl.java->run();

/* 执行器执行步骤 */
// 1. 执行器接口
ExecutorBiz.java->run();

// 2. 执行器实现
ExecutorBizImpl.java->run();

// 3. 把jobInfo 从 jobThreadRepository (ConcurrentMap) 中获取一个新线程，并开启新线程
XxlJobExecutor.java->registJobThread();

// 4. 保存到当前线程队列
JobThread.java->pushTriggerQueue();

// 5. 执行
JobThread.java->handler.execute(triggerParam.getExecutorParams());

调度中心（Admin）

实现 org.springframework.beans.factory.InitializingBean类，重写 afterPropertiesSet 方法，在初始化bean的时候都会执行该方法

DisposableBean spring停止时执行

结束加载项

  1. 停止定时任务调度器（中断scheduleThread，中断ringThread）
  2. 停止触发线程池（JobTriggerPoolHelper）
  3. 停止注册监控器（registryThread）
  4. 停止失败日志监控器（monitorThread）
  5. 停止RPC服务（stopRpcProvider）
手动执行方式

JobInfoController.java

@RequestMapping("/trigger")
@ResponseBody
//@PermissionLimit(limit = false)
public ReturnT<String> triggerJob(int id, String executorParam) {
    // force cover job param
    if (executorParam == null) {
        executorParam = "";
    }

    JobTriggerPoolHelper.trigger(id, TriggerTypeEnum.MANUAL, -1, null, executorParam);
    return ReturnT.SUCCESS;
}
定时调度策略

调度策略执行图

1072053-20190920094826086-2070926333.png

调度策略源码

JobScheduleHelper.java->start();
路由策略
第一个

固定选择第一个机器

ExecutorRouteFirst.java->route();
最后一个

固定选择最后一个机器

ExecutorRouteLast.java->route();
轮询

随机选择在线的机器

ExecutorRouteRound.java->route();

private static int count(int jobId) {
    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        routeCountEachJob.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // count++
    Integer count = routeCountEachJob.get(jobId);
    count = (count==null || count>1000000)?(new Random().nextInt(100)):++count;  // 初始化时主动Random一次，缓解首次压力
    routeCountEachJob.put(jobId, count);
    return count;
}
随机

随机获取地址列表中的一个

ExecutorRouteRandom.java->route();
一致性HASH

一个job通过hash算法固定使用一台机器，且所有任务均匀散列在不同机器

ExecutorRouteConsistentHash.java->route();

public String hashJob(int jobId, List<String> addressList) {

    // ------A1------A2-------A3------
    // -----------J1------------------
    TreeMap<Long, String> addressRing = new TreeMap<Long, String>();
    for (String address: addressList) {
        for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
            long addressHash = hash("SHARD-" + address + "-NODE-" + i);
            addressRing.put(addressHash, address);
        }
    }

    long jobHash = hash(String.valueOf(jobId));
    // 取出键值 >= jobHash
    SortedMap<Long, String> lastRing = addressRing.tailMap(jobHash);
    if (!lastRing.isEmpty()) {
        return lastRing.get(lastRing.firstKey());
    }
    return addressRing.firstEntry().getValue();
}
最不经常使用

使用频率最低的机器优先被选举
把地址列表加入到内存中，等下次执行时剔除无效的地址，判断地址列表中执行次数最少的地址取出
频率、次数

ExecutorRouteLFU.java->route();

public String route(int jobId, List<String> addressList) {

    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        jobLfuMap.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // lfu item init
    HashMap<String, Integer> lfuItemMap = jobLfuMap.get(jobId);     // Key排序可以用TreeMap+构造入参Compare；Value排序暂时只能通过ArrayList；
    if (lfuItemMap == null) {
        lfuItemMap = new HashMap<String, Integer>();
        jobLfuMap.putIfAbsent(jobId, lfuItemMap);   // 避免重复覆盖
    }

    // put new
    for (String address: addressList) {
        if (!lfuItemMap.containsKey(address) || lfuItemMap.get(address) >1000000 ) {
            // 0-n随机数，包括0不包括n
            lfuItemMap.put(address, new Random().nextInt(addressList.size()));  // 初始化时主动Random一次，缓解首次压力
        }
    }
    // remove old
    List<String> delKeys = new ArrayList<>();
    for (String existKey: lfuItemMap.keySet()) {
        if (!addressList.contains(existKey)) {
            delKeys.add(existKey);
        }
    }
    if (delKeys.size() > 0) {
        for (String delKey: delKeys) {
            lfuItemMap.remove(delKey);
        }
    }
    
    /*********************** 优化 START ***********************/
    // 优化  remove old部分
    Iterator<String> iterable = lfuItemMap.keySet().iterator();
    while (iterable.hasNext()) {
        String address = iterable.next();
        if (!addressList.contains(address)) {
            iterable.remove();
        }
    }
    /*********************** 优化 START ***********************/

    // load least userd count address
    // 从小到大排序
    List<Map.Entry<String, Integer>> lfuItemList = new ArrayList<Map.Entry<String, Integer>>(lfuItemMap.entrySet());
    Collections.sort(lfuItemList, new Comparator<Map.Entry<String, Integer>>() {
        @Override
        public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
            return o1.getValue().compareTo(o2.getValue());
        }
    });

    Map.Entry<String, Integer> addressItem = lfuItemList.get(0);
    String minAddress = addressItem.getKey();
    addressItem.setValue(addressItem.getValue() + 1);

    return addressItem.getKey();
}
最近最久未使用

最久未使用的机器优先被选举
用链表的方式存储地址，第一个地址使用后下次该任务过来使用第二个地址，依次类推（PS：有点类似轮询策略）
与轮询策略的区别：

  1. 轮询策略是第一次随机找一台机器执行，后续执行会将索引加1取余
  2. 轮询策略依赖 addressList 的顺序，如果这个顺序变了，索引到下一次的机器可能不是期望的顺序
  3. LRU算法第一次执行会把所有地址加载进来并缓存，从第一个地址开始执行，即使 addressList 地址顺序变了也不影响
    次数
ExecutorRouteLRU.java->route();

public String route(int jobId, List<String> addressList) {

    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        jobLRUMap.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // init lru
    LinkedHashMap<String, String> lruItem = jobLRUMap.get(jobId);
    if (lruItem == null) {
        /**
         * LinkedHashMap
         *      a、accessOrder：ture=访问顺序排序（get/put时排序）；false=插入顺序排期；
         *      b、removeEldestEntry：新增元素时将会调用，返回true时会删除最老元素；可封装LinkedHashMap并重写该方法，比如定义最大容量，超出是返回true即可实现固定长度的LRU算法；
         */
        lruItem = new LinkedHashMap<String, String>(16, 0.75f, true);
        jobLRUMap.putIfAbsent(jobId, lruItem);
    }

    /*********************** 举个例子 START ***********************/
    // 如果accessOrder为true的话，则会把访问过的元素放在链表后面，放置顺序是访问的顺序 
    // 如果accessOrder为flase的话，则按插入顺序来遍历
    LinkedHashMap<String, String> lruItem = new LinkedHashMap<String, String>(16, 0.75f, true);
        jobLRUMap.putIfAbsent(1, lruItem);
        lruItem.put("192.168.0.1", "192.168.0.1");
        lruItem.put("192.168.0.2", "192.168.0.2");
        lruItem.put("192.168.0.3", "192.168.0.3");
        String eldestKey = lruItem.entrySet().iterator().next().getKey();
        String eldestValue = lruItem.get(eldestKey);
        System.out.println(eldestValue + ": " + lruItem);
        eldestKey = lruItem.entrySet().iterator().next().getKey();
        eldestValue = lruItem.get(eldestKey);
        System.out.println(eldestValue + ": " + lruItem);
    
    // 输出结果：
    192.168.0.1: {192.168.0.2=192.168.0.2, 192.168.0.3=192.168.0.3, 192.168.0.1=192.168.0.1}
192.168.0.2: {192.168.0.3=192.168.0.3, 192.168.0.1=192.168.0.1, 192.168.0.2=192.168.0.2}
    /*********************** 举个例子 END ***********************/
    
    // put new
    for (String address: addressList) {
        if (!lruItem.containsKey(address)) {
            lruItem.put(address, address);
        }
    }
    // remove old
    List<String> delKeys = new ArrayList<>();
    for (String existKey: lruItem.keySet()) {
        if (!addressList.contains(existKey)) {
            delKeys.add(existKey);
        }
    }
    if (delKeys.size() > 0) {
        for (String delKey: delKeys) {
            lruItem.remove(delKey);
        }
    }

    // load
    String eldestKey = lruItem.entrySet().iterator().next().getKey();
    String eldestValue = lruItem.get(eldestKey);
    return eldestValue;
}
故障转移

按照顺序依次进行心跳检测，第一个心跳检测成功的机器选定为目标执行器并发起调度

ExecutorRouteFailover.java->route();
忙碌转移

按照顺序依次进行空闲检测，第一个空闲检测成功的机器选定为目标执行器并发起调度

ExecutorRouteBusyover.java->route();
分片广播

广播触发对应集群中所有机器执行一次任务，同时传递分片参数；可根据分片参数开发分片任务

阻塞处理策略

为了解决执行线程因并发问题、执行效率慢、任务多等原因而做的一种线程处理机制，主要包括 串行、丢弃后续调度、覆盖之前调度，一般常用策略是串行机制

ExecutorBlockStrategyEnum.java

SERIAL_EXECUTION("Serial execution"), // 串行
DISCARD_LATER("Discard Later"), // 丢弃后续调度
COVER_EARLY("Cover Early"); // 覆盖之前调度

ExecutorBizImpl.java->run();

// executor block strategy
if (jobThread != null) {
    ExecutorBlockStrategyEnum blockStrategy = ExecutorBlockStrategyEnum.match(triggerParam.getExecutorBlockStrategy(), null);
    if (ExecutorBlockStrategyEnum.DISCARD_LATER == blockStrategy) {
        // discard when running
        if (jobThread.isRunningOrHasQueue()) {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "block strategy effect："+ExecutorBlockStrategyEnum.DISCARD_LATER.getTitle());
        }
    } else if (ExecutorBlockStrategyEnum.COVER_EARLY == blockStrategy) {
        // kill running jobThread
        if (jobThread.isRunningOrHasQueue()) {
            removeOldReason = "block strategy effect：" + ExecutorBlockStrategyEnum.COVER_EARLY.getTitle();

            jobThread = null;
        }
    } else {
        // just queue trigger
    }
}
单机串行

对当前线程不做任何处理，并在当前线程的队列里增加一个执行任务

丢弃后续调度

如果当前线程阻塞，后续任务不再执行，直接返回失败

覆盖之前调度

创建一个移除原因，新建一个线程去执行后续任务

运行模式
ExecutorBizImpl.java->run();
BEAN

java里的bean对象

GLUE(Java)

利用java的反射机制，通过代码字符串生成实体类

IJobHandler originJobHandler = GlueFactory.getInstance().loadNewInstance(triggerParam.getGlueSource());

GroovyClassLoader
GLUE(Shell Python PHP Nodejs PowerShell)

按照文件命名规则创建一个执行脚本文件和一个日志输出文件，通过脚本执行器执行

失败重试次数

任务失败后记录到 xxl_job_log 中，由失败监控线程查询处理失败的任务且失败次数大于0，继续执行

任务超时时间

把超时时间给 triggerParam 触发参数，在调用执行器的任务时超时时间，有点类似HttpClient的超时时间

执行器（Exector）

  1. 注册自己的机器地址

  2. 注册项目中的 JobHandler

  3. 提供被调度中心调用的接口

    public interface ExecutorBiz {

    /**
     * 供调度中心检测机器是否存活
     *
     * beat
     * @return
     */
    public ReturnT<String> beat();

    /**
     * 供调度中心检测机器是否空闲
     *
     * @param jobId
     * @return
     */
    public ReturnT<String> idleBeat(int jobId);

    /**
     * kill
     * @param jobId
     * @return
     */
    public ReturnT<String> kill(int jobId);

    /**
     * log
     * @param logDateTim
     * @param logId
     * @param fromLineNum
     * @return
     */
    public ReturnT<LogResult> log(long logDateTim, long logId, int fromLineNum);

    /**
     * 执行触发器
     * 
     * @param triggerParam
     * @return
     */
    public ReturnT<String> run(TriggerParam triggerParam);

}

总结

1072053-20190920094739862-1959701255.png

学到了什么
  1. 算法（LFU、LRU、轮询等）
  2. JDK动态代理对象（详细研究）
  3. 用到了Netty（详细研究）
  4. FutureTask
  5. GroovyClassLoader
posted on 2019-09-20 09:43  小猴子先生 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/guoyinli/p/11555035.html

weixin_30868855
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
xxl-job No such file or directory java.io.IOException: No such file or directory
更新失败的博客
03-31 6875
xxl-job No such file or directory java.io.IOException: No such file or directory at java.io.UnixFileSystem.createFileExclusively(Native Method) XxlJobFileAppender
XXL-JOB日志目录无法被创建bug；[rCallbackThread] c.x.j.c.l.XxlJobFileAppender: No such file or directory
L1511768722的博客
11-22 3788
XXL-JOB运行时候报错log日志文件就会报错
XXL-JOB源码分析
lzd649648959的专栏
05-06 1212
/doc :文档资料- /db :“调度数据库”建表脚本- /xxl-job-admin :调度中心（任务调度管理平台），项目源码- /xxl-job-core :公共Jar依赖（调度核心- /xxl-job-executor-samples :执行器， Sample示例项目 （大家可以在该项目上进行开发，也可以将现有项目改造生成执行器项目）
spring-boot XXL-JOB java.io.IOException: No such file or directory
by690162303的博客
05-12 5583
spring-boot 使用 XXL-JOB XxlJobHelper.log("ip:"+ip+" 执行成功!! "+number ); 在本地环境下，从admin客户端可以看到执行日志信息，在虚拟机 Linux环境下 系统提示 找不到文件或文件夹 2022-05-12 16:33:08.030 ERROR 97519 --- [rCallbackThread] com.xxl.job.core.log.XxlJobFileAppender : No such file or dire
Xxl-job客户端启动 StatusCode(404) invalid 问题原因及解决方案做下简单记录
huawd的博客
12-21 1万+
Xxl-job 执行器回调调度中心注册报错404，解决方案
xxl-job源码下载
03-14
XXL-JOB是一款开源的任务调度平台，其设计目标是轻量、简单且易于扩展，适合在微服务架构中用于分布式任务调度。以下是关于XXL-JOB的一些关键知识点： 1. **核心概念**： - **任务调度器(XXL-JOB Executor)**：...
xxl-job实战源码
03-24
**XXL-JOB实战源码解析** ...通过深入学习和实践XXL-JOB源码，开发者可以更好地理解分布式任务调度的原理，从而灵活地在项目中运用和定制。同时，了解源码有助于排查问题和优化性能，提升系统的整体效率。
xxl-job-2.2.0.zip
11-16
总之，XXL-JOB-2.2.0源码的分析可以帮助我们理解分布式任务调度的实现细节，了解任务的分发、执行、监控等核心流程，为自定义任务处理和扩展提供指导。深入学习这些源码，不仅可以提升开发技能，也能提高解决实际...
分布式调度xxl-job
01-17
* XXLJob2.3：XXL-Job支持XXLJob2.3版本。 知识点四：XXL-Job的学习.form * 视频讲解：XXL-Job的学习形式包括视频讲解。 * 文字笔记：XXL-Job的学习形式包括文字笔记。 * 原理分析：XXL-Job的学习形式包括原理分析...
xxl-job.rar
03-02
4. **源码分析**： 提供的源码有助于开发者深入理解XXL-JOB的工作原理。主要涉及调度中心的调度算法、执行器的心跳机制、任务的分发策略以及GLUE任务的执行流程等。 5. **xxl-job-2.3.0.jar**： 这是XXL-JOB核心...
xxl-job 注册失败 启动报 The access token is wrong的错误
qq_23257129的博客
07-31 5868
xxl-job、xxl-job admin、springboot、xxl-job registry fail、The access token is wrong.
xxljob整合springboot
weixin_44925711的博客
06-26 595
xxljob
xxljob 自动清理日志的业务逻辑，以及涉及到的文件
一天不写代码难受的博客
12-14 3697
xxljob
【xxljob报错】com.xxl.job.core.log.XxlJobFileAppender : No such file or directory
JavaEdge全是干货的技术号
04-07 577
Linux 环境下 无权限创建文件夹 需手动在 根目录下 /data/applogs/xxl-job/jobhandler 创建这几个目录。SpringBoot 项目使用 XXL-JOB，执行到。
Mac Idea 出现 Failed to create parent directories for
leishigege的博客
07-14 7894
Mac 编码问题
Linux: 运行存在的可执行文件提示 No such file or directory
热门推荐
JiMoKuangXiangQu的专栏
11-10 1万+
linux, 文件系统, ftrace
No such file or directory的原因
csdn20142的博客
03-17 3299
出现bad interpreter:No such file or directory的原因 今天写as日志监控脚本的时候，有个py程序是在win环境下编写的，在win环境下运行没有问题，但是放到lin...
xxl-job 执行成功,但是报“任务结果丢失，标记失败“错误
不善言谈者
11-22 7898
xxl-job 调用成功,但是结果报:任务结果丢失,标记失败错误; 自动注册时,注册的不是服务器本身的ip,而是docker 的ip
3.xxl-job实战3.1下拉xxl-job源码
最新发布
05-23
下面是在xxl-job 3.1版本中拉取源码的步骤： 1. 打开xxl-job官网，点击页面右上角的"下载"按钮，在弹出的下载页面中下载xxl-job 3.1版本的源码压缩包； 2. 解压源码压缩包，可以看到源代码的目录结构； 3. 根据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值