Flink 三种时间窗口、窗口处理函数使用及案例

标签：Flink 窗口 flink streaming org apache import 处理函数

Flink 在数据处理过程中越来越常见，它在流处理领域提供了丰富的窗口机制来处理无界数据流，我们聊下三种时间窗口，包括时间窗口的概念、窗口处理函数的使用以及实际案例。

一、Flink 中的时间概念

在 Flink 中，有三种时间概念：

事件时间（Event Time）：是事件实际发生的时间，通常由事件中的时间戳表示。这是最符合实际情况的时间概念，但也需要处理数据乱序和延迟的情况。
处理时间（Processing Time）：是指数据在 Flink 算子中被处理的时间。处理时间是最简单的时间概念，不需要考虑数据的乱序和延迟，但可能会导致结果不准确。
摄入时间（Ingestion Time）：是数据进入 Flink 系统的时间。摄入时间介于事件时间和处理时间之间，它可以在一定程度上处理数据乱序，但也不能完全保证结果的准确性。

二、三种时间窗口

Flink 提供了三种主要的时间窗口：滚动窗口（Tumbling Windows）、滑动窗口（Sliding Windows）和会话窗口（Session Windows）。

1. 滚动窗口（Tumbling Windows）

滚动窗口是一种固定大小、不重叠的窗口。每个元素只属于一个窗口。

代码示例：

import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
public class TumblingWindowExample {
    public static void main(String[] args) throws Exception {
        // 创建流执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 创建一个简单的 DataStream
        DataStream<Integer> inputStream = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 应用滚动窗口，窗口大小为 3 秒
        DataStream<Integer> resultStream = inputStream
               .timeWindowAll(Time.seconds(3))
               .sum(0);
        // 打印结果
        resultStream.print();
        // 执行流程序
        env.execute();
    }
}

在上述代码中，我们创建了一个简单的整数数据流，并应用了滚动窗口，窗口大小为 3 秒。最后，我们对每个窗口中的元素求和并打印结果。

2. 滑动窗口（Sliding Windows）

滑动窗口是一种固定大小、可以重叠的窗口。每个元素可以属于多个窗口。

代码示例：

import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
public class SlidingWindowExample {
    public static void main(String[] args) throws Exception {
        // 创建流执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 创建一个简单的 DataStream
        DataStream<Integer> inputStream = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 应用滑动窗口，窗口大小为 5 秒，滑动步长为 2 秒
        DataStream<Integer> resultStream = inputStream
               .timeWindowAll(Time.seconds(5), Time.seconds(2))
               .sum(0);
        // 打印结果
        resultStream.print();
        // 执行流程序
        env.execute();
    }
}

在上述代码中，我们创建了一个整数数据流，并应用了滑动窗口，窗口大小为 5 秒，滑动步长为 2 秒。这意味着每 2 秒就会有一个新的窗口生成，并且每个窗口包含最近 5 秒内的数据。最后，我们对每个窗口中的元素求和并打印结果。

3. 会话窗口（Session Windows）

会话窗口是一种根据活动间隙划分的窗口。当一段时间内没有数据到达时，会话窗口会关闭。

代码示例：

import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.GlobalWindow;
import org.apache.flink.streaming.api.windowing.windows.SessionWindow;
public class SessionWindowExample {
    public static void main(String[] args) throws Exception {
        // 创建流执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 创建一个简单的 DataStream
        DataStream<Integer> inputStream = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 应用会话窗口，间隙时间为 3 秒
        DataStream<Integer> resultStream = inputStream
               .windowAll(SessionWindows.withGap(Time.seconds(3)))
               .sum(0);
        // 打印结果
        resultStream.print();
        // 执行流程序
        env.execute();
    }
}

在上述代码中，我们创建了一个整数数据流，并应用了会话窗口，间隙时间为 3 秒。这意味着当连续数据之间的时间间隔超过 3 秒时，一个新的会话窗口会开始。最后，我们对每个窗口中的元素求和并打印结果。

三、窗口处理函数

Flink 提供了多种窗口处理函数，用于对窗口中的数据进行计算。以下是一些常见的窗口处理函数：

1. 增量聚合函数（Incremental Aggregation Functions）

增量聚合函数可以在窗口中逐个处理元素，并在处理过程中维护一个中间结果。常见的增量聚合函数有 sum、min、max 和 count 等。

代码示例：

import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
public class IncrementalAggregationExample {
    public static void main(String[] args) throws Exception {
        // 创建流执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 创建一个简单的 DataStream
        DataStream<Integer> inputStream = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 应用滚动窗口，窗口大小为 3 秒，并使用增量聚合函数求和
        DataStream<Integer> resultStream = inputStream
               .timeWindowAll(Time.seconds(3))
               .sum(0);
        // 打印结果
        resultStream.print();
        // 执行流程序
        env.execute();
    }
}

在上述代码中，我们使用了 sum 作为增量聚合函数，对每个滚动窗口中的元素求和。

2. 全窗口函数（Full Window Functions）

全窗口函数在窗口关闭时对窗口中的所有元素进行计算。常见的全窗口函数有 reduce、aggregate 和 apply 等。

代码示例：

import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
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;
import java.util.Arrays;
public class FullWindowFunctionExample {
    public static void main(String[] args) throws Exception {
        // 创建流执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 创建一个简单的 DataStream
        DataStream<Integer> inputStream = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 应用滚动窗口，窗口大小为 3 秒，并使用全窗口函数求平均值
        DataStream<Double> resultStream = inputStream
               .timeWindowAll(TumblingProcessingTimeWindows.of(Time.seconds(3)))
               .apply(new AverageWindowFunction());
        // 打印结果
        resultStream.print();
        // 执行流程序
        env.execute();
    }
    // 自定义全窗口函数，用于求平均值
    public static class AverageWindowFunction implements org.apache.flink.streaming.api.functions.windowing.AllWindowFunction<Integer, Double, TimeWindow> {
        @Override
        public void apply(TimeWindow window, Iterable<Integer> values, Collector<Double> out) throws Exception {
            int sum = 0;
            int count = 0;
            for (Integer value : values) {
                sum += value;
                count++;
            }
            out.collect((double) sum / count);
        }
    }
}

在上述代码中，我们自定义了一个全窗口函数 AverageWindowFunction，用于在滚动窗口关闭时计算窗口中元素的平均值。

四、案例分析

假设我们有一个电商网站的用户行为数据流，其中每个事件包含用户 ID、商品 ID 和事件时间戳。我们想要分析用户在一段时间内的购买行为，例如计算每个用户在每小时内的购买总额。

代码示例：

import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
public class EcommerceAnalyticsExample {
    public static void main(String[] args) throws Exception {
        // 创建流执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 创建一个模拟的用户行为数据流
        DataStream<UserAction> inputStream = env.fromElements(
                new UserAction("user1", "product1", 1000L),
                new UserAction("user1", "product2", 1005L),
                new UserAction("user2", "product3", 1010L),
                new UserAction("user1", "product4", 1020L),
                new UserAction("user2", "product5", 1030L),
                new UserAction("user1", "product6", 1040L),
                new UserAction("user2", "product7", 1050L),
                new UserAction("user1", "product8", 1060L),
                new UserAction("user2", "product9", 1070L),
                new UserAction("user1", "product10", 1080L)
        );
        // 应用滚动窗口，窗口大小为 1 小时，并按用户 ID 分组，计算每个用户在每小时内的购买总额
        DataStream<Tuple2<String, Double>> resultStream = inputStream
               .keyBy(UserAction::getUserId)
               .timeWindow(Time.hours(1))
               .sum("price")
               .map(userActionPriceSum -> new Tuple2<>(userActionPriceSum.f0, userActionPriceSum.f1));
        // 打印结果
        resultStream.print();
        // 执行流程序
        env.execute();
    }
    // 自定义用户行为类
    public static class UserAction {
        private String userId;
        private String productId;
        private double price;
        private long eventTimestamp;
        public UserAction(String userId, String productId, long eventTimestamp) {
            this.userId = userId;
            this.productId = productId;
            this.price = 10.0; // 假设每个商品的价格为 10 元
            this.eventTimestamp = eventTimestamp;
        }
        public String getUserId() {
            return userId;
        }
        public String getProductId() {
            return productId;
        }
        public double getPrice() {
            return price;
        }
        public long getEventTimestamp() {
            return eventTimestamp;
        }
    }
}

在上述代码中，我们首先创建了一个模拟的用户行为数据流，其中每个事件包含用户 ID、商品 ID 和事件时间戳。然后，我们应用滚动窗口，窗口大小为 1 小时，并按用户 ID 分组。最后，我们对每个窗口中的元素求和，计算每个用户在每小时内的购买总额，并打印结果。

五、总结

Flink 的窗口机制是处理无界数据流的强大工具。通过三种时间窗口（滚动窗口、滑动窗口和会话窗口）和丰富的窗口处理函数，我们可以灵活地对数据流进行各种分析和计算。在实际应用中，我们需要根据具体的业务需求选择合适的时间窗口和窗口处理函数，以获得准确的结果。同时，我们还需要考虑数据的乱序和延迟等问题，合理地设置时间戳提取器和水印生成器，以确保流处理的准确性和可靠性。

标签：Flink,窗口,flink,streaming,org,apache,import,处理函数
From： https://www.cnblogs.com/skonw/p/18640766

Flink 三种时间窗口、窗口处理函数使用及案例

一、Flink 中的时间概念

二、三种时间窗口

1. 滚动窗口（Tumbling Windows）

2. 滑动窗口（Sliding Windows）

3. 会话窗口（Session Windows）

三、窗口处理函数

1. 增量聚合函数（Incremental Aggregation Functions）

2. 全窗口函数（Full Window Functions）

四、案例分析

五、总结

相关文章

赞助商

阅读排行