SparkStreaming之窗口函数

最新推荐文章于 2024-03-07 13:54:29 发布
最新推荐文章于 2024-03-07 13:54:29 发布
阅读量1.4w 收藏 24
点赞数 11
分类专栏： SparkStreaming 文章标签： sparkStreaming 源码 spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/legotime/article/details/51836040
版权

WindowOperations（窗口操作）

         Spark还提供了窗口的计算，它允许你使用一个滑动窗口应用在数据变换中。下图说明了该滑动窗口。


如图所示，每个时间窗口在一个个DStream中划过，每个DSteam中的RDD进入Window中进行合并，操作时生成为

窗口化DSteam的RDD。在上图中，该操作被应用在过去的3个时间单位的数据，和划过了2个时间单位。这说明任

何窗口操作都需要指定2个参数。

  1. window length（窗口长度）：窗口的持续时间（上图为3个时间单位）
  2. sliding interval （滑动间隔）- 窗口操作的时间间隔（上图为2个时间单位）。

上面的2个参数的大小，必须是接受产生一个DStream时间的倍数

让我们用一个例子来说明窗口操作。比如说，你想用以前的WordCount的例子，来计算最近30s的数据的中的单词

数，10S接受为一个DStream。为此，我们要用reduceByKey操作来计算最近30s数据中每一个DSteam中关于

（word，1）的pair操作。它可以用reduceByKeyAndWindow操作来实现。一些常见的窗口操作如下。所有这些操作

都需要两个参数--- window length（窗口长度）和sliding interval（滑动间隔）。


-------------------------实验数据----------------------------------------------------------------------

spark
Streaming
better
than
storm
you
need
it
yes
do
it

（每秒在其中随机抽取一个，作为Socket端的输入），socket端的数据模拟和实验函数等程序见附录百度云链接

-----------------------------------------------window操作------------------------------------------------------------------------- 

//输入:窗口长度（隐：输入的滑动窗口长度为形成Dstream的时间）
//输出：返回一个DStream,這个DStream包含這个滑动窗口下的全部元素
def window(windowDuration: Duration): DStream[T] = window(windowDuration, this.slideDuration)

//输入:窗口长度和滑动窗口长度
//输出：返回一个DStream,這个DStream包含這个滑动窗口下的全部元素
def window(windowDuration: Duration, slideDuration: Duration): DStream[T] = ssc.withScope {
  new WindowedDStream(this, windowDuration, slideDuration)
}


import org.apache.log4j.{Level, Logger}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

object  windowOnStreaming {
  def main(args: Array[String]) {
    /**
      * this is test  of Streaming operations-----window
      */
    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
    Logger.getLogger("org.eclipse.jetty.Server").setLevel(Level.OFF)

    val conf = new SparkConf().setAppName("the Window operation of SparK Streaming").setMaster("local[2]")
    val sc = new SparkContext(conf)
    val ssc = new StreamingContext(sc,Seconds(2))


    //set the Checkpoint directory
    ssc.checkpoint("/Res")

    //get the socket Streaming data
    val socketStreaming = ssc.socketTextStream("master",9999)

    val data = socketStreaming.map(x =>(x,1))
    //def window(windowDuration: Duration): DStream[T]
    val getedData1 = data.window(Seconds(6))
    println("windowDuration only : ")
    getedData1.print()
    //same as
    // def window(windowDuration: Duration, slideDuration: Duration): DStream[T]
    //val getedData2 = data.window(Seconds(9),Seconds(3))
    //println("Duration and SlideDuration : ")
    //getedData2.print()

    ssc.start()
    ssc.awaitTermination()
  }

}



--------------------reduceByKeyAndWindow操作--------------------------------

/**通过对每个滑动过来的窗口应用一个reduceByKey的操作，返回一个DSream，有点像
* `DStream.reduceByKey(),但是只是這个函数只是应用在滑动过来的窗口，hash分区是采用spark集群
* 默认的分区树
 * @param reduceFunc 从左到右的reduce 函数
 * @param windowDuration 窗口时间
* 滑动窗口默认是1个batch  interval
* 分区数是是RDD默认（depend on spark集群core）
*/
def reduceByKeyAndWindow(
    reduceFunc: (V, V) => V,
    windowDuration: Duration
  ): DStream[(K, V)] = ssc.withScope {
  reduceByKeyAndWindow(reduceFunc, windowDuration, self.slideDuration, defaultPartitioner())
}

/**通过对每个滑动过来的窗口应用一个reduceByKey的操作，返回一个DSream，有点像
* `DStream.reduceByKey(),但是只是這个函数只是应用在滑动过来的窗口，hash分区是采用spark集群
* 默认的分区树
 * @param reduceFunc 从左到右的reduce 函数
 * @param windowDuration 窗口时间
* @param slideDuration  滑动时间
*/
def reduceByKeyAndWindow(
    reduceFunc: (V, V) => V,
    windowDuration: Duration,
    slideDuration: Duration
  ): DStream[(K, V)] = ssc.withScope {
  reduceByKeyAndWindow(reduceFunc, windowDuration, slideDuration, defaultPartitioner())
}


/**通过对每个滑动过来的窗口应用一个reduceByKey的操作，返回一个DSream，有点像
* `DStream.reduceByKey(),但是只是這个函数只是应用在滑动过来的窗口，hash分区是采用spark集群
* 默认的分区树
 * @param reduceFunc 从左到右的reduce 函数
 * @param windowDuration 窗口时间
* @param slideDuration  滑动时间

 * @param numPartitions  每个RDD的分区数.
 */
def reduceByKeyAndWindow(
    reduceFunc: (V, V) => V,
    windowDuration: Duration,
    slideDuration: Duration,
    numPartitions: Int
  ): DStream[(K, V)] = ssc.withScope {
  reduceByKeyAndWindow(reduceFunc, windowDuration, slideDuration,
    defaultPartitioner(numPartitions))
}

/**
 /**通过对每个滑动过来的窗口应用一个reduceByKey的操作，返回一个DSream，有点像
* `DStream.reduceByKey(),但是只是這个函数只是应用在滑动过来的窗口，hash分区是采用spark集群
* 默认的分区树
 * @param reduceFunc 从左到右的reduce 函数
 * @param windowDuration 窗口时间
* @param slideDuration  滑动时间

 * @param numPartitions  每个RDD的分区数.
 * @param partitioner    设置每个partition的分区数
*/
def reduceByKeyAndWindow(
    reduceFunc: (V, V) => V,
    windowDuration: Duration,
    slideDuration: Duration,
    partitioner: Partitioner
  ): DStream[(K, V)] = ssc.withScope {
  self.reduceByKey(reduceFunc, partitioner)
      .window(windowDuration, slideDuration)
      .reduceByKey(reduceFunc, partitioner)
}

/**
 *通过对每个滑动过来的窗口应用一个reduceByKey的操作.同时对old RDDs进行了invReduceFunc操作
* hash分区是采用spark集群，默认的分区树
 * @param reduceFunc从左到右的reduce 函数
 * @param invReduceFunc inverse reduce function; such that for all y, invertible x:
 *                      `invReduceFunc(reduceFunc(x, y), x) = y`
 * @param windowDuration窗口时间
 * @param slideDuration  滑动时间
 * @param filterFunc     来赛选一定条件的 key-value 对的
 */
def reduceByKeyAndWindow(
    reduceFunc: (V, V) => V,
    invReduceFunc: (V, V) => V,
    windowDuration: Duration,
    slideDuration: Duration = self.slideDuration,
    numPartitions: Int = ssc.sc.defaultParallelism,
    filterFunc: ((K, V)) => Boolean = null
  ): DStream[(K, V)] = ssc.withScope {
  reduceByKeyAndWindow(
    reduceFunc, invReduceFunc, windowDuration,
    slideDuration, defaultPartitioner(numPartitions), filterFunc
  )
}

/**
*通过对每个滑动过来的窗口应用一个reduceByKey的操作.同时对old RDDs进行了invReduceFunc操作
* hash分区是采用spark集群，默认的分区树
 * @param reduceFunc从左到右的reduce 函数
 * @param invReduceFunc inverse reduce function; such that for all y, invertible x:
 *                      `invReduceFunc(reduceFunc(x, y), x) = y`
 * @param windowDuration窗口时间
 * @param slideDuration  滑动时间
 * @param partitioner    每个RDD的分区数.
 * @param filterFunc     来赛选一定条件的 key-value 对的
 */
def reduceByKeyAndWindow(
    reduceFunc: (V, V) => V,
    invReduceFunc: (V, V) => V,
    windowDuration: Duration,
    slideDuration: Duration,
    partitioner: Partitioner,
    filterFunc: ((K, V)) => Boolean
  ): DStream[(K, V)] = ssc.withScope {

  val cleanedReduceFunc = ssc.sc.clean(reduceFunc)
  val cleanedInvReduceFunc = ssc.sc.clean(invReduceFunc)
  val cleanedFilterFunc = if (filterFunc != null) Some(ssc.sc.clean(filterFunc)) else None
  new ReducedWindowedDStream[K, V](
    self, cleanedReduceFunc, cleanedInvReduceFunc, cleanedFilterFunc,
    windowDuration, slideDuration, partitioner
  )
}



import org.apache.log4j.{Level, Logger}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}


object reduceByWindowOnStreaming {

  def main(args: Array[String]) {
    /**
      * this is test  of Streaming operations-----reduceByKeyAndWindow
      */
    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
    Logger.getLogger("org.eclipse.jetty.Server").setLevel(Level.OFF)

    val conf = new SparkConf().setAppName("the reduceByWindow operation of SparK Streaming").setMaster("local[2]")
    val sc = new SparkContext(conf)
    val ssc = new StreamingContext(sc,Seconds(2))

    //set the Checkpoint directory
    ssc.checkpoint("/Res")

    //get the socket Streaming data
    val socketStreaming = ssc.socketTextStream("master",9999)

    val data = socketStreaming.map(x =>(x,1))
    //def reduceByKeyAndWindow(reduceFunc: (V, V) => V, windowDuration: Duration  ): DStream[(K, V)]
    //val getedData1 = data.reduceByKeyAndWindow(_+_,Seconds(6))

    val getedData2 = data.reduceByKeyAndWindow(_+_,
      (a,b) => a+b*0
      ,Seconds(6),Seconds(2))

    val getedData1 = data.reduceByKeyAndWindow(_+_,_-_,Seconds(9),Seconds(6))

    println("reduceByKeyAndWindow : ")
    getedData1.print()

    ssc.start()
    ssc.awaitTermination()


  }
}


這里出现了invReduceFunc函数這个函数有点特别，一不注意就会出错，现在通过分析源码中的

ReducedWindowedDStream這个类内部来进行说明：


------------------reduceByWindow操作---------------------------

/输入：reduceFunc、窗口长度、滑动长度
//输出：（a,b）为从几个从左到右一次取得两个元素
//（，a,b）进入reduceFunc,
def reduceByWindow(
    reduceFunc: (T, T) => T,
    windowDuration: Duration,
    slideDuration: Duration
  ): DStream[T] = ssc.withScope {
  this.reduce(reduceFunc).window(windowDuration, slideDuration).reduce(reduceFunc)
}
/**
*输入reduceFunc，invReduceFunc，窗口长度、滑动长度
 */
def reduceByWindow(
    reduceFunc: (T, T) => T,
    invReduceFunc: (T, T) => T,
    windowDuration: Duration,
    slideDuration: Duration
  ): DStream[T] = ssc.withScope {
    this.map((1, _))
        .reduceByKeyAndWindow(reduceFunc, invReduceFunc, windowDuration, slideDuration, 1)
        .map(_._2)
}



import org.apache.log4j.{Level, Logger}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**
  * Created by root on 6/23/16.
  */
object reduceByWindow {
  def main(args: Array[String]) {
    /**
      * this is test  of Streaming operations-----reduceByWindow
      */
    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
    Logger.getLogger("org.eclipse.jetty.Server").setLevel(Level.OFF)

    val conf = new SparkConf().setAppName("the reduceByWindow operation of SparK Streaming").setMaster("local[2]")
    val sc = new SparkContext(conf)
    val ssc = new StreamingContext(sc,Seconds(2))
    //set the Checkpoint directory
    ssc.checkpoint("/Res")

    //get the socket Streaming data
    val socketStreaming = ssc.socketTextStream("master",9999)

    //val data = socketStreaming.reduceByWindow(_+_,Seconds(6),Seconds(2))
    val data = socketStreaming.reduceByWindow(_+_,_+_,Seconds(6),Seconds(2))


    println("reduceByWindow: count the number of elements")
    data.print()


    ssc.start()
    ssc.awaitTermination()

  }
}




-----------------------------------------------countByWindow操作---------------------------------

/**
* 输入 窗口长度和滑动长度，返回窗口内的元素数量
 * @param windowDuration 窗口长度
* @param slideDuration  滑动长度
*/
def countByWindow(
    windowDuration: Duration,
    slideDuration: Duration): DStream[Long] = ssc.withScope {
  this.map(_ => 1L).reduceByWindow(_ + _, _ - _, windowDuration, slideDuration)
//窗口下的DStream进行map操作，把每个元素变为1之后进行reduceByWindow操作
 }



import org.apache.log4j.{Level, Logger}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**
  * Created by root on 6/23/16.
  */
object countByWindow {
  def main(args: Array[String]) {

    /**
      * this is test  of Streaming operations-----countByWindow
      */
    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
    Logger.getLogger("org.eclipse.jetty.Server").setLevel(Level.OFF)

    val conf = new SparkConf().setAppName("the reduceByWindow operation of SparK Streaming").setMaster("local[2]")
    val sc = new SparkContext(conf)
    val ssc = new StreamingContext(sc,Seconds(2))
    //set the Checkpoint directory
    ssc.checkpoint("/Res")

    //get the socket Streaming data
    val socketStreaming = ssc.socketTextStream("master",9999)

    val data = socketStreaming.countByWindow(Seconds(6),Seconds(2))


    println("countByWindow: count the number of elements")
    data.print()


    ssc.start()
    ssc.awaitTermination()


  }
}

-------------------------------- countByValueAndWindow-------------

/**
*输入 窗口长度、滑动时间、RDD分区数（默认分区是等于并行度）
 * @param windowDuration width of the window; must be a multiple of this DStream's
 *                       batching interval
 * @param slideDuration  sliding interval of the window (i.e., the interval after which
 *                       the new DStream will generate RDDs); must be a multiple of this
 *                       DStream's batching interval
 * @param numPartitions  number of partitions of each RDD in the new DStream.
 */
def countByValueAndWindow(
    windowDuration: Duration,
    slideDuration: Duration,
    numPartitions: Int = ssc.sc.defaultParallelism)
    (implicit ord: Ordering[T] = null)
    : DStream[(T, Long)] = ssc.withScope {
  this.map((_, 1L)).reduceByKeyAndWindow(
    (x: Long, y: Long) => x + y,
    (x: Long, y: Long) => x - y,
    windowDuration,
    slideDuration,
    numPartitions,
    (x: (T, Long)) => x._2 != 0L
  )
}


import org.apache.log4j.{Level, Logger}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**
  * Created by root on 6/23/16.
  */
object countByValueAndWindow {
  def main(args: Array[String]) {
    /**
      * this is test  of Streaming operations-----countByValueAndWindow
      */
    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
    Logger.getLogger("org.eclipse.jetty.Server").setLevel(Level.OFF)

    val conf = new SparkConf().setAppName("the reduceByWindow operation of SparK Streaming").setMaster("local[2]")
    val sc = new SparkContext(conf)
    val ssc = new StreamingContext(sc,Seconds(2))
    //set the Checkpoint directory
    ssc.checkpoint("/Res")

    //get the socket Streaming data
    val socketStreaming = ssc.socketTextStream("master",9999)

    val data = socketStreaming.countByValueAndWindow(Seconds(6),Seconds(2))


    println("countByWindow: count the number of elements")
    data.print()


    ssc.start()
    ssc.awaitTermination()
  }

}





附录

链接：http://pan.baidu.com/s/1slkqwBb 密码：d92r
















legotime
关注
  • 11
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sparkstreaming.zip
11-27
java的sparkstreaming连接kafka的例子，kafka生产者生产消息，消费者读取消息，sparkstreaming读取kafka小区并进行存储iotdb数据库。
SparkStreaming（六）操作函数之Window Operations
myroncham的博客
01-04 898
目录： 5.2、Window Operations 5.2.1、window(windowLength, slideInterval) 5.2.2、countByWindow(windowLength,slideInterval) 5.2.3、reduceByWindow(func, windowLength,      slideInterval) 5.2.4、reduceByKeyA...
Exception in thread “main“ java.lang.Exception: The window duration of windowed DStream (30000 ms) m
最新发布
2301_79197199的博客
03-07 227
java.lang.Exception:窗口DStream的窗口持续时间(30000毫秒)必须是父DStream的slide duration 持续时间(20000毫秒)的倍数。荒找了半天的错，就是没有找到，还好会点英语，细细翻译报错才知道哪里错了。这是配置上下文环境，箭头指向是多少秒读取数据。5是streamingContext的秒数。他们三什么关系呢，我画一个图你们就知道了。第一个参数的秒数是第二个参数秒数的的倍数。window(第一个参数，第二个参数)
大数据开发 | Spark Streaming窗口函数
zjjcchina的博客
06-16 425
在Spark Streaming中，它是一种在实时数据流中进行聚合操作的方法，将一定时间范围内的数据收集在一起，进行处理并输出结果，可以帮助我们对数据流进行更精细的处理和分析。例如，如果将窗口大小设置为10秒，滑动间隔设置为5秒，那么每5秒钟会有一个新的窗口开始，每个窗口包含前10秒钟的数据，而每个窗口之间会有5秒钟的重叠部分。与滑动窗口不同的是，滚动窗口中的窗口之间没有重叠部分，即每个窗口的数据都是不重叠的。需要注意的是，Map窗口函数只能对窗口内的数据进行操作，无法获取窗口的元数据信息。
Spark Streaming 窗口函数window
giantleech的博客
06-23 645
Spark Streaming 窗口函数window Spark Streaming之window滑动窗口应用，Spark Streaming提供了滑动窗口操作的支持，从而让我们可以对一个滑动窗口内的数据执行计算操作。每次掉落在窗口内的RDD的数据，会被聚合起来执行计算操作，然后生成新的RDD，新的RDD组合成一个新的DStream在窗体函数展示 网官图中所示，就是对每三秒钟的数据执行一次滑动窗口计算，这3秒内的3个RDD会被聚合起来进行处理，然后过了两秒钟，又会对最近三秒内的数据执行滑动窗口计算。所以每个
sparkstreaming sparkstreaming窗口函数
a3125504x的博客
09-07 457
sparkstreaming窗口函数windows函数概念sparkstreaming内置窗口函数代码示例官网链接 windows函数概念 与聚合函数每次只返回一个值不同，窗口函数可以每次返回当前数据流的多个值，并在数据流上进行滑动。 如上图所示 上图每次处理3个batch的数据，每个2秒进行一次滑动。因此会有数据的重复处理，如果不想重复处理可以将windows length和sliding internval设置成相等的值 每次窗口滑动时，DStream中落入窗口的RDD就会被合并计算成新的windo
SparkStreaming编程讲解
01-30
1.什么是SparkStreaming？2.SparkStreaming可以接受那些数据源？3.Dstream，我们可以进行哪两种操作？Sparkstreaming:构建在Spark上处理Stream数据的框架，基本的原理是将Stream数据分成小的时间片断（几秒），以...
SparkStreaming之WordCount案例
01-07
使用 netcat 工具向 9999 端口不断的发送数据，通过 SparkStreaming 读取端口数据并统 计不同单词出现的次数 。 二、netcat操作 1、虚拟机中安装netcat [root@hadoop1 spark]# yum install -y nc 2、启动程序并发送...
SparkStreaming实时计算框架介绍
02-25
SparkStreaming是建立在Spark上的实时计算框架，通过它提供的丰富的API、基于内存的高速执行引擎，用户可以结合流式、批处理和交互试查询应用。本文将详细介绍SparkStreaming实时计算框架的原理与特点、适用场景。...
SPARK实现单字段窗口函数
10-28
在SPARK中实现对单字段分区，对单字段排序，进行窗口函数ROWNUMBER以及LIMIT
spark的window窗口函数
01-09
spark窗口函数的测试代码和数据 主要包括 countByKeyValueAndWindow reduceByKeyAndWindows
SparkStreaming入门案例
06-22
本文SparkStream从磁盘文件、HDFS、KAFKA获取数据源，以单词频次统计作为入门案例，介绍了SparkStream模块API的使用。同时介绍了SparkStream的特点
【Spark五十八】Spark Streaming详解（重点窗口计算）
bit1129的博客
02-13 3260
前面有几篇关于Spark Streaming的博客，那会只是作为Spark入门，快速体验Spark之用，只是照着葫芦画瓢。本文结合Spark官网上Spark Streaming的编程指南对Spark Streaming进行介绍 StreamingContext 如同SparkContext一样，StreamingContext也是Spark Streaming应用程序通往Spark集群的通...
Spark Streaming窗口函数
踏雪无痕
06-20 623
一.简介 Spark Streaming还提供了窗口计算，可以在数据的滑动窗口上应用转换。下图说明了此滑动窗口。 如该图所示，每当窗口滑动在源DStream，落入窗口内的源RDDS被组合及操作以产生RDDS的窗口DStream。在这种特定情况下，该操作将应用于数据的最后3个时间单位，并以2个时间单位滑动。这表明任何窗口操作都需要指定两个参数。 窗口长度 - 窗口的持续时间。 滑动间隔 -进行窗口操作的间隔。 这两个参数必须是源DStream的批处理间隔的倍数。 让我们用一个例子来说明窗口操作。每10秒
浅谈Streaming的窗口操作
大数据的成长之路
03-05 349
Streaming的窗口操作 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vvPgeteO-1583414936482)(C:\Users\孙拾柒\AppData\Roaming\Typora\typora-user-images\1583414365744.png)] 任何窗口操作需要两个参数： 窗口长度：上图为3个时间单位 滑动间隔：上图为2个时间单位 窗...
SparkStreaming---窗口函数
shall潇の菜园
06-23 321
文章目录一、窗口函数二、transform 一、窗口函数 package window import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord} import org.apache.spark.SparkConf import org.apache.spark.streaming.dstream.{DStream, InputDStream} import org.apache.spark.streaming.kaf
Spark Streaming2.3.x大数据企业级项目实战
01-15
本课程为项目实战课，项目各个环节既深入讲解理论知识，又结合项目业务进行实操，从而达到一站式掌握大数据离线项目。
spark streaming 窗口函数window
04-08
spark streaming 窗口函数是对数据流实时处理中的数据进行分组操作并对每一组数据进行聚合运算的一种功能。它可以将有限大小的数据块视为一个整体来进行处理，并能够根据应用需求在不同大小的窗口上进行计算。窗口...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值