Flink処理関数の戦闘2：KeyedProcessFunctionクラス

この記事は「Flink処理関数の戦闘」シリーズの2回目です。前の記事の「Flink処理関数の戦闘：ProcessFunctionクラス」では、最も簡単なProcessFunctionクラス、今日理解できるKeyedProcessFunction、およびこのクラスによってもたらされるいくつかの機能について学びました；

KeyedProcessFunctionについて

クラス図を比較すると、KeyedProcessFunctionと
ここに画像の説明を挿入
ProcessFunctionが直接関連していないことがわかります。KeyedProcessFunctionは、KeyedStreamのデータコレクションを処理するために使用されます。ProcessFunctionクラスと比較すると、KeyedProcessFunctionにはより多くの機能があります。公式ドキュメントは赤いボックスで示されているとおり、状態処理とタイマー関数は両方です。 KeyedProcessFunctionは次の機能のみを備えています。
ここに画像の説明を挿入
紹介の後、例を通して学習しましょう。

バージョン情報

開発環境オペレーティングシステム：MacBook Pro 13インチ、macOS Catalina 10.15.3
開発ツール：IDEA ULTIMATE 2018.3
JDK：1.8.0_211
メイベン：3.6.0
フリンク：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）	[email protected]：zq2599 / blog_demos.git	プロジェクトのソースコードの倉庫アドレス、sshプロトコル

このgitプロジェクトには複数のフォルダーがあります。この章のアプリケーションは、次の図の赤いボックスに示すように、flinkstudyフォルダーの下にあります。
ここに画像の説明を挿入

前書き

この実際の戦闘の目的は、KeyedProcessFunctionを学習することです。内容は次のとおりです。

このマシンのポート9999を聞いて文字列を取得します。
各文字列をスペースで区切り、それをTuple2インスタンスに変換します。f0は分離された単語で、f1は1です。
上記のTuple2インスタンスは、f0フィールドを使用してパーティション化し、KeyedStreamを取得します。
KeyedSteamはカスタムKeyedProcessFunction処理に転送します。
カスタムKeyedProcessFunctionの機能は、各単語の最後の出現時刻を記録し、10秒のタイマーを構築します。単語が10秒後に再び表示されない場合、単語と出現回数の合計がダウンストリームに送信されますオペレーター;

コーディング

記事「Flink Processing Function One：ProcessFunction Class」で作成したプロジェクトflinkstudyを引き続き使用します。
BeanクラスCountWithTimestampを作成します。これには3つのフィールドがあり、利便性のためにパブリックとして設定します。

package com.bolingcavalry.keyedprocessfunction;

public class CountWithTimestamp {
    
    
    public String key;

    public long count;

    public long lastModified;
}

複数のTuple2インスタンスを生成するために文字列を分割するために使用されるFlatMapFunction実装クラスSplitterを作成します。f0は分離された単語で、f1は1に等しいです。

package com.bolingcavalry;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.Collector;
import org.apache.flink.util.StringUtils;

public class Splitter implements FlatMapFunction<String, Tuple2<String, Integer>> {
    
    
    @Override
    public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
    
    

        if(StringUtils.isNullOrWhitespaceOnly(s)) {
    
    
            System.out.println("invalid line");
            return;
        }

        for(String word : s.split(" ")) {
    
    
            collector.collect(new Tuple2<String, Integer>(word, 1));
        }
    }
}

最後に、ロジック関数全体の本体：カスタムKeyedProcessFunctionサブクラスを持つProcessTime.java、およびプログラムエントリのメインメソッドコードを以下にリストした後、主要な部分を紹介します。

package com.bolingcavalry.keyedprocessfunction;

import com.bolingcavalry.Splitter;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple;
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.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.AssignerWithPeriodicWatermarks;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.streaming.api.watermark.Watermark;
import org.apache.flink.util.Collector;

import java.text.SimpleDateFormat;
import java.util.Date;


/**
 * @author will
 * @email [email protected]
 * @date 2020-05-17 13:43
 * @description 体验KeyedProcessFunction类(时间类型是处理时间)
 */
public class ProcessTime {
    
    

    /**
     * KeyedProcessFunction的子类，作用是将每个单词最新出现时间记录到backend，并创建定时器，
     * 定时器触发的时候，检查这个单词距离上次出现是否已经达到10秒，如果是，就发射给下游算子
     */
    static class CountWithTimeoutFunction extends KeyedProcessFunction<Tuple, Tuple2<String, Integer>, Tuple2<String, Long>> {
    
    

        // 自定义状态
        private ValueState<CountWithTimestamp> state;

        @Override
        public void open(Configuration parameters) throws Exception {
    
    
            // 初始化状态，name是myState
            state = getRuntimeContext().getState(new ValueStateDescriptor<>("myState", CountWithTimestamp.class));
        }

        @Override
        public void processElement(
                Tuple2<String, Integer> value,
                Context ctx,
                Collector<Tuple2<String, Long>> out) throws Exception {
    
    

            // 取得当前是哪个单词
            Tuple currentKey = ctx.getCurrentKey();

            // 从backend取得当前单词的myState状态
            CountWithTimestamp current = state.value();

            // 如果myState还从未没有赋值过，就在此初始化
            if (current == null) {
    
    
                current = new CountWithTimestamp();
                current.key = value.f0;
            }

            // 单词数量加一
            current.count++;

            // 取当前元素的时间戳，作为该单词最后一次出现的时间
            current.lastModified = ctx.timestamp();

            // 重新保存到backend，包括该单词出现的次数，以及最后一次出现的时间
            state.update(current);

            // 为当前单词创建定时器，十秒后后触发
            long timer = current.lastModified + 10000;

            ctx.timerService().registerProcessingTimeTimer(timer);

            // 打印所有信息，用于核对数据正确性
            System.out.println(String.format("process, %s, %d, lastModified : %d (%s), timer : %d (%s)\n\n",
                    currentKey.getField(0),
                    current.count,
                    current.lastModified,
                    time(current.lastModified),
                    timer,
                    time(timer)));

        }

        /**
         * 定时器触发后执行的方法
         * @param timestamp 这个时间戳代表的是该定时器的触发时间
         * @param ctx
         * @param out
         * @throws Exception
         */
        @Override
        public void onTimer(
                long timestamp,
                OnTimerContext ctx,
                Collector<Tuple2<String, Long>> out) throws Exception {
    
    

            // 取得当前单词
            Tuple currentKey = ctx.getCurrentKey();

            // 取得该单词的myState状态
            CountWithTimestamp result = state.value();

            // 当前元素是否已经连续10秒未出现的标志
            boolean isTimeout = false;

            // timestamp是定时器触发时间，如果等于最后一次更新时间+10秒，就表示这十秒内已经收到过该单词了，
            // 这种连续十秒没有出现的元素，被发送到下游算子
            if (timestamp == result.lastModified + 10000) {
    
    
                // 发送
                out.collect(new Tuple2<String, Long>(result.key, result.count));

                isTimeout = true;
            }

            // 打印数据，用于核对是否符合预期
            System.out.println(String.format("ontimer, %s, %d, lastModified : %d (%s), stamp : %d (%s), isTimeout : %s\n\n",
                    currentKey.getField(0),
                    result.count,
                    result.lastModified,
                    time(result.lastModified),
                    timestamp,
                    time(timestamp),
                    String.valueOf(isTimeout)));
        }
    }


    public static void main(String[] args) throws Exception {
    
    
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 并行度1
        env.setParallelism(1);

        // 处理时间
        env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);

        // 监听本地9999端口，读取字符串
        DataStream<String> socketDataStream = env.socketTextStream("localhost", 9999);

        // 所有输入的单词，如果超过10秒没有再次出现，都可以通过CountWithTimeoutFunction得到
        DataStream<Tuple2<String, Long>> timeOutWord = socketDataStream
                // 对收到的字符串用空格做分割，得到多个单词
                .flatMap(new Splitter())
                // 设置时间戳分配器，用当前时间作为时间戳
                .assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks<Tuple2<String, Integer>>() {
    
    

                    @Override
                    public long extractTimestamp(Tuple2<String, Integer> element, long previousElementTimestamp) {
    
    
                        // 使用当前系统时间作为时间戳
                        return System.currentTimeMillis();
                    }

                    @Override
                    public Watermark getCurrentWatermark() {
    
    
                        // 本例不需要watermark，返回null
                        return null;
                    }
                })
                // 将单词作为key分区
                .keyBy(0)
                // 按单词分区后的数据，交给自定义KeyedProcessFunction处理
                .process(new CountWithTimeoutFunction());

        // 所有输入的单词，如果超过10秒没有再次出现，就在此打印出来
        timeOutWord.print();

        env.execute("ProcessFunction demo : KeyedProcessFunction");
    }

    public static String time(long timeStamp) {
    
    
        return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date(timeStamp));
    }
}

上記のコードで注目すべき点がいくつかあります。

タイムスタンプがassignTimestampsAndWatermarksによって設定されると、ウォーターマークが使用されないため、getCurrentWatermarkはnullを返します。
processElementメソッドでは、state.value（）が現在の単語の状態を取得し、state.update（current）が現在の単語の状態を設定できます。この関数の詳細については、「ProcessFunctionの状態操作について（Flink-1.10）」を参照してください。
registerProcessingTimeTimerメソッドはタイマーのトリガー時間を設定します。ここでのタイマーはprocessTimeに基づいていることに注意してください。これは公式デモのeventTimeとは異なります。
タイマーがトリガーされた後、onTimerメソッドが実行されます。これには、タイマーのすべての情報、特に最初に設定されたタイマーのトリガー時間である入力パラメーターのタイムスタンプが含まれます。

検証

コンソールでコマンドnc -l 9999を実行して、コンソールからマシンのポート9999に文字列を送信できるようにします。
IDEAでProcessTimeクラスのmainメソッドを直接実行すると、プログラムの実行時にプログラムがマシンのポート9999の監視を開始します。
フロントコンソールでaaaと入力し、Enterキーを押します。10秒待機した後、IEDAコンソールは次の情報を出力します。結果は、期待どおりであることを示しています。
aaaの入力を続行してEnterキーを押します。結果は10秒以内である必要があります。結果は次の図のようになります。各Tuple2要素にはタイマーがありますが、2番目の入力はaaa、そのタイマーは出発前、aaaです。最新の出現時刻は3番目の入力操作によって更新されるため、2番目の入力aaaのタイマーでの比較操作により、aaaの最新（つまり3番目）の出現が10秒に達していないことがわかりました。 2番目の要素は、下流のオペレーターには出力されません。
下の図に示す赤いボックスに示すように、ダウンストリームオペレーターが受信したすべてのタイムアウト情報が印刷されます。1と3に等しい番号のレコードのみが印刷されます。数値が2の場合、10秒以内にaaaが再度入力されるため、タイムアウトの受信はありません。ダウンストリーム印刷：

この時点で、KeyedProcessFunction処理関数の学習は完了しています。その状態の読み取りと書き込み、およびタイマー操作は非常に実用的な機能です。この記事でリファレンスを提供していただければ幸いです。

私のパブリックアカウントへようこそ：プログラマーXin Chen

ここに画像の説明を挿入