Flink中的Windows

最新推荐文章于 2024-09-17 16:07:35 发布

王小工

最新推荐文章于 2024-09-17 16:07:35 发布

阅读量1.1k

点赞数 30

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

本文链接：https://blog.csdn.net/mqiqe/article/details/138941499

版权

大数据同时被 2 个专栏收录

49 篇文章 0 订阅

订阅专栏

Flink

46 篇文章 0 订阅

订阅专栏

简述

在Apache Flink中，Windows（窗口）是一个核心概念，特别是在处理流式数据时。Windows是一种将无限的数据流切割为有限的数据块（即窗口）以进行处理的手段。这在处理无限数据集时特别有用，因为无限数据集是不断增长的，无法直接对整个数据集进行操作。
Flink中的Windows主要可以分为两种类型：

1、Time Window（时间窗口）

时间窗口是按照时间生成的窗口。它基于时间边界来定义窗口的开始和结束。例如，你可以定义一个每5分钟一个的时间窗口，这样每过5分钟，就会有一个新的窗口被创建并处理。
Flink支持多种时间窗口类型，包括滚动窗口（Tumbling Windows）、滑动窗口（Sliding Windows）等。

2、Count Window（计数窗口）

计数窗口是按照指定的数据条数生成一个窗口，与时间无关。例如，你可以定义一个每100条数据一个的计数窗口，当数据流中到达100条数据时，就会创建一个新的窗口并处理。

除了窗口类型，Flink还提供了与窗口相关的其他组件和概念，如：

Assigner（分配器）：用于决定一个元素应该属于哪个窗口。
Trigger（触发器）：用于决定何时触发窗口的计算。
Function（函数）：在窗口上执行的计算逻辑。
Evictor（驱逐器）：在窗口函数执行前后，可以执行一些额外的数据处理工作，但并不常用。

Flink中的时间概念也与Windows紧密相关，包括：

Event Time：事件创建的时间，通常由事件中的时间戳描述。
Ingestion Time：事件进入Flink系统的时间。
Processing Time：事件被Flink算子处理时的时间。

在Flink的流式处理中，Windows是实现从流处理到批处理转变的重要桥梁。通过将无限的数据流切割为有限的窗口，我们可以对每个窗口内的数据进行聚合、转换或其他操作，从而得到有价值的结果。

窗口机制

Flink的窗口机制是一种对流处理框架中无限流数据流进行分组和聚合的重要机制。它允许用户将无限流数据流切分为有限的、连续的数据块（即窗口）进行处理。以下是Flink窗口机制的主要组成部分和原理：

窗口分配：
- Flink提供了多种窗口分配策略，如滚动窗口（Tumbling Windows）、滑动窗口（Sliding Windows）、会话窗口（Session Windows）等。
- 窗口分配策略根据时间、数量或其他条件对数据流进行切分，将数据分配到不同的窗口中进行处理。
- 在窗口分配过程中，Flink会根据设置的窗口大小和滑动步长（对于滑动窗口）等参数，将数据流中的元素分配到对应的窗口中。
窗口计算：
- 窗口计算是指在每个窗口内对数据进行聚合、计算或其他操作。
- Flink通过窗口函数（如ReduceFunction、AggregateFunction等）对每个窗口内的数据进行处理。
- 聚合操作可以是简单的求和、求平均等，也可以是更复杂的业务逻辑。
窗口输出：
- Flink提供了多种输出方式，如将计算结果发送到消息队列、存储到数据库或直接返回给调用方。
- 在每个窗口计算完成后，Flink会将结果按照设定的输出方式进行输出。
窗口原理的核心：
- 窗口原理的核心是窗口分配和窗口计算两个过程。
- 在这两个过程中，Flink通过灵活的窗口函数和窗口策略，可以实现各种窗口计算场景，如实时统计、滚动平均等。
使用场景：
- Flink的窗口机制可以用于实时计算和流式处理场景，如实时统计、实时推荐、实时报警等。
- 例如，可以使用Flink的窗口操作计算每分钟的用户访问量、每小时的销售额等实时指标。
优势：
- Flink的窗口机制支持高吞吐、低延迟、高性能的流式数据处理。
- Flink支持基于事件时间（Event Time）的窗口计算，这有助于保持事件原本产生时的时序性，避免网络传输或硬件系统的影响。

样例

Time Windows

Time Windows（时间窗口）是一种基于时间对数据流进行切分和处理的窗口类型。这些窗口通常用于对流数据进行时间范围的聚合操作，如计算一段时间内的平均值、总和或计数等。

滚动窗口

滚动窗口有固定的时间大小，并且每个窗口是互不重叠的。当时间前进到下一个窗口的起始时间时，就会创建一个新的窗口，并且开始处理该窗口内的数据。例如，一个5分钟的滚动窗口会每5分钟创建一个新的窗口，并且每个窗口都是独立的，不包含前一个或后一个窗口的数据。

import org.apache.flink.api.common.functions.MapFunction;  
import org.apache.flink.api.java.tuple.Tuple2;  
import org.apache.flink.streaming.api.datastream.DataStream;  
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;  
import org.apache.flink.streaming.api.functions.windowing.AllWindowFunction;  
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;  
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;  
import org.apache.flink.streaming.api.windowing.time.Time;  
import org.apache.flink.util.Collector;  
 
// 假设的Event类  
public class Event {  
   public long timestamp;  
   public String value;  
 
   // 构造函数、getter和setter省略...  
}  
 
public class FlinkTumblingWindowDemo {  
 
   public static void main(String[] args) throws Exception {  
       // 设置执行环境  
       final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();  
 
       // 创建一些模拟数据  
       DataStream<Event> eventStream = env.fromElements(  
               new Event(1609459200L, "event1"), // 2021-01-01 00:00:00  
               new Event(1609459210L, "event2"),  
               new Event(1609459220L, "event3"),  
               new Event(1609459260L, "event4"),  
               // ...更多事件  
               new Event(1609462800L, "eventN") // 2021-01-01 01:00:00  
       );  
 
       // 分配时间戳和水印（这里简化为直接使用时间戳作为事件时间）  
       eventStream = eventStream.assignTimestampsAndWatermarks(  
           (event, timestamp) -> event.timestamp  
       );  
 
       // 使用滚动事件时间窗口，每5分钟一个窗口  
       DataStream<Tuple2<Long, Integer>> windowCounts = eventStream  
           .keyBy(event -> 1) // 假设我们想要全局计数，因此keyBy一个常量  
           .timeWindow(TumblingEventTimeWindows.of(Time.minutes(5)))  
           .apply(new AllWindowFunction<Event, Tuple2<Long, Integer>, TimeWindow>() {  
               @Override  
               public void apply(TimeWindow window, Iterable<Event> input, Collector<Tuple2<Long, Integer>> out) {  
                   int count = 0;  
                   for (Event event : input) {  
                       count++;  
                   }  
                   out.collect(new Tuple2<>(window.getStart(), count));  
               }  
           });  
 
       // 打印结果  
       windowCounts.print();  
 
       // 执行任务  
       env.execute("Flink Tumbling Window Demo");  
   }  
 
   // 省略了Event类的实现细节  
}

在上面的示例中，首先创建了一个StreamExecutionEnvironment，然后生成了一个包含Event对象的数据流。使用assignTimestampsAndWatermarks方法来为事件分配时间戳和水印，这里简单地假设事件的时间戳就是其timestamp字段的值。
然后，使用了timeWindow方法来定义了一个基于事件时间的滚动窗口，窗口大小为5分钟。keyBy(event -> 1)是一个简单的全局key，因为想要计算全局的计数，而不是基于某个特定键的分组计数。
最后，定义了一个AllWindowFunction来处理每个窗口中的事件。在这个函数中，简单地计算了每个窗口中的事件数量，并将窗口的开始时间和事件数量作为Tuple2<Long, Integer>输出。
请注意，在实际应用中，可能需要根据数据源和具体需求来调整时间戳分配、水印生成和窗口函数的逻辑。此外，Flink还提供了许多其他窗口函数和操作符，用于更复杂的窗口化操作。

滑动窗口

滑动窗口也有固定的时间大小，但与滚动窗口不同的是，滑动窗口有一个滑动间隔（通常小于窗口大小）。这意味着滑动窗口会定期向前滑动，并且每个窗口可能包含前一个窗口的部分数据。例如，一个5分钟的滑动窗口，每1分钟滑动一次，将会覆盖从当前时间开始的5分钟内的数据，并在每1分钟时向前滑动。

首先，定义一个Event类，该类包含一个时间戳和一个值：

public class Event {  
    public long timestamp;  
    public String value;  
  
    // 构造函数、getter和setter省略...  
  
    @Override  
    public String toString() {  
        return "Event{" +  
                "timestamp=" + timestamp +  
                ", value='" + value + '\'' +  
                '}';  
    }  
}

然后，编写一个Flink程序来使用滑动时间窗口：

import org.apache.flink.api.common.functions.MapFunction;  
import org.apache.flink.streaming.api.datastream.DataStream;  
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;  
import org.apache.flink.streaming.api.functions.windowing.AllWindowFunction;  
import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows;  
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;  
  
public class FlinkSlidingWindowDemo {  
  
    public static void main(String[] args) throws Exception {  
        // 设置执行环境  
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();  
  
        // 创建一些模拟数据  
        DataStream<Event> eventStream = env.fromElements(  
                new Event(1609459200L, "event1"), // 2021-01-01 00:00:00  
                new Event(1609459210L, "event2"),  
                new Event(1609459220L, "event3"),  
                // ... 更多事件  
                new Event(1609459260L, "event4"),  
                new Event(1609459270L, "event5"),  
                new Event(1609459280L, "event6")  
        );  
  
        // 分配时间戳和水印（这里简化为直接使用时间戳作为事件时间）  
        eventStream = eventStream.assignTimestampsAndWatermarks(  
            (event, timestamp) -> event.timestamp  
        );  
  
        // 使用滑动事件时间窗口，窗口大小为30秒，每10秒滑动一次  
        DataStream<String> windowCounts = eventStream  
            .keyBy(event -> 1) // 假设我们想要全局计数，因此keyBy一个常量  
            .timeWindow(SlidingEventTimeWindows.of(Time.seconds(30), Time.seconds(10)))  
            .apply(new AllWindowFunction<Event, String, TimeWindow>() {  
                @Override  
                public void apply(TimeWindow window, Iterable<Event> input, Collector<String> out) {  
                    int count = 0;  
                    for (Event event : input) {  
                        count++;  
                    }  
                    out.collect("Window [" + window.getStart() + "," + window.getEnd() + "] has " + count + " events");  
                }  
            });  
  
        // 打印结果  
        windowCounts.print();  
  
        // 执行任务  
        env.execute("Flink Sliding Window Demo");  
    }  
  
    // 省略了Event类的实现细节  
}

在这个示例中，我们创建了一个包含一些模拟事件的DataStream。然后，我们为每个事件分配了一个时间戳（这里我们假设时间戳就是事件实际发生的时间），并使用assignTimestampsAndWatermarks方法设置了水印生成逻辑。
接下来，我们使用timeWindow方法定义了一个滑动事件时间窗口。窗口大小为30秒，并且每10秒向前滑动一次。我们使用keyBy(event -> 1)来创建一个全局的key，这样我们就可以得到所有事件的滑动窗口计数，而不是基于某个特定key的分组计数。
最后，我们定义了一个AllWindowFunction来处理每个窗口中的事件。在这个函数中，我们计算了每个窗口中的

Count Window

CountWindow 是一种基于事件数量的窗口类型，而不是基于时间的。当达到指定的元素数量时，窗口就会关闭并触发计算。不过，Flink 官方 API 中并没有直接提供名为 CountWindow 的特定窗口分配器，但可以使用 TumblingCountWindows（翻滚计数窗口）或自定义一个基于元素计数的窗口。

以下是使用 TumblingCountWindows，它会在每个元素数量达到指定的阈值时创建一个新的窗口。以下是一个使用 TumblingCountWindows 的示例：

import org.apache.flink.api.common.functions.MapFunction;  
import org.apache.flink.streaming.api.datastream.DataStream;  
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;  
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;  
import org.apache.flink.streaming.api.windowing.assigners.TumblingCountWindows;  
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;  
import org.apache.flink.util.Collector;  
  
public class FlinkCountWindowDemo {  
  
    public static void main(String[] args) throws Exception {  
        // 设置执行环境  
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();  
  
        // 创建一些模拟数据  
        DataStream<Integer> dataStream = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  
  
        // 使用翻滚计数窗口，每个窗口包含5个元素  
        DataStream<Integer> windowCounts = dataStream  
            .keyBy(value -> 1) // 假设我们想要全局计数，因此keyBy一个常量  
            .window(TumblingCountWindows.of(5)) // 每5个元素一个窗口  
            .apply(new WindowFunction<Integer, Integer, Integer, TumblingCountWindows>() {  
                @Override  
                public void apply(Integer key, TumblingCountWindows window, Iterable<Integer> input, Collector<Integer> out) throws Exception {  
                    int sum = 0;  
                    for (Integer value : input) {  
                        sum += value;  
                    }  
                    out.collect(sum); // 或者你可以计算元素的数量等  
                }  
            });  
  
        // 打印结果  
        windowCounts.print();  
  
        // 执行任务  
        env.execute("Flink Count Window Demo");  
    }  
}

在这个示例中，创建了一个包含整数的 DataStream，并使用 keyBy(value -> 1) 创建一个全局的 key，以便可以得到所有事件的翻滚计数窗口。定义了一个 WindowFunction 来处理每个窗口中的元素，并计算它们的和（虽然在这个例子中可能更关心元素的数量，但为了演示，计算了和）。
注意，如果想要实现一个真正的滑动计数窗口（即窗口大小固定但可以在未达到完整大小时就关闭并触发计算），可能需要自定义一个 WindowAssigner 和一个相应的 Trigger。这通常更复杂，并且需要深入理解 Flink 的窗口处理机制。

自定义 Window

如果想要实现自定义的窗口（Window），需要实现 WindowAssigner 接口。WindowAssigner 负责将元素分配给窗口，并且定义了窗口的边界。
下面是一个自定义窗口分配器（WindowAssigner）的示例，该分配器基于元素计数来定义窗口。这个示例演示了一个简单的翻滚计数窗口（类似于 TumblingCountWindows），可以根据需要扩展它以创建更复杂的窗口策略。

import org.apache.flink.streaming.api.windowing.assigners.WindowAssigner;  
import org.apache.flink.streaming.api.windowing.windows.Window;  
import org.apache.flink.util.Collector;  
  
import java.util.Collection;  
  
public class CustomCountWindowAssigner extends WindowAssigner<Object, CustomCountWindow> {  
  
    private final long size;  
  
    public CustomCountWindowAssigner(long size) {  
        this.size = size;  
    }  
  
    @Override  
    public Collection<CustomCountWindow> getWindows(Object element, long timestamp, WindowAssignerContext context) {  
        // 这里我们简单地返回一个包含单个窗口的集合  
        // 你可以根据需要返回多个窗口或动态计算窗口  
        return Collections.singletonList(new CustomCountWindow(context.getCurrentWindowCount() / size));  
    }  
  
    @Override  
    public boolean isEventTime() {  
        // 因为我们不使用时间戳来定义窗口，所以返回 false  
        return false;  
    }  
  
    @Override  
    public Trigger<Object, CustomCountWindow> getDefaultTrigger(StreamExecutionEnvironment env) {  
        // 你可以返回一个自定义的 Trigger，但在这个例子中我们使用默认的 CountTrigger  
        // Flink 为翻滚计数窗口提供了一个默认的 Trigger，它会在每个窗口的元素数量达到窗口大小时触发  
        return new CountTrigger<Object>(size);  
    }  
  
    @Override  
    public TypeSerializer<CustomCountWindow> getWindowSerializer(ExecutionConfig executionConfig) {  
        // 返回一个用于序列化窗口的序列化器  
        // 在这个例子中，我们需要自定义 CustomCountWindow 的序列化器  
        // 这里只是一个示例，你需要根据你的窗口类来实现序列化器  
        return null; // 示例中未实现  
    }  
  
    @Override  
    public boolean assignsToSubwindows() {  
        // 如果你的 WindowAssigner 会将元素分配给子窗口，返回 true  
        // 在这个例子中，我们直接分配到整个窗口，所以返回 false  
        return false;  
    }  
  
    // 自定义窗口类，用于表示基于计数的窗口  
    public static class CustomCountWindow extends Window {  
        private final long start;  
        private final long end;  
  
        public CustomCountWindow(long start) {  
            this.start = start * size;  
            this.end = (start + 1) * size;  
        }  
  
        @Override  
        public long maxTimestamp() {  
            return end - 1; // 窗口结束时间戳的前一个时间戳（包含）  
        }  
  
        // 其他方法，如 minTimestamp(), ... 可以根据需要实现  
  
        @Override  
        public String toString() {  
            return "CustomCountWindow{" +  
                    "start=" + start +  
                    ", end=" + end +  
                    '}';  
        }  
    }  
}

请注意，上面的 getWindowSerializer 方法需要返回一个 TypeSerializer 来序列化自定义窗口类 CustomCountWindow。由于这个示例是概念性的，没有包含实际的序列化器实现。在实际应用中，需要为你的窗口类实现一个 TypeSerializer。
此外，CustomCountWindow 类是一个简单的窗口表示，它包含开始和结束索引（基于元素计数）。可以根据需要添加更多的字段或方法。
最后，要在 Flink 作业中使用这个自定义窗口分配器，可以像下面这样使用它：

DataStream<...> windowedStream = inputStream  
    .keyBy(...) // 根据需要设置 key  
    .window(new CustomCountWindowAssigner(5)) // 使用自定义窗口分配器  
    .apply(...); // 应用窗口函数