CoProcessFunction實戰三部曲之三：定時器和側輸出

程式設計師欣宸發表於2021-07-22

Function定時器

歡迎訪問我的GitHub

https://github.com/zq2599/blog_demos

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

系列文章連結

本篇概覽

本文是《CoProcessFunction實戰三部曲》的終篇，主要內容是在CoProcessFunction中使用定時器和側輸出，對上一篇的功能進行增強；
回顧上一篇的功能：一號流收到aaa後儲存在狀態中，直到二號流收到aaa，把兩個aaa的值相加後輸出到下游；
上述功能有個問題：二號流如果一直收不到aaa，下游就一直沒有aaa的輸出，相當於進入一號流的aaa已經石沉大海了；
今天的實戰就是修復上述問題：aaa在一個流中出現後，10秒之內如果出現在另一個流中，就像以前那樣值相加，輸出到下游，如果10秒內沒有出現在另一個流，就流向側輸出，再將所有狀態清理乾淨；

參考文章

理解狀態：《深入瞭解ProcessFunction的狀態操作(Flink-1.10)》
理解定時器：《理解ProcessFunction的Timer邏輯》

梳理流程

為了編碼的邏輯正確，我們們把正常和異常的流程先梳理清楚；
下圖是正常流程：aaa在一號流出現後，10秒內又在二號流出現了，於是相加並流向下遊：
再來看異常的流程，如下圖，一號流在16:14:01收到aaa，但二號流一直沒有收到aaa，等到10秒後，也就是16:14:11，定時器被觸發，從狀態1得知10秒前一號流收到過aaa，於是將資料流向一號側輸出：
接下來編碼實現上面的功能；

原始碼下載

如果您不想寫程式碼，整個系列的原始碼可在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資料夾下，如下圖紅框所示：
在這裡插入圖片描述

CoProcessFunction的子類

前面的兩篇實戰中，CoProcessFunction的子類都寫成了匿名類，如下圖紅框：
本文中，CoProcessFunction子類會用到外部類的成員變數，因此不能再用匿名類了，新增CoProcessFunction的子類ExecuteWithTimeoutCoProcessFunction.java，稍後會說明幾個關鍵點：

package com.bolingcavalry.coprocessfunction;

import com.bolingcavalry.Utils;
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.functions.co.CoProcessFunction;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 實現雙流業務邏輯的功能類
 */
public class ExecuteWithTimeoutCoProcessFunction extends CoProcessFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple2<String, Integer>> {

    private static final Logger logger = LoggerFactory.getLogger(ExecuteWithTimeoutCoProcessFunction.class);

    /**
     * 等待時間
     */
    private static final long WAIT_TIME = 10000L;

    public ExecuteWithTimeoutCoProcessFunction(OutputTag<String> source1SideOutput, OutputTag<String> source2SideOutput) {
        super();
        this.source1SideOutput = source1SideOutput;
        this.source2SideOutput = source2SideOutput;
    }

    private OutputTag<String> source1SideOutput;

    private OutputTag<String> source2SideOutput;

    // 某個key在processElement1中存入的狀態
    private ValueState<Integer> state1;

    // 某個key在processElement2中存入的狀態
    private ValueState<Integer> state2;

    // 如果建立了定時器，就在狀態中儲存定時器的key
    private ValueState<Long> timerState;

    // onTimer中拿不到當前key，只能提前儲存在狀態中（KeyedProcessFunction的OnTimerContext有API可以取到，但是CoProcessFunction的OnTimerContext卻沒有）
    private ValueState<String> currentKeyState;

    @Override
    public void open(Configuration parameters) throws Exception {
        // 初始化狀態
        state1 = getRuntimeContext().getState(new ValueStateDescriptor<>("myState1", Integer.class));
        state2 = getRuntimeContext().getState(new ValueStateDescriptor<>("myState2", Integer.class));
        timerState = getRuntimeContext().getState(new ValueStateDescriptor<>("timerState", Long.class));
        currentKeyState = getRuntimeContext().getState(new ValueStateDescriptor<>("currentKeyState", String.class));
    }

    /**
     * 所有狀態都清理掉
     */
    private void clearAllState() {
        state1.clear();
        state2.clear();
        currentKeyState.clear();
        timerState.clear();
    }

    @Override
    public void processElement1(Tuple2<String, Integer> value, Context ctx, Collector<Tuple2<String, Integer>> out) throws Exception {
        logger.info("processElement1：處理元素1：{}", value);

        String key = value.f0;

        Integer value2 = state2.value();

        // value2為空，就表示processElement2還沒有處理或這個key，
        // 這時候就把value1儲存起來
        if(null==value2) {
            logger.info("processElement1：2號流還未收到過[{}]，把1號流收到的值[{}]儲存起來", key, value.f1);
            state1.update(value.f1);

            currentKeyState.update(key);

            // 開始10秒的定時器，10秒後會進入
            long timerKey = ctx.timestamp() + WAIT_TIME;
            ctx.timerService().registerProcessingTimeTimer(timerKey);
            // 儲存定時器的key
            timerState.update(timerKey);
            logger.info("processElement1：建立定時器[{}]，等待2號流接收資料", Utils.time(timerKey));
        } else {
            logger.info("processElement1：2號流收到過[{}]，值是[{}]，現在把兩個值相加後輸出", key, value2);

            // 輸出一個新的元素到下游節點
            out.collect(new Tuple2<>(key, value.f1 + value2));

            // 刪除定時器（這個定時器應該是processElement2建立的）
            long timerKey = timerState.value();
            logger.info("processElement1：[{}]的新元素已輸出到下游，刪除定時器[{}]", key, Utils.time(timerKey));
            ctx.timerService().deleteProcessingTimeTimer(timerKey);

            clearAllState();
        }
    }

    @Override
    public void processElement2(Tuple2<String, Integer> value, Context ctx, Collector<Tuple2<String, Integer>> out) throws Exception {
        logger.info("processElement2：處理元素2：{}", value);

        String key = value.f0;

        Integer value1 = state1.value();

        // value1為空，就表示processElement1還沒有處理或這個key，
        // 這時候就把value2儲存起來
        if(null==value1) {
            logger.info("processElement2：1號流還未收到過[{}]，把2號流收到的值[{}]儲存起來", key, value.f1);
            state2.update(value.f1);

            currentKeyState.update(key);

            // 開始10秒的定時器，10秒後會進入
            long timerKey = ctx.timestamp() + WAIT_TIME;
            ctx.timerService().registerProcessingTimeTimer(timerKey);
            // 儲存定時器的key
            timerState.update(timerKey);
            logger.info("processElement2：建立定時器[{}]，等待1號流接收資料", Utils.time(timerKey));
        } else {
            logger.info("processElement2：1號流收到過[{}]，值是[{}]，現在把兩個值相加後輸出", key, value1);

            // 輸出一個新的元素到下游節點
            out.collect(new Tuple2<>(key, value.f1 + value1));

            // 刪除定時器（這個定時器應該是processElement1建立的）
            long timerKey = timerState.value();
            logger.info("processElement2：[{}]的新元素已輸出到下游，刪除定時器[{}]", key, Utils.time(timerKey));
            ctx.timerService().deleteProcessingTimeTimer(timerKey);

            clearAllState();
        }
    }

    @Override
    public void onTimer(long timestamp, OnTimerContext ctx, Collector<Tuple2<String, Integer>> out) throws Exception {
        super.onTimer(timestamp, ctx, out);

        String key = currentKeyState.value();

        // 定時器被觸發，意味著此key只在一箇中出現過
        logger.info("[{}]的定時器[{}]被觸發了", key, Utils.time(timestamp));

        Integer value1 = state1.value();
        Integer value2 = state2.value();

        if(null!=value1) {
            logger.info("只有1號流收到過[{}]，值為[{}]", key, value1);
            // 側輸出
            ctx.output(source1SideOutput, "source1 side, key [" + key+ "], value [" + value1 + "]");
        }

        if(null!=value2) {
            logger.info("只有2號流收到過[{}]，值為[{}]", key, value2);
            // 側輸出
            ctx.output(source2SideOutput, "source2 side, key [" + key+ "], value [" + value2 + "]");
        }

        clearAllState();
    }
}

關鍵點之一：新增狀態timerState，用於儲存定時器的key；
關鍵點之二：CoProcessFunction的onTimer中拿不到當前key(KeyedProcessFunction可以，其OnTimerContext類提供了API)，因此新增狀態currentKeyState，這樣在onTimer中就知道當前key了；
關鍵點之三：processElement1中，處理aaa時，如果2號流還沒收到過aaa，就存入狀態，並啟動10秒定時器；
關鍵點之四：processElement2處理aaa時，發現1號流收到過aaa，就相加再輸出到下游，並且刪除processElement1中建立的定時器，aaa相關的所有狀態也全部清理掉；
關鍵點之五：如果10秒內aaa在兩個流中都出現過，那麼一定會流入下游並且定時器會被刪除，因此，一旦onTimer被執行，意味著aaa只在一個流中出現過，而且已經過去10秒了，此時在onTimer中可以執行流向側輸出的操作；
以上就是雙流處理的邏輯和程式碼，接下來編寫AbstractCoProcessFunctionExecutor的子類；

業務執行類AddTwoSourceValueWithTimeout

負責執行整個功能的，是抽象類AbstractCoProcessFunctionExecutor的子類，如下，稍後會說明幾個關鍵點：

package com.bolingcavalry.coprocessfunction;

import com.bolingcavalry.Utils;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.AssignerWithPeriodicWatermarks;
import org.apache.flink.streaming.api.functions.co.CoProcessFunction;
import org.apache.flink.streaming.api.watermark.Watermark;
import org.apache.flink.util.OutputTag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author will
 * @email zq2599@gmail.com
 * @date 2020-11-11 09:48
 * @description 將兩個流中相通key的value相加，當key在一個流中出現後，
 *              會在有限時間內等待它在另一個流中出現，如果超過等待時間任未出現就在旁路輸出
 */
public class AddTwoSourceValueWithTimeout extends AbstractCoProcessFunctionExecutor {

    private static final Logger logger = LoggerFactory.getLogger(AddTwoSourceValueWithTimeout.class);

    // 假設aaa流入1號源後，在2號源超過10秒沒有收到aaa，那麼1號源的aaa就會流入source1SideOutput
    final OutputTag<String> source1SideOutput = new OutputTag<String>("source1-sideoutput"){};

    // 假設aaa流入2號源後，如果1號源超過10秒沒有收到aaa，那麼2號源的aaa就會流入source2SideOutput
    final OutputTag<String> source2SideOutput = new OutputTag<String>("source2-sideoutput"){};

    /**
     * 重寫父類的方法，保持父類邏輯不變，僅增加了時間戳分配器，向元素中加入時間戳
     * @param port
     * @return
     */
    @Override
    protected KeyedStream<Tuple2<String, Integer>, Tuple> buildStreamFromSocket(StreamExecutionEnvironment env, int port) {
        return env
                // 監聽埠
                .socketTextStream("localhost", port)
                // 得到的字串"aaa,3"轉成Tuple2例項，f0="aaa"，f1=3
                .map(new WordCountMap())
                // 設定時間戳分配器，用當前時間作為時間戳
                .assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks<Tuple2<String, Integer>>() {

                    @Override
                    public long extractTimestamp(Tuple2<String, Integer> element, long previousElementTimestamp) {
                        long timestamp = System.currentTimeMillis();
                        logger.info("新增時間戳，值：{}，時間戳：{}", element, Utils.time(timestamp));
                        // 使用當前系統時間作為時間戳
                        return timestamp;
                    }

                    @Override
                    public Watermark getCurrentWatermark() {
                        // 本例不需要watermark，返回null
                        return null;
                    }
                })
                // 將單詞作為key分割槽
                .keyBy(0);
    }

    @Override
    protected CoProcessFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple2<String, Integer>> getCoProcessFunctionInstance() {
        return new ExecuteWithTimeoutCoProcessFunction(source1SideOutput, source2SideOutput);
    }

    @Override
    protected void doSideOutput(SingleOutputStreamOperator<Tuple2<String, Integer>> mainDataStream) {
        // 兩個側輸出都直接列印
        mainDataStream.getSideOutput(source1SideOutput).print();
        mainDataStream.getSideOutput(source2SideOutput).print();
    }

    public static void main(String[] args) throws Exception {
        new AddTwoSourceValueWithTimeout().execute();
    }
}

關鍵點之一：增減成員變數source1SideOutput和source2SideOutput，用於側輸出；
關鍵點之二：重寫父類的buildStreamFromSocket方法，加了個時間戳分配器，這樣每個元素都帶有時間戳；
關鍵點之三：重寫父類的doSideOutput方法，這裡面會把側輸出的資料列印出來；
以上就是所有程式碼了，接下來開始驗證；

驗證（不超時的操作）

分別開啟本機的9998和9999埠，我這裡是MacBook，執行nc -l 9998和nc -l 9999
啟動Flink應用，如果您和我一樣是Mac電腦，直接執行AddTwoSourceValueWithTimeout.main方法即可（如果是windows電腦，我這沒試過，不過做成jar線上部署也是可以的）；
在監聽9998埠的控制檯輸入aaa,1，此時flink控制檯輸出如下，可見processElement1方法中，讀取state2為空，表示aaa在2號流還未出現過，此時的aaa是首次出現，應該放入state中儲存，並且建立了定時器：

18:18:10,472 INFO  AddTwoSourceValueWithTimeout  - 新增時間戳，值：(aaa,1)，時間戳：2020-11-12 06:18:10
18:18:10,550 INFO  ExecuteWithTimeoutCoProcessFunction  - processElement1：處理元素1：(aaa,1)
18:18:10,550 INFO  ExecuteWithTimeoutCoProcessFunction  - processElement1：2號流還未收到過[aaa]，把1號流收到的值[1]儲存起來
18:18:10,553 INFO  ExecuteWithTimeoutCoProcessFunction  - processElement1：建立定時器[2020-11-12 06:18:20]，等待2號流接收資料

儘快在監聽9999埠的控制檯輸入aaa,2，flink日誌如下所示，可見相加後輸出到下游，並且定時器也刪除了：

18:18:15,813 INFO  AddTwoSourceValueWithTimeout  - 新增時間戳，值：(aaa,2)，時間戳：2020-11-12 06:18:15
18:18:15,887 INFO  ExecuteWithTimeoutCoProcessFunction  - processElement2：處理元素2：(aaa,2)
18:18:15,887 INFO  ExecuteWithTimeoutCoProcessFunction  - processElement2：1號流收到過[aaa]，值是[1]，現在把兩個值相加後輸出
(aaa,3)
18:18:15,888 INFO  ExecuteWithTimeoutCoProcessFunction  - processElement2：[aaa]的新元素已輸出到下游，刪除定時器[2020-11-12 06:18:20]

驗證（超時的操作）

前面試過了正常流程，再來試試超時流程是否符合預期；
在監聽9998埠的控制檯輸入aaa,1，然後等待十秒，flink控制檯輸出如下，可見定時器被觸發，並且aaa流向了1號流的側輸出：

18:23:37,393 INFO  AddTwoSourceValueWithTimeout - 新增時間戳，值：(aaa,1)，時間戳：2020-11-12 06:23:37
18:23:37,417 INFO  ExecuteWithTimeoutCoProcessFunction - processElement1：處理元素1：(aaa,1)
18:23:37,417 INFO  ExecuteWithTimeoutCoProcessFunction - processElement1：2號流還未收到過[aaa]，把1號流收到的值[1]儲存起來
18:23:37,417 INFO  ExecuteWithTimeoutCoProcessFunction - processElement1：建立定時器[2020-11-12 06:23:47]，等待2號流接收資料
18:23:47,398 INFO  ExecuteWithTimeoutCoProcessFunction - [aaa]的定時器[2020-11-12 06:23:47]被觸發了
18:23:47,399 INFO  ExecuteWithTimeoutCoProcessFunction - 只有1號流收到過[aaa]，值為[1]
source1 side, key [aaa], value [1]

至此，CoProcessFunction實戰三部曲已經全部完成了，希望這三次實戰能夠給您一些參考，幫您更快掌握和理解CoProcessFunction；

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

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

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

CoProcessFunction實戰三部曲之一：基本功能
2021-07-14
Function
CoProcessFunction實戰三部曲之二：狀態處理
2021-07-16
Function
elasticsearch實戰三部曲之三：搜尋操作
2022-07-31
Elasticsearch
定時器-輸出比較PWM
2024-10-19
定時器
kubernetes下的Nginx加Tomcat三部曲之三：實戰擴容和升級
2022-05-19
NginxTomcat
php nginx 實時輸出
2019-02-16
PHPNginx
Flink 的側輸出流，怎麼玩？
2023-11-27
python怎樣實時輸出時間
2021-09-11
Python
Flink處理函式實戰之五：CoProcessFunction(雙流處理)
2021-07-13
函式Function
Flutter 快速上手定時器/倒數計時及實戰講解
2019-06-10
Flutter定時器
uniapp實戰——實現左側資料渲染和點選高亮
2020-12-11
APP
OpenFaaS實戰之三：Java函式
2021-07-28
Java函式
（定時）任務輸出重定向到日誌
2021-10-25
純生JS輪播，定時器新增和清除定時器
2020-11-26
JS定時器
Flink的DataSource三部曲之三:自定義
2020-11-07
Python 輸出當前日期和時間
2024-09-07
Python
STM32一個定時器輸出四路不同頻率和佔空比PWM波的方法
2023-12-03
定時器
GO的定時器Timer 和定時任務cron
2021-09-06
Go定時器
定時器（setInterval、setTimeout 和requestAnimationFrame）
2019-07-17
定時器requestAnimationFrame
Docker下Prometheus和Grafana三部曲之三：自定義監控項開發和配置
2022-08-26
DockerPrometheusGrafana
CDH+Kylin三部曲之三：Kylin官方demo
2022-12-07
Flink on Yarn三部曲之三：提交Flink任務
2022-12-04
Yarn
Qt中利用定時器QTimer實時顯示當前日期和時間
2019-02-23
QT定時器
實戰-MySQL定時增量備份（2）
2018-08-03
MySql
stm32f103在使用定時器1重對映引腳輸出PWM
2019-03-08
定時器
Flutter實戰: 如何同時設定Container的圖片和顏色
2020-01-13
FlutterAI
Go實戰準備工作---建立攜程池和定時任務
2020-10-08
Go
Go實戰準備工作---建立協程池和定時任務
2020-10-08
Go
Docker映象製作實戰：設定時區和系統編碼
2022-05-30
Docker
Flink的sink實戰之三：cassandra3
2020-11-10
Spring Cloud Gateway實戰之三：動態路由
2021-11-16
SpringCloudGateway路由
MyBatis初級實戰之三：springboot整合druid
2021-01-19
MyBatisSpring BootUI
uniapp實戰——實現右側資料的渲染
2020-12-11
APP
Git設定彩色輸出
2018-04-12
Git
PHP執行耗時指令碼實時輸出內容
2019-02-16
PHP指令碼
實戰-MySQL定時全量備份（1）
2018-08-03
MySql
elasticsearch實戰三部曲之二：文件操作
2022-07-30
Elasticsearch
elasticsearch實戰三部曲之一：索引操作
2022-07-29
Elasticsearch索引