Flink：窗口

最新推荐文章于 2024-06-26 09:25:06 发布
最新推荐文章于 2024-06-26 09:25:06 发布
阅读量205 收藏
点赞数 1
分类专栏： 大数据 文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/McGrady_Durant/article/details/119787900
版权

文章目录

窗口计算

概述

窗口计算是流计算的核心。

窗口计算就是把无界数据流切分为有限大小的“bucket”—>窗口（bucket/window/panel），在窗口上应用计算换上完成计算处理

在这里插入图片描述

整体的程序结构

在这里插入图片描述

窗口的切分

专业的说法：window assigner–>窗口分配器：把无界数据流怎么做窗口的划分

Tumbling Windows：滚动窗口

窗口大小是固定的、上一个窗口的结束是下一个窗口的开始（窗口不会重叠）

在这里插入图片描述

Sliding Windows：滑动窗口

窗口大小是固定的，窗口有可能有重叠。窗口会有一个滑动步长（上一个窗口开始，往后滑动一定的时间下一个窗口开始）

在这里插入图片描述

Session Windows：会话窗口

窗口大小不固定，窗口之间会有一个间隙（gap）

在这里插入图片描述

Global Window：全局窗口

整个数据流是一个窗口，因为数据流是无界的，所以全局窗口默认情况下，永远不会触发计算数据
在这里插入图片描述

窗口代码-窗口分配器

窗口切分—windowAssigner的使用

TumblingWindowsAssigner
package com.baizhi.flink.assigner

import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

/**
 * 通过滚动窗口对无界数据流进行窗口的切分
 * 以word count为需求实现
 */
object TumblingWindowsAssignerJob {

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

    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = environment.socketTextStream("hadoop10", 9999)

    val keyedStream: KeyedStream[(String, Int), String] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(_._1)

    //1.通过滚动窗口对无界数据流进行切分
    //2.滚动窗口的大小是5秒钟
    //3.ProcessingTime==》处理时间，以系统时钟作为时间基准
    
    //通过window算子对无界数据流进行窗口的切分：窗口分配器WindowAssigner
    val windowedStream: WindowedStream[(String, Int), String, TimeWindow] = keyedStream.window(TumblingProcessingTimeWindows.of(Time.seconds(5)))

    val result: DataStream[(String, Int)] = windowedStream.reduce((sum, elem) => (elem._1, sum._2 + elem._2))

    result.print()

    environment.execute("tumblingWindowsAssignerJob")
  }

}
SlidingWindowsAssigner
package com.baizhi.flink.assigner

import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.assigners.{SlidingProcessingTimeWindows, TumblingProcessingTimeWindows}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

object SlidingWindowsAssignerJob {

  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = environment.socketTextStream("hadoop10", 9999)

    val keyedStream: KeyedStream[(String, Int), String] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(_._1)


    //1.window算子实现窗口的划分
    //2SlidingProcessingTimeWindows实现滑动窗口
    //3.滑动窗口有固定大小：10秒钟；窗口的滑动步长5秒钟
    //滑动窗口有可能会重叠
    val windowedStream: WindowedStream[(String, Int), String, TimeWindow] = keyedStream.window(SlidingProcessingTimeWindows.of(Time.seconds(10), Time.seconds(5)))

    val result: DataStream[(String, Int)] = windowedStream.reduce((sum, elem) => (elem._1, sum._2 + elem._2))

    result.print()

    environment.execute("tumblingWindowsAssignerJob")
  }

}
SessionWindowsAssigner
package com.baizhi.flink.assigner

import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.assigners.{ProcessingTimeSessionWindows, TumblingProcessingTimeWindows}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

object SessionWindowsAssignerJob {

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

    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = environment.socketTextStream("hadoop10", 9999)

    val keyedStream: KeyedStream[(String, Int), String] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(_._1)

    //window算子实现窗口的划分
    //2.withGap方法里面的时间表示的是间隙。设置了间隙是5秒钟
    var windowedStream = keyedStream.window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
    val result: DataStream[(String, Int)] = windowedStream.reduce((sum, elem) => (elem._1, sum._2 + elem._2))

    result.print()

    environment.execute("tumblingWindowsAssignerJob")
  }

}
GlobalWindowAssigner
package com.baizhi.flink.assigner

import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.assigners.{GlobalWindows, TumblingProcessingTimeWindows}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.triggers.CountTrigger
import org.apache.flink.streaming.api.windowing.windows.{GlobalWindow, TimeWindow}

/**
 * 通过滚动窗口对无界数据流进行窗口的切分
 * 以word count为需求实现
 */
object GlobalWindowsAssignerJob {

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

    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = environment.socketTextStream("hadoop10", 9999)

    val keyedStream: KeyedStream[(String, Int), String] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(_._1)


    //window算子进行窗口的划分
    //globalWindows就是把整个无界数据流划分为一个窗口
    //因为无界数据流没有结束，全局窗口也没有结束，所以全局窗口默认的是永远不会触发计算函数
    val windowedStream: WindowedStream[(String, Int), String, GlobalWindow] = keyedStream
      .window(GlobalWindows.create())
      .trigger(CountTrigger.of[GlobalWindow](3))//这是一个数量触发器；窗口中的元素个数到达了规定的值3，就会触发执行

    val result: DataStream[(String, Int)] = windowedStream.reduce((sum, elem) => {
      println("***********")
      (elem._1, sum._2 + elem._2)
    })

    result.print()

    environment.execute("tumblingWindowsAssignerJob")
  }

}

窗口代码-窗口计算函数

reduceFunction

reduceFunction 做的是增量计算—》每过来一个数据，就会执行一次计算。到窗口结束，触发计算的时候，就把计算的结果发送出去

package com.baizhi.flink.function

import org.apache.flink.api.common.functions.ReduceFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time

object ReduceFunctionJob {

  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    val dataStream: DataStream[String] = environment.socketTextStream("hadoop10", 9999)

    val keyedStream: KeyedStream[(String, Int), String] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(_._1)

    val result: DataStream[(String, Int)] = keyedStream
      .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
      .reduce(new MyReduceFunction)

    result.print()

    environment.execute("reduceFunctionJob")
  }

}

class  MyReduceFunction extends ReduceFunction[(String, Int)]{
  override def reduce(value1: (String, Int), value2: (String, Int)): (String, Int) = {

//    println(value1+"***"+value2)

    (value2._1,value2._2+value1._2)
  }
}
processWindowFunction

processWindowFunction做的是批量计算—》每过来一个数据，就会把数据存储起来。到窗口结束，触发计算的时候，把所有的数据获取到进行一次性计算

可以获取到窗口的元数据信息—》窗口的开始时间，结束时间…

package com.baizhi.flink.function

import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.ProcessWindowFunction
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

object ProcessWindowFunctionJob {

  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    val dataStream: DataStream[String] = environment.socketTextStream("hadoop10", 9999)

    val keyedStream: KeyedStream[(String, Int), String] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(_._1)


    val result: DataStream[(String, Int)] = keyedStream
      .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
      .process(new MyProcessWindowFunction)

    result.print()


    environment.execute("processWindowFunctionJob")
  }

}


//四个类型参数
//In:输入数据的类型
//Out：输出数据的类型
//Key: Key的类型，keyBy所对应的类型。keyedStream[类型1,类型2]-->类型2就是key的类型
//Window：窗口的类型，分成了两种，一种是时间窗口，一种是全局窗口
//class MyProcessWindowFunction extends ProcessWindowFunction[In,Out,Key,Window]
class MyProcessWindowFunction extends ProcessWindowFunction[(String, Int),(String, Int),String,TimeWindow]{
  //处理数据

  /**
   *
   * @param key
   * @param context 上下文
   * @param elements 这个参数是一个集合，就是把所有落入到窗口的数据先暂存起来；当窗口触发计算函数的时候，再从这个集合中读取所有的数据进行计算处理
   * @param out
   */
  override def process(key: String, context: Context, elements: Iterable[(String, Int)], out: Collector[(String, Int)]): Unit = {

    //1.word count功能的实现
    val count: Int = elements.map(_._2).sum


    //2.获取元数据信息
    val timeWindow: TimeWindow = context.window

    //窗口的开始时间
    val start: Long = timeWindow.getStart

    //窗口的结束时间
    val end: Long = timeWindow.getEnd
    println(s"窗口时间:[${start}-${end}),窗口中的数据：${elements.mkString(",")}")



    //构建返回值
    out.collect((key,count))


  }
}
既要高效计算又要元数据信息
  • 高效计算就是指增量计算，是由ReduceFunction、aggregateFunction完成的
  • 元数据信息，是由ProcessWindowFunction完成的

就应该把这两个放在一起使用

package com.baizhi.flink.function

import org.apache.flink.api.common.functions.ReduceFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.ProcessWindowFunction
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

object ReduceAndProcessWindowFunctionJob {

  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    val dataStream: DataStream[String] = environment.socketTextStream("hadoop10", 9999)

    val keyedStream: KeyedStream[(String, Int), String] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(_._1)

    val result: DataStream[String] = keyedStream.window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
      .reduce(new MyReduceFunction2, new MyProcessWindowFunction2)

    result.print()


    environment.execute("processWindowFunctionJob")
  }

}
class MyReduceFunction2 extends ReduceFunction[(String,Int)]{
  override def reduce(value1: (String, Int), value2: (String, Int)): (String, Int) = {

    println(value1+"***"+value2)

    (value2._1,value1._2+value2._2)
  }
}

class MyProcessWindowFunction2 extends ProcessWindowFunction[(String,Int),String,String,TimeWindow]{
  override def process(key: String, context: Context, elements: Iterable[(String, Int)], out: Collector[String]): Unit = {

    //elements这里面存储的不是一个一个的数据，而是reduceFunction计算完成的结果
    println(elements.mkString(","))//

    val timeWindow: TimeWindow = context.window

    val start: Long = timeWindow.getStart

    val end: Long = timeWindow.getEnd
    println(s"窗口时间:[${start}-${end})")


    val list: List[(String, Int)] = elements.toList
    out.collect(list(0)._1+"的个数是："+list(0)._2)

  }
}
在窗口计算中使用状态
  • 在窗口中使用状态：一个窗口对应一个状态，做数据的存储
  • 在窗口之间使用状态：把所有窗口的数据汇总起来
package com.baizhi.flink.function

import org.apache.flink.api.common.state.{KeyedStateStore, ValueState, ValueStateDescriptor}
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.ProcessWindowFunction
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

object StateJob {

  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment


    val dataStream: DataStream[String] = environment.socketTextStream("hadoop10", 9999)

    val keyedStream: KeyedStream[(String, Int), String] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(_._1)

    val result: DataStream[String] = keyedStream
      .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
      .process(new MyProcessWindowFunction3)

    result.print()



    environment.execute("stateJob")
  }

}
class MyProcessWindowFunction3 extends ProcessWindowFunction[(String,Int),String,String,TimeWindow]{

  var vsdForEachWindow:ValueStateDescriptor[Int]=_
  var vsdForAllWindows:ValueStateDescriptor[Int]=_

  override def open(parameters: Configuration): Unit = {

    vsdForEachWindow=new ValueStateDescriptor[Int]("vsdfew",createTypeInformation[Int])
    vsdForAllWindows=new ValueStateDescriptor[Int]("vsdfaw",createTypeInformation[Int])

  }

  override def process(key: String, context: Context, elements: Iterable[(String, Int)], out: Collector[String]): Unit = {

    val count: Int = elements.map(_._2).sum


    //状态的使用

    //没有太大的意义，因为每个窗口的数据都进行了计算
    //针对每一个窗口
    val windowRuntimeContext: KeyedStateStore = context.windowState
    val valueStateForEachWindow: ValueState[Int] = windowRuntimeContext.getState(vsdForEachWindow)

    //全局的
    val globalRuntimeContext: KeyedStateStore = context.globalState
    //把所有窗口的数据都累计起来
    val valueStateForAllWindows: ValueState[Int] = globalRuntimeContext.getState(vsdForAllWindows)

    //从状态中读取之前所有窗口计算的单词的个数
    val oldCount: Int = valueStateForAllWindows.value()

    valueStateForAllWindows.update(oldCount+count)

    println(s"到目前位置，${key}的个数是："+valueStateForAllWindows.value())




    out.collect(key+"个数是："+count)

  }
}

Trigger

Trigger：触发器

由触发器决定了窗口的计算函数执行时间

  • 时间窗口-在默认情况下，时间窗口是在窗口结束时触发计算函数

  • 全局窗口-在默认情况下，永不触发

如果默认的触发器不能满足业务需要，就可以通过代码完成触发器的使用

keyedStream.window.trigger(trigger)

Flink提供了Trigger。flink提供了很多Trigger的具体类型可以直接使用

  • ConutTrigger:数量触发器，当窗口中的数据达到规定的数量时就触发计算
  • DeltaTrigger:计算两个数的差值，符合了规定的标准，就触发计算

如果Flink提供的Trigger具体类型不能满足业务需要，就自定义Trigger

  • 写一个类，继承Trigger
  • 重写里面的方法

Evictor

evict：剔除器，在计算函数触发计算之前/之后，可以把窗口中的数据剔除掉

keyedStream.window.evictor(evictor)

Flink提供了Evictor.Flink提供了很多具体的Evictor实现类

  • CountEvictor:数量剔除器，当窗口中数据的数量达到规定的值，进行数据的剔除

如果Flink提供的Evictor不能满足业务需要，可以自定义Evictor

  • 写一个类，实现Evictor接口
    定了窗口的计算函数执行时间

  • 时间窗口-在默认情况下，时间窗口是在窗口结束时触发计算函数

  • 全局窗口-在默认情况下，永不触发

如果默认的触发器不能满足业务需要，就可以通过代码完成触发器的使用

keyedStream.window.trigger(trigger)

Flink提供了Trigger。flink提供了很多Trigger的具体类型可以直接使用

  • ConutTrigger:数量触发器，当窗口中的数据达到规定的数量时就触发计算
  • DeltaTrigger:计算两个数的差值，符合了规定的标准，就触发计算

如果Flink提供的Trigger具体类型不能满足业务需要，就自定义Trigger

  • 写一个类，继承Trigger
  • 重写里面的方法

Evictor

evict：剔除器，在计算函数触发计算之前/之后，可以把窗口中的数据剔除掉

keyedStream.window.evictor(evictor)

Flink提供了Evictor.Flink提供了很多具体的Evictor实现类

  • CountEvictor:数量剔除器，当窗口中数据的数量达到规定的值，进行数据的剔除

如果Flink提供的Evictor不能满足业务需要，可以自定义Evictor

  • 写一个类，实现Evictor接口
  • 重写里面的方法

总结

窗口计算

  1. 对窗口的理解

窗口计算就是流计算中，把无界数据流切分成有限大小的窗口，在窗口上进行计算处理

  1. flink窗口计算的整体计算模型

通过windowAssigner对数据流进行切分，从而形成需要的窗口
滚动窗口：固定大小，窗口没有重叠
滑动窗口：固定大小，有滑动步长。窗口有可能会重叠
会话窗口：gap
上面的三种窗口属于时间窗口
全局窗口：整个无界数据流对应的是一个窗口。默认情况下，不会触发计算
如果有需要可以通过trigger完成触发器的使用
如果有需要，可以通过evictor进行计算函数执行之前或者之后进行数据的剔除
通过窗口计算函数完成窗口的计算处理

  1. 窗口的计算函数

reduce/aggregate/fold(被标记过时的)
增量计算

processWindowFunction
批量计算，可以获取到窗口的元数据信息
可以通过reduce以及processWindowFunction结合在一起完成增量计算的同时，获取到元数据信息

reduce(reduceFunction,processWindowFunction)
reduceFunction计算完成的结果，发送给了processWindowFunction
processWindowFunction获取到的是reduceFunction计算之后的结果
processWindowFunction把数据发送给下游
processWindowFunction中还可以获取到元数据信息
在窗口计算中使用状态
可以在processWindowFunction里面，读取到状态数据信息—>单个窗口的运行上下文（KeyStateStore）/整个数据流对应的运行时上下文

单个窗口的运行上下文对象获取到单个窗口对应的状态—》使用不多
整个数据流对应的运行时上下文—>globalState全局状态，所有窗口计算之后的结果都可以保存到这个状态中。这个状态可以保证窗口之间的计算结果的聚合

总结

  1. 对窗口的理解
    窗口计算就是流计算中，把无界数据流切分成有限大小的窗口，在窗口上进行计算处理
  2. flink窗口计算的整体计算模型
    通过windowAssigner对数据流进行切分，从而形成需要的窗口
    滚动窗口：固定大小，窗口没有重叠
    滑动窗口：固定大小，有滑动步长。窗口有可能会重叠
    会话窗口：gap
    上面的三种窗口属于时间窗口
    全局窗口：整个无界数据流对应的是一个窗口。默认情况下，不会触发计算
    如果有需要可以通过trigger完成触发器的使用
    如果有需要，可以通过evictor进行计算函数执行之前或者之后进行数据的剔除
    通过窗口计算函数完成窗口的计算处理
  3. 窗口的计算函数
    reduce/aggregate/fold(被标记过时的)
    增量计算
    processWindowFunction
    批量计算，可以获取到窗口的元数据信息
    可以通过reduce以及processWindowFunction结合在一起完成增量计算的同时，获取到元数据信息
    reduce(reduceFunction,processWindowFunction)
    reduceFunction计算完成的结果，发送给了processWindowFunction
    processWindowFunction获取到的是reduceFunction计算之后的结果
    processWindowFunction把数据发送给下游
    processWindowFunction中还可以获取到元数据信息
    在窗口计算中使用状态
    可以在processWindowFunction里面，读取到状态数据信息—>单个窗口的运行上下文（KeyStateStore）/整
    个数据流对应的运行时上下文
    单个窗口的运行上下文对象获取到单个窗口对应的状态—》使用不多
    整个数据流对应的运行时上下文—>globalState全局状态，所有窗口计算之后的结果都可以保存到这个状态
    中。这个状态可以保证窗口之间的计算结果的聚合
  4. 写代码
    包名
    公司域名逆序
    还需要写项目名
    com.baizhi.flink.===>其中flink是项目
    代码成块出现
    在代码和代码之间应用有空格
    每一块代码都应该有注释
    命名–>见名知意
    类名、接口名、枚举、注解所有单词首字母大写
    变量、方法名第一个单词首字母小写，后面的每一个单词首字母大写
McGrady_Durant
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
flink的窗口介绍
蜗牛小将
03-31 281
在真实世界中的，无时无刻不在生产数据，这些数据都是无界的，窗口的存在就是将无界的的数据流切割为有限的数据流的方式。 一般来说，根据业务类型，窗口可以分成两大类： 1、时间窗口 2、计数窗口 ...
flink：Apache Flink
02-04
跨不同时间语义（事件时间，处理时间）的灵活窗口（时间，计数，会话，自定义触发器） 容错和一次处理保证 流媒体程序中的自然背压 用于图处理（批处理），机器学习（批处理）和复杂事件处理（流处理）的库 对...
flink 窗口
weixin_66220149的博客
09-08 891
我们的flink主要是用来处理无界数据流，一种方式就是将我们的无界数据流切割成有限的“数据块”进行处理，这就是我们的窗口(window)。滑动窗口：timeWindow（Time.seconds(10),Time.seconds(5)) count-sliding-window。// TODO: 2022/9/2创建Flink流式处理环境。// TODO: 2022/9/2 设置并行度。4、滚动窗口（每个区消费总额Top3的公司）滚动窗口、滑动窗口、会话窗口。
flink的窗口
最新发布
天龙八部
06-26 1062
窗口是flink中重要的概念，为了方便高效的处理无界流，将数据切成有限的数据块进行处理；
flink窗口
cobracanary的博客
06-03 283
对flink窗口的一些思考
flink窗口（Window）
m0_66520412的博客
01-19 735
Flink 是一种流式计算引擎，主要是来处理无界数据流的，数据源源不断、无穷无尽。想 要更加方便高效地处理无界流，一种方式就是将无限数据切割成有限的“数据块”进行处理， 这就是所谓的“窗口”（Window）。
Flink:Flink
03-19
6. **窗口操作**：Flink提供了滑动窗口、会话窗口和 tumbling 窗口等多种窗口操作，以适应不同场景下的数据聚合需求。 7. **图处理（Gelly）**：Flink提供了Gelly库，用于处理图数据，支持图的创建、遍历和分析算法...
行动中的flink：行动中的flink
03-02
2. **窗口机制**：窗口是Flink处理无限数据流的关键工具。滑动窗口、会话窗口和 tumbling 窗口等提供了灵活的时间窗口划分方式，适用于各种实时分析场景。 3. **状态管理**：Flink提供了强大的状态管理功能，可以...
Apache Flink：详细入门.docx
05-20
1. 流处理特性：支持高吞吐、低延迟、高性能的流处理，支持带有事件时间的窗口（Window）操作，支持有状态计算的 Exactly-once 语义，支持高度灵活的窗口（Window）操作，支持基于 time、count、session 以及 data-...
awesome-flink：:smiling_face_with_sunglasses:精选的Flink和Flink生态系统资源惊人清单
01-31
6. **窗口机制**：Flink提供各种窗口类型（滑动窗口、会话窗口、翻转窗口等），用于在时间序列数据上进行聚合操作。 7. **连接器和格式**：Flink支持多种数据源和接收器，如Kafka、HDFS、RabbitMQ等，以及各种数据...
Flink 窗口
Java_KW的博客
04-06 1333
Flink 窗口 文章目录Flink 窗口一、Window1.1 概述1.2 Window 类型**滚动窗口（Tumbling Windows）****滑动窗口（Sliding Windows）****会话窗口（Session Windows）**二、Window API2.1 概述窗口分配器（Window Assigner）创建不同类型的窗口2.2 TimeWindow滚动时间窗口滑动时间窗口2.3 CountWindow滚动计数窗口滑动计数窗口2.4 window function增量聚合函数全窗口函数
Flink窗口
yingzi的技术博客
04-16 8295
文章目录窗口的概念窗口的分类按照驱动类型分类（1）时间窗口（2）计数窗口（Count Window）按照窗口分配数据的规则分类（1）滚动窗口（Tumbling Windows）（2）滑动窗口（Sliding Windows）（3）会话窗口（Session Windows）（4）全局窗口（Global Windows）窗口API概览按键分区窗口（Keyed）和非按键分区（Non-Keyed）代码中窗口API的调用窗口分配器（Window Assigners）1、时间窗口（1）滚动处理时间窗口（2）滑动处理时间
Flink之窗口
啥也不会的博客
05-22 1916
概述 Windows是处理无限流的核心。是一种切割无限数据为有限块进行处理的手段。Windows将流分成有限大小的“buckets”，我们可以在其上应用计算。 窗口式Flink程序的一般结构如下所示。第一个代码段指的是键控流，第二个代码段指的是非键控流。两者唯一的区别是keyBy(...)之后调用window(...)的称为成为键控流；DataStream直接调用windowAll(...)的称为非键控流。 Keyed Windows stream .keyBy(...)
flink窗口介绍
anita9999的博客
11-19 1224
1.窗口分类 滚动窗口（滚动时间窗口，滚动计数窗口） 滑动窗口（滑动时间窗口，滑动计数窗口） 会话窗口 全局窗口 2.窗口解释 滚动窗口（Tumbing Window）：固定时间生成一个窗口，或固定数据生成一个窗口；比如8点到9点，间隔一个小时生成一个窗口，那么8点到9点进来的数据进入这个窗口，窗口相当于一个桶，把数据存储起来；或进来10个数据生成一个窗口，放在这个窗口里。 滚动窗口时间间隔固定，采取左闭右开的原则，比如八点到九点，八点封闭，九点开，一个数据是九点进来，他应该是九点到十点的
Flink中的窗口
weixin_63257947的博客
05-03 405
注意：Flink中窗口并不是静态准备好的，而是动态创建——当有落在这个窗口区间范围的数据达到时，才创建对应的窗口。另外，这里我们认为到达窗口结束时间时，窗口就触发计算并关闭，事实上“触发计算”和“窗口关闭”两个行为也可以分开，这部分内容我们会在后面详述。我们定义了窗口分配器之后，我们只是知道了数据属于哪一个窗口，可以将数据收集起来了，至于收集起来要干什么，做什么计算，还是未知。与增量聚合函数不同，全窗口函数需要先收集窗口中的数据，并在内部缓存起来，等到窗口要输出结果的时候再取出数据进行计算。
flink窗口讲解
First_____的博客
03-02 1366
flink窗口讲解
深入理解Flink：从基础到实战
3. **窗口**：对于无界流，Flink使用窗口进行分组和聚合操作。 4. **状态管理**：Flink支持有状态计算，允许中间结果的持久化。 5. **容错机制**：Flink通过检查点和保存点实现故障恢复。 6. **水位线**：用于标记...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值