Flink实操 : 算子操作

最新推荐文章于 2024-07-25 11:50:51 发布
最新推荐文章于 2024-07-25 11:50:51 发布
阅读量1.4k 收藏 10
点赞数 1
分类专栏： Flink Flink实操
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglong_4444/article/details/114288304
版权

.

一 .前言

Transformation说明
map将DataStream中的每一个元素转换为另外一个元素
flatMap将DataStream中的每一个元素转换为0…n个元素
mapPartition将一个分区中的元素转换为另一个元素
filter过滤出来一些符合条件的元素
reduce可以对一个DataStream或者一个group来进行聚合计算，最终聚合成一个元素
reduceGroup将一个DataStream或者一个group聚合成一个或多个元素
aggregate按照内置的方式来进行聚合。例如：SUM/MIN/MAX…
distinct去重
join将两个DataStream按照一定条件连接到一起，形成新的DataStream
union将两个DataStream取并集，并不会去重
rebalance让每个分区的数据均匀分布，避免数据倾斜
partitionByHash按照指定的key进行hash分区
sortPartition指定字段对分区中的数据进行排序
keyBy按照指定的key来进行分流。
connect将两个DataStream组装成一个ConnectedStreams

二 .算子操作

在这里插入图片描述

2.1. map

将DataStream中的每一个元素转换为另外一个元素

示例

使用map操作，将以下数据

"1,张三", "2,李四", "3,王五", "4,赵六"

转换为一个scala的样例类。

步骤

  1. 获取ExecutionEnvironment运行环境
  2. 使用fromCollection构建数据源
  3. 创建一个User样例类
  4. 使用map操作执行转换
  5. 打印测试

参考代码



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


//  使用map操作，将以下数据
//
//  "1,张三", "2,李四", "3,王五", "4,赵六"
//  转换为一个scala的样例类。
//
//  步骤
//    获取ExecutionEnvironment运行环境
//    使用fromCollection构建数据源
//    创建一个User样例类
//    使用map操作执行转换
//    打印测试

object MapOp {

  // User实体类
  case class User( id:String , name :String )

  def main(args : Array[String]) : Unit = {
    // 1. 创建流处理环境
    val env : StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    // 2.用fromCollection创建DataStream(fromCollection)
    val data : DataStream[String]  = env.fromCollection(Array("1,张三", "2,李四", "3,王五", "4,赵六"))

    // 3.处理数据
    data.map( text => {
      val uStr:Array[String] = text.split(",")
      User(uStr(0),uStr(1))
    })

    // 3.打印输出
    data.print()

    // 4.执行任务
    env.execute()


  }

}

2.2. flatMap

将DataStream中的每一个元素转换为0…n个元素

示例

分别将以下数据，转换成国家、省份、城市三个维度的数据。

将以下数据

张三,中国,江西省,南昌市
李四,中国,河北省,石家庄市
Tom,America,NewYork,Manhattan

转换为

(张三,中国)
(张三,中国,江西省)
(张三,中国,江西省,江西省)
(李四,中国)
(李四,中国,河北省)
(李四,中国,河北省,河北省)
(Tom,America)
(Tom,America,NewYork)
(Tom,America,NewYork,NewYork)

思路

  • 以上数据为一条转换为三条，显然，应当使用flatMap来实现

  • 分别在flatMap函数中构建三个数据，并放入到一个列表中

    姓名, 国家
    姓名, 国家省份
    姓名, 国家省份城市

​

步骤

  1. 构建批处理运行环境

  2. 构建本地集合数据源

  3. 使用flatMap将一条数据转换为三条数据

    • 使用逗号分隔字段
    • 分别构建国家、国家省份、国家省份城市三个元组

  4. 打印输出

参考代码

package com.boyi.transform

import org.apache.flink.api.scala.createTypeInformation
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
  //
  //  分别将以下数据，转换成国家、省份、城市三个维度的数据。
  //
  //  将以下数据
  //
  //    张三,中国,江西省,南昌市
  //    李四,中国,河北省,石家庄市
  //    Tom,America,NewYork,Manhattan
  //  转换为
  //
  //    (张三,中国)
  //    (张三,中国,江西省)
  //    (张三,中国,江西省,江西省)
  //    (李四,中国)
  //    (李四,中国,河北省)
  //    (李四,中国,河北省,河北省)
  //    (Tom,America)
  //    (Tom,America,NewYork)
  //    (Tom,America,NewYork,NewYork)

object FlatMapOp {



  def main(args : Array[String]) : Unit = {
    // 1. 创建流处理环境
    val env : StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    // 2.用fromCollection创建DataStream(fromCollection)
    val data : DataStream[String] =  env.fromCollection(List("张三,中国,江西省,南昌市","李四,中国,河北省,石家庄市","Tom,America,NewYork,Manhattan"))
    // 3.处理数据
    val res = data.flatMap(text => {
      val dataStr : Array[String] = text.split(",")

      List(
        dataStr(0)+","+dataStr(1),
        dataStr(0)+","+dataStr(1)+","+dataStr(2),
        dataStr(0)+","+dataStr(1)+","+dataStr(2)+","+dataStr(3),
      )

    })
    // 3.打印输出
    res.print()

    // 4.执行任务
    env.execute()

  }

}

2.3. mapPartition

将一个分区中的元素转换为另一个元素

示例

使用mapPartition操作，将以下数据

"1,张三", "2,李四", "3,王五", "4,赵六"

转换为一个scala的样例类。

步骤

  1. 获取ExecutionEnvironment运行环境
  2. 使用fromCollection构建数据源
  3. 创建一个User样例类
  4. 使用mapPartition操作执行转换
  5. 打印测试

参考代码


import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment, createTypeInformation}

object MapPartitionOp {

  case class User(id:String,name:String)

  def main(args : Array[String]) : Unit ={
    // 1. 创建流处理环境
    val env : ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironment
    // 2.用fromCollection创建DataStream(fromCollection)
    val data: DataSet[String] = env.fromCollection(List("1,张三", "2,李四", "3,王五", "4,赵六"))
    // 3.处理数据
    val res : DataSet[User]  =  data.mapPartition(x=>{
      x.map(x =>{
        val fieldArr = x.split(",")
        User(fieldArr(0),fieldArr(1))
      })
    })
    // 4.打印输出
    res.print()
    
  }

}

map和mapPartition的效果是一样的，但如果在map的函数中，需要访问一些外部存储。例如：

访问mysql数据库，需要打开连接, 此时效率较低。而使用mapPartition可以有效减少连接数，提高效率

2.4. filter

过滤出来一些符合条件的元素

示例：

过滤出来以下以h开头的单词。

"hadoop", "hive", "spark", "flink"

步骤

  1. 获取ExecutionEnvironment运行环境
  2. 使用fromCollection构建数据源
  3. 使用filter操作执行过滤
  4. 打印测试

参考代码


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

object FilterOp {

  def main(args : Array[String]):Unit ={
    // 1. 创建流处理环境
    val env : StreamExecutionEnvironment = StreamExecutionEnvironment.createLocalEnvironment()

    // 2.用fromCollection创建DataStream(fromCollection)
    val data : DataStream[String] = env.fromCollection(List("hadoop", "hive", "spark", "flink"))
    // 3.处理数据
    val res = data.filter(x => {x.startsWith("h")})
    // 4.打印输出
    res.print()

    // 5.执行任务
    env.execute()
  }

}

2.5. reduce/groupBy

可以对一个dataset或者一个group来进行聚合计算，最终聚合成一个元素

示例1

请将以下元组数据，使用reduce操作聚合成一个最终结果

("java" , 1) , ("java", 1) ,("java" , 1)

将上传元素数据转换为("java",3)

步骤

  1. 获取ExecutionEnvironment运行环境
  2. 使用fromCollection构建数据源
  3. 使用redice执行聚合操作
  4. 打印测试

参考代码


import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment, createTypeInformation}

object ReduceOp {

  def main(args : Array[String]):Unit ={
    // 1. 创建流处理环境
    val env : ExecutionEnvironment  = ExecutionEnvironment.getExecutionEnvironment

    // 2.用fromCollection创建DataStream(fromCollection)
    val data : DataSet[(String,Int)]  = env.fromCollection(List(("java" , 1) , ("java", 1) ,("java" , 1) ))
    // 3.处理数据
    val res : DataSet[(String,Int)]  = data.reduce((x1,x2)=>{
     
      (x1._1,x1._2+x2._2)
    })
    // 4.打印输出
    res.print()
  }

}

示例2

请将以下元组数据，下按照单词使用groupBy进行分组，再使用reduce操作聚合成一个最终结果

("java" , 1) , ("java", 1) ,("scala" , 1)

转换为

("java", 2), ("scala", 1)

步骤

  1. 获取ExecutionEnvironment运行环境
  2. 使用fromCollection构建数据源
  3. 使用groupBy按照单词进行分组
  4. 使用reduce对每个分组进行统计
  5. 打印测试

参考代码


import org.apache.flink.api.scala.{ExecutionEnvironment, createTypeInformation}

object GroupByOp {
  def main(args : Array[String]):Unit ={
    // 1. 创建流处理环境
    val env = ExecutionEnvironment.getExecutionEnvironment
    // 2.用fromCollection创建DataStream(fromCollection)
    val data = env.fromCollection(List(("java" , 1) , ("java", 1) ,("scala" , 1)  ))
    // 3. 使用`groupBy`按照单词进行分组
    val groupData = data.groupBy(_._1)
    // 4. 使用`reduce`对每个分组进行统计
    val reduceData = groupData.reduce((x1,x2) =>{
      (x1._1, x1._2+x2._2)
    })
    // 5.执行任务/输出结果
    reduceData.print()
  }

}

2.6. reduceGroup/groupBy

可以对一个DataStream或者一个group来进行聚合计算，最终聚合成一个元素

reduce和reduceGroup的区别

在这里插入图片描述

  • reduce是将数据一个个拉取到另外一个节点，然后再执行计算
  • reduceGroup是先在每个group所在的节点上执行计算，然后再拉取

示例

请将以下元组数据，下按照单词使用groupBy进行分组，再使用reduceGroup操作进行单词计数

("java" , 1) , ("java", 1) ,("scala" , 1)

步骤

  1. 获取ExecutionEnvironment运行环境
  2. 使用fromCollection构建数据源
  3. 使用groupBy按照单词进行分组
  4. 使用reduceGroup对每个分组进行统计
  5. 打印测试

参考代码

  
  
import org.apache.flink.api.scala.{DataSet, ExecutionEnvironment, createTypeInformation}

object ReduceGroupOp {
  def main(args:Array[String]):Unit={

    // 1. 创建流处理环境
    val env : ExecutionEnvironment  = ExecutionEnvironment.getExecutionEnvironment
    // 2.用fromCollection创建DataStream(fromCollection)
    val data = env.fromCollection(List(("java" , 1) , ("java", 1) ,("scala" , 1)))
    // 3.使用`groupBy`按照单词进行分组
    val groupByData= data.groupBy(_._1)

    // 4.使用`reduceGroup`对每个分组进行统计
//    val reduceGroupData =  groupByData.reduceGroup { iter =>{
//      iter.reduce{(wc1, wc2) => (wc1._1,wc1._2 + wc2._2)}
//    } }

    val reduceGroupData =  groupByData.reduceGroup(x=>{
      x.reduce((x1,x2)=>{(x1._1,x1._2+x2._2)})
    })

    // 5.打印输出
    reduceGroupData.print()
    
  }
}

2.7. aggregate

按照内置的方式来进行聚合, Aggregate只能作用于元组上。例如：SUM/MIN/MAX…

示例

请将以下元组数据，使用aggregate操作进行单词统计

("java" , 1) , ("java", 1) ,("scala" , 1)

步骤

  1. 获取ExecutionEnvironment运行环境
  2. 使用fromCollection构建数据源
  3. 使用groupBy按照单词进行分组
  4. 使用aggregate对每个分组进行SUM统计
  5. 打印测试

参考代码


import org.apache.flink.api.java.aggregation.Aggregations
import org.apache.flink.api.scala.{ExecutionEnvironment, createTypeInformation}

object AggregateOp {
  def main(args: Array[String]): Unit = {
    // 1. 创建流处理环境
    val env = ExecutionEnvironment.getExecutionEnvironment
    // 2.用fromCollection创建DataStream(fromCollection)
    val data =  env.fromCollection(List(("java" , 1) , ("java", 1) ,("scala" , 1)))
    // 3. 使用`groupBy`按照单词进行分组
    val groupedDataStream = data.groupBy(0)

    // 4. 使用`aggregate`对每个分组进行`SUM`统计
    val resultDataStream = groupedDataStream.aggregate(Aggregations.SUM, 1)

    // 4.打印输出
    resultDataStream.print()

  }
}

注意

要使用aggregate，只能使用字段索引名或索引名称来进行分组groupBy(0)，否则会报一下错误:

Exception in thread "main" java.lang.UnsupportedOperationException: Aggregate does not support grouping with KeySelector functions, yet.

4.8. distinct

去除重复的数据

示例

请将以下元组数据，使用distinct操作去除重复的单词

("java" , 1) , ("java", 2) ,("scala" , 1)

去重得到

("java", 1), ("scala", 1)

步骤

  1. 获取ExecutionEnvironment运行环境
  2. 使用fromCollection构建数据源
  3. 使用distinct指定按照哪个字段来进行去重
  4. 打印测试

参考代码

// 1. 获取`ExecutionEnvironment`运行环境
val env = ExecutionEnvironment.getExecutionEnvironment

// 2. 使用`fromCollection`构建数据源
val wordcountDataStream = env.fromCollection(
    List(("java" , 1) , ("java", 1) ,("scala" , 1)  )
)

// 3. 使用`distinct`指定按照哪个字段来进行去重
val resultDataStream = wordcountDataStream.distinct(0)

// 4. 打印测试
resultDataStream.print()

2.8. join

使用join可以将两个DataStream连接起来

示例：

在资料\测试数据源中，有两个csv文件，有一个为score.csv，一个为subject.csv，分别保存了成绩数据以及学科数据。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QOLoEB7Z-1614675144146)(assets/1554285790727.png)]

需要将这两个数据连接到一起，然后打印出来。
在这里插入图片描述

步骤

  1. 分别将资料中的两个文件复制到项目中的data/join/input中

  2. 构建批处理环境

  3. 创建两个样例类

    * 学科Subject（学科ID、学科名字）
* 成绩Score（唯一ID、学生姓名、学科ID、分数——Double类型）

  4. 分别使用readCsvFile加载csv数据源，并制定泛型

  5. 使用join连接两个DataStream，并使用where、equalTo方法设置关联条件

  6. 打印关联后的数据源

参考代码

// 学科Subject（学科ID、学科名字）
case class Subject(id:Int, name:String)

// 成绩Score（唯一ID、学生姓名、学科ID、分数）
case class Score(id:Int, name:String, subjectId:Int, score:Double)


def main(args: Array[String]): Unit = {
    // 1. 获取`ExecutionEnvironment`运行环境
    val env = ExecutionEnvironment.getExecutionEnvironment

    // 3. 分别使用`readCsvFile`加载csv数据源
    val scoreDataStream = env.readCsvFile[Score]("./data/join/input/score.csv")
    val subjectDataStream = env.readCsvFile[Subject]("./data/join/input/subject.csv")

    // 4. 使用join连接两个DataStream，并使用`where`、`equalTo`方法设置关联条件
    val joinedDataStream = scoreDataStream.join(subjectDataStream).where(2).equalTo(0)

    // 5. 打印关联后的数据源
    joinedDataStream.print()
}

2.9. union

将两个DataStream取并集，不会去重。

示例

将以下数据进行取并集操作

数据集1

"hadoop", "hive", "flume"

数据集2

"hadoop", "hive", "spark"

步骤

  1. 构建批处理运行环境
  2. 使用fromCollection创建两个数据源
  3. 使用union将两个数据源关联在一起
  4. 打印测试

参考代码

   
import org.apache.flink.api.scala.{ExecutionEnvironment, createTypeInformation}

object UnionOp {
  def main(args: Array[String]): Unit = {
    // 1. 创建流处理环境
    val env = ExecutionEnvironment.getExecutionEnvironment
    // 2.用fromCollection创建DataStream(fromCollection)
    val data1 = env.fromCollection(List("hadoop", "hive", "flume"))

    val data2 = env.fromCollection(List("hadoop", "hive", "spark"))

    // 3.处理数据
    val res = data1.union(data2)
    // 4.打印输出
    res.print()

  }
}

2.10. rebalance

Flink也会产生数据倾斜的时候，例如：当前的数据量有10亿条，在处理过程就有可能发生如下状况：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4SBPJD76-1614675144155)(assets/1554292062536.png)]
rebalance会使用轮询的方式将数据均匀打散，这是处理数据倾斜最好的选择。

在这里插入图片描述

步骤

  1. 构建批处理运行环境

  2. 使用env.generateSequence创建0-100的并行数据

  3. 使用fiter过滤出来大于8的数字

  4. 使用map操作传入RichMapFunction，将当前子任务的ID和数字构建成一个元组

    在RichMapFunction中可以使用`getRuntimeContext.getIndexOfThisSubtask`获取子任务序号

  5. 打印测试

参考代码

    
import org.apache.flink.api.common.functions.RichMapFunction
import org.apache.flink.api.scala.{ExecutionEnvironment, createTypeInformation}


object RebalanceOp {
  def main(args: Array[String]): Unit = {
    // 1. 获取`ExecutionEnvironment`运行环境
    val env = ExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(2)

    // 2. 使用`env.generateSequence`创建0-100的并行数据
    val numDataStream = env.generateSequence(0, 100)

    // 3. 使用`fiter`过滤出来`大于8`的数字
    val filterDataStream = numDataStream.filter(_ > 8)

    // 4. 是否设置rebalance
    // filterDataStream.rebalance()

    // 5. 使用map操作传入`RichMapFunction`，将当前子任务的ID和数字构建成一个元组
    val resultDataStream = filterDataStream.map(new RichMapFunction[Long, (Long, Long)] {
      override def map(in: Long): (Long, Long) = {
        (getRuntimeContext.getIndexOfThisSubtask, in)
      }
    })

    // 6. 打印测试
    resultDataStream.print()
  }
}

上述代码没有加rebalance，通过观察，有可能会出现数据倾斜。

在filter计算完后，调用rebalance，这样，就会均匀地将数据分布到每一个分区中。

2.11. hashPartition

按照指定的key进行hash分区

示例

基于以下列表数据来创建数据源，并按照hashPartition进行分区，然后输出到文件。

List(1,1,1,1,1,1,1,2,2,2,2,2)

步骤

  1. 构建批处理运行环境
  2. 设置并行度为2
  3. 使用fromCollection构建测试数据集
  4. 使用partitionByHash按照字符串的hash进行分区
  5. 调用writeAsText写入文件到data/parition_output目录中
  6. 打印测试

参考代码

    package com.boyi.transform

import org.apache.flink.api.scala.{ExecutionEnvironment, createTypeInformation}

object HashPartitionOp {
  def main(args: Array[String]): Unit = {
    // 1. 创建流处理环境
    val env : ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironment
    // 设置并行度为`2`
    env.setParallelism(2)

    // 2.用fromCollection创建DataStream(fromCollection)
    val data = env.fromCollection(List(1,1,1,1,1,1,1,2,2,2,2,2))
    // 3.处理数据
    val partionData = data.partitionByHash(_.toString)

    // 4. 调用`writeAsText`写入文件到`/opt/a/tmp/testPartion`目录中
    partionData.writeAsText("/opt/a/tmp/testPartion")


    // 5.打印输出
    partionData.print()

  }
}

2.12. sortPartition

指定字段对分区中的数据进行排序

示例

按照以下列表来创建数据集

List("hadoop", "hadoop", "hadoop", "hive", "hive", "spark", "spark", "flink")

对分区进行排序后，输出到文件。

步骤

  1. 构建批处理运行环境
  2. 使用fromCollection构建测试数据集
  3. 设置数据集的并行度为2
  4. 使用sortPartition按照字符串进行降序排序
  5. 调用writeAsText写入文件到data/sort_output目录中
  6. 启动执行

参考代码


import org.apache.flink.api.common.operators.Order
import org.apache.flink.api.scala.{ExecutionEnvironment, createTypeInformation}

object SortPartionOp {



  def main(args : Array[String]) : Unit = {
    // 1. 创建流处理环境
    val env = ExecutionEnvironment.getExecutionEnvironment
    // 2.用fromCollection创建DataStream(fromCollection)
    val data = env.fromCollection(List("hadoop", "hadoop", "hadoop", "hive", "hive", "spark", "spark", "flink"))
    // 3.处理数据
    val res = data.sortPartition(_.toString,Order.DESCENDING)
    // 4.打印输出
    res.print()
  }

}

2.13. keyBy

按照指定的key来进行分流。可以按照索引名/字段名来指定分组的字段.

示例

读取socket数据源, 进行单词的计数

开发步骤

  1. 获取流处理运行环境
  2. 设置并行度
  3. 获取数据源
  4. 转换操作
    1. 以空白进行分割
    2. 给每个单词计数1
    3. 根据单词分组
    4. 求和
  5. 打印到控制台
  6. 执行任务

代码

  • 写法1 :

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

import scala.collection.mutable.ListBuffer

// 读取socket数据源, 进行单词的计数
object KeyBy02Op {


  def main(args: Array[String]): Unit = {
    // 1. 创建流处理环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.createLocalEnvironment(2)
    // 2.用fromCollection创建DataStream(fromCollection)
    val data : DataStream[String] = env.readTextFile("hdfs://h23:8020/tmp/test/score.csv")
    // 3.处理数据
    val res = data.flatMap(x => x.split(",")).map(x=>(x,1)).keyBy(x => {
      x._1
    }).sum(1)

    // 3.打印输出
    res.print()
    // 4.执行任务
    env.execute()
  }

}
  • 写法二:

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

import scala.collection.mutable.ListBuffer

// 读取socket数据源, 进行单词的计数
object KeyBy02Op {


  def main(args: Array[String]): Unit = {
    // 1. 创建流处理环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.createLocalEnvironment(2)
    // 2.用fromCollection创建DataStream(fromCollection)
    val data : DataStream[String] = env.readTextFile("hdfs://h23:8020/tmp/test/score.csv")
    // 3.处理数据
    val res = data.flatMap(x => x.split(",")).map(x=>(x,1)).keyBy(x => {
      x._1
    }).sum(1)

    // 3.打印输出
    res.print()
    // 4.执行任务
    env.execute()
  }

}

2.14. Connect

Connect用来将两个DataStream组装成一个ConnectedStreams。它用了两个泛型，即不要求两个dataStream的element是同一类型。这样我们就可以把不同的数据组装成同一个结构.

示例

读取两个不同类型的数据源，使用connect进行合并打印。

开发步骤

  1. 创建流式处理环境
  2. 添加两个自定义数据源
  3. 使用connect合并两个数据流,创建ConnectedStreams对象
  4. 遍历ConnectedStreams对象,转换为DataStream
  5. 打印输出,设置并行度为1
  6. 执行任务

自定义数据源

/**
  * 创建自定义并行度为1的source 
  * 实现从1开始产生递增数字 
  */
class MyLongSourceScala extends SourceFunction[Long] {
  var count = 1L
  var isRunning = true

  override def run(ctx: SourceContext[Long]) = {
    while (isRunning) {
      ctx.collect(count)
      count += 1
      TimeUnit.SECONDS.sleep(1)
    }
  }

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

/**
  * 创建自定义并行度为1的source
  * 实现从1开始产生递增字符串
  */
class MyStringSourceScala extends SourceFunction[String] {
  var count = 1L
  var isRunning = true

  override def run(ctx: SourceContext[String]) = {
    while (isRunning) {
      ctx.collect("str_" + count)
      count += 1
      TimeUnit.SECONDS.sleep(1)
    }
  }

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

代码


object StreamingDemoConnectScala {
  def main(args: Array[String]): Unit = {
    // 1. 创建流式处理环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    // 2. 添加两个自定义数据源
    val text1: DataStream[Long] = env.addSource(new MyLongSourceScala)
    val text2: DataStream[String] = env.addSource(new MyStringSourceScala)
    // 3. 使用connect合并两个数据流,创建ConnectedStreams对象
    val connectedStreams: ConnectedStreams[Long, String] = text1.connect(text2)
    // 4. 遍历ConnectedStreams对象,转换为DataStream
    val result: DataStream[Any] = connectedStreams.map(line1 => {
      line1
    }, line2 => {
      line2
    })
    // 5. 打印输出,设置并行度为1
    result.print().setParallelism(1)
    // 6. 执行任务
    env.execute("StreamingDemoWithMyNoParallelSourceScala")
  }
}
张伯毅
关注
专栏目录
Flink实例（六十五）: Flink的任务链实操（一）
微信搜：import_bigdata，大数据领域硬核原创作者
01-23 663
声明：本系列博客是根据SGG的视频整理而成，非常适合大家入门学习。 《2021年最新版大数据面试题全面开启更新》 Flink的任务链 Flink 中的每个算子都可以设置并行度，每个算子的一个并行度实例就是一个 subTask。由于 Flink 的 TaskManager 运行 Task 的时候是每个 Task 采用一个单独的线程，这会带来很多线程切换和数据交换的开销，进而影响吞吐量。 为了避免数据在网络或线程之间传输导致的开销，Flink 会在 JobGraph 阶段，将代码中可以优化的算子优化成一个
Flink实例（六十六）: Flink的任务链实操（二）
微信搜：import_bigdata，大数据领域硬核原创作者
01-23 1049
声明：本系列博客是根据SGG的视频整理而成，非常适合大家入门学习。 《2021年最新版大数据面试题全面开启更新》 Operator Chains(操作链) Flink出于分布式执行的目的，将operator的subtask链接在一起形成task（类似spark中的管道）。 每个task在一个线程中执行。 将operators链接成task是非常有效的优化：它可以减少线程与线程间的切换和数据缓冲的开销，并在降低延迟的同时提高整体吞吐量。 链接的行为可以在编程API中进行
Flink--- 批处理 / 流处理
qq_70085330的博客
08-18 3300
flink 流处理 批处理
Flink 批处理
daqu1314的博客
06-11 2061
1.flink source (1)文件数据源 val wordAgg: AggregateDataSet[(String, Int)] = env.readTextFile("./test.txt").flatMap(_.split(" ")).map((_,1)).groupBy(0).sum(1) wordAgg.print() (2)hdfs 数据源 val hdfsDS: DataSet[String] = env.readTextFile("hdfs://node01:8020/t
Flink -2-Flink 算子和java代码简单使用
最新发布
苍煜
07-25 879
文章目录DataSet 批处理算子一、Source算子1. fromCollection2. readTextFile3. readTextFile：读取压缩文件二、Transform转换算子1： map2：flatMap3：Filter 算子4：Reduce 算子5：Aggregations6：Distinct 算子7：First 算子8：Join 算子9：Outer Join 算子10：Cross 算子11：Union 算子三、Sink算子1. collect2. writeAsTextDataStre
Flink批处理
ZHANGHUI3239619的专栏
10-05 226
flink打jar包：
flink实现流处理和批处理
zouyang920的博客
04-23 833
1.流处理系统流处理系统，其节点间数据传输的标准模型是：当一条数据被处理完成后，序列化到缓存中，然后立刻通过网络传输到下一个节点，由下一个节点继续处理。2.批处理系统批处理系统，其节点间数据传输的标准模型是：当一条数据被处理完成后，序列化到缓存中，并不会立刻通过网络传输到下一个节点，当缓存写满，就持久化到本地硬盘上，当所有数据都被处理完成后，才开始将处理后的数据通过网络传输到下一个节点。
Flink_算子操作
weixin_43003792的博客
02-25 136
一：简单转换算子 1.map 类型转换 一对一转换 值转换 2.flatMap ==scala map之后flat _.split(",") 3.Filter() 过滤 二：键控流 1.keyBy 并不对数据具体处理 只是转换 KeyedStream 2.keyBy(“id”) 根据id分组 三：滚动聚合算子 对数据一直做滚动计算 1.sum 2.min min(“temperture”) 取出保留对应字段的最小值 持续更新 *只保留值，并不保留该整个字段。 3.max 4.minBy
从零开始flink-flink基本操作
weixin_43470617的博客
08-05 625
flink基本操作
Flink 内容分享(一)：Fink原理、实战与性能优化(一)_flink原理、实战与性能优化
2401_84167086的博客
04-29 489
Flink程序开发的流程总结如下：1）获得一个执行环境2）加载/创建初始化数据3）指定数据操作的算子4）指定结果数据存放位置5）调用execute()触发执行程序注意：Flink程序是延迟计算的，只有最后调用execute()方法的时候才会真正触发执行程序。
Flink windowAll 函数案例代码实操
qq_31866793的博客
08-28 4658
1，先创建一个生产者 模拟数据 package com.coder.flink.core.a_bilibili; import com.coder.flink.core.streaming2.custormSource.MyNoParalleSource; import org.apache.flink.api.common.serialization.SimpleStringSchema...
flink 批处理学习笔记
qq_34348168的博客
06-09 624
1.创建flink的java项目 mvn archetype:generate \ -DarchetypeGroupId=org.apache.flink \ -DarchetypeArtifactId=flink-quickstart-java \ -DarchetypeVersion=...
Flink--批处理HelloWorld
MINGZHEFENG的博客
11-26 913
批处理WordCount 第一步：创建批处理执行环境 ExecutionEnvironment.getExecutionEnvironment 然后这里需要import: import org.apache.flink.api.scala.ExecutionEnvironment import org.apache.flink.api.java.ExecutionEnvironment 注意：使用scala api又需要引入java东西，所有很多类名称一样，所以引入的时候要注意引入的名称。这里引入scala
Flink 内容分享(十七)：基于Flink的“批处理”尝试
之乎者也·的博客
12-31 1202
Flink可以说是当下最流行的分布式流数据处理引擎。但我最近在尝试基于Flink实现数据的“微批处理”的过程中却屡屡碰壁，结果并不完美，但也对于Flink的keyBy，snapshot等机制有了更进一步的的体会，聊以记录下。需要优化的流处理作业（下称作业）中的消息处理需要满足以下几点：至少一次（at least once）的处理语义；按key保序；秒级时延。第一点基于Flink的checkpoint机制和kafka可设置消费offset的特性即可实现。
Flink学习系列之二 Flink批处理
大佛拈花的博客
10-28 564
需求：统计文件夹下的单词出现的次数 此时我们可以使用Flink的批处理，我的data目录下有a.txt文件，输入任意的单词，然后我们开始统计。代码如下： public class BatchHandler { public static void main(String[] args) throws Exception{ //1 获取流式环境 Exec...
Flink 快速上手（批处理+流处理）
mengxianglong123的博客
03-26 7219
一、环境准备 工欲善其事，必先利其器。在进行代码的编写之前，先将我们使用的开发环境和工具介绍一下： 系统环境为 Windows 10。 需提前安装 Java 8。 集成开发环境（IDE）使用 IntelliJ IDEA，具体的安装流程参见 IntelliJ 官网。 安装 IntelliJ IDEA 之后，还需要安装一些插件——Maven 和Git。Maven 用来管理项目依赖；通过 Git 可以轻松获取我们的示例代码，并进行本地代码的版本控制。 二、创建项目 在准备好所有的开发环境之后，我们就可以开始开
Flink做一个批处理
Betty_May的博客
10-27 852
用Flink做出来的第一个程序 使用Flink做一个简单的Wordcount批处理 flink初学者，第一个Wordcount其实琢磨了很久很久，但是今天终于成功了，写下来供大家参考： 打开IDEA，创建一个maven项目 命名 首先配置以下依赖：pom.xml <dependencies> <dependency> <groupId>org.apache.flink</groupId> &l
Flink 批处理之DataSet（source、sink、Transformation）
qq_37135484的博客
03-31 1821
介绍flink批处理开发流程,以及各类常用source&sink详细
flink 简单的批处理样例
RShbwq的博客
10-22 312
1. 第一个import是引入flink 批处理执行所需要的环境 2. 第二个import是引入flink 的隐式转换，如果没有这个，就会报错 3. flink 批处理是不需要env.execute()，这个要特别注意，不然会报各种奇怪的问题 4. 注意流式引入与批处理引入的包不一样 以下式流式处理的包 import org.apache.flink.streaming.api.scala._ import org.apache.flink.streaming.api.scala.StreamExecu.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值