Spark RDD案例（三）连续分布数据按照条件rollup

最新推荐文章于 2023-09-27 11:19:42 发布
原创 最新推荐文章于 2023-09-27 11:19:42 发布 · 498 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spark #scala #分布式 #大数据

本文介绍了如何使用Spark的RDD处理连续分布数据的条件rollup操作。通过示例展示了如何处理和汇总大数据，特别是针对时间间隔内的流量统计。在案例中，数据按用户ID和时间戳分段，当相邻数据时间间隔不超过10分钟时进行汇总。通过一系列转换、分组和计算，最终得到符合需求的汇总结果。

Spark RDD案例（三）连续分布数据按照条件rollup

1. 背景

  1. Spark作为大数据分析引擎，本身可以做离线和准实时数据处理
  2. Spark抽象出的操作对象如RDD、dataSet、dataFrame、DStream等都是高层级的抽象，屏蔽了分布式数据处理代码细节，操作分布式数据和处理就像使用scala集合接口一样便利。这样可以很大降低编程使用和理解门槛。
  3. 在实际生产中，大数据处理面临的业务需求和正常java 业务需求一样，都是基于数据做处理。不同的是正常java业务数据相对较少，如mysql中适合存储的数据是小而美的如500万行数据及以下，而大数据存储500万行才达到海量数据存储的门槛。
  4. 实际生产中，大数据和小批量Java数据处理需求往往类似，如连续分布的一些数据按照一定条件累积汇总，如电信商统计用户流量是按照时间间隔分段统计，如汽车速度区间统计，例如跑步app对配速的分段精确统计等等。

2. 案例

  1. 需求
  • 这里是要求将2条数据的下载流量汇总，第一个字段是用户id，第二个第三个是开始和结束时间戳，第三个是下行流量
  • 汇总条件是，同一用户，上一条数据的结束时间和当前一条数据的开始时间间隔不超过10min，超过则重新汇总
  1. 数据
1,2020-02-18 14:20:30,2020-02-18 14:46:30,20  
1,2020-02-18 14:47:20,2020-02-18 15:20:30,30        
1,2020-02-18 15:37:23,2020-02-18 16:05:26,40            
1,2020-02-18 16:06:27,2020-02-18 17:20:49,50          
1,2020-02-18 17:21:50,2020-02-18 18:03:27,60          
2,2020-02-18 14:18:24,2020-02-18 15:01:40,20
2,2020-02-18 15:20:49,2020-02-18 15:30:24,30
2,2020-02-18 16:01:23,2020-02-18 16:40:32,40
2,2020-02-18 16:44:56,2020-02-18 17:40:52,50
3,2020-02-18 14:39:58,2020-02-18 15:35:53,20
3,2020-02-18 15:36:39,2020-02-18 15:24:54,30

2.1 代码一

package com.doit.practice

import java.text.SimpleDateFormat
import java.util.Date

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
 * 1,2020-02-18 14:20:30,2020-02-18 14:46:30,20
 * 1,2020-02-18 14:47:20,2020-02-18 15:20:30,30
 * 1,2020-02-18 15:37:23,2020-02-18 16:05:26,40
 * 1,2020-02-18 16:06:27,2020-02-18 17:20:49,50
 * 1,2020-02-18 17:21:50,2020-02-18 18:03:27,60
 * 2,2020-02-18 14:18:24,2020-02-18 15:01:40,20
 * 2,2020-02-18 15:20:49,2020-02-18 15:30:24,30
 * 2,2020-02-18 16:01:23,2020-02-18 16:40:32,40
 * 2,2020-02-18 16:44:56,2020-02-18 17:40:52,50
 * 3,2020-02-18 14:39:58,2020-02-18 15:35:53,20
 * 3,2020-02-18 15:36:39,2020-02-18 15:24:54,30
 *
 */

object NetFlowRollUp {
  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf().setAppName("NetFlowRollUp").setMaster("local[*]")

    val sc = new SparkContext(conf)

    // 1,   2020-02-18 14:20:30,   2020-02-18 14:46:30,   20
    // 这里是要求将2条数据的下载流量汇总，
    // 第一个字段是用户id，第二个第三个是开始和结束时间戳，第三个是下行流量
    // 汇总条件是，同一用户，上一条数据的结束时间和当前一条数据的开始时间间隔不超过10min，超过则重新汇总

    // 处理思路是，
    // 先将数据根据uid分组，分组之后，将数据根据开始时间排序（排序时需要转换为长整型数字，方便排序）
    // 排序之后，还需要去重，防止有重复脏数据，这时候方便去重，将数据转换为uid，开始，结束为key，下行流量为value
    // 然后使用类似lag操作，分组数据处理，将每个组的数据转换为List或者Array，，判断2条数据之间结束和开始时间间隔是否小于10min，是标记为0，不是标记为1
    // 再对这个标记做累加操作，这样相同类型数据就会是0   1   2 这种统一累加标记。
    // 针对这种累加标记做分组，对相应的流量做聚合，就得到想要的数据
    // 如果需要可视化好一些，对时间戳做转换，格式化一下

    val linesRDD: RDD[String] = sc.textFile("E:\\DOITLearning\\12.Spark\\netflowRollupSourceData.txt")

    // 将数据做转换，切分，注意涉及到数据处理用到对象，使用mapPartitions更加合适，因为可以复用
    // 数据还需要去重
    val mapedRDD: RDD[((String, Long, Long), Double)] = linesRDD.mapPartitions(iter => {

      // 2020-02-18 14:20:30
      val simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

      // 注意这里需要将时间字符串转为长整型数字，方便后续对比大小
      iter.map(line => {
        val strings: Array[String] = line.split("\\,")
        val uid: String = strings(0)
        val beginStr: String = strings(1)
        val endStr: String = strings(2)
        val downflowStr: String = strings(3)
        val downflowNum: Double = downflowStr.toDouble

        val beginDate: Date = simpleDateFormat.parse(beginStr)
        val beginTime: Long = beginDate.getTime

        val endDate: Date = simpleDateFormat.parse(endStr)
        val endTime: Long = endDate.getTime

        // 将数据转换为想要的数据
        ((uid, beginTime, endTime), downflowNum)
      })
    }).distinct()
    println("mapedRDD: " + mapedRDD.collect().toBuffer)
    /*
    * mapedRDD: ArrayBuffer(((1,1582006830000,1582008390000),20.0), ((1,1582008440000,1582010430000),
    * 30.0), ((1,1582011443000,1582013126000),40.0), ((1,1582013187000,1582017649000),50.0),
    * ((1,1582017710000,1582020207000),60.0), ((2,1582006704000,1582009300000),20.0),
    * ((2,1582010449000,1582011024000),30.0), ((2,1582012883000,1582015232000),40.0),
    *  ((2,1582015496000,1582018852000),50.0), ((3,1582007998000,1582011353000),20.0),
    * ((3,1582011399000,1582010694000),30.0))
    * */

    // 然后根据uid做转换，然后排序
    val reMapedRDD: RDD[(String, (Long, Long, Double))] = mapedRDD.map(ele => {
      (ele._1._1, (ele._1._2, ele._1._3, ele._2))
    })
    println("reMapedRDD: " + reMapedRDD.collect().toBuffer)
    /*
    * reMapedRDD: ArrayBuffer((1,(1582017710000,1582020207000,60.0)), (2,(1582006704000,1582009300000,20.0)),
    *  (3,(1582011399000,1582010694000,30.0)), (1,(1582006830000,1582008390000,20.0)),
    * (1,(1582008440000,1582010430000,30.0)), (1,(1582011443000,1582013126000,40.0)),
    * (1,(1582013187000,1582017649000,50.0)), (2,(1582010449000,1582011024000,30.0)),
    * (3,(1582007998000,1582011353000,20.0)), (2,(1582015496000,1582018852000,50.0)),
    * (2,(1582012883000,1582015232000,40.0)))
    * */

    // 根据uid分组
    val groupedRDD: RDD[(String, Iterable[(Long, Long, Double)])] = reMapedRDD.groupByKey()
    println("groupedRDD: " + groupedRDD.collect().toBuffer)
    /*
    * groupedRDD: ArrayBuffer((2,CompactBuffer((1582006704000,1582009300000,20.0),
    * (1582010449000,1582011024000,30.0), (1582015496000,1582018852000,50.0),
    * (1582012883000,1582015232000,40.0))), (3,CompactBuffer((1582011399000,1582010694000,30.0),
    * (1582007998000,1582011353000,20.0))), (1,CompactBuffer((1582017710000,1582020207000,60.0),
    *  (1582006830000,1582008390000,20.0), (1582008440000,1582010430000,30.0),
    * (1582011443000,1582013126000,40.0), (1582013187000,1582017649000,50.0))))
    * */

    // 对数据进行排序,按照日期做排序
    val sumedRDD: RDD[(String, (Long, Long, Double, Int))] = groupedRDD.flatMapValues(iter => {

      // 在这里面做数据排序
      val sortedList: List[(Long, Long, Double)] = iter.toList.sortBy(_._1)

      // 在这里给每条数据打标记，判断是否前后间隔小于10min
      var tempEndTime = 0L
      var flag = 0
      var sum = 0

      // (1582006830000,1582008390000,20.0)
      sortedList.map(x => {
        val currentStartTime: Long = x._1
        val currentEndTime = x._2

        // 如果tempEndTime==0.说明是第一条数据，不需要做这个相减操作
        if (tempEndTime != 0) {
          // 如果大于10min，则标记为1
          if ((currentStartTime - tempEndTime) / 60 / 1000 > 10) {
            flag = 1
          } else {
            flag = 0
          }
        }

        // sum就是针对flag标记位0 1做累加的字段
        sum += flag

        tempEndTime = currentEndTime

        // 返回数据
        (currentStartTime, currentEndTime, x._3, sum)
      })
    })
    println("sumedRDD: " + sumedRDD.collect().toBuffer)

    // 对数据做转换，将uid和这个sum标记字段变成key，其他变成value，都是元组形式
    val reMapedSumedRDD: RDD[((String, Int), (Long, Long, Double))] = sumedRDD.map(x => {

      ((x._1, x._2._4), (x._2._1, x._2._2, x._2._3))
    })
    println("reMapedSumedRDD: " + reMapedSumedRDD.collect().toBuffer)
    /*
    * reMapedSumedRDD: ArrayBuffer(((2,0),(1582006704000,1582009300000,20.0)),
    * ((2,1),(1582010449000,1582011024000,30.0)),
    * ((2,2),(1582012883000,1582015232000,40.0)),
    * ((2,2),(1582015496000,1582018852000,50.0)),
    *  ((3,0),(1582007998000,1582011353000,20.0)),
    * ((3,0),(1582011399000,1582010694000,30.0)),
    * ((1,0),(1582006830000,1582008390000,20.0)),
    *  ((1,0),(1582008440000,1582010430000,30.0)),
    * ((1,1),(1582011443000,1582013126000,40.0)),
    * ((1,1),(1582013187000,1582017649000,50.0)),
    * ((1,1),(1582017710000,1582020207000,60.0)))
    * */

    // 使用reduceByKey对数据做聚合,保留最开始一条的开始时间，保留最后一条的结束时间，对流量做汇总
    val reduceResRDD: RDD[((String, Int), (Long, Long, Double))] = reMapedSumedRDD.reduceByKey((tupleThree1, tupleThree2) => {

      (Math.min(tupleThree1._1, tupleThree2._1), Math.max(tupleThree1._2, tupleThree2._2), tupleThree1._3 + tupleThree2._3)
    })
    println("reduceResRDD: " + reduceResRDD.collect().toBuffer)

    // 对日期做格式化, 因为需要对每条数据做处理，所以使用mapPartitions可以复用日期格式化对象·
    val formatedResRDD: RDD[((String, Int), (String, String, Double))] = reduceResRDD.mapPartitions(iter => {

      val format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

      // ((1,1),(1582017710000,1582020207000,60.0)))
      iter.map(ele => {
        val startTime: Long = ele._2._1
        val endTime: Long = ele._2._2

        val startDate = new Date(startTime)
        val endDate = new Date(endTime)

        val startDateStr: String = format.format(startDate)
        val endDateStr: String = format.format(endDate)

        ((ele._1._1, ele._1._2), (startDateStr, endDateStr, ele._2._3))
      })
    })
    println("formatedResRDD: " + formatedResRDD.collect().toBuffer)
    /*
    * formatedResRDD: ArrayBuffer(
    * ((2,1),(2020-02-18 15:20:49,2020-02-18 15:30:24,30.0)),
    *  ((1,0),(2020-02-18 14:20:30,2020-02-18 15:20:30,50.0)),
    * ((3,0),(2020-02-18 14:39:58,2020-02-18 15:35:53,50.0)),
    * ((2,2),(2020-02-18 16:01:23,2020-02-18 17:40:52,90.0)),
    * ((1,1),(2020-02-18 15:37:23,2020-02-18 18:03:27,150.0)),
    * ((2,0),(2020-02-18 14:18:24,2020-02-18 15:01:40,20.0)))
    * */

    /*
      * 1,2020-02-18 14:20:30,2020-02-18 14:46:30,20
      * 1,2020-02-18 14:47:20,2020-02-18 15:20:30,30
      *
      * 1,2020-02-18 15:37:23,2020-02-18 16:05:26,40
      * 1,2020-02-18 16:06:27,2020-02-18 17:20:49,50
      * 1,2020-02-18 17:21:50,2020-02-18 18:03:27,60
      *
      * 2,2020-02-18 14:18:24,2020-02-18 15:01:40,20
      *
      * 2,2020-02-18 15:20:49,2020-02-18 15:30:24,30
      *
      * 2,2020-02-18 16:01:23,2020-02-18 16:40:32,40
      * 2,2020-02-18 16:44:56,2020-02-18 17:40:52,50
      * 
      * 3,2020-02-18 14:39:58,2020-02-18 15:35:53,20
      * 3,2020-02-18 15:36:39,2020-02-18 15:24:54,30
    * */
    // 符合预期，如果需要按照顺序，可以对uid再做一次排序，sortBy即可

    sc.stop()
  }
}

运行结果

formatedResRDD: ArrayBuffer(((2,1),(2020-02-18 15:20:49,2020-02-18 15:30:24,30.0)), ((1,0),(2020-02-18 14:20:30,2020-02-18 15:20:30,50.0)), ((3,0),(2020-02-18 14:39:58,2020-02-18 15:35:53,50.0)), ((2,2),(2020-02-18 16:01:23,2020-02-18 17:40:52,90.0)), ((1,1),(2020-02-18 15:37:23,2020-02-18 18:03:27,150.0)), ((2,0),(2020-02-18 14:18:24,2020-02-18 15:01:40,20.0)))

注意，这里的数据做转换之后，立即做了去重，因为实际生产中，经常会有各种原因导致的重复数据，这里需要根据用户id，开始结束时间为key去重
之后将转换后的数据使用mapPartitions进行分区处理，因为涉及到对象重复使用时，一般都是用这种分区处理，这样一个区只需要创建一个对象，对比map一条创建一个，性能会有提升
注意做转换时，为了方便后续对比，将时间字符串转换位长整型long类型
为了方便对数据做分组，再做一次转换，以uid为key，其他字段为value
然后使用groupByKey对数据做划分
之后使用flatMapValues对数据做转换和展平处理
首先对每个分区中数据转换，toList，并且以开始时间排序，升序。 Int的排序规则定义再Ordering文件中，包括元组等的排序规则也定义在这里，作为隐式参数调用
之后就是将List中数据使用map迭代转换，这里目标是将标记位以及标记位的累加值计算出来，最后以这个标记位累加值作为key，对数据做分组
在之后，对数据做转换，使用reduceByKey对数据做最后计算，得出需要累加的流量，连续数据的开始时间，连续数据的结束时间
最后使用map对数据做格式化转换

实际企业生产中，开发工作第一步是先确认需求，需求确认后，先使用要处理的数据集的小样本，编写样例demo代码尝试，如果可行再工程化编码，遵守公司代码规范，将代码编写，测试，验证，部署到测试环境中

SparkSQL系列-4、数据处理分析
不积跬步无以至千里，不积小流无以成江河
08-15 1499
SparkSQL系列-4、数据处理分析
[Spark版本更新]--2.3.0发行说明
欢迎来到我的博客，一起探索代码里的世界！
03-03 1万+
自从2017年12月1日发布spark-2.2.1以来，已有3个月时间。2018年2月28日，spark官方发布了一个大版本Spark-2.3.0，解决了1399个大大小小的问题。一、DataBricks做了相关说明今天，我们很高兴地宣布Databricks上的Apache Spark 2.3.0作为其Databricks Runtime 4.0的一部分。我们要感谢Apache Spark社区为S...
spark 分层聚合方法rollup()实践应用
Toby的博客
04-19 810
1、rollup()分层聚合方法 -实践1 #in python from pyspark.sql.functions import count,min,max,avg,var_pop,stddev_pop,countDistinct df.rollup("code")\ .agg(countDistinct("user_id").alias("user_cnt"))\ .select("code","user_cnt")\ .orderBy("code")\ .show(200)
spark rdd 做判断_Spark的transformation和action算子介绍
weixin_29470893的博客
01-25 334
Spark支持两种RDD操作：transformation和action。transformation操作会针对已有的RDD创建一个新的RDD；而action则主要是对RDD进行最后的操作，比如遍历、reduce、保存到文件等，并可以返回结果给Driver程序。例如，map就是一种transformation操作，它用于将已有RDD的每个元素传入一个自定义的函数，并获取一个新的元素，然后将所有的新...
spark rollup和cube的区别
清风徐来
01-13 1771
这两个函数在spark中是用来代替spark sql 的GROUPING SETS函数的。 主要的作用都是对多列做groupBy。既然spark中已经有了groupBy函数，这两个函数又是用来干啥的？他们之间有什么区别？ Spark The Defination Guide书中解释是这样的： cube函数: Rather than treating elements hierarchically, a cube does the same thing across all dimensions ro
cassandra-spark-rollup:使用 Apache Spark 进行指标汇总
06-12
卡桑德拉火花汇总 ####指标汇总与 Apache Spark args = String - cassandraHost String - cassandraKeyspace String - cassandraTable Integer - rollup Long - periodStart Long - periodStop String - sparkMaster
Spark DataFrame中rollup和cube使用
k_wzzc的博客
07-28 1037
Spark DataFrame中rollup和cube使用 我们平时在做报表的时候，经常会有各种分维度的汇总计算，在spark中我们最常用的就是groupBy操作，groupBy就是按照给定的字段名分组，后面接sum、count、avg等聚合操作；在spark中也提供了rollup、cube这样的分组函数，接下来本文就以一个实例展示一下这两个函数的作用。 我们先来看个需求：下面的表是某公司最近两年...
案例 计算店铺的月销售额和累加到当前月的销售和--spark程序编写
小丑八怪的博客
01-01 595
/** * 数据： * shop1,2019-01-18,500 * shop1,2019-02-10,500 * shop1,2019-02-10,200 * shop1,2019-02-11,600 * shop1,2019-02-12,400 * shop1,2019-02-13,200 * shop1,2019-02-15,100 * shop2,2019-02-10,100 * shop2,2019-02-11,100 * shop2,2019-02-13,100 * sh
Spark中SQL与DSL编程风格的使用（附花式查询与单词记数案例）
奇迹虎虎的博客
02-23 3209
Spark中SQL与DSL编程风格的使用（附花式查询与单词记数案例），SQL风格先把DataFrame注册成一个临时视图，DSL风格其实就是DataFrame对象调用API的过程。
【读书笔记】spark快速数据分析（持续更新...）
风吹柳花满店香
10-18 667
文章目录spark核心概念RDD编程RDD支持的操作RDD持久化方式RDD的创建RDD伪集合操作向spark传参RDD常见操作RDD持久化PairRDD 转换操作spark常见问题数据倾斜 spark核心概念 drive program 驱动器程序 当我们使用spark shell时，我们已经拥有了一个实际的驱动器即spark shell本身 连接对象 SparkContext 一个spar...
SparkSQL 中group by、grouping sets、rollup和cube方法的详解
xdx_dili的博客
09-27 2210
SparkSQL 中group by、grouping sets、rollup和cube方法的详解
SparkSQL 中group by、grouping sets、rollup和cube方法详解
腾飞的大象
12-04 1万+
      在平时的工作中，经常有按照不同维度筛选和统计数据的需求。拿视频会员订单数据来说吧，运营人员要查看深圳市的成功下单数或则深圳市某一种产品的成功下单数或者某一种产品的所有成功下单数时，每天的订单数又很大，现查的话按照不同的维度去查询又很慢。此时本篇文章或许会帮助到你。 group by:主要用来对查询的结果进行分组，相同组合的分组条件在结果集中只显示一行记录...
group by、grouping sets、rollup和cube方法详解
kw-home
11-18 8555
在平时的工作中，经常有按照不同维度筛选和统计数据的需求。拿视频会员订单数据来说吧，运营人员要查看深圳市的成功下单数或则深圳市某一种产品的成功下单数或者某一种产品的所有成功下单数时，每天的订单数又很大，现查的话按照不同的维度去查询又很慢。此时本篇文章或许会帮助到你。 group by：主要用来对查询的结果进行分组，相同组合的分组条件在结果集中只显示一行记录。可以添加聚合函数。 grouping sets：对分组集中指定的组表达式的每个子集执行group by，group by A,B grouping s
SparkSQL统计——连续3天或以上
JIE的博客 --- moon_coder
12-23 3625
前言：本章用到了开窗函数，不了解的可以去看看。 SQL开窗函数（窗口函数）详解_流水随清风的博客-优快云博客_sql开窗函数 数据源下载： 链接: https://pan.baidu.com/s/1WMz8B-xJZjOoMmlaLurjZg 提取码: eetv 数据源展示： 案例实现要求：统计每月连续3天或以上的用户个数 思路讲解： 1.以当前时间为基准值，获取到前面两天的时间以及后面两天的时间 通过lag和lead获取，注意它们的默认值，以及over中的排序为升.
rollup和cube区别（基于spark sql）以及用dataFrame代码实现
卡奥斯道的博客
01-09 2178
1. rollup前后对比 前： |pcode|event_date|duration|                     +-----+----------+--------+ |    1|2018-09-02|       3|                      |    1|2018-09-03|       2| |    1|2018-09-04|       1| ...
Spark使用总结与分享
weixin_34245169的博客
04-05 266
背景     使用spark开发已有几个月。相比于python/hive，scala/spark学习门槛较高。尤其记得刚开时，举步维艰，进展十分缓慢。不过谢天谢地，这段苦涩（bi）的日子过去了。忆苦思甜，为了避免项目组的其他同学走弯路，决定总结和梳理spark的使用经验。     Spark基础     基石RDD     spark的核心是RDD（弹性分布式数据集），一种...
Spark-SQL之DataFrame操作大全
weixin_30355437的博客
10-12 6013
　　Spark SQL中的DataFrame类似于一张关系型数据表。在关系型数据库中对单表或进行的查询操作，在DataFrame中都可以通过调用其API接口来实现。可以参考，Scala提供的DataFrame API。 　　本文中的代码基于Spark-1.6.2的文档实现。 一、DataFrame对象的生成 　　Spark-SQL可以以其他RDD对象、parquet文...
hive新功能 Cube, Rollup介绍
热门推荐
扫大街的程序员
12-08 2万+
说明：hive之cube、rollup，还有窗口函数，在传统关系型数据（oracle、sqlserver）中都是有的，用法都很相似。 GROUPING SETS GROUPING SETS作为GROUP BY的子句，允许开发人员在GROUP BY语句后面指定多个统计选项，可以简单理解为多条group by语句通过union all把查询结果聚合起来结合起来，下面是几个实例可以帮助我们了
Spark RDD：分布式数据集详解
3. **弹性**：RDD设计时考虑到内存限制，当内存不足时，RDD的分区可以溢写到磁盘，以确保计算的连续性，这种特性使得Spark能在有限的内存资源下处理大规模数据。 4. **基于内存**：Spark尽可能地将数据保留在内存中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值