flinkScala

最新推荐文章于 2024-08-05 11:29:42 发布
最新推荐文章于 2024-08-05 11:29:42 发布
阅读量2.8k 收藏
点赞数
文章标签： apache scala java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43705952/article/details/121801028
版权
本文档展示了如何使用Apache Flink和Scala进行网络流量分析。通过实例代码，实现了Apache日志事件的处理，包括数据转换、时间戳处理、窗口聚合以及自定义的预聚合函数和窗口处理函数，旨在统计URL的访问次数和实现唯一访客计数。
摘要由CSDN通过智能技术生成

package com. gu.networkflow_analysis

import java.sql.Timestamp
import java.text.SimpleDateFormat

import org.apache.flink.api.common.functions.AggregateFunction
import org.apache.flink.api.common.state.{ListState, ListStateDescriptor, MapState, MapStateDescriptor}
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.WindowFunction
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

import scala.collection.mutable.ListBuffer

/**

  • Copyright © 2018-2028 All Rights Reserved
  • Project: UserBehaviorAnalysis
  • Package: com. gu.networkflow_analysis
  • Version: 1.0
  • Created by wushengran on 2019/9/23 9:21
    */

// 输入数据样例类
case class ApacheLogEvent( ip: String, userId: String, eventTime: Long, method: String, url: String)

// 窗口聚合结果样例类
case class UrlViewCount( url: String, windowEnd: Long, count: Long )

object NetworkFlow {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setParallelism(1)
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

// val dataStream = env.readTextFile(“D:\Projects\BigData\UserBehaviorAnalysis\NetworkFlowAnalysis\src\main\resources\apache.log”)
val dataStream = env.socketTextStream(“localhost”, 7777)
.map( data => {
val dataArray = data.split(" ")
// 定义时间转换
val simpleDateFormat = new SimpleDateFormat(“dd/MM/yyyy:HH:mm:ss”)
val timestamp = simpleDateFormat.parse(dataArray(3).trim).getTime
ApacheLogEvent( dataArray(0).trim, dataArray(1).trim, timestamp, dataArray(5).trim, dataArray(6).trim )
} )
.assignTimestampsAndWatermarks( new BoundedOutOfOrdernessTimestampExtractorApacheLogEvent {
override def extractTimestamp(element: ApacheLogEvent): Long = element.eventTime
} )
.keyBy(_.url)
.timeWindow(Time.minutes(10), Time.seconds(5))
.allowedLateness(Time.seconds(60))
.aggregate( new CountAgg(), new WindowResult() )

val processedStream = dataStream
  .keyBy(_.windowEnd)
  .process( new TopNHotUrls(5) )

dataStream.print("aggregate")
processedStream.print("process")

env.execute("network flow job")

}
}

// 自定义预聚合函数
class CountAgg() extends AggregateFunction[ApacheLogEvent, Long, Long]{
override def add(value: ApacheLogEvent, accumulator: Long): Long = accumulator + 1

override def createAccumulator(): Long = 0L

override def getResult(accumulator: Long): Long = accumulator

override def merge(a: Long, b: Long): Long = a + b
}

// 自定义窗口处理函数
class WindowResult() extends WindowFunction[Long, UrlViewCount, String, TimeWindow]{
override def apply(key: String, window: TimeWindow, input: Iterable[Long], out: Collector[UrlViewCount]): Unit = {
out.collect( UrlViewCount( key, window.getEnd, input.iterator.next() ) )
}
}

// 自定义排序输出处理函数
class TopNHotUrls(topSize: Int) extends KeyedProcessFunction[Long, UrlViewCount, String]{
lazy val urlState: MapState[String, Long] = getRuntimeContext.getMapState( new MapStateDescriptor[String, Long](“url-state”, classOf[String], classOf[Long] ) )

override def processElement(value: UrlViewCount, ctx: KeyedProcessFunction[Long, UrlViewCount, String]#Context, out: Collector[String]): Unit = {
urlState.put(value.url, value.count)
ctx.timerService().registerEventTimeTimer(value.windowEnd + 1)
}

override def onTimer(timestamp: Long, ctx: KeyedProcessFunction[Long, UrlViewCount, String]#OnTimerContext, out: Collector[String]): Unit = {
// 从状态中拿到数据
val allUrlViews: ListBuffer[(String, Long)] = new ListBuffer(String, Long)
val iter = urlState.entries().iterator()
while(iter.hasNext){
val entry = iter.next()
allUrlViews += (( entry.getKey, entry.getValue ))
}

// urlState.clear()

val sortedUrlViews = allUrlViews.sortWith(_._2 > _._2).take(topSize)

// 格式化结果输出
val result: StringBuilder = new StringBuilder()
result.append("时间：").append( new Timestamp( timestamp - 1 ) ).append("\n")
for( i <- sortedUrlViews.indices ){
  val currentUrlView = sortedUrlViews(i)
  result.append("NO").append(i + 1).append(":")
    .append(" URL=").append(currentUrlView._1)
    .append(" 访问量=").append(currentUrlView._2).append("\n")
}
result.append("=============================")
Thread.sleep(1000)
out.collect(result.toString())

}
}
package com. gu.networkflow_analysis

import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time

/**

  • Copyright © 2018-2028 All Rights Reserved
  • Project: UserBehaviorAnalysis
  • Package: com. gu.networkflow_analysis
  • Version: 1.0
  • Created by wushengran on 2019/9/23 10:28
    */

// 定义输入数据的样例类
case class UserBehavior( userId: Long, itemId: Long, categoryId: Int, behavior: String, timestamp: Long )

object PageView {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
env.setParallelism(1)

// 用相对路径定义数据源
val resource = getClass.getResource("/UserBehavior.csv")
val dataStream = env.readTextFile(resource.getPath)
  .map( data => {
    val dataArray = data.split(",")
    UserBehavior( dataArray(0).trim.toLong, dataArray(1).trim.toLong, dataArray(2).trim.toInt, dataArray(3).trim, dataArray(4).trim.toLong )
  } )
  .assignAscendingTimestamps(_.timestamp * 1000L)
  .filter( _.behavior == "pv" )    // 只统计pv操作
  .map( data => ("pv", 1) )
  .keyBy(_._1)
  .timeWindow(Time.hours(1))
  .sum(1)

dataStream.print("pv count")

env.execute("page view jpb")

}
}
package com. gu.networkflow_analysis

import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.AllWindowFunction
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

/**

  • Copyright © 2018-2028 All Rights Reserved
  • Project: UserBehaviorAnalysis
  • Package: com. gu.networkflow_analysis
  • Version: 1.0
  • Created by wushengran on 2019/9/23 10:43
    */
    case class UvCount( windowEnd: Long, uvCount: Long )

object UniqueVisitor {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
env.setParallelism(1)

// 用相对路径定义数据源
val resource = getClass.getResource("/UserBehavior.csv")
val dataStream = env.readTextFile(resource.getPath)
  .map( data => {
    val dataArray = data.split(",")
    UserBehavior( dataArray(0).trim.toLong, dataArray(1).trim.toLong, dataArray(2).trim.toInt, dataArray(3).trim, dataArray(4).trim.toLong )
  } )
  .assignAscendingTimestamps(_.timestamp * 1000L)
  .filter( _.behavior == "pv" )    // 只统计pv操作
  .timeWindowAll( Time.hours(1) )
  .apply( new UvCountByWindow() )

dataStream.print()
env.execute("uv job")

}
}

class UvCountByWindow() extends AllWindowFunction[UserBehavior, UvCount, TimeWindow]{
override def apply(window: TimeWindow, input: Iterable[UserBehavior], out: Collector[UvCount]): Unit = {
// 定义一个scala set，用于保存所有的数据userId并去重
var idSet = SetLong
// 把当前窗口所有数据的ID收集到set中，最后输出set的大小
for( userBehavior <- input ){
idSet += userBehavior.userId
}
out.collect( UvCount( window.getEnd, idSet.size ) )
}
}
package com. gu.networkflow_analysis

import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.ProcessWindowFunction
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.triggers.{Trigger, TriggerResult}
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector
import redis.clients.jedis.Jedis

/**

  • Copyright © 2018-2028 All Rights Reserved

  • Project: UserBehaviorAnalysis

  • Package: com. gu.networkflow_analysis

  • Version: 1.0

  • Created by wushengran on 2019/9/23 11:34
    */
    object UvWithBloom {
    def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    env.setParallelism(1)

    // 用相对路径定义数据源
    val resource = getClass.getResource("/UserBehavior.csv")
    val dataStream = env.readTextFile(resource.getPath)
    .map(data => {
    val dataArray = data.split(",")
    UserBehavior(dataArray(0).trim.toLong, dataArray(1).trim.toLong, dataArray(2).trim.toInt, dataArray(3).trim, dataArray(4).trim.toLong)
    })
    .assignAscendingTimestamps(.timestamp * 1000L)
    .filter(    .behavior == “pv”) // 只统计pv操作
    .map(data => (“dummyKey”, data.userId))
    .keyBy(_._1)
    .timeWindow(Time.hours(1))
    .trigger(new MyTrigger())
    .process(new UvCountWithBloom())

    dataStream.print()

    env.execute(“uv with bloom job”)
    }
    }

// 自定义窗口触发器
class MyTrigger() extends Trigger[(String, Long), TimeWindow] {
override def onEventTime(time: Long, window: TimeWindow, ctx: Trigger.TriggerContext): TriggerResult = TriggerResult.CONTINUE

override def onProcessingTime(time: Long, window: TimeWindow, ctx: Trigger.TriggerContext): TriggerResult = TriggerResult.CONTINUE

override def clear(window: TimeWindow, ctx: Trigger.TriggerContext): Unit = {}

override def onElement(element: (String, Long), timestamp: Long, window: TimeWindow, ctx: Trigger.TriggerContext): TriggerResult = {
// 每来一条数据，就直接触发窗口操作，并清空所有窗口状态
TriggerResult.FIRE_AND_PURGE
}
}

// 定义一个布隆过滤器
class Bloom(size: Long) extends Serializable {
// 位图的总大小，默认16M
private val cap = if (size > 0) size else 1 << 27

// 定义hash函数
def hash(value: String, seed: Int): Long = {
var result = 0L
for( i <- 0 until value.length ){
result = result * seed + value.charAt(i)
}
result & ( cap - 1 )
}
}

class UvCountWithBloom() extends ProcessWindowFunction[(String, Long), UvCount, String, TimeWindow]{
// 定义redis连接
lazy val jedis = new Jedis(“localhost”, 6379)
lazy val bloom = new Bloom(1<<29)

override def process(key: String, context: Context, elements: Iterable[(String, Long)], out: Collector[UvCount]): Unit = {
// 位图的存储方式，key是windowEnd，value是bitmap
val storeKey = context.window.getEnd.toString
var count = 0L
// 把每个窗口的uv count值也存入名为count的redis表，存放内容为（windowEnd -> uvCount），所以要先从redis中读取
if( jedis.hget(“count”, storeKey) != null ){
count = jedis.hget(“count”, storeKey).toLong
}
// 用布隆过滤器判断当前用户是否已经存在
val userId = elements.last._2.toString
val offset = bloom.hash(userId, 61)
// 定义一个标识位，判断reids位图中有没有这一位
val isExist = jedis.getbit(storeKey, offset)
if(!isExist){
// 如果不存在，位图对应位置1，count + 1
jedis.setbit(storeKey, offset, true)
jedis.hset(“count”, storeKey, (count + 1).toString)
out.collect( UvCount(storeKey.toLong, count + 1) )
} else {
out.collect( UvCount(storeKey.toLong, count) )
}
}
}

package com. gu.marketanalysis

import java.sql.Timestamp

import org.apache.flink.api.common.functions.AggregateFunction
import org.apache.flink.api.common.state.{ValueState, ValueStateDescriptor}
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.WindowFunction
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

/**

  • Copyright © 2018-2028 All Rights Reserved
  • Project: UserBehaviorAnalysis
  • Package: com. gu.marketanalysis
  • Version: 1.0
  • Created by wushengran on 2019/9/24 10:10
    */
    // 输入的广告点击事件样例类
    case class AdClickEvent( userId: Long, adId: Long, province: String, city: String, timestamp: Long )
    // 按照省份统计的输出结果样例类
    case class CountByProvince( windowEnd: String, province: String, count: Long )
    // 输出的黑名单报警信息
    case class BlackListWarning( userId: Long, adId: Long, msg: String )

object AdStatisticsByGeo {
// 定义侧输出流的tag
val blackListOutputTag: OutputTag[BlackListWarning] = new OutputTagBlackListWarning

def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
env.setParallelism(1)

// 读取数据并转换成AdClickEvent
val resource = getClass.getResource("/AdClickLog.csv")
val adEventStream = env.readTextFile(resource.getPath)
  .map( data => {
    val dataArray = data.split(",")
    AdClickEvent( dataArray(0).trim.toLong, dataArray(1).trim.toLong, dataArray(2).trim, dataArray(3).trim, dataArray(4).trim.toLong )
  } )
  .assignAscendingTimestamps(_.timestamp * 1000L)

// 自定义process function，过滤大量刷点击的行为
val filterBlackListStream = adEventStream
  .keyBy( data => (data.userId, data.adId) )
  .process( new FilterBlackListUser(100) )

// 根据省份做分组，开窗聚合
val adCountStream = filterBlackListStream
  .keyBy(_.province)
  .timeWindow( Time.hours(1), Time.seconds(5) )
  .aggregate( new AdCountAgg(), new AdCountResult() )

adCountStream.print("count")
filterBlackListStream.getSideOutput(blackListOutputTag).print("blacklist")

env.execute("ad statistics job")

}

class FilterBlackListUser(maxCount: Int) extends KeyedProcessFunction[(Long, Long), AdClickEvent, AdClickEvent]{
// 定义状态，保存当前用户对当前广告的点击量
lazy val countState: ValueState[Long] = getRuntimeContext.getState(new ValueStateDescriptor[Long](“count-state”, classOf[Long]))
// 保存是否发送过黑名单的状态
lazy val isSentBlackList: ValueState[Boolean] = getRuntimeContext.getState( new ValueStateDescriptor[Boolean](“issent-state”, classOf[Boolean]) )
// 保存定时器触发的时间戳
lazy val resetTimer: ValueState[Long] = getRuntimeContext.getState( new ValueStateDescriptor[Long](“resettime-state”, classOf[Long]) )

override def processElement(value: AdClickEvent, ctx: KeyedProcessFunction[(Long, Long), AdClickEvent, AdClickEvent]#Context, out: Collector[AdClickEvent]): Unit = {
  // 取出count状态
  val curCount = countState.value()

  // 如果是第一次处理，注册定时器，每天00：00触发
  if( curCount == 0 ){
    val ts = ( ctx.timerService().currentProcessingTime()/(1000*60*60*24) + 1) * (1000*60*60*24)
    resetTimer.update(ts)
    ctx.timerService().registerProcessingTimeTimer(ts)
  }

  // 判断计数是否达到上限，如果到达则加入黑名单
  if( curCount >= maxCount ){
    // 判断是否发送过黑名单，只发送一次
    if( !isSentBlackList.value() ){
      isSentBlackList.update(true)
      // 输出到侧输出流
      ctx.output( blackListOutputTag, BlackListWarning(value.userId, value.adId, "Click over " + maxCount + " times today.") )
    }
    return
  }
  // 计数状态加1，输出数据到主流
  countState.update( curCount + 1 )
  out.collect( value )
}

override def onTimer(timestamp: Long, ctx: KeyedProcessFunction[(Long, Long), AdClickEvent, AdClickEvent]#OnTimerContext, out: Collector[AdClickEvent]): Unit = {
  // 定时器触发时，清空状态
  if( timestamp == resetTimer.value() ){
    isSentBlackList.clear()
    countState.clear()
    resetTimer.clear()
  }
}

}
}

// 自定义预聚合函数

最低0.47元/天 解锁文章
给我一个苹果
关注
搭建Flink的Scala开发环境
tx2976273659的博客
09-09 1589
搭建Flink的Scala开发环境
flink学习（scala版）--第二章：Flink快速上手
simple_code
03-21 1077
flink快速上手
Flink开发：Java vs. Scala - 代码对比分析，选择你的最佳拍档
最新发布
sinner小屋
08-05 1363
本文通过代码对比分析了在Flink开发中选择Java或Scala的优劣。Java因其广泛的使用、成熟的生态系统和强大的IDE支持而受到青睐；而Scala则以其简洁的语法、强大的类型系统和函数式编程特性吸引开发者。文章还探讨了编译执行速度、内存管理、社区支持和第三方库等因素。最终建议，选择语言应基于项目需求、团队技能、长期维护和性能要求。无论选择Java还是Scala，都应考虑具体情境和偏好，以找到最适合的开发“拍档”。
28-ScalaFlink
Eistert
07-06 618
ScalaFlink 介绍 Flink源码主要是Java语言编写的, 开发中首选Java开发Flink 如果考虑到编码效率和简洁性可以考虑使用Scala 注意: Spark源码主要是Scala编写的, 开发中首选Scala开发Spark 如果考虑到编码的规范性,可以考虑使用Java 环境 0.导入依赖 <!--依赖Scala语言--> <dependency> <groupId>org.scala-lang</groupId
Flink(scala版)学习 day01
chenlujun98的博客
12-07 1091
day01课堂笔记 flink简介 flink引入 大数据技术架构发展阶段 总共有四代,mr–>DAG框架(tez) --> Spark流批处理框架,内存计算(伪实时) -->flink流批处理,内存计算(真正的实时计算) flink vs spark 什么是flink flink是一个分布式,高性能,随时可用的准确的流式计算框架,flink可以对无界数据(流处理)和有界数据(批处理)进行有状态计算(flink天生支持状态计算)的分布式,高性能的计算框架. flink流处理特性 fli
flink学习（scala版)--第三章：Flink的部署模式
simple_code
03-24 1221
flink学习（scala版)--第三章：Flink的部署模式
FlinkScala将数据转换为jsonObject
03-28
要将数据转换为 JsonObject，可以使用 Flink 的 GSON 库。以下是一个示例代码： ``` ... val data = Seq( ("user1", "password1", "John", "Doe", 25), ("user2", "password2", "Jane", "Doe", 30), ...
FlinkScala将数据转换为json
03-28
要将数据转换为JSON格式，可以使用Scala中的Jackson库。以下是一个示例代码： ```Scala ... case class Person(name: String, age: Int) val person = Person("John", 30) ...// Create an ObjectMapper and register ...
【职业大赛笔记2】搭建Flink的Scala开发环境
qq_68937561的博客
09-11 614
flink的scala开发环境
Flink-Scala 学习（一）
一名全栈小白的博客
06-01 717
Flink-Scala 学习
flink-code-scala-0421：Flink-scala
02-15
flink-code-scala-0421：Flink-scala
flink-1.9.2-bin-hadoop2.7-scala_2.12最新flink集群分布式版本
04-20
支持hadoop2.7.2 scala 2.12，编译完成的二进制包flink安装包，亲测可用，注意压缩包是250M，这才是正确的。其他100多M都不对。由于超过220M，所以提供百度云盘链接的形式。
【Flink Scala】Flink的简介和项目的搭建
HR的博客
03-23 1539
本文学习于尚硅谷的视频：B站视频 Flink的简介和项目的搭建初识FlinkFlink的重要特点事件驱动型流与批的世界观分层API项目的搭建批处理 初识Flink Flink 起源于 Stratosphere项目，Stratosphere是在 2010~2014 年由 3 所地处柏林的大学和欧洲的一些其他的大学共同进行的研究项目，2014 年 4 月 Stratosphere 的代 码 被 复 制 并 捐 赠 给 了 Apache软 件 基 金 会 ， 参 加 这 个 孵 化 项 目 的 初 始 成 .
【Flink Scala】Flink状态管理
HR的博客
03-31 786
Flink状态管理Flink状态管理Flink中的状态有状态的算子和应用程序算子状态键控状态（keyed state）键控状态的代码实现状态编程实例 Flink状态管理 Flink中的状态 由一个任务维护，并且用来计算某个结果的所有数据，都属于这个任务的状态 可以认为状态就是一个本地变量，可以被任务的业务逻辑访问 Flink会进行状态管理，包括状态一致性、故障处理以及高效存储和访问，以便开发人员可以专注于应用程序的逻辑 再Flink中，状态始终与特定算子相关联 为了使运行时的Flink了解算子的状态，算.
flink学习（scala版)--第三章：Flink的部署模式之（快速启动一个flink集群并且向集群提交任务）
simple_code
03-22 1138
Flink的部署模式之（快速启动一个flink集群并且向集群提交任务）
Flink加载数据源的五种方式(scala版)
weixin_67766119的博客
10-07 1926
Flink加载数据源的五种方式
Flink介绍，窗口和状态的原理及基础使用(scala)
weixin_40366684的博客
05-04 2298
Flink入门介绍Flink学习记录（窗口，状态原理及基础使用）Flink为什么流行1.擅长处理有界和无界数据2.部署到任意地方3.运行任意规模的应用4.利用内存性能Flink怎么运作Flink背后的方法支撑1.灵活的窗口机制2.有状态的计算以出租车数据处理过程为例1.环境准备与起步2.行驶数据清洗（基本算子的使用）4.费用匹配（状态的使用）5.计时器（过期状态的处理） Flink学习记录（窗口，...
Flink获取数据源的四种方式 (scala)
weixin_54635964的博客
01-02 3091
Flink获取数据源 1.Flink从集合中读取数据源 使用fromCollection() 方法将数据放入Seq序列中作为Flink的数据源 object Collections { def main(args: Array[String]): Unit = { //声明 flink 的运行环境 var env = StreamExecutionEnvironment.getExecutionEnvironment var ds = env.fromCollec.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值