大数据技术之flink（3）

最新推荐文章于 2023-07-11 09:13:04 发布

dCHENz

最新推荐文章于 2023-07-11 09:13:04 发布

阅读量341

点赞数

分类专栏：大数据文章标签：大数据 flink

dongchenze

本文链接：https://blog.csdn.net/E699A8/article/details/105183607

版权

大数据专栏收录该内容

45 篇文章 8 订阅

订阅专栏

本文深入探讨了Flink中的Window概念，包括CountWindow和TimeWindow的类型，以及滚动窗口、滑动窗口和会话窗口的特性与应用场景。详细介绍了Window API的使用，如TimeWindow和CountWindow，并讲解了Flink的时间语义，特别是EventTime的引入和Watermark机制，用于处理乱序事件。

摘要由CSDN通过智能技术生成

前言

你们好我是啊晨
接着更新Flink技术。
废话不多说，内容很多选择阅读，详细。
请：

第六章Flink 中的 Window

6.1 Window

6.1.1 Window 概述

streaming 流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而 window 是一种切割无限数据为有限块进行处理的手段。

Window 是无限数据流处理的核心，Window 将一个无限的 stream 拆分成有限大小的”buckets”桶（1、拆分的条件可以是时间，多长时间拆分一次 2、也可以是记录条数，多少条记录拆分一次），我们可以在这些桶上做计算操作。

6.1.2 Window 类型

Window 可以分成两类：
CountWindow：按照指定的数据条数生成一个 Window，与时间无关。
TimeWindow：按照时间生成 Window。

（小插曲）Hadoop hdfs : namenode secondrynamenode
Secondrynamenode复制namenode 工作，定期将edits日志数据和fsimage，在Secondrynamenode端进行合并。
Secondrynamenode应该在什么时候去合并?配置时候有两个参数：时间和次数
flume:source channel sink 15s 30s 60s

对于 TimeWindow，可以根据窗口实现原理的不同分成三类：滚动窗口（Tumbling Window）、滑动窗口（Sliding Window）和会话窗口（Session Window）。

滚动窗口（Tumbling Windows）
将数据依据固定的窗口长度对数据进行切片。
特点：时间对齐，窗口长度固定，没有重叠。所有的数据只能落在一个窗口里面
滚动窗口分配器将每个元素分配到一个指定窗口大小的窗口中，滚动窗口有一个固定的大小，并且不会出现重叠。例如：如果你指定了一个 5 分钟大小的滚动窗口，窗口的创建如下图所示：

适用场景：适合做 BI 统计等（做每个时间段的聚合计算）。
滑动窗口（Sliding Windows）
滑动窗口是固定窗口的更广义的一种形式，滑动窗口由固定的窗口长度和滑动间隔组成。一次数据统计的时间长度每次统计移动多长的时间
特点：时间对齐，窗口长度固定，可以有重叠。一个数据可以被统计多次，滑动间隔、窗口长度是某个数值的整数倍
滑动窗口分配器将元素分配到固定长度的窗口中，与滚动窗口类似，窗口的大小由窗口大小参数来配置，另一个窗口滑动参数控制滑动窗口开始的频率。因此，滑动窗口如果滑动参数小于窗口大小的话，窗口是可以重叠的，在这种情况下元素会被分配到多个窗口中。
例如，你有 10 分钟的窗口和 5 分钟的滑动，那么每个窗口中 5 分钟的窗口里包含着上个 10 分钟产生的数据，如下图所示：

适用场景：对最近一个时间段内的统计（求某接口最近 5min 的失败率来决定是否要报警）。
会话窗口（Session Windows）
电商网站：登录一个系统之后，多长时间没有操作，session就失效。
手机银行：登录一个系统之后，多长时间没有操作，session就失效要求重新登。
由一系列事件组合一个指定时间长度的 timeout 间隙组成，类似于 web 应用的
session，也就是一段时间没有接收到新数据就会生成新的窗口。
特点：时间无对齐。多长时间之内没有收到数据，这个不是人为能规定的。
session 窗口分配器通过 session 活动来对元素进行分组，session 窗口跟滚动窗口和滑动窗口相比，不会有重叠和固定的开始时间和结束时间的情况，相反，当它在一个固定的间周期内不再收到元素，即非活动间隔产生，那个这个窗口就会关闭。一个 session 窗口通过一个 session 间隔来配置，这个 session 间隔定义了非活跃周期的长度，当这个非活跃周期产生，那么当前的 session 将关闭并且后续的元素将被分配到新的 session 窗口中去。

6.2 Window API

6.2.1 TimeWindow

TimeWindow 是将指定时间范围内的所有数据组成一个 window，一次对一个window 里面的所有数据进行计算。

滚动窗口
Flink 默认的时间窗口根据 Processing Time 进行窗口的划分，将 Flink 获取到的数据根据进入 Flink 的时间划分到不同的窗口中。

object Windows {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = env.socketTextStream("linux01", 9999)
    val countStream: DataStream[(String, Int)] = dataStream.map(r => (r, 1)).keyBy(0).timeWindow(Time.milliseconds(2000)).sum(1)
    countStream.print()
    env.execute("Windows is runned")
  }
}

时间间隔可以通过 Time.milliseconds(x)，Time.seconds(x)，Time.minutes(x)等其中的一个来指定。

滑动窗口（SlidingEventTimeWindows）
滑动窗口和滚动窗口的函数名是完全一致的，只是在传参数时需要传入两个参数，一个
是 window_size，一个是 sliding_size。
下面代码中的 sliding_size 设置为了 5s，也就是说，窗口每 5s 就计算一次，每一次计
算的 window 范围是 15s 内的所有元素。

object Windows {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = env.socketTextStream("linux01", 9999)
    val countStream: DataStream[(String, Int)] = dataStream.map(r => (r, 1)).keyBy(0).timeWindow(Time.milliseconds(5000),Time.milliseconds(1000)).sum(1)
    countStream.print()
    env.execute("Windows is runned")
  }
}

时间间隔可以通过 Time.milliseconds(x)，Time.seconds(x)，Time.minutes(x)等其中的一个来指定。

6.2.2 CountWindow

CountWindow 根据窗口中相同 key 元素的数量来触发执行，执行时只计算元素数量达到窗口大小的 key 对应的结果。
注意：CountWindow 的 window_size 指的是相同 Key 的元素的个数，不是输入的所有元素的总数。
1 滚动窗口
默认的 CountWindow 是一个滚动窗口，只需要指定窗口大小即可，当相同key元素元素数量达到窗口大小时，就会触发窗口的执行。

object Windows {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = env.socketTextStream("linux01", 9999)
    val countStream: DataStream[(String, Int)] = dataStream.map(r => (r, 1)).keyBy(0).countWindow(5).sum(1)
    countStream.print()
    env.execute("Windows is runned")
  }
}

2 滑动窗口
滑动窗口和滚动窗口的函数名是完全一致的，只是在传参数时需要传入两个参数，一个是 window_size，一个是 sliding_size。
下面代码中的 sliding_size 设置为了 2，也就是说，每收到两个相同 key 的数据就计算一次，每一次计算的 window 范围是 5 个元素。

object Windows {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = env.socketTextStream("linux01", 9999)
    val countStream: DataStream[(String, Int)] = dataStream.map(r => (r, 1)).keyBy(0).countWindow(5,2).sum(1)
    countStream.print()
    env.execute("Windows is runned")
  }
}

有状态：当前窗口的数据和之前的数据要做累加、整合、运算
无状态：每次只统计自己窗口中的数据

6.2.3 window function

window function 定义了要对窗口中收集的数据做的计算操作，主要可以分为两类：

增量聚合函数（incremental aggregation functions）
每条数据到来就进行计算，保持一个简单的状态。典型的增量聚合函数有
ReduceFunction, AggregateFunction。

object Windows {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = env.socketTextStream("linux01", 9999)
    dataStream.map(r => (r, 1))
      .keyBy(_._1)
      .timeWindow(Time.seconds(3), Time.seconds(3))
        .reduce(new ReduceFunction[(String, Int)] {
          override def reduce(t: (String, Int), t1: (String, Int)): (String, Int) = {
            return (t._1,t._2+t1._2)
          }
        }).print()

    env.execute("Windows is runned")
  }
}

全窗口函数（full window functions）
先把窗口所有数据收集起来，等到计算的时候会遍历所有数据。ProcessWindowFunction 就是一个全窗口函数。

object Windows {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = env.socketTextStream("linux01", 9999)
    dataStream.map(r => (r, 1))
      .keyBy(_._1)
      .timeWindow(Time.seconds(3), Time.seconds(3))
        .process(new ProcessWindowFunction[(String, Int), (String, Int), String, TimeWindow] {
          override def process(key: String, context: Context, elements: Iterable[(String, Int)], out: Collector[(String, Int)]): Unit = {
            var sum =0
            elements.foreach(kv=>{
              sum += kv._2
            })
            out.collect(key,sum)
          }
        }).print()
    env.execute("Windows is runned")
  }
}

6.2.4 其它可选 API

trigger() —— 触发器定义 window 什么时候关闭，触发计算并输出结果
evitor() —— 移除器定义移除某些数据的逻辑
allowedLateness() —— 允许处理迟到的数据
sideOutputLateData() —— 将迟到的数据放入侧输出流
getSideOutput() —— 获取侧输出流

第七章时间语义与 Wartermark

7.1 Flink 中的时间语义

在 Flink 的流式处理中，会涉及到时间的不同概念，如下图所示：
在这里插入图片描述
EventTime：
是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每一条日志都会记录自己的生成时间，Flink 通过时间戳分配器访问事件时间戳。例如：点击网站上的某个链接的时间

env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

IngestionTime：
某个Flink节点的source operator接收到数据的时间，例如：某个source消费到kafka中的数据

env.setStreamTimeCharacteristic(TimeCharacteristic.IngestionTime)

ProcessingTime：
是每一个执行基于时间操作的算子的本地系统时间，与机器相关，默认的时间属性就是 Processing Time。例如：timeWindow接收到数据的时间
env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime)

7.2 EventTime 的引入

在 Flink 的流式处理中，绝大部分的业务都会使用 eventTime，一般只在eventTime 无法使用时，才会被迫使用 ProcessingTime 或者 IngestionTime。
如果要使用 EventTime，那么需要引入 EventTime 的时间属性，引入方式如下所示：

val env = StreamExecutionEnvironment.getExecutionEnvironment
// 从调用时刻开始给 env 创建的每一个 stream 追加时间特征
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

7.3 Watermark

7.3.1 基本概念

我们知道，流处理从事件产生，到流经 source，再到 operator，中间是有一个过程和时间的，虽然大部分情况下，流到 operator 的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络、分布式等原因，导致乱序的产生，所谓乱序，就是指 Flink 接收到的事件的先后顺序不是严格按照事件的 Event Time 顺序排列的。
在这里插入图片描述
那么此时出现一个问题，一旦出现乱序，如果只根据 eventTime 决定 window 的运行，我们不能明确数据是否全部到位，但又不能无限期的等下去，此时必须要有个机制来保证一个特定的时间后，必须触发 window 去进行计算了，这个特别的机制，就是 Watermark。
Watermark 是一种衡量 Event Time 进展的机制。
Watermark 是用于处理乱序事件的，而正确的处理乱序事件，通常用Watermark 机制结合 window 来实现。
数据流中的 Watermark 用于表示 timestamp 小于 Watermark 的数据，都已经到达了，因此，window 的执行也是由 Watermark 触发的。
Watermark 可以理解成一个延迟触发机制，我们可以设置 Watermark 的延时时长 t，每次系统会校验已经到达的数据中最大的 maxEventTime，然后认定 eventTime小于 maxEventTime - t 的所有数据都已经到达，如果有窗口的停止时间等于maxEventTime – t，那么这个窗口被触发执行。
有序流的 Watermarker 如下图所示：（Watermark 设置为 0）
在这里插入图片描述
乱序流的 Watermarker 如下图所示：（Watermark 设置为 2）

当 Flink 接收到数据时，会按照一定的规则去生成 Watermark，这条 Watermark就等于当前所有到达数据中的 maxEventTime - 延迟时长，也就是说，Watermark 是由数据携带的，一旦数据携带的 Watermark 比当前未触发的窗口的停止时间要晚，那么就会触发相应窗口的执行。由于 Watermark 是由数据携带的，因此，如果运行过程中无法获取新的数据，那么没有被触发的窗口将永远都不被触发。

上图中，我们设置的允许最大延迟到达时间为 2s，所以时间戳为 7s 的事件对应的 Watermark 是 5s，时间戳为 12s 的事件的 Watermark 是 10s，如果我们的窗口 1 是 1s~5s，窗口 2 是 6s~10s，那么时间戳为 7s 的事件到达时的 Watermarker 恰好触发窗口 1，时间戳为 12s 的事件到达时的 Watermark 恰好触发窗口 2。

Watermark 就是触发前一窗口的“关窗时间”，一旦触发关门那么以当前时刻为准在窗口范围内的所有所有数据都会收入窗中。

只要没有达到水位那么不管现实中的时间推进了多久都不会触发关窗。

解决乱序的一种机制，没到来的，我就等等你，直到设定的时间

7.3.2 Watermark 的引入

watermark 的引入很简单，对于乱序数据，最常见的引用方式如下：

//分配 Timestamp 时间戳和Watermarks 水位线
dataStream.assignTimestampsAndWatermarks(
//BoundedOutOfOrdernessTimestampExtractor 有界无序数据时间戳提取器
//(Time.millisecond s(1000) 就是要等待延迟的时间
 new BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.milliseconds(1000)) {
      //提取时间戳的方法 从传入的数据中提起时间戳
      override def extractTimestamp(element: SensorReading): Long = {
        element.timestamp * 1000//时间戳单位是毫秒
     }
  }
)

element.timestamp使用element中的timestamp 字段做时间戳

Event Time 的使用一定要指定数据源中的时间戳。否则程序无法知道事件的事件时间是什么(数据源里的数据没有时间戳的话，就只能使用 Processing Time 了)。
我们看到上面的例子中创建了一个看起来有点复杂的类，这个类实现的其实就是分配时间戳的接口。Flink 暴露了 TimestampAssigner 接口供我们实现，使我们可以自定义如何从事件数据中抽取时间戳。

val env = StreamExecutionEnvironment.getExecutionEnvironment
// 从调用时刻开始给 env 创建的每一个 stream 追加时间特性
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
val readings: DataStream[SensorReading] = env
.addSource(new SensorSource) .assignTimestampsAndWatermarks(new MyAssigner())

MyAssigner 有两种类型
AssignerWithPeriodicWatermarks 周期性生成
AssignerWithPunctuatedWatermarks 间断式地生成
以上两个接口都继承自 TimestampAssigner。

Assigner with periodic watermarks
周期性的生成 watermark：系统会周期性的将 watermark 插入到流中(水位线也是一种特殊的事件!)。默认周期是 200 毫秒。可以使用

ExecutionConfig.setAutoWatermarkInterval()方法进行设置。
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCha
racteristic.EventTime)
// 每隔 5 秒产生一个 watermark
env.getConfig.setAutoWatermarkInterval(5000)

产生 watermark 的逻辑：每隔 5 秒钟，Flink 会调AssignerWithPeriodicWatermarks 的 getCurrentWatermark()方法。如果方法返回一个时间戳大于之前水位的时间戳，新的 watermark 会被插入到流中。这个检查保证了水位线是单调递增的。如果方法返回的时间戳小于等于之前水位的时间戳，则不会产生新的 watermark。

例子，自定义一个周期性的时间戳抽取：

class PeriodicAssigner extends
AssignerWithPeriodicWatermarks[SensorReading] {
val bound: Long = 60 * 1000 // 延时为 1 分钟
var maxTs: Long = Long.MinValue // 观察到的最大时间戳
override def getCurrentWatermark: Watermark = {
new Watermark(maxTs - bound) }
override def extractTimestamp(r: SensorReading, previousTS: Long) = {
maxTs = maxTs.max(r.timestamp) r.timestamp
} }

一种简单的特殊情况是，如果我们事先得知数据流的时间戳是单调递增的，也就是说没有乱序，那我们可以使用 assignAscendingTimestamps，这个方法会直接使用数据的时间戳生成 watermark。

val stream: DataStream[SensorReading] = ...
val withTimestampsAndWatermarks = stream
.assignAscendingTimestamps(e => e.timestamp)
>> result: E(1), W(1), E(2), W(2), ...

而对于乱序数据流，如果我们能大致估算出数据流中的事件的最大延迟时间，就可以使用如下代码：

val stream: DataStream[SensorReading] = ...
val withTimestampsAndWatermarks = stream.assignTimestampsAndWatermarks(
new SensorTimeAssigner
)
class SensorTimeAssigner extends
BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.seconds(5)) {
// 抽取时间戳
override def extractTimestamp(r: SensorReading): Long = r.timestamp
}
>> relust: E(10), W(0), E(8), E(7), E(11), W(1), ...

Assigner with punctuated watermarks
间断式地生成 watermark。和周期性生成的方式不同，这种方式不是固定时间的，而是可以根据需要对每条数据进行筛选和处理。直接上代码来举个例子，我们只给sensor_1 的传感器的数据流插入 watermark：

class PunctuatedAssigner extends
AssignerWithPunctuatedWatermarks[SensorReading] {
val bound: Long = 60 * 1000
override def checkAndGetNextWatermark(r: SensorReading, extractedTS:
Long): Watermark = {
if (r.id == "sensor_1") {
new Watermark(extractedTS - bound) } else {
null
} }
override def extractTimestamp(r: SensorReading, previousTS: Long): Long
= { r.timestamp
} }

7.4 EvnetTime 在 window 中的使用

窗口	代码
滚动	.window(TumblingEventTimeWindows.of(Time.seconds(5)))
滑动	.window(SlidingEventTimeWindows.of(Time.seconds(10),Time.seconds(5)))
回话	.window(EventTimeSessionWindows.withGap(Time.seconds(5)))

7.4.1 滚动窗口（TumblingEventTimeWindows）

def main(args: Array[String]): Unit = {
 // 环境
 val env: StreamExecutionEnvironment = 
StreamExecutionEnvironment.getExecutionEnvironment
 env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
 env.setParallelism(1)
 val dstream: DataStream[String] = env.socketTextStream("localhost",7777)
 val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map
{ text =>
 val arr: Array[String] = text.split(" ")
 (arr(0), arr(1).toLong, 1)
 }
 val textWithEventTimeDstream: DataStream[(String, Long, Int)] = 
textWithTsDstream.assignTimestampsAndWatermarks(new 
BoundedOutOfOrdernessTimestampExtractor[(String, Long,
Int)](Time.milliseconds(1000)) {
 override def extractTimestamp(element: (String, Long, Int)): Long = {
 return element._2
 }
 })
 val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = 
textWithEventTimeDstream.keyBy(0)
 textKeyStream.print("textkey:")
 val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] 
= textKeyStream.window(TumblingEventTimeWindows.of(Time.seconds(2)))
 val groupDstream: DataStream[mutable.HashSet[Long]] = 
windowStream.fold(new mutable.HashSet[Long]()) { case (set, (key, ts, count)) 
=>
 set += ts
 }
 groupDstream.print("window::::").setParallelism(1)
env.execute()
 } }

结果是按照 Event Time 的时间窗口计算得出的，而无关系统的时间（包括输入的快慢）。

7.4.2 滑动窗口（SlidingEventTimeWindows）

def main(args: Array[String]): Unit = {
 // 环境
 val env: StreamExecutionEnvironment = 
StreamExecutionEnvironment.getExecutionEnvironment
 env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
 env.setParallelism(1)
 val dstream: DataStream[String] = env.socketTextStream("localhost",7777)
 val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map { text 
=>
 val arr: Array[String] = text.split(" ")
 (arr(0), arr(1).toLong, 1)
 }
 val textWithEventTimeDstream: DataStream[(String, Long, Int)] = 
textWithTsDstream.assignTimestampsAndWatermarks(new 
BoundedOutOfOrdernessTimestampExtractor[(String, Long, 
Int)](Time.milliseconds(1000)) {
 override def extractTimestamp(element: (String, Long, Int)): Long = {return element._2
 }
 })
 val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = 
textWithEventTimeDstream.keyBy(0)
 textKeyStream.print("textkey:")
 val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] = 
textKeyStream.window(SlidingEventTimeWindows.of(Time.seconds(2),Time.millis
econds(500)))
 val groupDstream: DataStream[mutable.HashSet[Long]] = windowStream.fold(new 
mutable.HashSet[Long]()) { case (set, (key, ts, count)) =>
 set += ts
 }
 groupDstream.print("window::::").setParallelism(1)
 env.execute()
}

7.4.3 会话窗口（EventTimeSessionWindows）

相邻两次数据的 EventTime 的时间差超过指定的时间间隔就会触发执行。如果加入 Watermark，会在符合窗口触发的情况下进行延迟。到达延迟水位再进行窗口触发。

def main(args: Array[String]): Unit = {
 // 环境
 val env: StreamExecutionEnvironment = 
StreamExecutionEnvironment.getExecutionEnvironment
 env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
 env.setParallelism(1)
 val dstream: DataStream[String] = env.socketTextStream("localhost",7777)
 val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map { text 
=>
 val arr: Array[String] = text.split(" ")
 (arr(0), arr(1).toLong, 1)
 }
 val textWithEventTimeDstream: DataStream[(String, Long, Int)] = 
textWithTsDstream.assignTimestampsAndWatermarks(new 
BoundedOutOfOrdernessTimestampExtractor[(String, Long, 
Int)](Time.milliseconds(1000)) {
 override def extractTimestamp(element: (String, Long, Int)): Long = {
 return element._2
 }
 })
 val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = 
textWithEventTimeDstream.keyBy(0)
 textKeyStream.print("textkey:")
 val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] 
=textKeyStream.window(EventTimeSessionWindows.withGap(Time.milliseconds(500)
) )
 windowStream.reduce((text1,text2)=>
 ( text1._1,0L,text1._3+text2._3)
 ) .map(_._3).print("windows:::").setParallelism(1)
 env.execute()
 }

❤ღ( ´･ᴗ･` )比心

未完结，一定敲敲敲着去理解，下篇继续更新大数据其他内容，谢谢观看

dCHENz

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
大数据技术之flink（3）

文章目录前言❤ღ( ´･ᴗ･` )比心前言你们好我是啊晨今儿更新spark 技术Spark Streaming。废话不多说，内容很多选择阅读，详细。请：第六章Flink 中的 Window6.1 Window6.1.1 Window 概述streaming 流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而 window 是...
复制链接

扫一扫