flink processwindowfunction_Flink处理函数实战之三：窗口处理

本文是《Flink处理函数实战》系列的第三篇，内容是学习以下两个窗口相关的处理函数：

1. ProcessAllWindowFunction：处理每个窗口内的所有元素；
2. ProcessWindowFunction：处理指定key的每个窗口内的所有元素；

前文链接

1. 《深入了解ProcessFunction的状态操作(Flink-1.10)》
2. 《Flink处理函数实战之一：ProcessFunction类》
3. 《Flink处理函数实战之二：KeyedProcessFunction类》

关于ProcessAllWindowFunction

• ProcessAllWindowFunction和《Flink处理函数实战之一：ProcessFunction类》中的ProcessFunction类相似，都是用来对上游过来的元素做处理，不过ProcessFunction是每个元素执行一次processElement方法，ProcessAllWindowFunction是每个窗口执行一次process方法(方法内可以遍历该窗口内的所有元素)；
• 用类图对比可以更形象的认识差别，下图左侧是ProcessFunction，右侧是ProcessAllWindowFunction：

关于ProcessWindowFunction

ProcessWindowFunction和KeyedProcessFunction类似， 都是处理分区的数据，不过KeyedProcessFunction是每个元素执行一次processElement方法，而ProcessWindowFunction是每个窗口执行一次process方法(方法内可以遍历该key当前窗口内的所有元素)；用类图对比可以更形象的认识差别，下图左侧是KeyedProcessFunction，右侧是ProcessWindowFunction：

• 另外还一个差异：ProcessWindowFunction.process方法的入参就有分区的key值，而KeyedProcessFunction.processElement方法的入参没有这个参数，而是需要Context.getCurrentKey()才能取到分区的key值；

注意事项：

窗口处理函数的process方法，以ProcessAllWindowFunction为例，如下图红框所示，其入参可以遍历当前窗口内的所有元素，这意味着当前窗口的所有元素都保存在堆内存中，所以请在设计阶段就严格控制窗口内元素的内存使用量，避免耗尽TaskManager节点的堆内存：

接下来通过实战学习ProcessAllWindowFunction和ProcessWindowFunction；

版本信息

1. 开发环境操作系统：MacBook Pro 13寸， macOS Catalina 10.15.4
2. 开发工具：IntelliJ IDEA 2019.3.2 (Ultimate Edition)
3. JDK：1.8.0_121
4. Maven：3.3.9
5. Flink：1.9.2

源码下载

如果您不想写代码，整个系列的源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：

这个git项目中有多个文件夹，本章的应用在flinkstudy文件夹下，如下图红框所示：

如何实战ProcessAllWindowFunction

接下来通过以下方式验证ProcessAllWindowFunction功能：

1. 每隔1秒发出一个Tuple2对象，对象的f0字段在aaa和bbb之间变化，f1字段固定为1；
2. 设置5秒的滚动窗口；
3. 自定义ProcessAllWindowFunction扩展类，功能是统计每个窗口内元素的数量，将统计结果发给下游算子；
4. 下游算子将统计结果打印出来；
5. 核对发出的数据和统计信息，看是否一致；

开始编码

• 继续使用《Flink处理函数实战之一：ProcessFunction类》一文中创建的工程flinkstudy；
• 新建ProcessAllWindowFunctionDemo类，如下：

package com.bolingcavalry.processwindowfunction;import org.apache.flink.api.java.tuple.Tuple2;import org.apache.flink.streaming.api.TimeCharacteristic;import org.apache.flink.streaming.api.datastream.DataStream;import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;import org.apache.flink.streaming.api.functions.source.SourceFunction;import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction;import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;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.text.SimpleDateFormat;import java.util.Date;public class ProcessAllWindowFunctionDemo {    public static void main(String[] args) throws Exception {        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();        // 使用事件时间        env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);        // 并行度为1        env.setParallelism(1);        // 设置数据源，一共三个元素        DataStream> dataStream = env.addSource(new SourceFunction>() {            @Override            public void run(SourceContext> ctx) throws Exception {                for(int i=1; i(name, 1), timeStamp);                    // 每发射一次就延时1秒                    Thread.sleep(1000);                }            }            @Override            public void cancel() {            }        });        // 将数据用5秒的滚动窗口做划分，再用ProcessAllWindowFunction        SingleOutputStreamOperator mainDataStream = dataStream                // 5秒一次的滚动窗口                .timeWindowAll(Time.seconds(5))                // 统计当前窗口内的元素数量，然后把数量、窗口起止时间整理成字符串发送给下游算子                .process(new ProcessAllWindowFunction, String, TimeWindow>() {                    @Override                    public void process(Context context, Iterable> iterable, Collector collector) throws Exception {                        int count = 0;                        // iterable可以访问当前窗口内的所有数据，                        // 这里简单处理，只统计了元素数量                        for (Tuple2 tuple2 : iterable) {                            count++;                        }                        // 将当前窗口的起止时间和元素数量整理成字符串                        String value = String.format("window, %s - %s, %d",                                // 当前窗口的起始时间                                time(context.window().getStart()),                                // 当前窗口的结束时间                                time(context.window().getEnd()),                                // 当前key在当前窗口内元素总数                                count);                        // 发射到下游算子                        collector.collect(value);                    }                });        // 打印结果，通过分析打印信息，检查ProcessWindowFunction中可以处理所有key的整个窗口的数据        mainDataStream.print();        env.execute("processfunction demo : processallwindowfunction");    }    public static String time(long timeStamp) {        return new SimpleDateFormat("hh:mm:ss").format(new Date(timeStamp));    }}

• 关于ProcessAllWindowFunctionDemo，有几点需要注意：

1. 滚动窗口设置用timeWindowAll方法；
2. ProcessAllWindowFunction的匿名子类的process方法中，context.window().getStart()方法可以取得当前窗口的起始时间，getEnd()方法可以取得当前窗口的结束时间；

• 编码结束，执行ProcessAllWindowFunctionDemo类验证数据，如下图，检查其中一个窗口的元素详情和ProcessAllWindowFunction执行结果，可见符合预期：

ProcessAllWindowFunction已经了解，接下来尝试ProcessWindowFunction；

如何实战ProcessWindowFunction

接下来通过以下方式验证ProcessWindowFunction功能：

1. 每隔1秒发出一个Tuple2对象，对象的f0字段在aaa和bbb之间变化，f1字段固定为1；
2. 以f0字段为key进行分区；
3. 分区后的数据进入5秒的滚动窗口；
4. 自定义ProcessWindowFunction扩展类，功能之一是统计每个key在每个窗口内元素的数量，将统计结果发给下游算子；
5. 功能之二是在更新当前key的元素总量，然后在状态后端(backend)保存，这是验证KeyedStream在处理函数中的状态读写能力；
6. 下游算子将统计结果打印出来；
7. 核对发出的数据和统计信息(每个窗口的和总共的分别核对)，看是否一致；

开始编码

• 新建ProcessWindowFunctionDemo.java：

package com.bolingcavalry.processwindowfunction;import org.apache.flink.api.common.state.ValueState;import org.apache.flink.api.common.state.ValueStateDescriptor;import org.apache.flink.api.java.tuple.Tuple2;import org.apache.flink.configuration.Configuration;import org.apache.flink.streaming.api.TimeCharacteristic;import org.apache.flink.streaming.api.datastream.DataStream;import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;import org.apache.flink.streaming.api.functions.source.SourceFunction;import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;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.text.SimpleDateFormat;import java.util.Date;public class ProcessWindowFunctionDemo {    public static void main(String[] args) throws Exception {        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();        // 使用事件时间        env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);        // 并行度为1        env.setParallelism(1);        // 设置数据源，一共三个元素        DataStream> dataStream = env.addSource(new SourceFunction>() {            @Override            public void run(SourceContext> ctx) throws Exception {                int aaaNum = 0;                int bbbNum = 0;                for(int i=1; i(name, 1), timeStamp);                    // 每发射一次就延时1秒                    Thread.sleep(1000);                }            }            @Override            public void cancel() {            }        });        // 将数据用5秒的滚动窗口做划分，再用ProcessWindowFunction        SingleOutputStreamOperator mainDataStream = dataStream                // 以Tuple2的f0字段作为key，本例中实际上key只有aaa和bbb两种                .keyBy(value -> value.f0)                // 5秒一次的滚动窗口                .timeWindow(Time.seconds(5))                // 统计每个key当前窗口内的元素数量，然后把key、数量、窗口起止时间整理成字符串发送给下游算子                .process(new ProcessWindowFunction, String, String, TimeWindow>() {                    // 自定义状态                    private ValueState state;                    @Override                    public void open(Configuration parameters) throws Exception {                        // 初始化状态，name是myState                        state = getRuntimeContext().getState(new ValueStateDescriptor<>("myState", KeyCount.class));                    }                    @Override                    public void process(String s, Context context, Iterable> iterable, Collector collector) throws Exception {                        // 从backend取得当前单词的myState状态                        KeyCount current = state.value();                        // 如果myState还从未没有赋值过，就在此初始化                        if (current == null) {                            current = new KeyCount();                            current.key = s;                            current.count = 0;                        }                        int count = 0;                        // iterable可以访问该key当前窗口内的所有数据，                        // 这里简单处理，只统计了元素数量                        for (Tuple2 tuple2 : iterable) {                            count++;                        }                        // 更新当前key的元素总数                        current.count += count;                        // 更新状态到backend                        state.update(current);                        // 将当前key及其窗口的元素数量，还有窗口的起止时间整理成字符串                        String value = String.format("window, %s, %s - %s, %d,    total : %d",                                // 当前key                                s,                                // 当前窗口的起始时间                                time(context.window().getStart()),                                // 当前窗口的结束时间                                time(context.window().getEnd()),                                // 当前key在当前窗口内元素总数                                count,                                // 当前key出现的总数                                current.count);                        // 发射到下游算子                        collector.collect(value);                    }                });        // 打印结果，通过分析打印信息，检查ProcessWindowFunction中可以处理所有key的整个窗口的数据        mainDataStream.print();        env.execute("processfunction demo : processwindowfunction");    }    public static String time(long timeStamp) {        return new SimpleDateFormat("hh:mm:ss").format(new Date(timeStamp));    }    static class KeyCount {        /**         * 分区key         */        public String key;        /**         * 元素总数         */        public long count;    }}

• 上述代码有几处需要关注：

1. 静态类KeyCount.java，是用来保存每个key元素总数的数据结构；
2. timeWindow方法设置了市场为5秒的滚动窗口；
3. 每个Tuple2元素以f0为key进行分区；
4. open方法对名为myState的自定义状态进行注册；
5. process方法中，state.value()取得当前key的状态，tate.update(current)更新当前key的状态；

• 接下来运行ProcessWindowFunctionDemo类检查数据，如下图，process方法内，对窗口内元素的统计和数据源打印的一致，并且从backend取得的总数在累加后和数据源的统计信息也一致：

至此，处理函数中窗口处理相关的实战已经完成，如果您也在学习Flink的处理函数，希望本文能给您一些参考；

欢迎关注我的公众号：程序员欣宸