flink常用算子以及window

Flink 窗口种类以及常用算子

flink有以下几类窗口：

Tumbling Windows

滚动窗口长度固定，滑动间隔等于窗口长度，窗口元素之间没有交叠。

// tumbling event-time windows
input
    .keyBy(<key selector>)
    .window(TumblingEventTimeWindows.of(Time.seconds(5)))
    .<windowed transformation>(<window function>)

Sliding Windows

滑动窗口长度固定，窗口长度大于窗口滑动间隔，元素存在交叠。

// sliding event-time windows
input
    .keyBy(<key selector>)
    .window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))
    .<windowed transformation>(<window function>)

Global Windows

全局窗口会将所有key相同的元素放到一个窗口中，默认该窗口永远都不会关闭（永远都不会触发），因为该窗口没有默认的窗口触发器Trigger，因此需要用户自定义Trigger。

input
    .keyBy(<key selector>)
    .window(GlobalWindows.create())
    .<windowed transformation>(<window function>)

Session Windows（MergerWindow）

通过计算元素时间间隔，如果间隔小于session gap，则会合并到一个窗口中；如果大于时间间隔，当前窗口关闭，后续的元素属于新的窗口。与滚动窗口和滑动窗口不同的是会话窗口没有固定的窗口大小，底层本质上做的是窗口合并。

// event-time session windows with static gap
input
    .keyBy(<key selector>)
    .window(EventTimeSessionWindows.withGap(Time.minutes(10)))
    .<windowed transformation>(<window function>)

Event Time

Flink在做窗口计算的时候支持以下语义的window：Processing time、Event time、Ingestion time

Processing time:使用处理节点时间，计算窗口，默认

Event time：使用事件产生时间，计算窗口- 精确

Ingestion time：数据进入到Flink的时间，一般是通过SourceFunction指定时间

常用算子

map

map可以理解为映射，对每个元素进行一定的变换后，映射为另一个元素

object MapOperator {
  def main(args: Array[String]): Unit = {
    //获取环境变量
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //准备数据,类型DataStreamSource
    val dataStreamSource = env.fromElements(Tuple1.apply("flink")
                                            ,Tuple1.apply("spark")
                                            ,Tuple1.apply("hadoop"))
      .map("hello"+_._1)
      .print()
    env.execute("flink map operator")
  }
}

运行结果：
3> hello hadoop
2> hello spark
1> hello flink

flatmap

flatmap可以理解为将元素摊平，每个元素可以变为0个、1个、或者多个元素。

 env.fromElements(Tuple1.apply("flink jobmanger taskmanager")
      ,Tuple1.apply("spark streaming")
      ,Tuple1.apply("hadoop hdfs"))
      .flatMap(_._1.split(" "))
      .print()
运行结果：
hadoop
hdfs
spark
streaming
flink
jobmanger
taskmanager

filter

filter是进行筛选。

env.fromElements(Tuple1.apply("flink jobmanger taskmanager")
      ,Tuple1.apply("spark streaming")
      ,Tuple1.apply("hadoop hdfs"))
      .flatMap(_._1.split(" "))
      .filter(_.equals("flink"))
      .print()
运行结果：
flink

keyBy

逻辑上将Stream根据指定的Key进行分区，是根据key的散列值进行分区的。

注：keyed state 必须要在keyby() 之后使用

env.fromElements(Tuple1.apply("flink jobmanger taskmanager")
      , Tuple1.apply("flink streaming")
      , Tuple1.apply("hadoop jobmanger"))
      .flatMap(_._1.split(" "))
      .map(data => {
        (data, 1)
      })
      .keyBy(0)
      .reduce((t1,t2)=>{(t1._1,t1._2+t2._2)})
      .print().setParallelism(1)
运行结果：
(hadoop,1)
(flink,1)
(flink,2)
(jobmanger,1)
(jobmanger,2)
(taskmanager,1)
(streaming,1)

Aggregations

DataStream API 支持各种聚合，这些函数可以应用于 KeyedStream 以获得 Aggregations 聚合

常用的方法有

min、minBy、max、minBy、sum
max 和 maxBy 之间的区别在于 max 返回流中的最大值，但 maxBy 返回具有最大值的键， min 和 minBy 同理

输入：
zs 001 1200
zs 001 1500
   env.socketTextStream("localhost",8888)
      .map(_.split("\\s+"))
      .map(ts=>(ts(0),ts(1),ts(2).toDouble))
      .keyBy(1)
      .min(2)
      .print()
运行结果：
1> (zs,001,1200.0)
1> (zs,001,1200.0)

reduce

reduce是归并操作，它可以将KeyedStream 转变为 DataStream；对每一组内的元素进行归并操作，即第一个和第二个归并，结果再与第三个归并…

env.fromElements(Tuple1.apply("flink jobmanger taskmanager")
      , Tuple1.apply("flink streaming")
      , Tuple1.apply("hadoop jobmanger"))
      .flatMap(_._1.split(" "))
      .map(data => {
        (data, 1)
      })
      .keyBy(0)
      .reduce((t1,t2)=>{(t1._1,t1._2+t2._2)})
      .print().setParallelism(1)
运行结果：
(hadoop,1)
(flink,1)
(flink,2)
(jobmanger,1)
(jobmanger,2)
(taskmanager,1)
(streaming,1)

fold

给定一个初始值，将各个元素逐个归并计算。它将KeyedStream转变为DataStream；指定一个开始的值，对每一组内的元素进行归并操作，即第一个和第二个归并，结果再与第三个归并…

    env.fromElements(Tuple1.apply("flink jobmanger taskmanager")
      , Tuple1.apply("flink streaming")
      , Tuple1.apply("hadoop jobmanger"))
      .flatMap(_._1.split(" "))
      .map(data => {
        (data, 1)
      })
      .keyBy(0)
      .fold(("",11))((t1,t2)=>{(t2._1,t1._2+t2._2)})
      .print().setParallelism(1)
运行结果：
(jobmanger,11)
(jobmanger,12)
(taskmanager,11)
(streaming,11)
(hadoop,11)
(flink,11)
(flink,12)

union

union可以将多个流合并到一个流中，以便对合并的流进行统一处理。是对多个流的水平拼接。

参与合并的流必须是同一种类型。

dataStream1.union(dataStream2, dataStream3, ...)

join

根据指定的Key将两个流进行关联。

      //两个流进行join操作，是inner join，关联上的才能保留下来
        DataStream<String> result =  stream1.join(stream2)
                //关联条件
                .where(t1->t1.getField(0)).equalTo(t2->t2.getField(0))
                //每5秒一个滚动窗口
                .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
                //关联后输出
                .apply((t1,t2)->t1.getField(1)+"|"+t2.getField(1))
                ;

split

将一个流拆分为多个流。

val lines = env.socketTextStream("localhost",8888)
    val splitStream: SplitStream[String] = lines.split(line => {
      if (line.contains("zs")) {
        List("zs") //分支名称
      } else {
        List("ls") //分支名称
      }
    })

Select

从拆分流中选择特定流，那么就得搭配使用 Select 算子

输入：
zs 001 1200
zs 001 1500
ls 002 1000
   oo2 2000
    val lines = env.socketTextStream("localhost",8888)
    val splitStream: SplitStream[String] = lines.split(line => {
      if (line.contains("zs")) {
        List("zs") //分支名称
      } else {
        List("ls") //分支名称
      }
    })
    splitStream.select("zs").print("zs")
    splitStream.select("ls").print("ls")
运行结果：
zs:2> zs 001 1200
zs:3> zs 001 1500
ls:4> ls 002 1000
ls:1>    oo2 2000

Side Out

输入：
zs 001 1200
ls 002 1500
    val lines = env.socketTextStream("localhost",8888) 
    val outTag: OutputTag[String] = new OutputTag[String]("zs")
    // processFunction: ProcessFunction[T, R]
    val result: DataStream[String] = lines.process(new ProcessFunction[String, String] {
      override def processElement(value: String, ctx: ProcessFunction[String, String]#Context, out: Collector[String]): Unit = {
        if (value.contains("zs")) {
          ctx.output(outTag, value)
        } else {
          out.collect(value)
        }
      }
    })
    result.print("正常输出")
    //获取侧输出流中的数据
    result.getSideOutput(outTag).print("侧输出")
运行结果：
正常输出:2> ls 002 1000
侧输出:3> zs 001 1200

ValueSate

var env=StreamExecutionEnvironment.getExecutionEnvironment
env.socketTextStream("localhost",8888)
.flatMap(_.split("\\s+"))
.map((_,1))
.keyBy(0)
.map(new RichMapFunction[(String,Int),(String,Int)] {
    var vs:ValueState[Int]=_
    
    override def open(parameters: Configuration): Unit = {
        val vsd=new ValueStateDescriptor[Int]("valueCount",createTypeInformation[Int])
        vs=getRuntimeContext.getState[Int](vsd)
    }
    
    override def map(value: (String, Int)): (String, Int) = {
        val histroyCount = vs.value()
        val currentCount=histroyCount+value._2
        vs.update(currentCount)
        (value._1,currentCount)
    }
}).print()

KafkaSource

val prop = new Properties()
prop.setProperty("zookeeper.connect", ZOOKEEPER_HOST)
    prop.setProperty("bootstrap.server", KAFKA_BROKER)
    prop.setProperty("group.id", TRANSACTION_GROUP)
    prop.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")
    prop.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")
    prop.setProperty("auto.offset.reset", "latest")
val lines=env.addSource(new FlinkKafkaConsumer("topic",new SimpleStringSchema(),properties))
    lines.flatMap(_.split("\\s+"))
    .map((_,1))
    .keyBy(t=>t._1)
    .sum(1)
    .print()

如果使用SimpleStringSchema，只能获取value，如果想要获取更多信息，比如 key/value/partition/offset ，用户可以通过继承KafkaDeserializationSchema类自定义反序列化对象

import org.apache.flink.api.common.typeinfo.TypeInformation
import org.apache.flink.streaming.connectors.kafka.KafkaDeserializationSchema
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.flink.streaming.api.scala._

class KafkaDeserializationSchema extends KafkaDeserializationSchema[(String,String)] {
  override def isEndOfStream(nextElement: (String, String)): Boolean = {
    false
  }
    
  override def deserialize(record: ConsumerRecord[Array[Byte], Array[Byte]]): (String, String) = {
    var key=""
    if(record.key()!=null && record.key().size!=0){
      key=new String(record.key())
    }
    val value=new String(record.value())
    (key,value)
  }
    
  //tuple元素类型
  override def getProducedType: TypeInformation[(String, String)] = {
    createTypeInformation[(String, String)]
  }
}

如果Kafka存储的数据为json格式时，可以使用系统自带的一些支持json的Schema：

JsonNodeDeserializationSchema：要求value必须是json格式的字符串

flink常用算子以及window

Flink 窗口种类以及常用算子

Tumbling Windows

Sliding Windows

Global Windows

Session Windows（MergerWindow）

Event Time

常用算子

map

flatmap

filter

keyBy

Aggregations

reduce

fold

union

join

split

Select

Side Out

ValueSate

KafkaSource

「Pygors跨平台GUI」1：Pygors跨平台GUI应用研究

[转帖]

python列出centos7内存使用前50的进程信息

Garnet：微软官方基于.NET开源的高性能分布式缓存存储数据库

Flink执行图

Java响应式编程

评估统计算法在银行伪造钞票检测中的价值

nodejs学习06——小案例

Apache Impala總結

數倉ods分區總結

shell腳本基本操作一

flink常用算子以及window

Kylin中使用Api構建cube以及狀態監控腳本

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結