Flink窗口计算全解析：从基础到实战

于 2025-05-27 08:30:00 发布
阅读量1k 收藏 27
点赞数 8
CC 4.0 BY-SA版权
分类专栏： 大数据技术与应用 # Flink # 基于Scala对Flink的实现 文章标签： flink scala apache 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57376564/article/details/148143402

目录

代码各部分详细解释

1. 包导入与数据模型定义

2. 执行环境设置

3. 数据源与时间戳分配

4. 增量聚合函数 Reduce

5. 增量聚合函数 Aggregate

6. 全窗口函数 WindowFunction

7. 全窗口函数 ProcessWindowFunction

8. 增量聚合函数与全窗口函数的结合使用

代码原理知识背景拓展

1. 窗口计算基础

2. 增量聚合函数

3. 全窗口函数

4. 时间语义

5. 水位线（Watermark）

6. 窗口分配器

7. 状态管理

8. 容错机制

package window

import java.text.SimpleDateFormat

import org.apache.flink.api.common.eventtime.{SerializableTimestampAssigner, WatermarkStrategy}
import org.apache.flink.api.common.functions.{AggregateFunction, ReduceFunction}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.{ProcessWindowFunction, WindowFunction}
import org.apache.flink.streaming.api.windowing.assigners.{EventTimeSessionWindows, SlidingEventTimeWindows, TumblingEventTimeWindows, 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
import source.ClickSource

case class UrlViewCount(url:String,count:Long,widowStart:String,windowEnd:String)
/**
 *
 * @PROJECT_NAME: flink1.13
 * @PACKAGE_NAME: window
 * @author: 赵嘉盟-HONOR
 * @data: 2023-05-23 0:21
 * @DESCRIPTION
 *
 */
object windowFunction {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val data = env.addSource(new ClickSource)
      .assignTimestampsAndWatermarks(WatermarkStrategy.forMonotonousTimestamps()
        .withTimestampAssigner(new SerializableTimestampAssigner[source.Event] {
          override def extractTimestamp(t: source.Event, l: Long): Long = t.timestamp
        }))
    //TODO 增量聚合函数 Reduce(流处理)
    data.map(data => (data.user,1)).keyBy(_._1)
      .window(TumblingEventTimeWindows.of(Time.seconds(5)))
      .reduce((state,data)=>(data._1,data._2+state._2)).print("reduceLmd")

    data.map(data => (data.user, 1)).keyBy(_._1)
      .window(TumblingEventTimeWindows.of(Time.seconds(5)))
      .reduce(new ReduceFunction[(String, Int)] {
        override def reduce(t: (String, Int), t1: (String, Int)): (String, Int) = (t._1,t._2+t1._2)
      }).print("reduceFunction")

    val data2 = env.addSource(new ClickSource)
      .assignAscendingTimestamps(_.timestamp) //升序数据时间戳提取
      .keyBy(data => "kry").window(TumblingEventTimeWindows.of(Time.seconds(10)))
    //TODO 增量聚合函数 Aggregate（统计PV，UV，输出PV/UV）
      data2
      .aggregate(new AggregateFunction[source.Event,(Long,Set[String]),Double] {
        override def createAccumulator(): (Long, Set[String]) = (0L,Set[String]())
        override def add(in: source.Event, acc: (Long, Set[String])): (Long, Set[String]) = (acc._1+1,acc._2+in.user)
        override def getResult(acc: (Long, Set[String])): Double = acc._1.toDouble/acc._2.size
        override def merge(acc: (Long, Set[String]), acc1: (Long, Set[String])): (Long, Set[String]) = ???
      }).print("aggregate")

    //TODO 全窗口函数 windowFunction（apply）（批处理）
    data2.apply(new WindowFunction[source.Event,String,String,TimeWindow] {
      override def apply(key: String, window: TimeWindow, input: Iterable[source.Event], out: Collector[String]): Unit = {
        var userSet=Set[String]()
        input.foreach(userSet+=_.user)
        val uv=userSet.size
        val windowStart=window.getStart
        val windowEnd=window.getEnd
        out.collect(s"窗口 $windowStart ~ $windowEnd 的UV值为 $uv")
      }
    }).print("windowFunction")

    data2.apply((key,window,input,out:Collector[String])=>{
      var userSet = Set[String]()
      input.foreach(userSet += _.user)
      val uv = userSet.size
      val windowStart = window.getStart
      val windowEnd = window.getEnd
      out.collect(s"窗口 $windowStart ~ $windowEnd 的UV值为 $uv")
    })

    //TODO 全窗口函数 processWindowFunction（process）
    data2.process(new ProcessWindowFunction[source.Event,String,String,TimeWindow] {
      override def process(key: String, context: Context, elements: Iterable[source.Event], out: Collector[String]): Unit = {
        var userSet = Set[String]()
        elements.foreach(userSet += _.user)
        val uv = userSet.size
        val windowStart = context.window.getStart
        val windowEnd = context.window.getEnd
        out.collect(s"窗口 $windowStart ~ $windowEnd 的UV值为 $uv")
      }
    }).print("processWindowFunction")

    //TODO 增量聚合函数与券窗口函数的结合使用：分组计算PV
    data2.aggregate(new AggregateFunction[source.Event,Long,Long] {
      override def createAccumulator(): Long = 0L
      override def add(in: source.Event, acc: Long): Long = acc+1
      override def getResult(acc: Long): Long = acc
      override def merge(acc: Long, acc1: Long): Long = ???
    },new ProcessWindowFunction[Long,UrlViewCount,String,TimeWindow] {
      override def process(key: String, context: Context, elements: Iterable[Long], out: Collector[UrlViewCount]): Unit = {
        out.collect(UrlViewCount(key,
          elements.iterator.next(),
          new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(context.window.getStart),
          new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(context.window.getEnd)
        ))
      }
    }).print("windowFunctionPlusMax")
    env.execute("windowFunction")
  }

}

这段代码是一个使用 Apache Flink 进行窗口计算的示例，展示了如何使用不同的窗口函数和聚合函数来处理流数据。以下是代码各部分的详细解释以及相关原理知识的拓展。

代码各部分详细解释

1. 包导入与数据模型定义
package window

import java.text.SimpleDateFormat

import org.apache.flink.api.common.eventtime.{SerializableTimestampAssigner, WatermarkStrategy}
import org.apache.flink.api.common.functions.{AggregateFunction, ReduceFunction}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.{ProcessWindowFunction, WindowFunction}
import org.apache.flink.streaming.api.windowing.assigners.{EventTimeSessionWindows, SlidingEventTimeWindows, TumblingEventTimeWindows, 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
import source.ClickSource

case class UrlViewCount(url: String, count: Long, widowStart: String, windowEnd: String)
  • 包导入：引入了 Flink 相关的各种类和接口，包括窗口分配器、时间语义、聚合函数、窗口函数等。
  • UrlViewCount 样例类：定义了一个数据模型，用于存储 URL 的访问次数、窗口开始时间和结束时间。
2. 执行环境设置
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setParallelism(1)
  • 创建执行环境：获取 Flink 的流执行环境。
  • 设置并行度：将任务的并行度设置为 1，方便调试和观察结果。
3. 数据源与时间戳分配
val data = env.addSource(new ClickSource)
  .assignTimestampsAndWatermarks(WatermarkStrategy.forMonotonousTimestamps()
    .withTimestampAssigner(new SerializableTimestampAssigner[source.Event] {
      override def extractTimestamp(t: source.Event, l: Long): Long = t.timestamp
    }))
  • 添加数据源：从自定义的 ClickSource 中获取数据。
  • 分配时间戳和水位线：使用 WatermarkStrategy.forMonotonousTimestamps() 为单调递增的时间戳生成水位线，并通过 withTimestampAssigner 从事件中提取时间戳。
4. 增量聚合函数 Reduce
data.map(data => (data.user, 1)).keyBy(_._1)
  .window(TumblingEventTimeWindows.of(Time.seconds(5)))
  .reduce((state, data) => (data._1, data._2 + state._2)).print("reduceLmd")

data.map(data => (data.user, 1)).keyBy(_._1)
  .window(TumblingEventTimeWindows.of(Time.seconds(5)))
  .reduce(new ReduceFunction[(String, Int)] {
    override def reduce(t: (String, Int), t1: (String, Int)): (String, Int) = (t._1, t._2 + t1._2)
  }).print("reduceFunction")
  • 第一种方式：使用匿名函数进行增量聚合，计算每个用户在 5 秒滚动窗口内的点击次数。
  • 第二种方式：实现 ReduceFunction 接口进行增量聚合，功能与第一种方式相同。
5. 增量聚合函数 Aggregate
val data2 = env.addSource(new ClickSource)
  .assignAscendingTimestamps(_.timestamp)
  .keyBy(data => "kry").window(TumblingEventTimeWindows.of(Time.seconds(10)))

data2
  .aggregate(new AggregateFunction[source.Event, (Long, Set[String]), Double] {
    override def createAccumulator(): (Long, Set[String]) = (0L, Set[String]())
    override def add(in: source.Event, acc: (Long, Set[String])): (Long, Set[String]) = (acc._1 + 1, acc._2 + in.user)
    override def getResult(acc: (Long, Set[String])): Double = acc._1.toDouble / acc._2.size
    override def merge(acc: (Long, Set[String]), acc1: (Long, Set[String])): (Long, Set[String]) =???
  }).print("aggregate")
  • 数据源与窗口设置：从 ClickSource 获取数据，设置升序时间戳，按 "kry" 分组，使用 10 秒滚动窗口。
  • 聚合函数：计算每个窗口内的平均 UV（Unique Visitor）。
6. 全窗口函数 WindowFunction
data2.apply(new WindowFunction[source.Event, String, String, TimeWindow] {
  override def apply(key: String, window: TimeWindow, input: Iterable[source.Event], out: Collector[String]): Unit = {
    var userSet = Set[String]()
    input.foreach(userSet += _.user)
    val uv = userSet.size
    val windowStart = window.getStart
    val windowEnd = window.getEnd
    out.collect(s"窗口 $windowStart ~ $windowEnd 的 UV 值为 $uv")
  }
}).print("windowFunction")

data2.apply((key, window, input, out: Collector[String]) => {
  var userSet = Set[String]()
  input.foreach(userSet += _.user)
  val uv = userSet.size
  val windowStart = window.getStart
  val windowEnd = window.getEnd
  out.collect(s"窗口 $windowStart ~ $windowEnd 的 UV 值为 $uv")
})
  • 第一种方式：实现 WindowFunction 接口，计算每个窗口内的 UV 值并输出。
  • 第二种方式：使用匿名函数实现相同的功能。
7. 全窗口函数 ProcessWindowFunction
data2.process(new ProcessWindowFunction[source.Event, String, String, TimeWindow] {
  override def process(key: String, context: Context, elements: Iterable[source.Event], out: Collector[String]): Unit = {
    var userSet = Set[String]()
    elements.foreach(userSet += _.user)
    val uv = userSet.size
    val windowStart = context.window.getStart
    val windowEnd = context.window.getEnd
    out.collect(s"窗口 $windowStart ~ $windowEnd 的 UV 值为 $uv")
  }
}).print("processWindowFunction")
  • 实现 ProcessWindowFunction：计算每个窗口内的 UV 值并输出，与 WindowFunction 类似，但提供了更多的上下文信息。
8. 增量聚合函数与全窗口函数的结合使用
data2.aggregate(new AggregateFunction[source.Event, Long, Long] {
  override def createAccumulator(): Long = 0L
  override def add(in: source.Event, acc: Long): Long = acc + 1
  override def getResult(acc: Long): Long = acc
  override def merge(acc: Long, acc1: Long): Long =???
}, new ProcessWindowFunction[Long, UrlViewCount, String, TimeWindow] {
  override def process(key: String, context: Context, elements: Iterable[Long], out: Collector[UrlViewCount]): Unit = {
    out.collect(UrlViewCount(key,
      elements.iterator.next(),
      new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(context.window.getStart),
      new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(context.window.getEnd)
    ))
  }
}).print("windowFunctionPlusMax")
  • 增量聚合：计算每个窗口内的点击次数。
  • 全窗口函数：将点击次数、窗口开始时间和结束时间封装成 UrlViewCount 对象并输出。

代码原理知识背景拓展

1. 窗口计算基础

在流处理中，窗口计算是一种常用的技术，用于对一段时间内的数据进行聚合操作。Flink 提供了多种窗口类型，包括滚动窗口（Tumbling Windows）、滑动窗口（Sliding Windows）和会话窗口（Session Windows）。

2. 增量聚合函数
  • ReduceFunction：对窗口内的数据进行逐步聚合，每次处理一个新元素时更新聚合结果。
  • AggregateFunction：更灵活的增量聚合函数，允许定义初始值、累加器和合并逻辑。
3. 全窗口函数
  • WindowFunction：在窗口关闭时对整个窗口的数据进行处理，适用于需要访问整个窗口数据的场景。
  • ProcessWindowFunction：与 WindowFunction 类似，但提供了更多的上下文信息，如当前窗口的开始时间、结束时间和水位线等。
4. 时间语义

Flink 支持三种时间语义：事件时间（Event Time）、摄入时间（Ingestion Time）和处理时间（Processing Time）。事件时间是指事件实际发生的时间，通过水位线（Watermark）来处理乱序数据。

5. 水位线（Watermark）

水位线是 Flink 中处理乱序数据的关键机制，它表示一个时间戳，在这个时间戳之前的数据都已经到达。水位线的生成可以是单调递增的，也可以是有界乱序的。

6. 窗口分配器

Flink 提供了多种窗口分配器，用于将数据流划分为不同的窗口。滚动窗口是固定大小的窗口，滑动窗口可以重叠，会话窗口根据事件之间的时间间隔来划分。

7. 状态管理

在窗口计算中，Flink 需要管理窗口的状态，包括聚合结果、时间戳等。状态管理对于保证计算的准确性和容错性非常重要。

8. 容错机制

Flink 提供了强大的容错机制，通过检查点（Checkpoint）和重启策略来保证在故障发生时能够恢复计算。

通过以上解释和拓展，你应该对 Flink 的窗口计算有了更深入的理解。希望这段代码示例和原理知识对你有所帮助。

Flink 自定义数据源：从理论到实践的全方位指南
大模型大数据攻城狮的专栏
03-25 1143
在 Flink 的世界里，数据源是数据流的 “源头活水”。简单来说，它负责从外部系统（比如数据库、消息队列、文件系统等）读取数据，并将其转化为 Flink 内部能够处理的格式，供后续的算子（Operator）加工。不管是实时流处理的无界数据，还是批处理的有限数据集，数据源都是那个默默干活的 “搬运工”。Flink 的数据源设计非常灵活，它通过一套精心设计的组件架构，确保既能支持内置的开箱即用功能，又能让开发者自由定制。分片（Splits）：数据的逻辑切片。
用 Flink CEP 打造实时超时预警：从理论到实战
最新发布
大模型大数据攻城狮的专栏
07-16 587
我们需要一个事件类来表示订单事件，包含用户ID、事件类型（下单或支付）、时间戳等字段。// 用户ID// 事件类型：create（下单）或 pay（支付）// 事件时间戳// Getter 和 Setter@Override// 设备ID// 温度值（摄氏度）// 事件时间戳// Getter 和 Setter@Override。
10分钟了解Flink窗口计算
程序员半支烟，wechat：yclxiao
04-26 863
本文主要讲了窗口的时间概念、窗口分配、窗口函数的使用，以及触发器、清除器的使用。
Apache Flink，流计算？不仅仅是流计算！
阿里技术
01-03 1355
阿里妹导读：2018年12月下旬，由阿里巴巴集团主办的Flink Forward China在北京国家会议中心举行。Flink Forward是由Apache软件基金会授...
Flink 窗口计算
sxsAffable的博客
06-19 1052
在当今大数据时代，实时数据处理的需求日益增长，Flink 的窗口计算在这一领域中发挥着至关重要的作用。 窗口计算使得我们能够将无界的数据流切分成有意义的片段，从而进行特定时间段内的数据聚合和分析。
Flink窗口计算
weixin_53209289的博客
07-27 392
DataStream result = input .keyBy(0) // 根据键值进行分组 .timeWindow(Time.minutes(1)) // 定义1分钟的时间窗口 .sum(1);首先根据键值进行分组（keyBy），然后定义一个1分钟的时间窗口（timeWindow），最后对窗口内的数据进行求和（sum）。注意，Flink还支持更复杂的窗口计算，如会话窗口（Session Windows）和全局窗口（Global Windows）。
Flink入门到精通：从基础到实战全解析
本视频教程是Flink入门到精通的全面指南，适合不同层次的学习者，从零基础小白到高级开发者都能在此找到所需的知识。课程内容丰富，涵盖了Flink框架的基础介绍、集群搭建与运维、数据处理流程的各个方面。 首先，...
Flink 水位线全解析：从原理到实战，彻底掌握事件时间处理！
shengjk1的博客
03-17 798
本文深入探讨了 Apache Flink 中的水位线（Watermark）机制，特别是 WATERMARK FOR event_time AS event_time 的语法及其在实际应用中的重要性
Flink窗口函数高级用法：时间窗口与计数窗口的深度解析
!...# 1. Flink窗口函数概述 Apache Flink作为一款流处理框架，其窗口函数对于实时数据分析至关重要。在大数据的动态流中，窗口函数能将事件分割成不同的时间段，使得开发者能够...在本章中，我们将先对Flink窗口函数的
flink计算详解
03-20
2017年中国数据库大会，华为技术研究所团队详细介绍的flink技术，以及流计算
Flink: 窗口计算
McGrady_Durant的博客
08-19 677
文章目录Event-time WindowEvent TimeWatermark-水位线迟到数据 Event-time Window Event Time Flink在流计算的过程中，支持多种时间概念。Event Time / Processing Time / Ingestion Time Processing Time：处理时间是指执行相应操作的机器的系统时间。 Event Time：事件时间是每个事件在其生产设备上发生的时间。处理乱序数据（数据的处理和数据的生成顺序乱啦） Ingestion：摄取
基础篇（三）：Flink window窗口计算
firefish009的博客
02-17 824
一、基本概念理解 1、窗口： 是将无限的数据流根据时间语义维度切割成一个有限大小的桶，然后对这个桶内的数据进行计算 2、窗口分类： 滚动窗口 tumbling window 描述：按照固定的时间长度对数据流切分，且窗口之间不会出现重叠 滑动窗口 sliding window 描述：由固定的窗口长度和滑动间隔组成，窗口之间有重叠，通常滑动间隔要小于窗口长度 会话窗口 session window 描述：在一定的时间长度timeout没有接收到数据，则生成一个新的窗口 全局窗口 g
Flink核心技术与实战（2）- 窗口计算（1）
一角残叶的博客
02-24 3346
1 窗口计算 1.1 window抽象概念 1.2 Window Assigner Flink支持的窗口类型 1.3 预置的 Keyed Windows 1.4 触发器 一次触发
Flink（十）窗口计算
又小雨的博客
08-18 2707
一、简介 窗口计算：flink的灵魂 窗口计算就是把无界数据流切分为有限大小的“bucket”—>窗口（bucket/window/panel），在窗口上应用计算换上完成计算处理 核心：窗口的划分和计算 我们经常需要在一个时间窗口维度上对数据进行聚合，窗口是流处理应用中经常需要解决的问题。Flink的窗口算子为我们提供了方便易用的API，我们可以将数据流切分成一个个窗口，对窗口内的数据进行处理。 大致程序结构： 按照有没有进行keyby分成了两种 不同的处理方式 首先，我们要决定是否对一个DataS
Flink的窗口计算案例
ZH519080的博客
04-15 3358
Flink的关于窗口算子的一般应用
flink事件属于窗口的计算方法
qq_18218071的博客
12-20 2466
背景 疑问1.一个窗口会不会变化？ 我们都知道flink有窗口和watermark的概念，当watermark大于窗口的endTime，将触发窗口中数据的计算，watermark是一个不断递增的时间戳，是不断变化的，如果我们假设一个窗口的开始时间和结束时间也是不断变化的，那么watermark就不好触发窗口计算。所以根据我们的假设，内心也是认为一个特定的窗口的开始和结束时间肯定是固定的。 疑问2.窗口是怎么初始化的？ 如果一个特定的窗口是不会变化的，比如滚动窗口，我们在代码中只需要传入窗口的size，就可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

渣渣盟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值