sparkStreaming

最新推荐文章于 2023-12-29 15:18:20 发布
最新推荐文章于 2023-12-29 15:18:20 发布
阅读量536 收藏 4
点赞数 1
分类专栏： Spark 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34795664/article/details/79946542
版权

1、sparkStreaming

  • 它是一个可扩展，高吞吐具有容错性的流式计算。

2、sparkStreaming特性

  • 1、易用性
    • 可以像编写离线批处理一样去编写流式程序
    • 可以使用java/python/R
  • 2、容错性
    • 保证数据恰好只被处理一次
  • 3、融合spark体系

3、sparkStreaming原理

  • Spark Streaming 是基于spark的流式批处理引擎，其基本原理是把输入数据以某一时间间隔批量的处理，当批处理间隔缩短到秒级时，便可以用于处理实时数据流。

4、Dstream

  • Discretized Stream是Spark Streaming的基础抽象，代表持续性的数据流和经过各种Spark算子操作后的结果数据流.

5、Dstream操作

  • transformation
    • 它是一个转换,与RDD中的transformation算子操作类似，它会生成一个新的Dstream
  • outputOperations
    • 类似于rdd中的action操作，触发任务的运行，得到结果数据。

6、DStream操作实战

需要引入对应的jar包

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_2.11</artifactId>
            <version>2.0.2</version>
        </dependency>
  • 1.SparkStreaming接受socket数据，实现单词计数WordCount
package cn.test.stream

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}

//todo:利用sparkStreaming接受socket数据，实现单词计数
object SparkStreamingSocket {
  def main(args: Array[String]): Unit = {
     //1、创建sparkConf   设置master的地址local[N] ,n必须大于1，其中1个线程负责去接受数据，另一线程负责处理接受到的数据
      val sparkConf: SparkConf = new SparkConf().setAppName("SparkStreamingSocket").setMaster("local[2]")
    // 2、创建sparkContext
      val sc = new SparkContext(sparkConf)
      sc.setLogLevel("WARN")
    //3、创建streamingContext,需要sparkContext和以多久时间间隔为一个批次
     val ssc = new StreamingContext(sc,Seconds(5))
    //4、通过streaming接受socket数据
      val stream: ReceiverInputDStream[String] = ssc.socketTextStream("192.168.200.100",9999)
    //5、切分每一行
      val words: DStream[String] = stream.flatMap(_.split(" "))
    //6、每个单词记为1
      val wordAndOne: DStream[(String, Int)] = words.map((_,1))
    //7、相同单词出现的次数累加
      val result: DStream[(String, Int)] = wordAndOne.reduceByKey(_+_)

    //8、打印
      result.print()

    //9、开启流式计算
      ssc.start()
      //一直会阻塞，等待退出
      ssc.awaitTermination()
  }
}
  • 2.SparkStreaming接受socket数据，实现单词计数累加
package cn.test.stream

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}

//todo:利用sparkStreaming接受socket数据，实现所有批次单词计数结果累加
object SparkStreamingSocketTotal {

  //定义一个方法
  //currentValues:他表示在当前批次每个单词出现的所有的1   (hadoop,1) (hadoop,1)(hadoop,1)
  //historyValues:他表示在之前所有批次中每个单词出现的总次数   (hadoop,100)
  def updateFunc(currentValues:Seq[Int], historyValues:Option[Int]):Option[Int] = {
          val newValue: Int = currentValues.sum+historyValues.getOrElse(0)
          Some(newValue)
  }

  def main(args: Array[String]): Unit = {
      //1、创建sparkConf
      val sparkConf: SparkConf = new SparkConf().setAppName("SparkStreamingSocketTotal").setMaster("local[2]")
      //2、创建sparkContext
      val sc = new SparkContext(sparkConf)
      sc.setLogLevel("WARN")
     //3、创建streamingContext
      val ssc = new StreamingContext(sc,Seconds(5))
     //设置checkpoint目录
      ssc.checkpoint("./ck")
    //4、接受socket数据
      val stream: ReceiverInputDStream[String] = ssc.socketTextStream("192.168.200.100",9999)
    //5、切分每一行
      val words: DStream[String] = stream.flatMap(_.split(" "))
    //6、把每一个单词计为1
      val wordAndOne: DStream[(String, Int)] = words.map((_,1))
    //7、相同单词出现的次数累加
      val result: DStream[(String, Int)] = wordAndOne.updateStateByKey(updateFunc)

    //8、打印结果数据
      result.print()

    //9、开启流式计算
      ssc.start()
      ssc.awaitTermination()
    }
}
  • 3.SparkStreaming开窗函数reduceByKeyAndWindow，实现单词计数
package cn.test.stream

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}

//todo:利用sparkStreaming开窗函数 reducebyKeyAndWindow实现单词计数
object SparkStreamingSocketWindow {

  //定义一个方法
  //currentValues:他表示在当前批次每个单词出现的所有的1   (hadoop,1) (hadoop,1)(hadoop,1)
  //historyValues:他表示在之前所有批次中每个单词出现的总次数   (hadoop,100)
  def updateFunc(currentValues:Seq[Int], historyValues:Option[Int]):Option[Int] = {
    val newValue: Int = currentValues.sum+historyValues.getOrElse(0)
    Some(newValue)
  }

  def main(args: Array[String]): Unit = {
    //1、创建sparkConf
    val sparkConf: SparkConf = new SparkConf().setAppName("SparkStreamingSocketWindow").setMaster("local[2]")
    //2、创建sparkContext
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("WARN")
    //3、创建streamingContext
    val ssc = new StreamingContext(sc,Seconds(5))
    //设置checkpoint目录
    ssc.checkpoint("./ck")
    //4、接受socket数据
    val stream: ReceiverInputDStream[String] = ssc.socketTextStream("192.168.200.100",9999)
    //5、切分每一行
    val words: DStream[String] = stream.flatMap(_.split(" "))
    //6、把每一个单词计为1
    val wordAndOne: DStream[(String, Int)] = words.map((_,1))
    //7、相同单词出现的次数累加
    //reduceByKeyAndWindow该方法需要三个参数
    //reduceFunc：需要一个函数
    //windowDuration:表示窗口的长度
    //slideDuration:表示窗口滑动时间间隔，即每隔多久计算一次
    val result: DStream[(String, Int)] = wordAndOne.reduceByKeyAndWindow((x:Int,y:Int)=>x+y,Seconds(5),Seconds(10))

    //8、打印结果数据
    result.print()

    //9、开启流式计算
    ssc.start()
    ssc.awaitTermination()
  }
}
  • 4.SparkStreaming开窗函数统计一定时间内的热门词汇
    • 统计人单词时调用transform自写函数体
package cn.test.stream
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
//todo:利用sparkStreaming开窗函数统计单位时间内热门词汇----出现频率比较高的词汇
object SparkStreamingSocketWindowHotWords {
  //定义一个方法
  //currentValues:他表示在当前批次每个单词出现的所有的1   (hadoop,1) (hadoop,1)(hadoop,1)
  //historyValues:他表示在之前所有批次中每个单词出现的总次数   (hadoop,100)
  def updateFunc(currentValues:Seq[Int], historyValues:Option[Int]):Option[Int] = {
    val newValue: Int = currentValues.sum+historyValues.getOrElse(0)
    Some(newValue)
  }
  def main(args: Array[String]): Unit = {
    //1、创建sparkConf
    val sparkConf: SparkConf = new SparkConf().setAppName("SparkStreamingSocketWindowHotWords").setMaster("local[2]")
    //2、创建sparkContext
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("WARN")
    //3、创建streamingContext
    val ssc = new StreamingContext(sc,Seconds(5))
    //设置checkpoint目录
    ssc.checkpoint("./ck")
    //4、接受socket数据
    val stream: ReceiverInputDStream[String] = ssc.socketTextStream("192.168.200.100",9999)
    //5、切分每一行
    val words: DStream[String] = stream.flatMap(_.split(" "))
    //6、把每一个单词计为1
    val wordAndOne: DStream[(String, Int)] = words.map((_,1))
    //7、相同单词出现的次数累加
    //reduceByKeyAndWindow该方法需要三个参数
    //reduceFunc：需要一个函数
    //windowDuration:表示窗口的长度
    //slideDuration:表示窗口滑动时间间隔，即每隔多久计算一次
    val result: DStream[(String, Int)] = wordAndOne.reduceByKeyAndWindow((x:Int,y:Int)=>x+y,Seconds(10),Seconds(5))
    //8、按照单词出现的次数降序排列
val sortedDstream: DStream[(String, Int)] = result.transform(rdd => {
  //将rdd中数据按照单词出现的次数降序排列
  val sortedRDD: RDD[(String, Int)] = rdd.sortBy(_._2, false)
  //取出前3位
  val sortHotWords: Array[(String, Int)] = sortedRDD.take(3)
  //打印前3位结果数据
  sortHotWords.foreach(x => println(x))
  sortedRDD
})


//9、打印排序后的结果数据
sortedDstream.print()

//10、开启流式计算
ssc.start()
ssc.awaitTermination()
  }

}

7、SparkStreaming整合Flume

  • Poll方式

      package cn.test.dstream.flume

      import java.net.InetSocketAddress

      import org.apache.spark.{SparkConf, SparkContext}
      import org.apache.spark.storage.StorageLevel
      import org.apache.spark.streaming.{Seconds, StreamingContext}
      import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
      import org.apache.spark.streaming.flume.{FlumeUtils, SparkFlumeEvent}

      //todo:利用sparkStreaming对接flume数据，实现单词计算------Poll拉模式
      object SparkStreamingFlume_Poll {
        def main(args: Array[String]): Unit = {
           //1、创建sparkConf
            val sparkConf: SparkConf = new SparkConf().setAppName("SparkStreamingFlume_Poll").setMaster("local[2]")
          //2、创建sparkContext
            val sc = new SparkContext(sparkConf)
            sc.setLogLevel("WARN")
          //3、创建StreamingContext
            val ssc = new StreamingContext(sc,Seconds(5))
          //定义一个flume地址集合，可以同时接受多个flume的数据
          val address=Seq(new InetSocketAddress("192.168.200.100",9999),new InetSocketAddress("192.168.200.101",9999))

          //4、获取flume中数据
            val stream: ReceiverInputDStream[SparkFlumeEvent] = FlumeUtils.createPollingStream(ssc,address,StorageLevel.MEMORY_AND_DISK_SER_2)
          //5、从Dstream中获取flume中的数据  {"header":xxxxx   "body":xxxxxx}
            val lineDstream: DStream[String] = stream.map(x => new String(x.event.getBody.array()))
          //6、切分每一行,每个单词计为1
            val wordAndOne: DStream[(String, Int)] = lineDstream.flatMap(_.split(" ")).map((_,1))
          //7、相同单词出现的次数累加
            val result: DStream[(String, Int)] = wordAndOne.reduceByKey(_+_)
          //8、打印输出
          result.print()

          //开启计算
            ssc.start()
            ssc.awaitTermination()

        }
      }
  • push方式
package cn.test.dstream.flume

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.flume.{FlumeUtils, SparkFlumeEvent}

//todo:利用sparkStreaming对接flume数据，实现单词计数------Push推模式
object SparkStreamingFlume_Push {

  def main(args: Array[String]): Unit = {
    //1、创建sparkConf
      val sparkConf: SparkConf = new SparkConf().setAppName("SparkStreamingFlume_Push").setMaster("local[2]")
    //2、创建sparkContext
      val sc = new SparkContext(sparkConf)
      sc.setLogLevel("WARN")
    //3、创建StreamingContext
      val ssc = new StreamingContext(sc,Seconds(5))
    //4、获取flume中的数据
    val stream: ReceiverInputDStream[SparkFlumeEvent] = FlumeUtils.createStream(ssc,"192.168.11.123",9999)
    //5、从Dstream中获取flume中的数据  {"header":xxxxx   "body":xxxxxx}
    val lineDstream: DStream[String] = stream.map(x => new String(x.event.getBody.array()))
    //6、切分每一行,每个单词计为1
    val wordAndOne: DStream[(String, Int)] = lineDstream.flatMap(_.split(" ")).map((_,1))
    //7、相同单词出现的次数累加
    val result: DStream[(String, Int)] = wordAndOne.reduceByKey(_+_)
    //8、打印输出
    result.print()

    //开启计算
    ssc.start()
    ssc.awaitTermination()
  }
}

8、Spark Streaming整合kafka实战

  • KafkaUtils.createDstream方式（基于kafka高级Api—–偏移量由zk保存）
package cn.test.kafka

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.kafka.KafkaUtils

import scala.collection.immutable

//todo:sparkStreaming整合kafka---基于receiver（高级api）
object SparkStreamingKafkaReceiver {
  def main(args: Array[String]): Unit = {
      //1、创建sparkConf
      val sparkConf: SparkConf = new SparkConf()
                                  .setAppName("SparkStreamingKafkaReceiver")
                                  .setMaster("local[4]") //线程数要大于receiver个数
                                    .set("spark.streaming.receiver.writeAheadLog.enable","true")
                                      //表示开启WAL预写日志，保证数据源的可靠性
      //2、创建sparkContext
      val sc = new SparkContext(sparkConf)
      sc.setLogLevel("WARN")
      //3、创建streamingContext
      val ssc = new StreamingContext(sc,Seconds(5))
        ssc.checkpoint("./spark_receiver")
      //4、准备zk地址
      val zkQuorum="node1:2181,node2:2181,node3:2181"
      //5、准备groupId
      val groupId="spark_receiver"
      //6、定义topic   当前这个value并不是topic对应的分区数，而是针对于每一个分区使用多少个线程去消费
     val topics=Map("spark_01" ->2)
      //7、KafkaUtils.createStream 去接受kafka中topic数据
      //(String, String) 前面一个string表示topic名称，后面一个string表示topic中的数据
    //使用多个reveiver接受器去接受kafka中topic数据
    val dstreamSeq: immutable.IndexedSeq[ReceiverInputDStream[(String, String)]] = (1 to 3).map(x => {
      val stream: ReceiverInputDStream[(String, String)] = KafkaUtils.createStream(ssc, zkQuorum, groupId, topics)
      stream
      }
    )

    //利用streamingcontext调用union,获取得到所有receiver接受器的数据
    val totalDstream: DStream[(String, String)] = ssc.union(dstreamSeq)

     //8、获取kafka中topic的数据
    val topicData: DStream[String] = totalDstream.map(_._2)
     //9、切分每一行
      val wordAndOne: DStream[(String, Int)] = topicData.flatMap(_.split(" ")).map((_,1))
     //10、相同单词出现的次数累加
      val result: DStream[(String, Int)] = wordAndOne.reduceByKey(_+_)
    //11、打印结果数据
      result.print()


    //12、开启流式计算
      ssc.start()
      ssc.awaitTermination()

  }
}
  • KafkaUtils.createDirectStream方式（基于kafka低级Api—–偏移量由客户端程序保存）
package cn.test.kafka

import kafka.serializer.StringDecoder
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka.KafkaUtils

//todo:sparkSteaming整合kafka----采用direct(低级Api)
object SparkStreamingKafkaDirect {
  def main(args: Array[String]): Unit = {
      //1、创建sparkConf
      val sparkConf: SparkConf = new SparkConf().setAppName("SparkStreamingKafkaDirect").setMaster("local[2]")
      //2、创建sparkContext
      val sc = new SparkContext(sparkConf)
      sc.setLogLevel("WARN")
      //3、创建streamingcontext
      val ssc = new StreamingContext(sc,Seconds(5))
      ssc.checkpoint("./spark_direct") //它会保存topic的偏移量
      //4、准备kafka参数
      val kafkaParams=Map("metadata.broker.list"->"node1:9092,node2:9092,node3:9092","group.id" ->"spark_direct")
      //5、准备topic
      val topics=Set("spark_01")
      //6、获取kafka中的数据
      val dstream: InputDStream[(String, String)] = KafkaUtils.createDirectStream[String,String,StringDecoder,StringDecoder](ssc,kafkaParams,topics)
      //7、获取topic中的数据
        val data: DStream[String] = dstream.map(_._2)
      //8、切分每一行，每个单词计为1，把相同单词出现的次数累加
        val result: DStream[(String, Int)] = data.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)

      //9、打印结果数据
        result.print()

      //10、开启流式计算
        ssc.start()
        ssc.awaitTermination()

  }
}
qq_34795664
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SparkStreaming-概述
weixin_44085996的博客
09-26 2976
一、Spark Streaming概述 1.什么是Spark Streaming SparkStreaming类似于ApacheStorm，用于流式数据的处理。根据官方文档介绍，Spark
Spark Streaming简单入门（示例+原理）
热门推荐
Yage的博客
06-21 3万+
一个简单的示例 以一个简单的例子开始spark streaming的学习之旅！我们会从本机的7777端口源源不断地收到以换行符分隔的文本数据流 // 在本地启动名为SimpleDemo的SparkStreaming应用 // 该应用拥有两个线程，其批处理时间间隔为1s // 创建SparkConf val conf = new SparkConf().setMaster("local[2]").s...
大数据系列之Spark Streaming
牧羊人的方向
05-05 4940
Spark Streaming是构建在Spark上的实时流计算框架，可以进行实时流数据处理。本文简要介绍了Spark Streaming的基本概念和基本算子的使用。
Spark（四）— Spark Streaming
ks_1998的博客
05-01 3323
Spark（四）— Spark Streaming
SparkStream
docsz的博客
04-08 444
SparkStreaming的核心思路： 把无边界的数据流抽象成DStream，在时间方向上，按照某个指定的时间间隔，把DStream切割成一个离散的RDD的序列，然后每一个都交给spark执行引擎进行处理。 SparkStreaming的编程套路： 1、获取编程入口：StreamingContext 2、通过StreamingContext构建第一个DStream 3、对于DStream进行各种...
Spark Streaming 示例
04-03
`SparkStreaming.zip` 文件可能包含了一个示例项目，演示了如何创建一个 Spark Streaming 应用来从 Kafka 消费数据。代码通常会包含以下步骤： 1. 创建 SparkConf 对象，配置 Spark 应用的属性，如应用程序名称、...
spark streaming
03-14
spark streaming streaming
SparkStreaming入门案例
06-22
Spark Streaming 入门案例 Spark Streaming 是一种构建在 Spark 上的实时计算框架，用来处理大规模流式数据。它将从数据源（如 Kafka、Flume、Twitter、ZeroMQ、HDFS 和 TCP 套接字）获得的连续数据流，离散化成一...
SparkStreaming_window_sparksql_reids
最新发布
HYSliuliuliu的博客
12-29 6577
Spark Streaming提供了滑动窗口操作的支持，从而让我们可以对一个滑动窗口内的数据执行计算操作。每次掉落在窗口内的RDD的数据，会被聚合起来执行计算操作，然后生成的RDD，会作为window DStream的一个RDD。比如下图中，就是对每三秒钟的数据执行一次滑动窗口计算，这3秒内的3个RDD会被聚合起来进行处理，然后过了两秒钟，又会对最近三秒内的数据执行滑动窗口计算。所以每个滑动窗口操作，都必须指定两个参数，窗口长度以及滑动间隔，而且这两个参数值都必须是batch间隔的整数倍。
spark的window窗口函数
01-09
spark窗口函数的测试代码和数据 主要包括 countByKeyValueAndWindow reduceByKeyAndWindows
Spark Streaming （一）| Spark，从入门到精通
AI黑板报的专栏
07-29 942
Spark Streaming 是批处理的流式实时计算框架，支持从多种数据源获取数据，如 Kafka、TCP sockets、文件系统等。它可以使用诸如 map、reduce、join 等高级函数进行复杂算法的处理，最后还可以将处理结果存储到文件系统，数据库等。
【Spark】 Spark特点介绍、Spark Streaming和Storm的区别
beautiful_huang的博客
01-02 491
文章目录一、Spark介绍二、Spark特点三、Spark Streaming和Storm 一、Spark介绍 Spark是一个基于内存的开源计算框架 Spark主要应用于大数据的计算,而Hadoop将主要用于大数据的存储（HDFS、HIVE、 Hbase等），Saprk+Hadoop组合，是未来大数据领域最热门的组合. Apache官方给出的定义是：通用的大数据快速处理引擎 Spsrk使用Spa...
Spark Streaming
qw311113qin的博客
05-27 1394
离散流：连续不断流入的数据，按时间处理，比如，连续一分钟内收集的数据作为一个单元，单元之间是相互独立的，就是把连续不断的数据流，切出不同的离散分片。把数据进行离散化处理；DStream是Spark Streaming特有的数据类型，代表一系列连续的RDD，可以看做一组RDDs，即RDD的一个序列，相当于是在RDD的基础上做了对时间的依赖。小方块代表一个数据，虚线与虚线之间代表数据窗口，比如说一分钟，五分钟等，在时间创建内，把小数据积累起来，构成大的批量数据文件，多个小数据块DAG汇聚成的大数据流DAG；
大数据开发：Spark Structured Streaming特性
shuimuzh123的博客
05-07 138
在Spark框架当中，早期的设计由Spark Streaming来负责实现流计算，但是随着现实需求的发展变化，Spark streaming的局限也显露了出来，于是Spark团队又设计了Spark Structured Streaming。今天的大数据开发分享，我们就主要来讲讲，Spark Structured Streaming特性。 Spark Structured Streaming流处理 因为流处理具有如下显著的复杂性特征，所以很难建立非常健壮的处理过程： 一是数据有各种不同格式（Jaso.
Spark Streaming之流式词频统计（Socket数据源）
碣石观海的博客
06-05 1831
一、环境 Spark、Hadoop环境搭建可参看之前文章。 开发环境： 系统：Win10 开发工具：scala-eclipse-IDE 项目管理工具：Maven 3.6.0 JDK 1.8 Scala 2.11.11 Spark 2.4.3 Spark运行环境： 系统：Linux CentOS7（两台机：主从节点） m...
第一章：Spark Streaming 实时计算
08-17
1.Spark Streaming：大数据实时计算介绍2.Spark Streaming：DStream基本工作原理3.Spark Streaming：StreamingContext详解技能点4.Spark Streaming：输入DStream和Receiver详解5.Spark Streaming：DStream的transformation操作概览
Selenium - 多窗口处理与网页frame
kami_ochin_akane的博客
09-12 902
Selenium 多窗口处理流程、切换案例。多 frame 切换，嵌套，未嵌套。
SparkStream详解
korry24的博客
06-22 631
SparkStream1、项目实例，从linux传输数据2、使用sparkStream读取kafka的数据，进行处理，再写回kafka 1、项目实例，从linux传输数据 新建maven项目，并导入依赖 <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-core_2.11</artifactId> <version&g

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值