Flink處理函式實戰之四:視窗處理

程式設計師欣宸發表於2020-11-23

歡迎訪問我的GitHub

https://github.com/zq2599/blog_demos

內容:所有原創文章分類彙總及配套原始碼,涉及Java、Docker、Kubernetes、DevOPS等;

Flink處理函式實戰系列連結

  1. 深入瞭解ProcessFunction的狀態操作(Flink-1.10)
  2. ProcessFunction
  3. KeyedProcessFunction類
  4. ProcessAllWindowFunction(視窗處理)
  5. CoProcessFunction(雙流處理)

本篇概覽

本文是《Flink處理函式實戰》系列的第四篇,內容是學習以下兩個視窗相關的處理函式:

  1. ProcessAllWindowFunction:處理每個視窗內的所有元素;
  2. ProcessWindowFunction:處理指定key的每個視窗內的所有元素;

關於ProcessAllWindowFunction

  1. ProcessAllWindowFunction和《Flink處理函式實戰之二:ProcessFunction類》中的ProcessFunction類相似,都是用來對上游過來的元素做處理,不過ProcessFunction是每個元素執行一次processElement方法,ProcessAllWindowFunction是每個視窗執行一次process方法(方法內可以遍歷該視窗內的所有元素);
  2. 用類圖對比可以更形象的認識差別,下圖左側是ProcessFunction,右側是ProcessAllWindowFunction:
    在這裡插入圖片描述

關於ProcessWindowFunction

  1. ProcessWindowFunction和KeyedProcessFunction類似,都是處理分割槽的資料,不過KeyedProcessFunction是每個元素執行一次processElement方法,而ProcessWindowFunction是每個視窗執行一次process方法(方法內可以遍歷該key當前視窗內的所有元素);
  2. 用類圖對比可以更形象的認識差別,下圖左側是KeyedProcessFunction,右側是ProcessWindowFunction:
    在這裡插入圖片描述
  3. 另外還一個差異: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):

名稱 連結 備註
專案主頁 https://github.com/zq2599/blog_demos 該專案在GitHub上的主頁
git倉庫地址(https) https://github.com/zq2599/blog_demos.git 該專案原始碼的倉庫地址,https協議
git倉庫地址(ssh) git@github.com:zq2599/blog_demos.git 該專案原始碼的倉庫地址,ssh協議

這個git專案中有多個資料夾,本章的應用在flinkstudy資料夾下,如下圖紅框所示:
在這裡插入圖片描述

如何實戰ProcessAllWindowFunction

接下來通過以下方式驗證ProcessAllWindowFunction功能:

  1. 每隔1秒發出一個Tuple2<String, Integer>物件,物件的f0欄位在aaa和bbb之間變化,f1欄位固定為1;
  2. 設定5秒的滾動視窗;
  3. 自定義ProcessAllWindowFunction擴充套件類,功能是統計每個視窗內元素的數量,將統計結果發給下游運算元;
  4. 下游運算元將統計結果列印出來;
  5. 核對發出的資料和統計資訊,看是否一致;

開始編碼

  1. 繼續使用《Flink處理函式實戰之二:ProcessFunction類》一文中建立的工程flinkstudy;
  2. 新建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<Tuple2<String,Integer>> dataStream = env.addSource(new SourceFunction<Tuple2<String, Integer>>() {
            @Override
            public void run(SourceContext<Tuple2<String, Integer>> ctx) throws Exception {
                for(int i=1; i<Integer.MAX_VALUE; i++) {
                    // 只有aaa和bbb兩種name
                    String name = 0==i%2 ? "aaa" : "bbb";

                    // 使用當前時間作為時間戳
                    long timeStamp = System.currentTimeMillis();

                    // 將資料和時間戳列印出來,用來驗證資料
                    System.out.println(String.format("source,%s, %s\n",
                            name,
                            time(timeStamp)));

                    // 發射一個元素,並且帶上了時間戳
                    ctx.collectWithTimestamp(new Tuple2<String, Integer>(name, 1), timeStamp);

                    // 每發射一次就延時1秒
                    Thread.sleep(1000);
                }
            }

            @Override
            public void cancel() {

            }
        });

        // 將資料用5秒的滾動視窗做劃分,再用ProcessAllWindowFunction
        SingleOutputStreamOperator<String> mainDataStream = dataStream
                // 5秒一次的滾動視窗
                .timeWindowAll(Time.seconds(5))
                // 統計當前視窗內的元素數量,然後把數量、視窗起止時間整理成字串傳送給下游運算元
                .process(new ProcessAllWindowFunction<Tuple2<String, Integer>, String, TimeWindow>() {
                    @Override
                    public void process(Context context, Iterable<Tuple2<String, Integer>> iterable, Collector<String> collector) throws Exception {
                        int count = 0;

                        // iterable可以訪問當前視窗內的所有資料,
                        // 這裡簡單處理,只統計了元素數量
                        for (Tuple2<String, Integer> tuple2 : iterable) {
                            count++;
                        }

                        // 將當前視窗的起止時間和元素數量整理成字串
                        String value = String.format("window, %s - %s, %d\n",
                                // 當前視窗的起始時間
                                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));
    }
}
  1. 關於ProcessAllWindowFunctionDemo,有幾點需要注意:

a. 滾動視窗設定用timeWindowAll方法;

b. ProcessAllWindowFunction的匿名子類的process方法中,context.window().getStart()方法可以取得當前視窗的起始時間,getEnd()方法可以取得當前視窗的結束時間;

  1. 編碼結束,執行ProcessAllWindowFunctionDemo類驗證資料,如下圖,檢查其中一個視窗的元素詳情和ProcessAllWindowFunction執行結果,可見符合預期:
    在這裡插入圖片描述
  2. ProcessAllWindowFunction已經瞭解,接下來嘗試ProcessWindowFunction;

如何實戰ProcessWindowFunction

接下來通過以下方式驗證ProcessWindowFunction功能:

  1. 每隔1秒發出一個Tuple2<String, Integer>物件,物件的f0欄位在aaa和bbb之間變化,f1欄位固定為1;
  2. 以f0欄位為key進行分割槽;
  3. 分割槽後的資料進入5秒的滾動視窗;
  4. 自定義ProcessWindowFunction擴充套件類,功能之一是統計每個key在每個視窗內元素的數量,將統計結果發給下游運算元;
  5. 功能之二是在更新當前key的元素總量,然後在狀態後端(backend)儲存,這是驗證KeyedStream在處理函式中的狀態讀寫能力;
  6. 下游運算元將統計結果列印出來;
  7. 核對發出的資料和統計資訊(每個視窗的和總共的分別核對),看是否一致;

開始編碼

  1. 新建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<Tuple2<String,Integer>> dataStream = env.addSource(new SourceFunction<Tuple2<String, Integer>>() {
            @Override
            public void run(SourceContext<Tuple2<String, Integer>> ctx) throws Exception {
                int aaaNum = 0;
                int bbbNum = 0;

                for(int i=1; i<Integer.MAX_VALUE; i++) {
                    // 只有aaa和bbb兩種name
                    String name = 0==i%2 ? "aaa" : "bbb";

                    //更新aaa和bbb元素的總數
                    if(0==i%2) {
                        aaaNum++;
                    } else {
                        bbbNum++;
                    }

                    // 使用當前時間作為時間戳
                    long timeStamp = System.currentTimeMillis();

                    // 將資料和時間戳列印出來,用來驗證資料
                    System.out.println(String.format("source,%s, %s,    aaa total : %d,    bbb total : %d\n",
                            name,
                            time(timeStamp),
                            aaaNum,
                            bbbNum));

                    // 發射一個元素,並且戴上了時間戳
                    ctx.collectWithTimestamp(new Tuple2<String, Integer>(name, 1), timeStamp);

                    // 每發射一次就延時1秒
                    Thread.sleep(1000);
                }
            }

            @Override
            public void cancel() {

            }
        });

        // 將資料用5秒的滾動視窗做劃分,再用ProcessWindowFunction
        SingleOutputStreamOperator<String> mainDataStream = dataStream
                // 以Tuple2的f0欄位作為key,本例中實際上key只有aaa和bbb兩種
                .keyBy(value -> value.f0)
                // 5秒一次的滾動視窗
                .timeWindow(Time.seconds(5))
                // 統計每個key當前視窗內的元素數量,然後把key、數量、視窗起止時間整理成字串傳送給下游運算元
                .process(new ProcessWindowFunction<Tuple2<String, Integer>, String, String, TimeWindow>() {

                    // 自定義狀態
                    private ValueState<KeyCount> 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<Tuple2<String, Integer>> iterable, Collector<String> 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<String, Integer> tuple2 : iterable) {
                            count++;
                        }

                        // 更新當前key的元素總數
                        current.count += count;

                        // 更新狀態到backend
                        state.update(current);

                        // 將當前key及其視窗的元素數量,還有視窗的起止時間整理成字串
                        String value = String.format("window, %s, %s - %s, %d,    total : %d\n",
                                // 當前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. 上述程式碼有幾處需要關注:

a. 靜態類KeyCount.java,是用來儲存每個key元素總數的資料結構;

b. timeWindow方法設定了市場為5秒的滾動視窗;

c. 每個Tuple2元素以f0為key進行分割槽;

d. open方法對名為myState的自定義狀態進行註冊;

e. process方法中,state.value()取得當前key的狀態,tate.update(current)更新當前key的狀態;

  1. 接下來執行ProcessWindowFunctionDemo類檢查資料,如下圖,process方法內,對視窗內元素的統計和資料來源列印的一致,並且從backend取得的總數在累加後和資料來源的統計資訊也一致:
    在這裡插入圖片描述
    至此,處理函式中視窗處理相關的實戰已經完成,如果您也在學習Flink的處理函式,希望本文能給您一些參考;

你不孤單,欣宸原創一路相伴

  1. Java系列
  2. Spring系列
  3. Docker系列
  4. kubernetes系列
  5. 資料庫+中介軟體系列
  6. DevOps系列

歡迎關注公眾號:程式設計師欣宸

微信搜尋「程式設計師欣宸」,我是欣宸,期待與您一同暢遊Java世界...
https://github.com/zq2599/blog_demos

相關文章