四、FLINK - ウィンドウ、イベント時刻と透かし原理と使用

開発 2019-12-10 05:30:41 訪問数: null

A、ウィンドウメカニズムをFLINK

1.1ウィンドウの概要

ストリーミングフローを計算するエンジン無制限のデータセットを処理するデータを処理するように設計された、データセットは無限にますます魅力本質的に無制限のデータセットであり、切除窓は、無制限のデータブロックを限定しました治療の手段。
ウィンドウのコア無制限のデータストリーム処理され、ウィンドウが「バケット」バケット限られたサイズの無限のストリームに分割されます、我々はこれらのバケットの計算処理を行うことができます。

1.2ウィンドウタイプ

：ウィンドウは、2つのカテゴリに分けることができる
CountWindow：ウィンドウを生成する時の独立したデータ片の数に応じて指定されました。以下は、使用
TimeWindowを：時間のウィンドウを生成します。非常に一般的に、どのような種類の時間のメインウィンドウの下。ウィンドウをスクロールする（タンブリングウィンドウ）、スライディングウィンドウ（スライディングウィンドウ）、セッション・ウィンドウ（セッションウィンドウ）とグローバルウィンドウ（グローバルウィンドウはほとんど使用されません）：4つのカテゴリがあります。

1.2.1スクロールウィンドウ（タンブリングWindowsの場合）

要約：固定窓のデータ長に基づいて、データスライス。唯一つの動作パラメータは、ウィンドウサイズである
特性：時間アライメントは、ウィンドウの長さが固定され、重なりません。
各ローリング・ウィンドウ分配要素がウィンドウの指定されたウィンドウサイズに割り当てられ、スクロールウィンドウは、固定されたサイズを有し、（直ちに両方時点の前後）しないオーバーラップを行います。例えば：あなたは次のようにウィンドウを作成するために、5分のスクロールウィンドウサイズを指定した場合：
四、FLINK - ウィンドウ、イベント時刻と透かし原理と使用
図1.2.1スクロールウィンドウの
アプリケーションシナリオ：BIの適切な統計（各期間について計算し重合を）。

1.2.2スライディングウィンドウ（Windowsのスライディング）

概要：スライディングウィンドウは、固定された間隔スライディングウィンドウの長さおよび組成によってウィンドウ動作パラメータをスライディング、固定窓のより一般化された形態です。
特徴：タイムアライメント、窓長さが固定され、重複があります。
スライディングウィンドウ分配要素は、固定長のウィンドウに割り当てられている、スクロール・ウィンドウと同様に、スライディングウィンドウ周波数開始の他のスライディングウィンドウ制御パラメータで構成ウィンドウサイズパラメータにウィンドウ・サイズ。ウィンドウパラメータをスライディングスライドウィンドウサイズよりも小さい場合従って、ウィンドウ要素が複数のウィンドウに割り当てされる場合には、重複することができます。
たとえば、ウィンドウをスライド5分、10分を持って、生成されたデータの最後の10分間で5分間ウィンドウを含む各ウィンドウは、以下のように
四、FLINK - ウィンドウ、イベント時刻と透かし原理と使用
ウィンドウスライディング図1.2.2
アプリケーションシナリオのための：最近の統計期間（かどうかをアラームに決定するためのインターフェースの故障率の5分を求めている最近）。

1.2.3セッション・ウィンドウ（セッションWindowsの場合）

概要：すなわち、時間の期間新しいデータが受信されないセッションのWebアプリケーションと同様に、タイムアウトイベントによってギャップの直列の組み合わせを指定した時間の長さは、新しいウィンドウを生成します。
特長：いいえ整列。いいえ固定長のウィンドウ
がある場合に要素パケットセッションによって実行されるセッション・ウィンドウディスペンサ活動は、セッション・ウィンドウは、逆に重複固定開始時刻と終了時刻の場合、存在しないであろう、スライディングウィンドウと比較ウィンドウをスクロールしないとしますもはや非アクティブの間隔で生成された時間の一定期間、内の要素を受け取り、ウィンドウが閉じます。セッション・ウィンドウの間隔がセッションで構成され、このセッションの間隔は不活動の期間が発生した場合、現在のセッションがクローズされ、後続の要素が新しいセッションにウィンドウに割り当てられます、非アクティブ期間の長さを規定します。
四、FLINK - ウィンドウ、イベント時刻と透かし原理と使用
図1.2.3セッションウィンドウ

1.3ウィンドウのWindows API

1.3.1ウィンドウのAPI分類

window数据源分为两种，一种是典型的KV类型（keyedStream），另一种是非KV类型（Non-keyedStream）。
区别：
keyedStream：
需要在使用窗口操作前，调用 keyBy对KV按照key进行分区，然后才可以调用window操作的api，比如 countWindow，timeWindow等

Non-keyedstream：
如果使用窗口操作前，没有使用keyBy算子，那么就认为是Non-keyedstream，调用的window api就是 xxxWindowAll，比如countWindowAll，timeWindowAll，而且因为是非KV，所以无法分区，也就是只有一个分区，那么这个窗口并行度只能是1。这个是要注意的。

1.3.2 countWindow

CountWindow根据窗口中相同key元素的数量来触发执行，执行时只计算元素数量达到窗口大小的key对应的结果。

有两个用法：
countWindow(window_size)：只指定窗口大小，此时窗口是滚动窗口
countWindow(window_size, slide)：指定窗口大小以及滑动间隔，此时窗口是滑动窗口

注意：CountWindow的window_size指的是相同Key的元素的个数，不是输入的所有元素的总数。

1、滚动窗口
默认的CountWindow是一个滚动窗口，只需要指定窗口大小即可，当元素数量达到窗口大小时，就会触发窗口的执行。

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

public class WindowTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> source = env.readTextFile("/test.txt");
        source.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
                for (String s1 : s.split(" ")) {
                    collector.collect(new Tuple2<>(s1, 1));
                }
            }
        }).keyBy(0).countWindow(5).reduce(new ReduceFunction<Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> reduce(Tuple2<String, Integer> t1, Tuple2<String, Integer> t2) throws Exception {
                return new Tuple2<>(t1.f0, t1.f1 + t2.f1);
            }
        }).print();

        env.execute("滚动窗口");
    }

}

2、滑动窗口
动窗口和滚动窗口的函数名是完全一致的，只是在传参数时需要传入两个参数，一个是window_size，一个是sliding_size。
下面代码中的sliding_size设置为了2，也就是说，每收到两个相同key的数据就计算一次，每一次计算的window范围是5个元素。

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

public class WindowTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> source = env.readTextFile("/test.txt");
        source.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
                for (String s1 : s.split(" ")) {
                    collector.collect(new Tuple2<>(s1, 1));
                }
            }
        }).keyBy(0).countWindow(5,2).reduce(new ReduceFunction<Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> reduce(Tuple2<String, Integer> t1, Tuple2<String, Integer> t2) throws Exception {
                return new Tuple2<>(t1.f0, t1.f1 + t2.f1);
            }
        }).print();

        env.execute("滑动窗口");
    }

}

1.3.3 timeWindow

​ TimeWindow是将指定时间范围内的所有数据组成一个window，一次对一个window里面的所有数据进行计算。同样支持类似上面的滚动窗口和滑动窗口模式。有两个工作参数：window_size和slide。只指定window_size时是滚动窗口。

1、滚动窗口
​ Flink默认的时间窗口根据Processing Time 进行窗口的划分，将Flink获取到的数据根据进入Flink的时间划分到不同的窗口中。

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;

public class WindowTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> source = env.readTextFile("/test.txt");
        source.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
                for (String s1 : s.split(" ")) {
                    collector.collect(new Tuple2<>(s1, 1));
                }
            }
        }).keyBy(0).timeWindow(Time.seconds(2)).reduce(new ReduceFunction<Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> reduce(Tuple2<String, Integer> t1, Tuple2<String, Integer> t2) throws Exception {
                return new Tuple2<>(t1.f0, t1.f1 + t2.f1);
            }
        }).print();

        env.execute("滚动窗口");
    }

}

2、滑动窗口
和上面类似，就是参数里面增加了slide参数，也就是滑动时间间隔。时间间隔可以通过Time.milliseconds(x)，Time.seconds(x)，Time.minutes(x)等其中的一个来指定。

1.3.4 window reduce

也就是在窗口算子之后执行reduce算子，用法和普通的reduce一样，只不过reduce的单位是一个窗口。即每一个窗口返回一次reduce结果。程序在上面，不重复了。

1.3.5 window fold

也就是在窗口算子之后执行fold算子，用法和普通的fold一样，只不过fold的单位是一个窗口。即每一个窗口返回一次reduce结果。程序在上面，不重复了。

1.3.6 window聚合操作

指的是max、min等这些聚合算子，只不过是在window算子之后使用，以窗口为单位，每一个窗口返回一次聚合结果，而不是像普通那样，每一次聚合结果都返回。

二、time、watermark和window

2.1 flink中 time的分类

在flink中，time有不同分类，如下：
Event Time：
是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每一条日志都会记录自己的生成时间，Flink通过时间戳分配器访问事件时间戳。

Ingestion Time：
是数据进入Flink的时间。

Processing Time：
是每一个执行基于时间操作的算子的本地系统时间，与机器相关，默认的时间属性就是Processing Time。也就是数据被处理时的当前时间。

这些时间有什么不同呢？因网络传输需要时间，所以Ingestion Time不一定和Event Time相等，很多情况下是不等的。同样Processing Time表示数据处理时的时间，如果数据是很久之前采集的，现在才处理，那么很明显，三个时间time都不会相等的。
四、FLINK - ウィンドウ、イベント時刻と透かし原理と使用
​ 图 2.1 flink--时间的概念

例子：
一条日志进入Flink的时间为2017-11-12 10:00:00.123，到达Window的系统时间为2017-11-12 10:00:01.234，日志的内容如下：
2017-11-02 18:37:15.624 INFO Fail over to rm2
可以看到，三个time都不相等。而对于业务来说，要统计1min内的故障日志个数，哪个时间是最有意义的？—— eventTime，因为我们要根据日志的生成时间进行统计。但是flink默认的窗口的时间是Processing Time，那么如何引入eventTime呢？

2.2 eventTime的引入

​ 在Flink的流式处理中，绝大部分的业务都会使用eventTime，一般只在eventTime无法使用时，才会被迫使用ProcessingTime或者IngestionTime。默认使用的是ProcessingTime。那么如何指定flink使用指定的time呢？

2.2.1 引入方式1：设置env时间类型

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setStreamTimeCharacteristic(时间类型);

//三种类型的time对应如下：
TimeCharacteristic.EventTime；  eventtime
TimeCharacteristic.IngestionTime;  到达flink的时间
TimeCharacteristic.ProcessingTime;  处理数据的时间

这种方式是整个env全局生效的，是直接将env默认的时间设置为eventtime。后面的窗口操作默认就会使用eventtime作为时间依据。如果想不同的窗口设置不同的时间类型，这种方式就行不通了。

2.2.2 引入方式2：单独设置window的实际类型

stream.window(TumblingEventTimeWindows.of(Time.seconds(5)))

.window这个api就是所有窗口总的api，其他窗口api都是通过这个api封装出来的。可以通过这个总api，参数直接窗口的类型，比如上面的就是指定eventtime 的timewindow，这样并不会影响整个env的时间类型。

同样的，其他时间类型窗口，比如：
SlidingEventTimeWindows  滑动eventtime窗口

基本上看名字就知道是什么时间类型（三大时间类型）、以及什么类型（滑动、滚动、会话窗口）的窗口了。注意：eventtime没有session窗口，processingTime和

2.3 watermark的原理

2.3.1 引入背景

​ 我们知道，流处理从事件产生，到流经source，再到operator，中间是有一个过程和时间的，虽然大部分情况下，流到operator的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络、背压等原因，导致乱序的产生，所谓乱序，就是指Flink接收到的事件的先后顺序不是严格按照事件的Event Time顺序排列的。
四、FLINK - ウィンドウ、イベント時刻と透かし原理と使用
​ 图 2.3 数据的乱序
​ 那么此时出现一个问题，一旦出现乱序，如果只根据eventTime决定window的运行，我们不能明确数据是否全部到位，但又不能无限期的等下去，此时必须要有个机制来保证一个特定的时间后，必须触发window去进行计算了，这个特别的机制，就是Watermark。
解释：
如果只按照到达的event的eventtime来触发窗口操作，假设有event1~5。如果到达顺序是乱的，比如event5最先达到，然后event1也达到了，那么flink这边怎么知道这中间还有没有数据呢？没办法的，不能确定数据是否完整到达，也不能无限制等待下去。所以需要一种机制来处理这种情况。

2.3.2 watermark机制原理

​ Watermark是一种衡量Event Time进展的机制，它是数据本身的一个隐藏属性，数据本身携带着对应的Watermark。Watermark是用于处理乱序事件的，而正确的处理乱序事件，通常用Watermark机制结合window来实现。
​ 数据流中的Watermark用于表示timestamp小于Watermark的数据，都已经到达了，因此，window的执行也是由Watermark触发的。
​ Watermark可以理解成一个延迟触发机制，我们可以设置Watermark的延时时长t，每次系统会校验已经到达的数据中最大的maxEventTime，然后认定eventTime小于maxEventTime - t的所有数据都已经到达，如果有窗口的停止时间等于maxEventTime – t，那么这个窗口被watermark触发执行。
解释：
​ watermark是一种概率性的机制。假设event1~5，如果event5已经到达了，那么其实按照event产生的先后顺序，正常情况下，前面的event1~4应该也到达了。而为了保证前面的event1~4的到达（其实是更多的到达，但是不一定全部都到达），在event5到达了之后，提供一定的延迟时间t。当event5到达，且经过 t 时间之后，正常情况下，前面的event1~4 大概率会到达了，如果没有到达，属于少数情况，那么就认为event5之前的event都到达了，无论是否真的全部到达了。如果在延迟时间之后到达了，这个旧数据直接会被丢弃。所以其实watermark就是一种保障更多event乱序到达的机制，提供了一定的延时机制，而因为只会延迟一定的时间，所以也不会导致flink无限期地等待下去。

有序数据流的watermark如下：（watermark设置为0）
四、FLINK - ウィンドウ、イベント時刻と透かし原理と使用
​ 图 2.4 有序数据流的watermark
乱序数据流的watermark如下：（watermark设置为2）
四、FLINK - ウィンドウ、イベント時刻と透かし原理と使用
​ 图 2.5 乱序数据流的watermark
​ 当Flink接收到每一条数据时，都会产生一条Watermark，这条Watermark就等于当前所有到达数据中的maxEventTime - 延迟时长t，也就是说，Watermark是由数据携带的，一旦数据携带的Watermark比当前未触发的窗口的停止时间要晚，那么就会触发相应窗口的执行。由于Watermark是由数据携带的，因此，如果运行过程中无法获取新的数据，那么没有被触发的窗口将永远都不被触发。
​ 上图中，我们设置的允许最大延迟到达时间为2s，所以时间戳为7s的事件对应的Watermark是5s，时间戳为12s的事件的Watermark是10s，如果我们的窗口1是1s~5s，窗口2是6s~10s，那么时间戳为7s的事件到达时的Watermarker恰好触发窗口1，时间戳为12s的事件到达时的Watermark恰好触发窗口2。
​ Window会不断产生，属于这个Window范围的数据会被不断加入到Window中，所有未被触发的Window都会等待触发，只要Window还没触发，属于这个Window范围的数据就会一直被加入到Window中，直到Window被触发才会停止数据的追加，而当Window触发之后才接受到的属于被触发Window的数据会被丢弃。如果产生的窗口中没有新到的数据，也就不会有watermark，那么窗口就不会被触发计算。

2.3.3 watermark的触发计算的条件

watermark时间（max_eventTime-t） >= window_end_time；
在[window_start_time,window_end_time)中有数据存在。

2.3.4 watermark的产生方式

Punctuated：不间断产生
数据流中每一个递增的EventTime都会产生一个Watermark。
在实际的生产中Punctuated方式在TPS很高的场景下会产生大量的Watermark在一定程度上对下游算子造成压力，所以只有在实时性要求非常高的场景才会选择Punctuated的方式进行Watermark的生成。

Periodic：周期性产生
周期性的（一定时间间隔或者达到一定的记录条数）产生一个Watermark。
在实际的生产中Periodic的方式必须结合时间和积累条数两个维度继续周期性产生Watermark，否则在极端情况下会有很大的延时。

这两种有不同的api实现，下面会讲

2.4 watermark的引入以及接口

2.4.1 watermark引入

需要先引入eventime，然后引入watermark

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

DataStreamSource<String> source = env.readTextFile("/test.txt");

//引入的watermark的实现类
source.assignTimestampsAndWatermarks(xx)

watermark的实现有两大类，对应上面的两种watermark的产生方式，有两个接口：

AssignerWithPeriodicWatermarks;   周期性产生watermark，即Period
AssignerWithPunctuatedWatermarks;  Punctuated：不间断产生

2.4.2 AssignerWithPeriodicWatermarks接口

看看AssignerWithPeriodicWatermarks这个接口的源码，主要用于周期性产生watermark

public interface AssignerWithPeriodicWatermarks<T> extends TimestampAssigner<T> {
    //获取当前的watermark
    @Nullable
    Watermark getCurrentWatermark();
}

//父接口===================
public interface TimestampAssigner<T> extends Function {
    //获取当前的时间戳
    long extractTimestamp(T var1, long var2);
}

2つの方法が各イベントのタイムスタンプを取得するための透かし、extractTimestampを生成するために、カバーに必要getCurrentWatermark（）が主にあります。
これは定期的に生成された透かしのインタフェースであるので、ENVの構成を指定、どのくらい発生期間を指定する必要がある、など。

env.getConfig().setAutoWatermarkInterval(n ms);
记住间隔时间单位是毫秒

例：

/*根据eventTime 创建处理watermark
*/
public class BoundedOutOfOrdernessGenerator implements AssignerWithPeriodicWatermarks<MyEvent> {

    //watermark延迟时间 t，单位是毫秒
    private final long maxOutOfOrderness = 3500; // 3.5 seconds

    //保存当前最大的时间戳
    private long currentMaxTimestamp;

    //根据传递进来的event，获取time，然后如果比当前最大的time还大，就替换，否则保持。因为数据乱序到达是无法保证时间是递增的
    @Override
    public long extractTimestamp(MyEvent element, long previousElementTimestamp) {
        long timestamp = element.getCreationTime();
        currentMaxTimestamp = Math.max(timestamp, currentMaxTimestamp);
        return timestamp;
    }

    //返回watermark
    @Override
    public Watermark getCurrentWatermark() {
        // return the watermark as current highest timestamp minus the out-of-orderness bound
        return new Watermark(currentMaxTimestamp - maxOutOfOrderness);
    }
}

setAutoWatermarkInterval（N MS）を加えたセットは、定期的にウォーターマークを生成することができます。

2.4.3 AssignerWithPunctuatedWatermarks接口

AssignerWithPunctuatedWatermarksは、主にリアルタイムで透かしを生成するために使用され、この送信元インターフェイスを見て

public interface AssignerWithPunctuatedWatermarks<T> extends TimestampAssigner<T> {
    //获取最新的watermark
    @Nullable
    Watermark checkAndGetNextWatermark(T var1, long var2);
}

//父接口
public interface TimestampAssigner<T> extends Function {
    //从event中获取timestamp
    long extractTimestamp(T var1, long var2);
}

実際には、文言及び上記と同様に、これは、透かしを生成するための時間間隔を設定しません。

2.4.4 FLINK自身の透かしの実装クラス

1、BoundedOutOfOrdernessTimestampExtractorは
クラスAssignerWithPeriodicWatermarksインタフェースを継承し、そのソースを参照します

package org.apache.flink.streaming.api.functions.timestamps;

import org.apache.flink.streaming.api.functions.AssignerWithPeriodicWatermarks;
import org.apache.flink.streaming.api.watermark.Watermark;
import org.apache.flink.streaming.api.windowing.time.Time;

public abstract class BoundedOutOfOrdernessTimestampExtractor<T> implements AssignerWithPeriodicWatermarks<T> {
    private static final long serialVersionUID = 1L;
    private long currentMaxTimestamp;
    private long lastEmittedWatermark = -9223372036854775808L;
    private final long maxOutOfOrderness;

    //构造方法中接收一个参数，就是延迟时间 t
    public BoundedOutOfOrdernessTimestampExtractor(Time maxOutOfOrderness) {
        if (maxOutOfOrderness.toMilliseconds() < 0L) {
            throw new RuntimeException("Tried to set the maximum allowed lateness to " + maxOutOfOrderness + ". This parameter cannot be negative.");
        } else {
            this.maxOutOfOrderness = maxOutOfOrderness.toMilliseconds();
            this.currentMaxTimestamp = -9223372036854775808L + this.maxOutOfOrderness;
        }
    }

    public long getMaxOutOfOrdernessInMillis() {
        return this.maxOutOfOrderness;
    }

    //需要重写的方法，用于获取timestamp
    public abstract long extractTimestamp(T var1);

    //获取watermark的方法已经写好了，用传递进来的延迟时间t来计算得出watermark
    public final Watermark getCurrentWatermark() {
        long potentialWM = this.currentMaxTimestamp - this.maxOutOfOrderness;
        if (potentialWM >= this.lastEmittedWatermark) {
            this.lastEmittedWatermark = potentialWM;
        }

        return new Watermark(this.lastEmittedWatermark);
    }

    public final long extractTimestamp(T element, long previousElementTimestamp) {
        long timestamp = this.extractTimestamp(element);
        if (timestamp > this.currentMaxTimestamp) {
            this.currentMaxTimestamp = timestamp;
        }

        return timestamp;
    }
}

このクラスは、ユーザー定義可能なセットに透かしトンの遅延時間を達成することです。

2、AscendingTimestampExtractorは
、クラスAssignerWithPeriodicWatermarksインタフェースを継承します。安定したタイムスタンプインクリメント、例えばカフカパーティションデータを有するデータソースは、情報の各片は、このクラスのために+1だけインクリメントされます。あなただけが書き換える必要があり
extractAscendingTimestamp方法を。

2.5イベント時刻、窓、及び例えば透かしと併せて

package flinktest;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;

public class EventTimeTest {
    public static void main(String[] args) {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        env.getConfig().setAutoWatermarkInterval(1000);

        DataStreamSource<String> source = env.readTextFile("/tmp/test.txt");

        source.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<String>(Time.milliseconds(3000)) {
            @Override
            public long extractTimestamp(String s) {
                return Integer.valueOf(s.split(" ")[0]);
            }
        }).flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
                Tuple2<String, Integer> tmpTuple = new Tuple2<>();
                for (String s1 : s.split(" ")) {
                    tmpTuple.setFields(s1, 1);
                    collector.collect(tmpTuple);
                }
            }
        }).keyBy(0)
                .timeWindow(Time.seconds(10))
                .reduce(new ReduceFunction<Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> reduce(Tuple2<String, Integer> t1, Tuple2<String, Integer> t2) throws Exception {
                        return new Tuple2<>(t1.f0, t1.f1 + t2.f1);
                    }
                })
                .print();
         try {
            env.execute("eventtime test");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ウィンドウAPIのクラスの継承構造

おすすめ

転載: blog.51cto.com/kinglab/2457255
おすすめ
中国人プログラマーの「35歳の呪い」
Lanya CorelDRAW プラグイン 2024.5.1 国際労働者の日バージョン、無料ダウンロード
ランキング
ループコントローラ
スピーカーの分類（スピーカーDiarisation）
雑音除去空気とフロートを除去するための統計的フィルタリング方法を使用して
Spring Cloudプロジェクトの構築（5）
Echarts去掉图形后面的网格线
【レジャー・楽しみ】C言語でクリスマスツリーを描く方法
ゲームが反映するように、後に＃589（本部2）ラウンドCodeforces
アレイの重複排除について知っているソリューションはいくつありますか？
NetBackupの証明書の有効期限は-nBuエラー8506に近づきます
Dockerコンテナの起動パラメータを表示する
アーカイブ
もっと
2024-05-04(18)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(35)
2024-04-29(5)
2024-04-28(12)
2024-04-27(29)
2024-04-26(22)
2024-04-25(31)

コードワールド

© 2018 codetd.com