flink学习（三）

最新推荐文章于 2024-04-15 03:44:35 发布
最新推荐文章于 2024-04-15 03:44:35 发布
阅读量258 收藏
点赞数
分类专栏： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Daivei_lai/article/details/108657735
版权

学习目标

1.入门案例(掌握)
2.DataStream的输入数据集source(掌握)
3.DataStream的Transformation(掌握)
4.DataStream数据输出sink(掌握)

1.入门案例

def main(args: Array[String]): Unit = {
    /**
     * 实现思路：
     * 1. 获取流处理运行环境
     * 2. 构建socket流数据源， 并指定IP地址和端口号
     * 3. 对接收到的数据转换成单词元组
     * 4. 使用keyBy 进行分流（分组）
     * 5. 使用timeWindow 指定窗口的长度（每5秒计算一次）
     * 6. 使用sum执行累加
     * 7. 打印输出
     * 8. 启动执行
     * 9. 在Linux中， 使用nc -lk 端口号监听端口， 并发送单词
     */
    //1.创建流处理的执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.构建数据源 使用的socket
    val socketDataStream: DataStream[String] = env.socketTextStream("node01",9999)
    //3.数据的处理
    import org.apache.flink.api.scala._
    //4.对接收到的数据转换成单词元组,使用keyBy 进行分流（分组）
    val groupKeyedStream: KeyedStream[(String, Int), Tuple] = socketDataStream.flatMap(x=>x.split(",")).map((_,1)).keyBy(0)
    //5.使用timeWindow 指定窗口的长度（每5秒计算一次）
    val windowedStream: WindowedStream[(String, Int), Tuple, TimeWindow] = groupKeyedStream.timeWindow(Time.seconds(5))
    //6.使用sum执行累加
    val resultDataStream: DataStream[(String, Int)] = windowedStream.sum(1)
    //7.打印数据
    resultDataStream.print()
    //8.执行程序
    env.execute("StreamWordCount")
  }

2.DataStream的输入数据集source

分为4类：

基于本地集合的 source（ Collection-based-source）

基于文件的 source（ File-based-source） - 读取文本文件， 即符合 TextInputFormat 规范 的文件， 并将其作为字符串返回

基于网络套接字的 source（ Socket-based-source） - 从 socket 读取。 元素可以用分隔符切分。

自定义的 source（ Custom-source

基于kafka的Source

2.1基于本地集合的 source

CollectionSource
ElementsSource
GenerateSequence

2.2基于文件的source

package com.czxy.flink.stream.source.file

import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}

//基于文件构建数据源
object StreamFromFileSource {
  def main(args: Array[String]): Unit = {

    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.构建数据源
    val fileDataStream: DataStream[String] = env.readTextFile("day03/data/input/wordcount.txt")
    //3.输出打印
    fileDataStream.print()
    //4.执行程序
    env.execute("StreamFromFileSource")

  }
}

2.3基于socket的source

参考入门案例

2.4自定义source

2.4.1SourceFunction： 创建非并行数据源

package com.czxy.flink.stream.source.customer

import org.apache.flink.streaming.api.functions.source.SourceFunction
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}

//自定义非并行数据源
object StreamCustomerNoParallelSource {
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.构建数据源
    import org.apache.flink.api.scala._
    val NoParallelDataStream: DataStream[Long] = env.addSource( new NoParallelSource()).setParallelism(1)
    //3.打印输出
    NoParallelDataStream.print()
    //4.执行程序
    env.execute("StreamCustomerNoParallelSource")
  }
  //实现一个单线程的，数据从1开始递增的数据集
  class NoParallelSource extends  SourceFunction[Long]() {

    var number:Long=1L
    var isRunning:Boolean=true

    override def run(ctx: SourceFunction.SourceContext[Long]): Unit = {
      while (isRunning){
        ctx.collect(number)
        number+=1
        Thread.sleep(1)
        if (number>5){
          cancel()
        }
      }
    }
    override def cancel(): Unit = {
      isRunning=false
    }
  }
}

2.4.2ParallelSourceFunction： 创建并行数据源

package com.czxy.flink.stream.source.customer

import org.apache.flink.streaming.api.functions.source.{ParallelSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}

object StreamCustomerParallelSource {
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.构建数据源
    import org.apache.flink.api.scala._
    val parallelSourceDataStream: DataStream[Long] = env.addSource(new ParallelSource()).setParallelism(2)
    //3.打印输出
    parallelSourceDataStream.print()
    //4.执行 程序
    env.execute("StreamCustomerParallelSource")
  }

  //创建一个并行度为1的数据源
  //实现从1开始产生递增数字
  class ParallelSource extends ParallelSourceFunction[Long]() {
    var number: Long = 1L
    var isRunning: Boolean = true

    override def run(ctx: SourceFunction.SourceContext[Long]): Unit = {
      while (isRunning) {
        ctx.collect(number)
        number += 1
        Thread.sleep(1)
        if (number > 5) {
          cancel()
        }

      }
    }

    override def cancel(): Unit = {
      isRunning = false
    }
  }

}

2.4.3RichParallelSourceFunction： 创建并行数据源

package com.czxy.flink.stream.source.customer

import org.apache.flink.streaming.api.functions.source.{RichParallelSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}

//自定义扩展类的并行数据源
object StreamCustomerRichParallelSource {
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.添加数据源
    import org.apache.flink.api.scala._
    val richParallelSourceDataStream: DataStream[Long] = env.addSource(new RichParallelSource()).setParallelism(2)
    //3.打印输出
    richParallelSourceDataStream.print()
    //4.执行程序
    env.execute("StreamCustomerRichParallelSource")
  }

  //自定义的数据源，实现从1开递增的数据集
  class RichParallelSource extends RichParallelSourceFunction[Long]() {
    var number: Long = 1L
    var isRunning: Boolean = true
    override def run(ctx: SourceFunction.SourceContext[Long]): Unit = {

      while (isRunning) {
        ctx.collect(number)
        number += 1
        Thread.sleep(1)
        if (number > 5) {
          cancel()
        }
      }
    }
    override def cancel(): Unit = {
      isRunning = false
    }
  }

}

2.4.4基于 kafka 的 source

在这里插入代码片package com.czxy.flink.stream.source.customer

import java.util.Properties

import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011
import org.apache.flink.streaming.util.serialization.SimpleStringSchema

object StreamKafkaSource {
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.设置Kafka
    val topic="test"
    val props = new Properties
    props.setProperty("bootstrap.servers", "node01:9092")
    props.setProperty("group.id", "test01")
    props.setProperty("key.deserializer",
      "org.apache.kafka.common.serialization.StringDeserializer")
    props.setProperty("value.deserializer",
      "org.apache.kafka.common.serialization.StringDeserializer")
    val consumer: FlinkKafkaConsumer011[String] = new FlinkKafkaConsumer011[String](topic,new SimpleStringSchema(),props)
    //设置从最新的数据进行消费
    consumer.setStartFromLatest()
    import org.apache.flink.api.scala._
    //2.添加数据
    val kafkaSource: DataStream[String] = env.addSource(consumer)
    //3.打印输出
    kafkaSource.print()
    //4.执行程序
    env.execute("StreamKafkaSource")
  }
}

2.4.5基于 mysql 的 source

package com.czxy.flink.stream.source.customer

import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.source.{RichSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}

//自定义从mysql获取数据源
object StreamFromMysqlSource {

  case class Student(stuId: Int, stuName: String, stuAddr: String, stuSex: String)

  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    import org.apache.flink.api.scala._
    //2.添加数据源
    val mysqlSource: DataStream[Student] = env.addSource(new MysqlSource())
    //3.打印输出
    mysqlSource.print()
    //4.执行程序
    env.execute("StreamFromMysqlSource")
  }

  class MysqlSource extends RichSourceFunction[Student]() {
    //声明一些对象
    var connection: Connection = null
    var ps: PreparedStatement = null

    //这个方法在初始化的时候被执行一次
    override def open(parameters: Configuration): Unit = {
      val driver = "com.mysql.jdbc.Driver"
      val url = "jdbc:mysql://localhost:3306/test"
      val username = "root"
      val password = "root"
      Class.forName(driver)
      connection = DriverManager.getConnection(url, username, password)
      val sql =
        """
          |select id,name,addr,sex
          |from student
          |""".stripMargin
      ps = connection.prepareStatement(sql)
    }

    //每条数据执行一次
    override def run(ctx: SourceFunction.SourceContext[Student]): Unit = {
      val queryResultSet: ResultSet = ps.executeQuery()
      while (queryResultSet.next()) {
        val stuId: Int = queryResultSet.getInt("id")
        val stuName: String = queryResultSet.getString("name")
        val stuAddr: String = queryResultSet.getString("addr")
        val stuSex: String = queryResultSet.getString("sex")
        val student: Student = Student(stuId, stuName, stuAddr, stuSex)
        ctx.collect(student)
      }
    }

    override def cancel(): Unit = {

    }
  }

}

3.DataStream 的 Transformation

3.1 KeyBy
逻辑上将一个流分成不相交的分区， 每个分区包含相同键的元素

package com.czxy.flink.stream.transformation

import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment}

//keyBy分组操作算子
object StreamKeyBy {
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
     val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.构建数据集
    import org.apache.flink.api.scala._
    val elementSource: DataStream[String] = env.fromElements("hadoop hadoop spark hive flink flink")
    //3.数据组合成元祖类型
    val wordAndOne: DataStream[(String, Int)] = elementSource.flatMap(x=>x.split(" ")).map((_,1))
    //4.进行分组
    val KeyedStream: KeyedStream[(String, Int), Tuple] = wordAndOne.keyBy(0)
    //5.聚合计算
    val result: DataStream[(String, Int)] = KeyedStream.reduce((v1,v2)=>(v1._1,v1._2+v2._2))
    //6.打印输出
    result.print().setParallelism(1)
    //7.执行程序
    env.execute("StreamKeyBy")
  }
}

3.2 Connect
用来将两个 dataStream 组装成一个 ConnectedStreams

package com.czxy.flink.stream.transformation

import org.apache.flink.streaming.api.functions.source.SourceFunction
import org.apache.flink.streaming.api.scala.{ConnectedStreams, DataStream, StreamExecutionEnvironment}

object StreamConnect {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    import org.apache.flink.api.scala._
    val source1: DataStream[Long] = env.addSource(new NoParallelSource()).setParallelism(1)
    val source2: DataStream[Long] = env.addSource(new NoParallelSource()).setParallelism(1)
    val connectedStreams: ConnectedStreams[Long, Long] = source1.connect(source2)
    val result: DataStream[String] = connectedStreams.map(item1 => {
      "item1: " + item1
    },
      item2 => {
        "item2: " + item2
      })
    result.print()
    env.execute("StreamConnect")
  }


  //实现一个单线程的，数据从1开始递增的数据集
  class NoParallelSource extends SourceFunction[Long]() {

    var number: Long = 1L
    var isRunning: Boolean = true

    override def run(ctx: SourceFunction.SourceContext[Long]): Unit = {
      while (isRunning) {
        ctx.collect(number)
        number += 1
        Thread.sleep(1)
        if (number > 5) {
          cancel()
        }
      }
    }

    override def cancel(): Unit = {
      isRunning = false
    }
  }

}

3.3 Split 和 select
Split 就是将一个 DataStream 分成两个或者多个 DataStream;Select 就是获取分流后对应的数据

package com.czxy.flink.stream.transformation

import org.apache.flink.streaming.api.scala.{DataStream, SplitStream, StreamExecutionEnvironment}

/**
 * 需求：
 * 给出数据 1, 2, 3, 4, 5, 6, 7
 * 请使用 split 和 select 把数据中的奇偶数分开， 并打印出奇数
 */
object StreamSplit {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    import org.apache.flink.api.scala._
    val source: DataStream[Int] = env.fromElements(1, 2, 3, 4, 5, 6, 7)
    val splitStream: SplitStream[Int] = source.split(x => {
      (x % 2) match {
        case 0 => List("偶数")
        case 1 => List("奇数")
      }
    })
    val result: DataStream[Int] = splitStream.select("奇数")
    result.print()
    env.execute("StreamSplit")
  }
}

4.DataStream数据输出sink(掌握)

4.1 将数据 sink 到本地文件(参考批处理)
4.2 Sink 到本地集合(参考批处理)
4.3 Sink 到 HDFS(参考批处理)
4.4sink 到 kafka

package com.czxy.flink.stream.sink

import java.util.Properties

import org.apache.flink.streaming.api.datastream.DataStreamSink
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer011
import org.apache.flink.streaming.util.serialization.SimpleStringSchema

object StreamKafkaSink {
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.构建数据集
    import org.apache.flink.api.scala._
    val source: DataStream[String] = env.fromElements("1,小丽,北京,女")
    //3.设置kafka的配置信息
    val topic="test"
    val properties: Properties = new Properties()
    properties.setProperty("bootstrap.servers","node01:9092")

    val flinkKafkaProducer: FlinkKafkaProducer011[String] = new FlinkKafkaProducer011[String](topic,new SimpleStringSchema(),properties)

    val result: DataStreamSink[String] = source.addSink(flinkKafkaProducer)

    env.execute("StreamKafkaSink")


  }
}

4.5sink 到 mysql

package com.czxy.flink.stream.sink

import java.sql.{Connection, DriverManager, PreparedStatement}

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.datastream.DataStreamSink
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}

object StreamMysqlSink {

  case class Student(stuId: Int, stuName: String, stuAddr: String, stuSex: String)

  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    import org.apache.flink.api.scala._
    val source: DataStream[Student] = env.fromElements(
      Student(9, "wangman", "beijing", "nv")
    )
    val result: DataStreamSink[Student] = source.addSink(new MysqlSink())
    env.execute("StreamMysqlSink")

  }

  class MysqlSink extends RichSinkFunction[Student]() {
    var connection: Connection = null
    var ps: PreparedStatement = null

    override def open(parameters: Configuration): Unit = {
      val driver = "com.mysql.jdbc.Driver"
      val url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&useSSL=false"
      val username = "root"
      val password = "root"
      Class.forName(driver)
      connection = DriverManager.getConnection(url, username, password)
      val sql =
        """
          |insert into student(id , name , addr , sex)values(?,?,?,?);
          |""".stripMargin
      ps = connection.prepareStatement(sql)
    }

    //每条数据执行一次
    override def invoke(value: Student): Unit = {
      try{
        ps.setInt(1, value.stuId)
        ps.setString(2, value.stuName)
        ps.setString(3, value.stuAddr)
        ps.setString(4, value.stuSex)
        ps.executeUpdate()
      }catch{
        case e:Exception=>println(e.getMessage)
      }

    }

  }

}

呀嘞牙嘞，下回再说

Daivei_lai
关注
专栏目录
Transform 算子（五）
一名全栈小白的博客
06-01 325
Transform 算子
Flink学习
weixin_44468025的博客
02-27 3197
一.定义 Flink是一个分布式计算框架，可以处理海量数据，既可以离线批处理，也可以做实时流处理。主要是用于实时流处理。 flink实时流处理的优势可以归纳为三点： ①低延迟 ②高吞吐 ③支持精确一次 从上图，可以看出flink可以接受多种数据源数据，比如socket，file，Kafka数据源等，然后通过flink处理计算。此外，flink也支持和主流的资源调度框架的整合，比如k8s,yarn,mesos,使得对整个集群的资源调度更为合理。最后flink可以将结果存到其他的应用系统中，比如hbase，m
flink的算子之transform算子
qw3276425405的博客
05-31 999
一.flink算子的执行过程 env -> source -> transform -> sink 3.transform算子 转换算子，把当前的DataStream转化为另一个DataStream 1）简单转换算子（DataStream） 不涉及到分组，不涉及拆分与合并，可以以one-to-one传递数据的流 前提：在虚拟机开启8888端口，在端口发送数据，在控制台进行接收原数据 nc -lk 8888 注意：转换算子需要用到隐式转换 import org.ap.
Flink开发五步之第三步：Transform算子汇总（直接动手操练吧）
渐宽阁读书小弟
03-11 637
目录： map flatmap filter keyby + reduce 滚动聚合算子（rolling Aggregation） sum() min() max() minBy() maxBy() split和select connect和comap union split和select的新写法：使用processFunction 结合 geiSideOutPut 暂时没学会，后期补 map p...
Java版Flink（六）transform算子
qq_41311979的博客
03-14 457
一、map map算子把input类型数据转换为output类型数据 eg：String input = “sensor,123456,33.0” SensorReading(“sensor”,123456L,33.0d) dataStream.map(new Mapfunction<input,output>{xxx}) import com.tan.flink.bean.SensorReading; import org.apache.flink.api.common.functions.M
Flink基础概念及算子_flink 算子(2)，大数据开发程序设计基础教程
最新发布
2401_84164469的博客
04-15 737
当Flink提供的所有分区策略都不能满足用户的需求时，我们可以通过使用partitionCustom()方法来自定义分区策略。
Flink学习指南2022版
03-25
### Flink学习指南2022版：深入了解Flink及其重要性 #### 一、Flink简介 **Flink**，作为Apache基金会旗下的一款开源大数据处理框架，自诞生以来便迅速成为了各大公司实时数据处理领域的首选工具。尤其在国内，以...
flink学习.zip
07-31
《Flink学习资源详解》 Apache Flink是一个用于处理无界和有界数据的开源流处理框架，它在大数据领域有着广泛的应用。本资源包针对Flink的学习提供了全面的指导，旨在帮助初学者和进阶者更好地理解和掌握Flink的...
michael-flink:Flink学习资料：Flink相关演示，源码分析样例和相关文档
03-23
《Flink学习之旅：深入解析与实践》 Apache Flink是一个强大的开源流处理框架，它在实时数据处理领域中占据着重要地位。本资源包"michael-flink"提供了丰富的Flink学习资料，包括Flink的相关演示、源码分析以及样例...
flink-study：Flink学习
02-21
《Flink学习：深入探索Java实现的流处理框架》 Apache Flink是一个开源的流处理框架，它在大数据处理领域有着广泛的应用。Flink的设计目标是支持低延迟、高吞吐量的数据处理，并且能够同时处理实时数据流和批处理...
connect flink_flink的开发中用了哪些算子？
weixin_33155857的博客
12-25 141
Flink中的算子是将一个或多个DataStream转换为新的DataStream，可以将多个转换组合成复杂的数据流拓扑。在Flink中，有多种不同的DataStream类型，他们之间是使用各种算子进行的。如下图所示：flink中常用的算子mapDataStream --> DataStream]：输入一个参数产生一个参数，map的功能是对输入的参数进行转换操作。flatMap[DataSt...
flink的transform方法
xuehuagongzi000的博客
10-31 541
1、简单转化算子(map,flatmap,filter这些)datastream和keyedStream都可以有，但是datastream没有聚合算子，只有keyedStream才有。键值转换后的才有滚动聚合算子sum(),min(),max() ,minBy(),maxBy()，reduce() 2、键值转换后的才有滚动聚合算子sum(),min(),max() ,minBy(),maxBy() min是来一条数据就和历史数据比较，然后输出最小值，格式还是SensorReading类型，如果取min(
Transform算子-使用Java开发
扛着锄头的码农
05-13 303
Transform算子-使用Java开发 Logger.getLogger("org").setLevel(Level.WARN); SparkConf conf = new SparkConf(); conf.setMaster("local[2]").setAppName("WordBlock"); JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(
Flink-Transform(转换)
qq_38304392的博客
06-08 914
书接上回。 3.Transform 转换算子【代码示例统一放在最后边】 3.1 map val streamMap = stream.map { x => x * 2 } 3.2 flatMap flatMap 的函数签名：def flatMap[A,B](as: List[A])(f: A ⇒ List[B]): List[B] 例如: flatMap(List(1,2,3)...
SparkStream之Transformation类算子
lixinkuan的博客
10-13 710
一、概述 SparkStreaming中的算子分为两类，一类是Transformation类算子，一类是OutPutOperator类算子。 Transformation类算子updateStateByKey，reduceByKeyAndWindow，transform OutPutOperator类算子print，foreachRDD，saveAsTextFile 二、transfo...
【flink学习笔记】【5】转换算子Transform
qq_40273172的博客
03-28 2414
transform+物理分区
Flink-入门编程及算子介绍
qq_30868737的博客
01-28 416
编程模型 Flink提供了不同级别的编程抽象，通过调用抽象的数据集调用算子构建DataFlow就可以实现对分布式的数据进行流式计算和离线计算，DataSet是批处理的抽象数据集，DataStream是流式计算的抽象数据集，他们的方法都分别为Source、Transformation、Sink Source主要负责数据的读取 Transformation主要负责对数据的转换操作 Sink负责最终计算好的结果数据输出。 DataStream实时wordcount package com.wedoctor.
Flink--Transform(简单转换算子)
MINGZHEFENG的博客
11-29 1163
简单转换算子 FLink中的简单转换算子 包含 map flatmap fiter 他们有一个共同的特点就是 1 to 1 类似于spark窄依赖 Map 输入一个 按照转换规则 输出一个 //创建执行环境 val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment //读取一个list并转换为datastream val intList = List(1,2
spark--transform算子--distinct
书灯的博客
07-18 470
distinct方法用于对本身的数据集进行去重处理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值