7、Flink四大基石之Time和WaterMark详解与详细示例（watermark基本使用、kafka作为数据源的watermark使用示例以及超出最大允许延迟数据的接收实现）

已于 2024-04-10 12:43:43 修改
阅读量4w 收藏 2
点赞数 2
分类专栏： # Flink专栏 文章标签： flink kafka watermaker flink 水印 flink kafka 水印 flink 水印策略 flink 水印自定义
于 2023-07-12 17:17:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenwewi520feng/article/details/131673646
版权

Flink 系列文章

一、Flink 专栏

Flink 专栏系统介绍某一知识点，并辅以具体的示例进行说明。

  • 1、Flink 部署系列
    本部分介绍Flink的部署、配置相关基础内容。

  • 2、Flink基础系列
    本部分介绍Flink 的基础部分，比如术语、架构、编程模型、编程指南、基本的datastream api用法、四大基石等内容。

  • 3、Flik Table API和SQL基础系列
    本部分介绍Flink Table Api和SQL的基本用法，比如Table API和SQL创建库、表用法、查询、窗口函数、catalog等等内容。

  • 4、Flik Table API和SQL提高与应用系列
    本部分是table api 和sql的应用部分，和实际的生产应用联系更为密切，以及有一定开发难度的内容。

  • 5、Flink 监控系列
    本部分和实际的运维、监控工作相关。

二、Flink 示例专栏

Flink 示例专栏是 Flink 专栏的辅助说明，一般不会介绍知识点的信息，更多的是提供一个一个可以具体使用的示例。本专栏不再分目录，通过链接即可看出介绍的内容。

两专栏的所有文章入口点击：Flink 系列文章汇总索引

文章目录

本文详细介绍了eventtime和watermark，包括watermark的Flink自带的api实现与自定义的实现，同时以三个示例来展示watermark的实际可能的应用场景。
本文依赖kafka环境可用。
本文分为四个部分，即EventTime与watermark介绍、watermark基本使用、kafka作为数据源的watermark使用示例以及超出最大允许延迟数据的接收实现。

一、事件时间与watermark

1、EventTime介绍

处理时间是指执行相应操作的机器的系统时间。
事件时间是每个事件在其生产设备上发生的时间。

下图形象的展示了event time 和 processing time的所处阶段。一般将Flink data source下的箭头表示为到达Flink的时间，即injestion time摄入时间。
在这里插入图片描述

2、Eventtime与watermark

支持事件时间的流处理器需要一种方法来测量事件时间的进度。例如，当事件时间超过一小时结束时，需要通知构建每小时窗口的窗口运算符，以便操作员可以关闭正在进行的窗口。

事件时间可以独立于处理时间进行。例如，在一个程序中，操作员的当前事件时间可能略微落后于处理时间（考虑接收事件的延迟），而两者以相同的速度进行。另一方面，另一个流程序可能会通过快进已经在 Kafka 主题（或其他消息队列）中缓冲的一些历史数据，在几秒钟的处理中完成数周的事件时间。

Flink 中衡量事件时间进度的机制是水印。水印作为数据流的一部分流动，并带有时间戳 t。水印（t） 声明事件时间已到达该流中的时间 t，这意味着流中不应再有时间戳为 t’ <= t 的元素（即时间戳早于或等于水印的事件）。

下图显示了具有（逻辑）时间戳和内联流动水印的事件流。在此示例中，事件是按顺序排列的（相对于其时间戳），这意味着水印只是流中的周期性标记。

在这里插入图片描述

水印对于无序流至关重要，如下图所示，事件不按其时间戳排序。通常，水印是一种声明，即到流中的该点，直到某个时间戳的所有事件都应该已到达。水印到达运算符后，运算符可以将其内部事件时钟提前到水印的值。
在这里插入图片描述

3、Watermarks in Parallel Streams

水印在source Function处或紧随source Function之后生成。source Function的每个并行子任务通常独立生成其水印。这些水印定义该特定并行源的事件时间。

当水印流经流媒体程序时，当水印到达的时候会触发事件时间的计算（they advance the event time at the operators where they arrive）。每当operator触发（advance）其事件时间时，它都会为其后续运算符在下游生成新的水印。

一些运算符使用多个输入流；例如，union，或 keyBy（…） 或 partition（…） 函数的运算符。此类运算符的当前事件时间是其输入流的事件时间的最小值。当其输入流更新其事件时间时，运算符也会更新。

		this.outOfOrdernessMillis = maxOutOfOrderness.toMillis();
		// start so that our lowest watermark would be Long.MIN_VALUE.
		this.maxTimestamp = Long.MIN_VALUE + outOfOrdernessMillis + 1;

下图显示了流经并行流的事件和水印以及跟踪事件时间的运算符的示例。

在这里插入图片描述

4、Lateness延迟

某些元素可能会违反水印条件，这意味着即使在 Watermark（t） 发生之后，也会出现更多时间戳为 t’ <= t 的元素。事实上，在许多现实世界的设置中，某些元素可以任意延迟，因此无法指定某个事件时间戳的所有元素发生的时间。此外，即使延迟是有限制的，通常也不希望将水印延迟太多，因为这会导致事件时间窗口的评估延迟太多。

出于这个原因，流应用可能会明确地期望一些后期元素。延迟元素是在系统的事件时钟（由水印指示）已经过了延迟元素时间戳的时间之后到达的元素。有关如何在事件时间窗口中使用延迟元素的搜集（一般用OutputTag）与使用视情况而定。代码示例如下：

DataStream<T> input = ...;

input
    .keyBy(<key selector>)
    .window(<window assigner>)
    .allowedLateness(<time>)
    .<windowed transformation>(<window function>);

5、watermark介绍

watermark就是给数据再额外的加的一个时间列，watermark是个时间戳。

watermark= 数据的事件时间 - 最大允许的延迟时间或乱序时间

watermark= 当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间
这样可以保证watermark水位线会一直上升(变大)，不会下降

  • 窗口计算的触发条件为
    1、窗口中有数据
    2、watermark>= 窗口的结束时间

6、Watermark 策略简介

使用 Flink API 时需要设置一个同时包含 TimestampAssigner 和 WatermarkGenerator 的 WatermarkStrategy。WatermarkStrategy 工具类中也提供了许多常用的 watermark 策略，并且用户也可以在某些必要场景下构建自己的 watermark 策略。WatermarkStrategy 接口如下：

public interface WatermarkStrategy<T> extends TimestampAssignerSupplier<T>, WatermarkGeneratorSupplier<T>{

    /**
     * 根据策略实例化一个可分配时间戳的 {@link TimestampAssigner}。
     */
    @Override
    TimestampAssigner<T> createTimestampAssigner(TimestampAssignerSupplier.Context context);

    /**
     * 根据策略实例化一个 watermark 生成器。
     */
    @Override
    WatermarkGenerator<T> createWatermarkGenerator(WatermarkGeneratorSupplier.Context context);
}

通常情况下，不用实现此接口，而是可以使用 WatermarkStrategy 工具类中通用的 watermark 策略，或者可以使用这个工具类将自定义的 TimestampAssigner 与 WatermarkGenerator 进行绑定。例如，想要使用有界无序（bounded-out-of-orderness）watermark 生成器和一个 lambda 表达式作为时间戳分配器，那么可以按照如下方式实现：

WatermarkStrategy
        .<Tuple2<Long, String>>forBoundedOutOfOrderness(Duration.ofSeconds(20))
        .withTimestampAssigner((event, timestamp) -> event.f0);
//其中 TimestampAssigner 的设置与否是可选的，大多数情况下，可以不用去特别指定。例如，当使用 Kafka 或 Kinesis 数据源时，你可以直接从 Kafka/Kinesis 数据源记录中获取到时间戳。

7、使用 Watermark 策略

WatermarkStrategy 可以在 Flink 应用程序中的两处使用

  • 第一种是直接在数据源上使用，相比第二种会更好。因为数据源可以利用 watermark 生成逻辑中有关分片/分区（shards/partitions/splits）的信息。使用这种方式，数据源通常可以更精准地跟踪 watermark，整体 watermark 生成将更精确。直接在源上指定 WatermarkStrategy 意味着必须使用特定数据源接口，参考下文的kafka部分，以及有关每个分区的 watermark 是如何生成以及工作的。
  • 第二种是直接在非数据源的操作之后使用，仅当无法直接在数据源上设置策略时，才应该使用第二种方式（在任意转换操作之后设置 WatermarkStrategy）
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

DataStream<MyEvent> stream = env.readFile(
        myFormat, myFilePath, FileProcessingMode.PROCESS_CONTINUOUSLY, 100,
        FilePathFilter.createDefaultFilter(), typeInfo);

DataStream<MyEvent> withTimestampsAndWatermarks = stream
        .filter( event -> event.severity() == WARNING )
        .assignTimestampsAndWatermarks(<watermark strategy>);

withTimestampsAndWatermarks
        .keyBy( (event) -> event.getGroup() )
        .window(TumblingEventTimeWindows.of(Time.seconds(10)))
        .reduce( (a, b) -> a.add(b) )
        .addSink(...);

使用 WatermarkStrategy 去获取流并生成带有时间戳的元素和 watermark 的新流时，如果原始流已经具有时间戳或 watermark，则新指定的时间戳分配器将覆盖原有的时间戳和 watermark。

8、处理空闲数据源

如果数据源中的某一个分区/分片在一段时间内未发送事件数据，则意味着 WatermarkGenerator 也不会获得任何新数据去生成 watermark。
称这类数据源为空闲输入或空闲源。在这种情况下，当某些其他分区仍然发送事件数据的时候就会出现问题。由于下游算子 watermark 的计算方式是取所有不同的上游并行数据源 watermark 的最小值，则其 watermark 将不会发生变化。

为了解决这个问题，可以使用 WatermarkStrategy 来检测空闲输入并将其标记为空闲状态。WatermarkStrategy 为此提供了一个工具接口：

WatermarkStrategy
        .<Tuple2<Long, String>>forBoundedOutOfOrderness(Duration.ofSeconds(20))
        .withIdleness(Duration.ofMinutes(1));

9、自定义 WatermarkGenerator

可以针对每个事件去生成 watermark。但是由于每个 watermark 都会在下游做一些计算，因此过多的 watermark 会降低程序性能。

TimestampAssigner 是一个可以从事件数据中提取时间戳字段的简单函数，但是 WatermarkGenerator 的编写相对就要复杂一些了，将在接下来的两小节中介绍如何实现此接口。WatermarkGenerator 接口代码如下：

/**
 * {@code WatermarkGenerator} 可以基于事件或者周期性的生成 watermark。
 *
 * <p><b>注意：</b>  WatermarkGenerator 将以前互相独立的 {@code AssignerWithPunctuatedWatermarks} 
 * 和 {@code AssignerWithPeriodicWatermarks} 一同包含了进来。
 */
@Public
public interface WatermarkGenerator<T> {

    /**
     * 每来一条事件数据调用一次，可以检查或者记录事件的时间戳，或者也可以基于事件数据本身去生成 watermark。
     */
    void onEvent(T event, long eventTimestamp, WatermarkOutput output);

    /**
     * 周期性的调用，也许会生成新的 watermark，也许不会。
     *
     * <p>调用此方法生成 watermark 的间隔时间由 {@link ExecutionConfig#getAutoWatermarkInterval()} 决定。
     */
    void onPeriodicEmit(WatermarkOutput output);
}

watermark 的生成方式本质上是有两种：周期性生成和标记生成。

  • 周期性生成器通常通过 onEvent() 观察传入的事件数据，然后在框架调用 onPeriodicEmit() 时发出 watermark。
  • 标记生成器将查看 onEvent() 中的事件数据，并等待检查在流中携带 watermark 的特殊标记事件或打点数据。当获取到这些事件数据时，它将立即发出 watermark。通常情况下，标记生成器不会通过 onPeriodicEmit() 发出 watermark。

1）、自定义周期性 Watermark 生成器

周期性生成器会观察流事件数据并定期生成 watermark（其生成可能取决于流数据，或者完全基于处理时间）。

生成 watermark 的时间间隔（每 n 毫秒）可以通过 ExecutionConfig.setAutoWatermarkInterval(…) 指定。每次都会调用生成器的 onPeriodicEmit() 方法，如果返回的 watermark 非空且值大于前一个 watermark，则将发出新的 watermark。

如下是两个使用周期性 watermark 生成器的简单示例。
Flink 已经附带了 BoundedOutOfOrdernessWatermarks，它实现了 WatermarkGenerator，其工作原理与下面的 BoundedOutOfOrdernessGenerator 相似。可以在这里参阅如何使用它的内容。

/**
 * 该 watermark 生成器可以覆盖的场景是：数据源在一定程度上乱序。
 * 即某个最新到达的时间戳为 t 的元素将在最早到达的时间戳为 t 的元素之后最多 n 毫秒到达。
 */
public class BoundedOutOfOrdernessGenerator implements WatermarkGenerator<MyEvent> {
    private final long maxOutOfOrderness = 3500; // 3.5 秒
    private long currentMaxTimestamp;

    @Override
    public void onEvent(MyEvent event, long eventTimestamp, WatermarkOutput output) {
        currentMaxTimestamp = Math.max(currentMaxTimestamp, eventTimestamp);
    }

    @Override
    public void onPeriodicEmit(WatermarkOutput output) {
        // 发出的 watermark = 当前最大时间戳 - 最大乱序时间
        output.emitWatermark(new Watermark(currentMaxTimestamp - maxOutOfOrderness - 1));
    }

}

/**
 * 该生成器生成的 watermark 滞后于处理时间固定量。它假定元素会在有限延迟后到达 Flink。
 */
public class TimeLagWatermarkGenerator implements WatermarkGenerator<MyEvent> {
    private final long maxTimeLag = 5000; // 5 秒

    @Override
    public void onEvent(MyEvent event, long eventTimestamp, WatermarkOutput output) {
        // 处理时间场景下不需要实现
    }

    @Override
    public void onPeriodicEmit(WatermarkOutput output) {
        output.emitWatermark(new Watermark(System.currentTimeMillis() - maxTimeLag));
    }
}

2）、自定义标记 Watermark 生成器

标记 watermark 生成器观察流事件数据并在获取到带有 watermark 信息的特殊事件元素时发出 watermark。

如下是实现标记生成器的方法，当事件带有某个指定标记时，该生成器就会发出 watermark：

public class PunctuatedAssigner implements WatermarkGenerator<MyEvent> {

    @Override
    public void onEvent(MyEvent event, long eventTimestamp, WatermarkOutput output) {
        if (event.hasWatermarkMarker()) {
            output.emitWatermark(new Watermark(event.getWatermarkTimestamp()));
        }
    }

    @Override
    public void onPeriodicEmit(WatermarkOutput output) {
        // onEvent 中已经实现
    }
}

10、Watermark 策略与 Kafka 连接器

当使用 Apache Kafka 连接器作为数据源时，每个 Kafka 分区可能有一个简单的事件时间模式（递增的时间戳或有界无序）。然而，当使用 Kafka 数据源时，多个分区常常并行使用，因此交错来自各个分区的事件数据就会破坏每个分区的事件时间模式（这是 Kafka 消费客户端所固有的）。

在这种情况下，你可以使用 Flink 中可识别 Kafka 分区的 watermark 生成机制。使用此特性，将在 Kafka 消费端内部针对每个 Kafka 分区生成 watermark，并且不同分区 watermark 的合并方式与在数据流 shuffle 时的合并方式相同。

例如，如果每个 Kafka 分区中的事件时间戳严格递增，则使用时间戳单调递增按分区生成的 watermark 将生成完美的全局 watermark。注意，在示例中未使用 TimestampAssigner，而是使用了 Kafka 记录自身的时间戳。

下图展示了如何使用单 kafka 分区 watermark 生成机制，以及在这种情况下 watermark 如何通过 dataflow 传播。
在这里插入图片描述

//kafka数据源示例，没有使用withTimestampAssigner
FlinkKafkaConsumer<MyType> kafkaSource = new FlinkKafkaConsumer<>("myTopic", schema, props);
kafkaSource.assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(20)));

DataStream<MyType> stream = env.addSource(kafkaSource);

//非kafka数据源示例，使用了withTimestampAssigner
WatermarkStrategy
        .<Tuple2<Long, String>>forBoundedOutOfOrderness(Duration.ofSeconds(20))
        .withTimestampAssigner((event, timestamp) -> event.f0);

11、算子处理 Watermark 的方式

一般情况下，在将 watermark 转发到下游之前，需要算子对其进行触发的事件完全进行处理。例如，WindowOperator 将首先计算该 watermark 触发的所有窗口数据，当且仅当由此 watermark 触发计算进而生成的所有数据被转发到下游之后，其才会被发送到下游。换句话说，由于此 watermark 的出现而产生的所有数据元素都将在此 watermark 之前发出。

相同的规则也适用于 TwoInputStreamOperator。但是，在这种情况下，算子当前的 watermark 会取其两个输入的最小值。

二、示例1：每5s统计一次地铁进站每个入口人数

每5s统计一次地铁进站每个入口人数，最多接受延迟3s的数据
数据结构：进站口、人数和进入时间

1、实现

  • bean
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author alanchan
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Subway {
	private String sNo;
	private Integer userCount;
	private Long enterTime;
}
  • 实现
import java.time.Duration;
import java.util.Random;
import java.util.UUID;

import org.apache.commons.lang.time.FastDateFormat;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
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.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

/**
 * @author alanchan 
 * 每10s统计一次地铁进站每个入口人数
 */
public class WatermarkDemo {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		FastDateFormat df = FastDateFormat.getInstance("HH:mm:ss");
		// env
		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);

		// source
		DataStreamSource<Subway> subwayDS = env.addSource(new SourceFunction<Subway>() {
			private boolean flag = true;

			@Override
			public void run(SourceContext<Subway> ctx) throws Exception {
				Random random = new Random();
				while (flag) {
					String sNo = "No"+random.nextInt(3);
					int userCount = random.nextInt(100);
					// 模拟延迟数据
					long eventTime = System.currentTimeMillis() - random.nextInt(10) * 1000;
					Subway subway = new Subway(sNo, userCount, eventTime);
					System.err.println(subway + " ，格式化后时间 " + df.format(subway.getEnterTime()));
					
					ctx.collect(subway);
					Thread.sleep(1000);
				}
			}

			@Override
			public void cancel() {
				flag = false;
			}
		});

		// transformation
		// 设置watermark = 当前最大的事件时间 - 最大允许的延迟时间或乱序时间
		SingleOutputStreamOperator<Subway> subwayWithWatermark = subwayDS
				.assignTimestampsAndWatermarks(WatermarkStrategy.<Subway>forBoundedOutOfOrderness(Duration.ofSeconds(3))// 指定最大允许的延迟时间
				.withTimestampAssigner((subway, timestamp) -> subway.getEnterTime()));// 指定eventtime事件时间列

		// 计算窗口
		SingleOutputStreamOperator<Subway> result = subwayWithWatermark
				.keyBy(Subway::getSNo)
				.window(TumblingEventTimeWindows.of(Time.seconds(5)))
				.sum("userCount");

		// sink
		result.print();

		// execute
		env.execute();
	}

}

2、验证

输出结果，按照预期计算出了结果

Subway(sNo=No0, userCount=7, enterTime=1689148937760) ，格式化后时间 16:02:17
Subway(sNo=No1, userCount=93, enterTime=1689148933782) ，格式化后时间 16:02:13
Subway(sNo=No2, userCount=21, enterTime=1689148940783) ，格式化后时间 16:02:20
10> Subway(sNo=No1, userCount=93, enterTime=1689148933782)
Subway(sNo=No0, userCount=7, enterTime=1689148936784) ，格式化后时间 16:02:16
Subway(sNo=No0, userCount=53, enterTime=1689148944788) ，格式化后时间 16:02:24
10> Subway(sNo=No0, userCount=14, enterTime=1689148937760)
Subway(sNo=No2, userCount=66, enterTime=1689148944790) ，格式化后时间 16:02:24
Subway(sNo=No2, userCount=97, enterTime=1689148944803) ，格式化后时间 16:02:24
Subway(sNo=No2, userCount=79, enterTime=1689148946807) ，格式化后时间 16:02:26
Subway(sNo=No2, userCount=83, enterTime=1689148945821) ，格式化后时间 16:02:25
Subway(sNo=No0, userCount=84, enterTime=1689148941836) ，格式化后时间 16:02:21
Subway(sNo=No2, userCount=50, enterTime=1689148947852) ，格式化后时间 16:02:27
Subway(sNo=No1, userCount=10, enterTime=1689148942864) ，格式化后时间 16:02:22
Subway(sNo=No0, userCount=20, enterTime=1689148944866) ，格式化后时间 16:02:24
Subway(sNo=No2, userCount=1, enterTime=1689148945877) ，格式化后时间 16:02:25
Subway(sNo=No0, userCount=62, enterTime=1689148953888) ，格式化后时间 16:02:33
3> Subway(sNo=No2, userCount=184, enterTime=1689148940783)
10> Subway(sNo=No0, userCount=157, enterTime=1689148944788)
3> Subway(sNo=No2, userCount=213, enterTime=1689148946807)
10> Subway(sNo=No1, userCount=10, enterTime=1689148942864)
。。。。。。

三、示例2：kafka数据源，每10s统计一次地铁进站每个入口人数

注意该示例中，发送数据时不需要eventtime，flink会以kafka发送数据的时间戳为eventtime，也不需要withTimestampAssigner指定eventtime，详见实现源码。
每10s统计一次地铁进站每个入口人数，最多接受延迟3s的数据
数据结构：进站口、人数

1、maven依赖

		<dependency>
			<groupId>org.apache.flink</groupId>
			<artifactId>flink-connector-kafka_2.12</artifactId>
			<version>${flink.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.flink</groupId>
			<artifactId>flink-sql-connector-kafka_2.12</artifactId>
			<version>${flink.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.flink</groupId>
			<artifactId>flink-connector-jdbc_2.12</artifactId>
			<version>${flink.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.flink</groupId>
			<artifactId>flink-csv</artifactId>
			<version>${flink.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.flink</groupId>
			<artifactId>flink-json</artifactId>
			<version>${flink.version}</version>
		</dependency>

2、实现

  • bean

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author alanchan
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Subway {
	private String sNo;
	private Integer userCount;
}
  • 实现
import java.time.Duration;
import java.util.Properties;

import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
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.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.streaming.util.serialization.SimpleStringSchema;

/**
 * @author alanchan
 *
 */
public class KafkaWatermarkDemo {

	/**
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		// env
		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
		// source
		// 准备kafka连接参数
		Properties props = new Properties();
		props.setProperty("bootstrap.servers", "server1:9092");
		props.setProperty("group.id", "flink");
		props.setProperty("auto.offset.reset", "latest");
		props.setProperty("flink.partition-discovery.interval-millis", "5000");
		props.setProperty("enable.auto.commit", "true");
		props.setProperty("auto.commit.interval.ms", "2000");
		// 使用连接参数创建FlinkKafkaConsumer/kafkaSource
		FlinkKafkaConsumer<String> kafkaSource = new FlinkKafkaConsumer<String>("t_kafkasource", new SimpleStringSchema(), props);
		// 使用kafkaSource
		DataStream<Subway> subwayDS = env.addSource(kafkaSource).map(new MapFunction<String, Subway>() {

			@Override
			public Subway map(String value) throws Exception {
				String[] arr = value.split(",");

				return new Subway(arr[0], Integer.parseInt(arr[1]));
			}
		});

		// transformation
		// 设置watermark = 当前最大的事件时间 - 最大允许的延迟时间或乱序时间
		SingleOutputStreamOperator<Subway> subwayWithWatermark = subwayDS
		.assignTimestampsAndWatermarks(WatermarkStrategy.<Subway>forBoundedOutOfOrderness(Duration.ofSeconds(3))// 指定最大允许的延迟时间
		);

		// 计算窗口
		SingleOutputStreamOperator<Subway> result = subwayWithWatermark.keyBy(Subway::getSNo).window(TumblingEventTimeWindows.of(Time.seconds(10))).sum("userCount");

		// sink
		result.print();

		// execute
		env.execute();

	}

}

3、验证

1）、验证步骤

1、启动kafka，创建topic
2、启动应用程序
3、在kafka命令行中输入符合格式要求的数据
4、观察应用程序的控制台输出

2）、验证

启动kafka、创建topic、启动应用程序不再赘述，如果不清楚的参考本人kafka专栏。
1、在kafka命令控制台输入数据

kafka-console-producer.sh --broker-list server1:9092 --topic t_kafkasource

[alanchan@server1 onekeystart]$ kafka-console-producer.sh --broker-list server1:9092 --topic t_kafkasource
>1,2
>1,3
>1,4
>1,5
>1,6
>1,7
>2,4
>2,6
>2,8
>3,6

2、观察应用程序中的控制台输出

7> Subway(sNo=1, userCount=20)
4> Subway(sNo=2, userCount=18)
7> Subway(sNo=1, userCount=7)

四、示例3：处理延迟数据超过能接受的时间，每10s统计一次地铁进站每个入口人数

每10s统计一次地铁进站每个入口人数，最多接受延迟3s的数据，超过可接受范围则另外接收。
一般而言，针对延迟超过计算窗口的数据处理方式不同，视具体的情况而定。
本示例仅仅是打印出来。
数据结构：进站口、人数和进入时间

1、实现

  • bean

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author alanchan
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Subway {
	private String sNo;
	private Integer userCount;
	private Long enterTime;

}
  • 实现

import java.time.Duration;
import java.util.Random;
import java.util.UUID;

import org.apache.commons.lang.time.FastDateFormat;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
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.source.SourceFunction.SourceContext;
import org.apache.flink.streaming.api.scala.OutputTag;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

/**
 * @author alanchan
 *
 */
public class WatermarkLatenessDemo {

	/**
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		FastDateFormat df = FastDateFormat.getInstance("HH:mm:ss");
		// env
		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);

		// source
		DataStreamSource<Subway> subwayDS = env.addSource(new SourceFunction<Subway>() {
			private boolean flag = true;

			@Override
			public void run(SourceContext<Subway> ctx) throws Exception {
				Random random = new Random();
				while (flag) {
					String sNo = "No" + random.nextInt(3);
					int userCount = random.nextInt(100);
					// 模拟延迟数据
					long eventTime = System.currentTimeMillis() - random.nextInt(20) * 1000;
					Subway subway = new Subway(sNo, userCount, eventTime);
					System.err.println(subway + " ，格式化后时间 " + df.format(subway.getEnterTime()));

					ctx.collect(subway);
					Thread.sleep(1000);
				}
			}

			@Override
			public void cancel() {
				flag = false;
			}
		});

		// transformation
		// 设置最大允许延迟时间3s
		SingleOutputStreamOperator<Subway> orderDSWithWatermark = subwayDS.assignTimestampsAndWatermarks(
				WatermarkStrategy.<Subway>forBoundedOutOfOrderness(Duration.ofSeconds(3)).withTimestampAssigner((subway, timestamp) -> subway.getEnterTime())// 指定事件时间列
		);

		// 接收延迟超过允许范围内的数据，供其他方式处理
		OutputTag<Subway> latenessData = new OutputTag<Subway>("seriousLateData", TypeInformation.of(Subway.class));

		SingleOutputStreamOperator<Subway> result1 = orderDSWithWatermark.keyBy(Subway::getSNo).window(TumblingEventTimeWindows.of(Time.seconds(10)))
				.allowedLateness(Time.seconds(3)).sideOutputLateData(latenessData).sum("userCount");

		DataStream<Subway> result2 = result1.getSideOutput(latenessData);

		// sink
		result1.print("延迟（含正常）在计算窗口内数据");
		result2.print("延迟不在计算窗口内数据");

		// execute
		env.execute();

	}

}

2、验证

验证比较简单，就是由系统自己生成数据，然后观察应用程序的控制台的输出是否与预期一致，经验证，本示例与预期一致。

Subway(sNo=No1, userCount=44, enterTime=1689152768384) ，格式化后时间 17:06:08
Subway(sNo=No1, userCount=24, enterTime=1689152764407) ，格式化后时间 17:06:04
Subway(sNo=No1, userCount=29, enterTime=1689152774418) ，格式化后时间 17:06:14
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No1, userCount=68, enterTime=1689152768384)
Subway(sNo=No1, userCount=83, enterTime=1689152767430) ，格式化后时间 17:06:07
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No1, userCount=151, enterTime=1689152768384)
Subway(sNo=No0, userCount=19, enterTime=1689152759435) ，格式化后时间 17:05:59
延迟不在计算窗口内数据:10> Subway(sNo=No0, userCount=19, enterTime=1689152759435)
Subway(sNo=No1, userCount=32, enterTime=1689152760443) ，格式化后时间 17:06:00
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No1, userCount=183, enterTime=1689152768384)
Subway(sNo=No0, userCount=56, enterTime=1689152775459) ，格式化后时间 17:06:15
Subway(sNo=No1, userCount=12, enterTime=1689152778472) ，格式化后时间 17:06:18
Subway(sNo=No1, userCount=26, enterTime=1689152776475) ，格式化后时间 17:06:16
Subway(sNo=No0, userCount=49, enterTime=1689152772488) ，格式化后时间 17:06:12
Subway(sNo=No2, userCount=93, enterTime=1689152767500) ，格式化后时间 17:06:07
延迟不在计算窗口内数据:3> Subway(sNo=No2, userCount=93, enterTime=1689152767500)
Subway(sNo=No1, userCount=26, enterTime=1689152779502) ，格式化后时间 17:06:19
Subway(sNo=No2, userCount=63, enterTime=1689152782512) ，格式化后时间 17:06:22
Subway(sNo=No1, userCount=73, enterTime=1689152775526) ，格式化后时间 17:06:15
Subway(sNo=No0, userCount=46, enterTime=1689152783539) ，格式化后时间 17:06:23
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No0, userCount=105, enterTime=1689152775459)
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No1, userCount=166, enterTime=1689152774418)
Subway(sNo=No2, userCount=72, enterTime=1689152779552) ，格式化后时间 17:06:19
延迟（含正常）在计算窗口内数据:3> Subway(sNo=No2, userCount=72, enterTime=1689152779552)
Subway(sNo=No0, userCount=43, enterTime=1689152774553) ，格式化后时间 17:06:14
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No0, userCount=148, enterTime=1689152775459)
Subway(sNo=No2, userCount=1, enterTime=1689152781567) ，格式化后时间 17:06:21
Subway(sNo=No2, userCount=49, enterTime=1689152775582) ，格式化后时间 17:06:15
延迟（含正常）在计算窗口内数据:3> Subway(sNo=No2, userCount=121, enterTime=1689152779552)
Subway(sNo=No1, userCount=4, enterTime=1689152782591) ，格式化后时间 17:06:22
Subway(sNo=No2, userCount=79, enterTime=1689152778604) ，格式化后时间 17:06:18
延迟（含正常）在计算窗口内数据:3> Subway(sNo=No2, userCount=200, enterTime=1689152779552)
Subway(sNo=No2, userCount=11, enterTime=1689152794608) ，格式化后时间 17:06:34
延迟（含正常）在计算窗口内数据:3> Subway(sNo=No2, userCount=64, enterTime=1689152782512)
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No1, userCount=4, enterTime=1689152782591)
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No0, userCount=46, enterTime=1689152783539)
Subway(sNo=No1, userCount=47, enterTime=1689152784620) ，格式化后时间 17:06:24
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No1, userCount=51, enterTime=1689152782591)
Subway(sNo=No0, userCount=12, enterTime=1689152788634) ，格式化后时间 17:06:28
延迟（含正常）在计算窗口内数据:10> Subway(sNo=No0, userCount=58, enterTime=1689152783539)
Subway(sNo=No0, userCount=71, enterTime=1689152790634) ，格式化后时间 17:06:30
Subway(sNo=No0, userCount=83, enterTime=1689152799635) ，格式化后时间 17:06:39
Subway(sNo=No0, userCount=11, enterTime=1689152799649) ，格式化后时间 17:06:39
Subway(sNo=No1, userCount=77, enterTime=1689152786650) ，格式化后时间 17:06:26
延迟不在计算窗口内数据:10> Subway(sNo=No1, userCount=77, enterTime=1689152786650)
Subway(sNo=No0, userCount=6, enterTime=1689152802662) ，格式化后时间 17:06:42
Subway(sNo=No1, userCount=87, enterTime=1689152791668) ，格式化后时间 17:06:31

以上，详细介绍了eventtime和watermark，包括watermark的Flink自带的api实现与自定义的实现，同时以三个示例来展示watermark的实际可能的应用场景。

一瓢一瓢的饮 alanchanchn
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Flink 源码解读系列 DataStream 带 Watermark 生成的时间戳分配器
SmartSi
09-10 1033
这篇文章主要从源码角度讲一下 Flink DataStream 中带 Watermark 生成的时间戳分配器。我们通常通过 DataStream 的 assignTimestampsAndWatermarks 方法分配时间戳并生成 Watermark。这两种时间戳分配器均是 TimestampAssigner 的子类，具体继承关系如下图所示。在为元素分配时间戳的基础之上增加了生成 Watermark 的逻辑，可以理解是一个实现 Watermark 生成逻辑的时间戳分配器。
flink生成Watermark之assignTimestampsAndWatermarks
小程序猿
11-22 9875
在DataStreamSource对象上调用assignTimestampsAndWatermarks方法，自定义Timestamp提取规则和Watermark生成规则。 文章目录基于AssignerWithPeriodicWatermarks接口 基于AssignerWithPeriodicWatermarks接口 AssignerWithPeriodicWatermarks接口扩展自TimestampAssigner类，其中extractTimestamp方法定义抽取Timestamp，getCurre
Flink自定义Assigning Timestamps和Watermarks
weixin_42412645的博客
06-23 7548
为了让event time工作，Flink需要知道事件的时间戳，这意味着流中的每个元素都需要分配其事件时间戳。这个通常是通过抽取或者访问事件中某些字段的时间戳来获取的。时间戳的分配伴随着水印的生成，告诉系统事件时间中的进度。下面介绍几种自定义事件时间戳方法 1.在数据流源中定义 可以看Flink静态Session Windows这边文章里面有 2.使用DataStream API中的assignA...
flink assignTimestampsAndWatermarks两种水印生成方式 源码分析
weixin_40809627的博客
07-28 1万+
时间戳和水印的时间生成方式一般有一下两种方式 1、BoundedOutOfOrdernessTimestampExtractor AscendingTimestampExtractor
flink watermark介绍及watermark的窗口触发机制
weixin_38251332的博客
05-11 1026
在谈watermark之前，首先需要了解flink的三种时间概念。在flink中，有三种时间戳概念：Event Time 、Processing Time 和 Ingestion Time。其中watermark只对Event Time类型的时间戳有用。
Flink 解决乱序问题之WaterMarker
胖虎儿的博客
05-26 8355
事件乱序了怎么办？用WaterMaker啦！
flink多并行数据源下的waterMark触发机制1.pdf
01-22
在本文中，我们将详细介绍 Flink 多并行数据源下的 WaterMark 触发机制，并提供一个示例程序来演示如何使用 Flink 实现 WaterMark 触发机制。 一、Flink 的时间概念 在 Flink 中，有三种时间概念：Event Time、...
watermark kafka案例
03-08
在大数据处理领域，Apache Kafka是一种广泛使用的分布式流处理平台，常用于实时数据传输与消息队列。本案例聚焦于Kafka中的Watermark机制，尤其在多分区环境下的应用，这在处理时间序列数据和流计算时显得尤为重要。...
《Flink大数据分析实战》随书示例代码
07-04
这本书通过实际的代码示例，旨在帮助读者深入理解Flink的架构、API使用以及在数据分析中的各种策略。以下是对这些示例代码的详细解析和相关知识点的介绍： 1. **Flink基础概念**： - **流处理与批处理**：Flink是...
flink datastream api 示例大全
最新发布
10-19
Flink DataStream API是Apache Flink流处理框架的核心部分，用于处理无界和有界数据流。这个API提供了丰富的操作符来构建复杂的数据处理管道。以下是对标题和描述中涉及的知识点的详细解释： 1. **异步IO...
flink入门到精通视频教程
07-15
7.Flink watermark与侧道输出 8.Flink状态计算 9.Flink容错checkpoint与一致性语义 10.Flink进阶 异步IO，背压，内存管理 11.Flink Table API与SQL 课程目录介绍 第一章 Flink简介 01.Flink的引入 02.什么是Flink 03...
Flink1.12 使用WatermarkStrategy生成时间戳
RonieWhite的博客
03-05 5030
Flink1.12版本后建议使用assignTimestampsAndWatermarks(WatermarkStrategy)的方式生成watermark，之前使用的assignTimestampsAndWatermarks(AssignerWithPunctuatedWatermarks)以及assignTimestampsAndWatermarks(timestampAndWatermarkAssigner)均不再被推荐使用，这里是根据官网给出的小例子，仅供参考： package demo; i
Flink中的时间语义与Watermark
huahuaxiaoshao的博客
05-12 1421
1 Flink中的时间语义 1.1 基本概念       在Flink的流式处理中，会涉及到时间的不同概念，如下图： 图1 Flink时间概念       Event Time：是事件创建的时间。它通常由事件中的时间戳描述，例如日志数据中的每一条记录都会带有时间戳，Flink通过时间戳分配器访问事件时间戳。       Inge
Flink系列：assignTimestampsAndWatermarks使用demo
NIO4444
05-05 3456
assignTimestampsAndWatermarks 指派时间戳，并生成WaterMark 相关demo Flink系列：事件Time时间乱序到达处理方法https://blog.csdn.net/VIP099/article/details/107048139 Flink系列：事件时间乱序到达处理完整Demo例子https://blog.csdn.net/VIP099/article/details/107142404 Flink系列：join算子的使用方法h...
Flink Watermark分配策略
weixin_47029065的博客
11-25 1285
WaterMark是Flink为了处理Event Time窗口计算提出的一种机制，本质上是一种时间戳。主要用来处理乱序数据或者延迟数据的，这里通常watermark机制结合window来实现（watermark用来触发window的计算）
Flink Program Guide （5） -- 预定义的Timestamp Extractor / Watermark Emitter （DataStream API编程指导 -- For Ja...
weixin_30376163的博客
08-09 222
本文翻译自Pre-defined Timestamp Extractors / Watermark Emitter ------------------------------------------------------------------------------------------ 正如timestamps and watermark handling中所述，Flink提供了...
1、Flink1.12.7或1.13.5详细介绍及本地安装部署、验证
热门推荐
alanchanchn的专栏
07-04 4万+
本示例以1.12版本进行介绍，当前版本更新至1.17。Flink 诞生于欧洲的一个大数据研究项目 StratoSphere。该项目是柏林工业大学的一个研究性项目。早期， Flink 是做 Batch 计算的，但是在 2014 年， StratoSphere 里面的核心成员孵化出 Flink，同年将 Flink 捐赠 Apache，并在后来成为 Apache 的顶级大数据项目，同时 Flink 计算的主流方向被定位为 Streaming， 即用流式计算来做所有大数据的计算。
Flink Watermark机制
chanyue123的博客
06-23 1673
flink watermark详解
Flink中在source流中自定义timestamp和watermark
04-24 5153
To work with Event Time, streaming programs need to set the time characteristic accordingly. 首先配置成，Event Time final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnviro

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一瓢一瓢的饮 alanchanchn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值