flink的流处理的source

flink的流处理的source

输入数据集DataSource
Flink 中你可以使用 StreamExecutionEnvironment.getExecutionEnvironment 创建流处理的执行环境
Flink 中你可以使用 StreamExecutionEnvironment.addSource(source) 来为你的程序添加数据来源。
Flink 已经提供了若干实现好了的 source functions，当然你也可以通过实现 SourceFunction 来自定义非并行的
source或者实现 ParallelSourceFunction 接口或者扩展 RichParallelSourceFunction 来自定义并行的
source。
Flink在流处理上的source和在批处理上的source基本一致。大致有4大类：
基于本地集合的source（Collection-based-source）
基于文件的source（File-based-source）- 读取文本文件，即符合 TextInputFormat 规范的文件，并将其作为字符
串返回
基于网络套接字的source（Socket-based-source）- 从 socket 读取。元素可以用分隔符切分。
自定义的source（Custom-source）

本地集合数据

package com.ccj.pxj.heima.stream.source

import org.apache.flink.streaming.api.scala._

import scala.collection.mutable
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

/**
 *作者：pxj
 *日期：20221-07-28
 */
object StreamingDemoFromCollectionSource {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    val datas: DataStream[String] = env.fromElements("sprk,kafka,hive")
    datas.print()
    println("---------")

    val datas1: DataStream[(String, Int)] = env.fromElements(("spark", 1), ("hive", 1), ("flink", 1))
    datas1.print()
    println("----------")
    val data: DataStream[String] = env.fromCollection(Array("hive", "hadoop"))
    println(data)
    val buffdata: DataStream[String] = env.fromCollection(ArrayBuffer("hive", "hadoop"))
    buffdata.print()
    val listData = env.fromCollection(List("spark", "flink"))
    listData.print()
    //5.用List创建DataStream
    val buffdatalist = env.fromCollection(ListBuffer("spark", "flink"))
    buffdatalist.print()
//    //6.用Vector创建DataStream
val vectorData = env.fromCollection(Vector("spark", "flink"))
    vectorData.print()
    //7.用Queue创建DataStream
    val QUEUE = env.fromCollection(mutable.Queue("spark", "flink"))
    QUEUE.print()
    //8.用Stack创建DataStream
    val ds8: DataStream[String] = env.fromCollection(mutable.Stack("spark", "flink"))
    ds8.print()
    //9.用Stream创建DataStream（Stream相当于lazy List，避免在中间过程中生成不必要的集合）
    val ds9: DataStream[String] = env.fromCollection(Stream("spark", "flink"))
    ds9.print()
    //10.用Seq创建DataStream
    val ds10: DataStream[String] = env.fromCollection(Seq("spark", "flink"))
    ds10.print()
    //11.用Set创建DataStream(不支持)
    //val ds11: DataStream[String] = senv.fromCollection(Set("spark", "flink"))
    //ds11.print()
    //12.用Iterable创建DataStream(不支持)
    //val ds12: DataStream[String] = senv.fromCollection(Iterable("spark", "flink"))
    //ds12.print()
    //13.用ArraySeq创建DataStream
    val ds13: DataStream[String] = env.fromCollection(mutable.ArraySeq("spark", "flink"))
    ds13.print()
    //14.用ArrayStack创建DataStream
    val ds14: DataStream[String] = env.fromCollection(mutable.ArrayStack("spark", "flink"))
    ds14.print()
    //15.用Map创建DataStream(不支持)
    //val ds15: DataStream[(Int, String)] = senv.fromCollection(Map(1 -> "spark", 2 -> "flink"))
    //ds15.print()
    //16.用Range创建DataStream
    val ds16: DataStream[Int] = env.fromCollection(Range(1, 9))
    ds16.print()
    //17.用fromElements创建DataStream
    val ds17: DataStream[Long] = env.generateSequence(1, 9)
    ds17.print()
    env.execute(this.getClass.getName)


  }

}

基于文件的source

Flink的流处理可以直接通过 readTextFile()
方法读取文件来创建数据源,方法如下:

package com.ccj.pxj.heima.stream.source
import org.apache.flink.streaming.api.scala._
object DataSourceFlie {
  def main(args: Array[String]): Unit = {
    val senv: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val datsst: DataStream[String] = senv.readTextFile("hdfs://192.168.25.60:9000//wc/output")
    datsst.print()
    senv.execute("pxj")
  }
}

基于网络套接字的source

上面两种方式创建的数据源一般都是固定的.如果需要源源不断的产生数据,可以使用socket的方式来获取数据,通过调
用 socketTextStream() 方法
示例
编写Flink程序，接收 socket 的单词数据，并以空格进行单词拆分打印。
步骤
1.获取流处理运行环境
2.构建socket流数据源，并指定IP地址和端口号
3.对接收到的数据进行空格拆分
4.打印输出
5.启动执行
6.在Linux中，使用 nc -lk 端口号 监听端口，并发送单词

package com.ccj.pxj.heima.stream.source
import org.apache.flink.streaming.api.scala._
object SocketSource {
  def main(args: Array[String]): Unit = {
    val senv: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val dats: DataStream[String] = senv.socketTextStream("192.168.25.60", 12345)
    dats.map(_.split(" ")).print()
    senv.execute("pxj")
  }
}

自定义source

我们也可以通过去实现 SourceFunction或者它的子类 RichSourceFunction 类来自定义实现一些自定义的source，Kafka创建source数据源类FlinkKafkaConsumer010 也是采用类似的方式。
自定义数据源
示例:
自定义数据源, 每1秒钟随机生成一条订单信息(
订单ID、用户ID 、 订单金额 、 时间戳 )
要求:
随机生成订单ID（UUID）
随机生成用户ID（0-2）
随机生成订单金额（0-100）
时间戳为当前系统时间
开发步骤:
1.创建订单样例类
2.获取流处理环境
3.创建自定义数据源循环1000次随机构建订单信息上下文收集数据每隔一秒执行一次循环
4.打印数据
5.执行任务

package com.ccj.pxj.heima.stream.source
import java.util.UUID
import java.util.concurrent.TimeUnit
import org.apache.flink.streaming.api.functions.source.{RichSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._
import scala.util.Random
object StreamFlinkSqlDemo {
  def main(args: Array[String]): Unit = {
    // 1. 获取流处理运行环境
    val senv: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    // 2. 创建一个自定义数据源
    val orderRuslt: DataStream[Order] = senv.addSource(new RichSourceFunction[Order] {
      override def run(ctx: SourceFunction.SourceContext[Order]): Unit = {
        for (i <- 0 until (1000)) {
          //随机生成订单ID（UUID）
          val id: String = UUID.randomUUID().toString
          //随机生成用户ID（0-2）
          val userId = Random.nextInt(3)
          //随机生成订单金额（0-100）
          val money = Random.nextInt(101)
          //时间戳为当前系统时间
          val timestamp: Long = System.currentTimeMillis()
          //收集数据
          ctx.collect(Order(id, userId, money, timestamp))
          //          每隔1秒生成一个订单
          TimeUnit.SECONDS.sleep(1)
        }
      }
      override def cancel(): Unit = ???
    })
     orderRuslt.print()
    senv.execute("pxj")
    
  }
}
case class Order(id: String, userId: Int, money: Long, createTime: Long)

使用MySQL作为数据源

上面我们已经使用了自定义数据源和Flink自带的Kafka source，那么接下来就模仿着写一个从 MySQL 中读取数据的
Source。

相关依赖
<!-- 指定mysql-connector的依赖 -->
<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.38</version>
</dependency>

开发步骤
1.自定义Source,继承自RichSourceFunction
2.实现run方法
1.加载驱动
2.创建连接
3.创建PreparedStatement
4.执行查询
5.遍历查询结果,收集数据
3.使用自定义Source
4.打印结果
5.执行任务

package com.ccj.pxj.heima.stream.source
import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}
import org.apache.flink.streaming.api.functions.source.{RichSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._
object DataSource_mysql {
  def main(args: Array[String]): Unit = {
    val senv: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
//    设置并行度
    senv.setParallelism(1)
    //    添加自定义MySQL数据源
    val datas: DataStream[User] = senv.addSource(new MySqlSource)
    datas.print()
    senv.execute("pxj")
  }
}
class MySqlSource extends RichSourceFunction[User]{
  override def run(ctx: SourceFunction.SourceContext[User]): Unit = {
//    加载MySQL驱动
    Class.forName("com.mysql.jdbc.Driver")
    // 2. 链接MySql
    val connection: Connection = DriverManager.getConnection("jdbc:mysql:///flink", "root", "1314520")
//    创建PreparedStatement
     var sql="select * from user"
    val ps: PreparedStatement = connection.prepareStatement(sql)
    //    执行SQL查询
    val queryRequest: ResultSet = ps.executeQuery()
//    遍历结果
    while (queryRequest.next()){
      val id: Int = queryRequest.getObject("id").toString.toInt
      val username: String = queryRequest.getObject("username").toString
      val password: String = queryRequest.getString("password")
      val name: String = queryRequest.getString("name")
      //收集数据
      ctx.collect(User(id,username,password,name))
    }
  }
  override def cancel(): Unit = ???
}
case class User(id:Int,username:String,password:String,name:String)
User(1,zhangsan,11111,张三)
User(2,lis,222,李四)

作者：pxj
日期：2021-07-29 23:21:59
你若安好便是晴天