Flink 快速实战开发

Flink 可谓是开启了流式计算技术的新时代，现在无论大中小公司基本上都对 Flink 技术有不同程度的尝试，或是已经进行了大量实时计算的改造。伴随着阿里对 Flink 的极力推崇，Flink 无论从自身优势还是外部言论都必将成为主流。

在本场 Chat 中，不光有从零开始的基础，更有理论讲解及实战使用，会讲到如下内容：

• 初识 Flink 及重要特点
• 快速上手 Flink：流处理/批处理
• Flink 部署模式：Standalone/Yarn
• Flink 运行架构及调度原理
• Flink 流处理 API 细致讲解
• Time 与 Window 的使用、Watermark 水印的引入
• Table API 与 SQL
• Flink CEP 介绍及使用

第一章 Flink 简介

1.1 初识 Flink

Flink 起源于 Stratosphere 项目，Stratosphere 是在 2010~2014 年由 3 所地处柏林的大学和欧洲的一些其他的大学共同进行的研究项目，2014 年 4 月 Stratosphere 的代码被复制并捐赠给了 Apache 软件基金会，参加这个孵化项目的初始成员是 Stratosphere 系统的核心开发人员，2014 年 12 月，Flink 一跃成为 Apache 软件基金会的顶级项目。

在德语中，Flink 一词表示快速和灵巧，项目采用一只松鼠的彩色图案作为 logo，这不仅是因为松鼠具有快速和灵巧的特点，还因为柏林的松鼠有一种迷人的红棕色，而 Flink 的松鼠 logo 拥有可爱的尾巴，尾巴的颜色与 Apache 软件基金会的 logo 颜色相呼应，也就是说，这是一只 Apache 风格的松鼠。Flink Logo

Flink 项目的理念是：“Apache Flink 是为分布式、高性能、随时可用以及准确的流处理应用程序打造的开源流处理框架”。

Apache Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。Flink 被设计在所有常见的集群环境中运行，以内存执行速度和任意规模来执行计算。

1.2 Flink 的重要特点

1.2.1 事件驱动型 (Event-driven)

事件驱动型应用是一类具有状态的应用，它从一个或多个事件流提取数据，并根据到来的事件触发计算、状态更新或其他外部动作。比较典型的就是以 kafka 为代表的消息队列几乎都是事件驱动型应用。

与之不同的就是 SparkStreaming 微批次，如图：事件驱动型：

1.2.2 流与批的世界观

批处理的特点是有界、持久、大量，非常适合需要访问全套记录才能完成的计算工作，一般用于离线统计。

流处理的特点是无界、实时, 无需针对整个数据集执行操作，而是对通过系统传输的每个数据项执行操作，一般用于实时统计。

在 spark 的世界观中，一切都是由批次组成的，离线数据是一个大批次，而实时数据是由一个一个无限的小批次组成的。

而在 flink 的世界观中，一切都是由流组成的，离线数据是有界限的流，实时数据是一个没有界限的流，这就是所谓的有界流和无界流。

无界数据流：无界数据流有一个开始但是没有结束，它们不会在生成时终止并提供数据，必须连续处理无界流，也就是说必须在获取后立即处理 event。对于无界数据流我们无法等待所有数据都到达，因为输入是无界的，并且在任何时间点都不会完成。处理无界数据通常要求以特定顺序（例如事件发生的顺序）获取 event，以便能够推断结果完整性。

有界数据流：有界数据流有明确定义的开始和结束，可以在执行任何计算之前通过获取所有数据来处理有界流，处理有界流不需要有序获取，因为可以始终对有界数据集进行排序，有界流的处理也称为批处理。这种以流为世界观的架构，获得的最大好处就是具有极低的延迟。

1.2.3 分层 API

最底层级的抽象仅仅提供了有状态流，它将通过过程函数（Process Function）被嵌入到 DataStream API 中。底层过程函数（Process Function）与 DataStream API 相集成，使其可以对某些特定的操作进行底层的抽象，它允许用户可以自由地处理来自一个或多个数据流的事件，并使用一致的容错的状态。除此之外，用户可以注册事件时间并处理时间回调，从而使程序可以处理复杂的计算。

实际上，大多数应用并不需要上述的底层抽象，而是针对核心 API（Core APIs） 进行编程，比如 DataStream API（有界或无界流数据）以及 DataSet API（有界数据集）。这些 API 为数据处理提供了通用的构建模块，比如由用户定义的多种形式的转换（transformations），连接（joins），聚合（aggregations），窗口操作（windows）等等。DataSet API 为有界数据集提供了额外的支持，例如循环与迭代。这些 API 处理的数据类型以类（classes）的形式由各自的编程语言所表示。

Table API 是以表为中心的声明式编程，其中表可能会动态变化（在表达流数据时）。Table API 遵循（扩展的）关系模型：表有二维数据结构（schema）（类似于关系数据库中的表），同时 API 提供可比较的操作，例如 select、project、join、group-by、aggregate 等。Table API 程序声明式地定义了什么逻辑操作应该执行，而不是准确地确定这些操作代码的看上去如何。

尽管 Table API 可以通过多种类型的用户自定义函数（UDF）进行扩展，其仍不如核心 API 更具表达能力，但是使用起来却更加简洁（代码量更少）。除此之外，Table API 程序在执行之前会经过内置优化器进行优化。

你可以在表与 DataStream/DataSet 之间无缝切换，以允许程序将 Table API 与 DataStream 以及 DataSet 混合使用。

Flink 提供的最高层级的抽象是 SQL 。这一层抽象在语法与表达能力上与 Table API 类似，但是是以 SQL 查询表达式的形式表现程序。SQL 抽象与 Table API 交互密切，同时 SQL 查询可以直接在 Table API 定义的表上执行。

目前 Flink 作为批处理还不是主流，不如 Spark 成熟，所以 DataSet 使用的并不是很多。Flink Table API 和 Flink SQL 也并不完善，大多都由各大厂商自己定制。所以我们主要说 DataStream API 的使用。实际上 Flink 作为最接近 Google DataFlow 模型的实现，是流批统一的观点，所以基本上使用 DataStream 就可以了。

第二章 快速上手

2.1 搭建 maven 工程 FlinkTutorial

2.1.1 pom 文件

    4.0.0    com.test.flink    FlinkTutorial    1.0-SNAPSHOT                        org.apache.flink            flink-scala_2.11            1.7.2                                    org.apache.flink            flink-streaming-scala_2.11            1.7.2                                net.alchim31.maven        scala-maven-plugin        3.4.6                                                                        testCompile                                                            org.apache.maven.plugins            maven-assembly-plugin            3.0.0                                                jar-with-dependencies                                                                            make-assembly                    package                                            single                                                            

2.1.2 添加 scala 框架 和 scala 文件夹

2.2 批处理 wordcount

src/main/scala/com.test.wc/WordCount.scala

object WordCount {  def main(args: Array[String]): Unit = {    // 创建执行环境    val env = ExecutionEnvironment.getExecutionEnvironment    // 从文件中读取数据    val inputPath = "D:\\Projects\\BigData\\TestWC1\\src\\main\\resources\\hello.txt"    val inputDS: DataSet[String] = env.readTextFile(inputPath)    // 分词之后，对单词进行 groupby 分组，然后用 sum 进行聚合    val wordCountDS: AggregateDataSet[(String, Int)] = inputDS.flatMap(_.split(" ")).map((_, 1)).groupBy(0).sum(1)    // 打印输出    wordCountDS.print()  }}

注意：Flink 程序支持 java 和 scala 两种语言，本文中以 scala 语言为主。在引入包中，有 java 和 scala 两种包时注意要使用 scala 的包。

2.3 流处理 wordcount

src/main/scala/com.test.wc/StreamWordCount.scala

object StreamWordCount {  def main(args: Array[String]): Unit = {    // 从外部命令中获取参数    val params: ParameterTool =  ParameterTool.fromArgs(args)    val host: String = params.get("host")    val port: Int = params.getInt("port")    // 创建流处理环境    val env = StreamExecutionEnvironment.getExecutionEnvironment    // 接收 socket 文本流    val textDstream: DataStream[String] = env.socketTextStream(host, port)    // flatMap 和 Map 需要引用的隐式转换    import org.apache.flink.api.scala._    val dataStream: DataStream[(String, Int)] = textDstream.flatMap(_.split("\\s")).filter(_.nonEmpty).map((_, 1)).keyBy(0).sum(1)    dataStream.print().setParallelism(1)    // 启动 executor，执行任务    env.execute("Socket stream word count")  }}

测试——在 linux 系统中用 netcat 命令进行发送测试。

第三章 Flink 部署

3.1 Standalone 模式

3.1.1 安装

解压缩 flink-1.7.2-bin-hadoop27-scala_2.11.tgz，进入 conf 目录中。

1. 修改 flink/conf/flink-conf.yaml 文件：
2. 修改 /conf/slave 文件：
3. 分发给另外两台机子：（分发脚本 xsync 自行编写）
4. 启动：访问 http://localhost:8081 可以对 flink 集群和任务进行监控管理。

3.1.2 提交任务

1. 准备数据文件

2. 把含数据文件的文件夹，分发到 taskmanage 机器中由于读取数据是从本地磁盘读取，实际任务会被分发到 taskmanage 的机器中，所以要把目标文件分发。

3. 执行程序

   ./flink run -c  com.test.flink.app.BatchWcApp   /ext/flink0503-1.0-SNAPSHOT.jar   --input /applog/flink/input.txt --output /applog/flink/output.csv

   

4. 到目标文件夹中查看计算结果

注意：计算结果根据会保存到 taskmanage 的机器下，不会在 jobmanage 下。

1. 在 webui 控制台查看计算过程

3.2 Yarn 模式

1. 启动 hadoop 集群

2. 启动 yarn-session

其中：-n(--container)：TaskManager 的数量。-s(--slots)： 每个 TaskManager 的 slot 数量，默认一个 slot 一个 core，默认每个 taskmanager 的 slot 的个数为 1，有时可以多一些 taskmanager，做冗余。-jm：JobManager 的内存（单位 MB)。-tm：每个 taskmanager 的内存（单位 MB)。-nm：yarn 的 appName (现在 yarn 的 ui 上的名字)。 -d：后台执行。

1. 执行任务
2. 去 yarn 控制台查看任务状态

第四章 Flink 运行架构

4.1 任务提交流程（yarn 模式）

图 Yarn 模式任务提交流程

Flink 任务提交后，Client 向 HDFS 上传 Flink 的 Jar 包和配置，之后向 Yarn ResourceManager 提交任务，ResourceManager 分配 Container 资源并通知对应的 NodeManager 启动 ApplicationMaster，ApplicationMaster 启动后加载 Flink 的 Jar 包和配置构建环境，然后启动 JobManager，之后 ApplicationMaster 向 ResourceManager 申请资源启动 TaskManager，ResourceManager 分配 Container 资源后，由 ApplicationMaster 通知资源所在节点的 NodeManager 启动 TaskManager，NodeManager 加载 Flink 的 Jar 包和配置构建环境并启动 TaskManager，TaskManager 启动后向 JobManager 发送心跳包，并等待 JobManager 向其分配任务。

4.2 任务调度原理

图 任务调度原理

客户端不是运行时和程序执行的一部分，但它用于准备并发送 dataflow(JobGraph)给 Master(JobManager)，然后，客户端断开连接或者维持连接以等待接收计算结果。

当 Flink 集群启动后，首先会启动一个 JobManger 和一个或多个的 TaskManager。由 Client 提交任务给 JobManager，JobManager 再调度任务到各个 TaskManager 去执行，然后 TaskManager 将心跳和统计信息汇报给 JobManager。TaskManager 之间以流的形式进行数据的传输。上述三者均为独立的 JVM 进程。

Client 为提交 Job 的客户端，可以是运行在任何机器上（与 JobManager 环境连通即可）。提交 Job 后，Client 可以结束进程（Streaming 的任务），也可以不结束并等待结果返回。

JobManager 主要负责调度 Job 并协调 Task 做 checkpoint，职责上很像 Storm 的 Nimbus。从 Client 处接收到 Job 和 JAR 包等资源后，会生成优化后的执行计划，并以 Task 的单元调度到各个 TaskManager 去执行。

TaskManager 在启动的时候就设置好了槽位数（Slot），每个 slot 能启动一个 Task，Task 为线程。从 JobManager 处接收需要部署的 Task，部署启动后，与自己的上游建立 Netty 连接，接收数据并处理。

关于执行图

Flink 中的执行图可以分成四层：StreamGraph -> JobGraph -> ExecutionGraph -> 物理执行图。

StreamGraph：是根据用户通过 Stream API 编写的代码生成的最初的图。用来表示程序的拓扑结构。

JobGraph：StreamGraph 经过优化后生成了 JobGraph，提交给 JobManager 的数据结构。主要的优化为，将多个符合条件的节点 chain 在一起作为一个节点，这样可以减少数据在节点之间流动所需要的序列化/反序列化/传输消耗。

ExecutionGraph：JobManager 根据 JobGraph 生成 ExecutionGraph。ExecutionGraph 是 JobGraph 的并行化版本，是调度层最核心的数据结构。

物理执行图：JobManager 根据 ExecutionGraph 对 Job 进行调度后，在各个 TaskManager 上部署 Task 后形成的“图”，并不是一个具体的数据结构。

4.3 Worker 与 Slots

每一个 worker(TaskManager) 都是一个 JVM 进程，它可能会在独立的线程上执行一个或多个 subtask。为了控制一个 worker 能接收多少个 task，worker 通过 task slot 来进行控制（一个 worker 至少有一个 task slot）。

每个 task slot 表示 TaskManager 拥有资源的一个固定大小的子集。假如一个 TaskManager 有三个 slot，那么它会将其管理的内存分成三份给各个 slot。资源 slot 化意味着一个 subtask 将不需要跟来自其他 job 的 subtask 竞争被管理的内存，取而代之的是它将拥有一定数量的内存储备。需要注意的是，这里不会涉及到 CPU 的隔离，slot 目前仅仅用来隔离 task 的受管理的内存。

通过调整 task slot 的数量，允许用户定义 subtask 之间如何互相隔离。如果一个 TaskManager 一个 slot，那将意味着每个 task group 运行在独立的 JVM 中（该 JVM 可能是通过一个特定的容器启动的），而一个 TaskManager 多个 slot 意味着更多的 subtask 可以共享同一个 JVM。而在同一个 JVM 进程中的 task 将共享 TCP 连接（基于多路复用）和心跳消息。它们也可能共享数据集和数据结构，因此这减少了每个 task 的负载。图 TaskManager 与 Slot

Task Slot 是静态的概念，是指 TaskManager 具有的并发执行能力，可以通过参数 taskmanager.numberOfTaskSlots 进行配置；而并行度 parallelism 是动态概念，即 TaskManager 运行程序时实际使用的并发能力，可以通过参数 parallelism.default 进行配置。

也就是说，假设一共有 3 个 TaskManager，每一个 TaskManager 中的分配 3 个 TaskSlot，也就是每个 TaskManager 可以接收 3 个 task，一共 9 个 TaskSlot，如果我们设置 parallelism.default=1，即运行程序默认的并行度为 1，9 个 TaskSlot 只用了 1 个，有 8 个空闲，因此，设置合适的并行度才能提高效率。

4.4 程序与数据流

所有的 Flink 程序都是由三部分组成的： Source 、Transformation和Sink。

Source 负责读取数据源，Transformation 利用各种算子进行处理加工，Sink 负责输出。

在运行时，Flink 上运行的程序会被映射成 streaming dataflows，它包含了这三部分。每一个 dataflow 以一个或多个 sources 开始以一个或多个 sinks 结束。dataflow 类似于任意的有向无环图（DAG），当然特定形式的环可以通过 iteration 构建。在大部分情况下，程序中的 transformations 跟 dataflow 中的 operator 是一一对应的关系，但有时候，一个 transformation 可能对应多个 operator。图 程序与数据流

4.5 并行数据流

Flink 程序的执行具有并行、分布式的特性。在执行过程中，一个 stream 包含一个或多个 stream partition ，而每一个 operator 包含一个或多个 operator subtask，这些 operator subtasks 在不同的线程、不同的物理机或不同的容器中彼此互不依赖得执行。

一个特定 operator 的 subtask 的个数被称之为其 parallelism(并行度)。一个 stream 的并行度总是等同于其 producing operator 的并行度。一个程序中，不同的 operator 可能具有不同的并行度。图 并行数据流

Stream 在 operator 之间传输数据的形式可以是 one-to-one(forwarding)的模式也可以是 redistributing 的模式，具体是哪一种形式，取决于 operator 的种类。

One-to-one：stream(比如在 source 和 map operator 之间)维护着分区以及元素的顺序。那意味着 map operator 的 subtask 看到的元素的个数以及顺序跟 source operator 的 subtask 生产的元素的个数、顺序相同，map、fliter、flatMap 等算子都是 one-to-one 的对应关系。

Ø 类似于 spark 中的窄依赖

Redistributing：stream(map()跟 keyBy/window 之间或者 keyBy/window 跟 sink 之间)的分区会发生改变。每一个 operator subtask 依据所选择的 transformation 发送数据到不同的目标 subtask。例如，keyBy() 基于 hashCode 重分区、broadcast 和 rebalance 会随机重新分区，这些算子都会引起 redistribute 过程，而 redistribute 过程就类似于 Spark 中的 shuffle 过程。

Ø 类似于 spark 中的宽依赖

4.6 task 与 operator chains

相同并行度的 one to one 操作，Flink 这样相连的 operator 链接在一起形成一个 task，原来的 operator 成为里面的 subtask。将 operators 链接成 task 是非常有效的优化：它能减少线程之间的切换和基于缓存区的数据交换，在减少时延的同时提升吞吐量。链接的行为可以在编程 API 中进行指定。 图 task 与 operator chains

第五章 Flink 流处理 Api

5.1 Environment

5.1.1 getExecutionEnvironment

创建一个执行环境，表示当前执行程序的上下文。 如果程序是独立调用的，则此方法返回本地执行环境；如果从命令行客户端调用程序以提交到集群，则此方法返回此集群的执行环境，也就是说，getExecutionEnvironment 会根据查询运行的方式决定返回什么样的运行环境，是最常用的一种创建执行环境的方式。

val env: ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironmentval env = StreamExecutionEnvironment.getExecutionEnvironment

如果没有设置并行度，会以 flink-conf.yaml 中的配置为准，默认是 1。

5.1.2 createLocalEnvironment

返回本地执行环境，需要在调用时指定默认的并行度。

5.1.3 createRemoteEnvironment

返回集群执行环境，将 Jar 提交到远程服务器。需要在调用时指定 JobManager 的 IP 和端口号，并指定要在集群中运行的 Jar 包。

5.2 Source

5.2.1 从集合读取数据

// 定义样例类，传感器 id，时间戳，温度case class SensorReading(id: String, timestamp: Long, temperature: Double)object Sensor {  def main(args: Array[String]): Unit = {    val env = StreamExecutionEnvironment.getExecutionEnvironment    val stream1 = env      .fromCollection(List(        SensorReading("sensor_1", 1547718199, 35.80018327300259),        SensorReading("sensor_6", 1547718201, 15.402984393403084),        SensorReading("sensor_7", 1547718202, 6.720945201171228),        SensorReading("sensor_10", 1547718205, 38.101067604893444)      ))    stream1.print("stream1:").setParallelism(1)    env.execute()  }}

5.2.2 从文件读取数据

val stream2 = env.readTextFile("YOUR_FILE_PATH")

5.2.3 以 kafka 消息队列的数据作为来源

val properties = new Properties()properties.setProperty("bootstrap.servers", "localhost:9092")properties.setProperty("group.id", "consumer-group")properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")properties.setProperty("auto.offset.reset", "latest")val stream3 = env.addSource(new FlinkKafkaConsumer011[String]("sensor", new SimpleStringSchema(), properties))

Flink+kafka是如何实现exactly-once语义的？

Flink 通过 checkpoint 来保存数据是否处理完成的状态。

由 JobManager 协调各个 TaskManager 进行 checkpoint 存储，checkpoint 保存在 StateBackend 中，默认 StateBackend 是内存级的，也可以改为文件级的进行持久化保存。

执行过程实际上是一个两段式提交，每个算子执行完成，会进行“预提交”，直到执行完 sink 操作，会发起“确认提交”，如果执行失败，预提交会放弃掉。

如果宕机需要通过 StateBackend 进行恢复，只能恢复所有确认提交的操作。

5.3 Transform

转换算子

5.3.1 map

5.3.2 flatMap

flatMap 的函数签名：def flatMapA,B(f: A ⇒ List[B]): List[B]

例如：flatMap(List(1,2,3))(i ⇒ List(i,i))

结果是 List(1,1,2,2,3,3),

而 List("a b", "c d").flatMap(line ⇒ line.split(" "))

结果是 List(a, b, c, d)。

5.3.3 Filter

5.3.4 KeyBy

DataStream → KeyedStream：逻辑地将一个流拆分成不相交的分区，每个分区包含具有相同 key 的元素，在内部以 hash 的形式实现的。

5.3.5 滚动聚合算子（Rolling Aggregation）

这些算子可以针对 KeyedStream 的每一个支流做聚合。

sum()、min()、max()、minBy()、maxBy()

5.3.6 Reduce

KeyedStream → DataStream：一个分组数据流的聚合操作，合并当前的元素和上次聚合的结果，产生一个新的值，返回的流中包含每一次聚合的结果，而不是只返回最后一次聚合的最终结果。

val stream2 = env.readTextFile("YOUR_PATH\\sensor.txt")  .map( data => {    val dataArray = data.split(",")    SensorReading(dataArray(0).trim, dataArray(1).trim.toLong, dataArray(2).trim.toDouble)  })  .keyBy("id")  .reduce( (x, y) => SensorReading(x.id, x.timestamp + 1, y.temperature) )

5.3.7 Split 和 Select

Split图 Split

DataStream → SplitStream：根据某些特征把一个 DataStream 拆分成两个或者多个 DataStream。

Select图 Select

SplitStream→DataStream：从一个 SplitStream 中获取一个或者多个 DataStream。

需求：传感器数据按照温度高低（以 30 度为界），拆分成两个流。

val splitStream = stream2  .split( sensorData => {    if (sensorData.temperature > 30) Seq("high") else Seq("low")  } )val high = splitStream.select("high")val low = splitStream.select("low")val all = splitStream.select("high", "low")

5.3.8 Connect 和 CoMap

图 Connect 算子

DataStream,DataStream → ConnectedStreams：连接两个保持他们类型的数据流，两个数据流被 Connect 之后，只是被放在了一个同一个流中，内部依然保持各自的数据和形式不发生任何变化，两个流相互独立。

CoMap,CoFlatMap图 CoMap/CoFlatMap

ConnectedStreams → DataStream：作用于 ConnectedStreams 上，功能与 map 和 flatMap 一样，对 ConnectedStreams 中的每一个 Stream 分别进行 map 和 flatMap 处理。

val warning = high.map( sensorData => (sensorData.id, sensorData.temperature) )val connected = warning.connect(low)val coMap = connected.map(    warningData => (warningData._1, warningData._2, "warning"),    lowData => (lowData.id, "healthy"))

5.3.9 Union

图 Union

DataStream → DataStream：对两个或者两个以上的 DataStream 进行 union 操作，产生一个包含所有 DataStream 元素的新 DataStream。注意:如果你将一个 DataStream 跟它自己做 union 操作，在新的 DataStream 中，你将看到每一个元素都出现两次。

//合并以后打印val unionStream: DataStream[StartUpLog] = appStoreStream.union(otherStream)unionStream.print("union:::")

Connect 与 Union 区别：

1. Union 之前两个流的类型必须是一样，Connect 可以不一样，在之后的 coMap 中再去调整成为一样的。

2. Connect 只能操作两个流，Union 可以操作多个。

5.4 Sink

Flink 没有类似于 spark 中 foreach 方法，让用户进行迭代的操作。虽有对外的输出操作都要利用 Sink 完成。最后通过类似如下方式完成整个任务最终输出操作。

  stream.addSink(new MySink(xxxx)) 

官方提供了一部分的框架的 sink。除此以外，需要用户自定义实现 sink。

5.4.1 Kafka

pom.xml

    org.apache.flink    flink-connector-kafka-0.11_2.11    1.7.2

主函数中添加 sink：

val union = high.union(low).map(_.temperature.toString)union.addSink(new FlinkKafkaProducer011[String]("localhost:9092", "test", new SimpleStringSchema()))

5.4.2 Redis

pom.xml

    org.apache.bahir    flink-connector-redis_2.11    1.0

定义一个 redis 的 mapper 类，用于定义保存到 redis 时调用的命令：

class MyRedisMapper extends RedisMapper[SensorReading]{  override def getCommandDescription: RedisCommandDescription = {    new RedisCommandDescription(RedisCommand.HSET, "sensor_temperature")  }  override def getValueFromData(t: SensorReading): String = t.temperature.toString  override def getKeyFromData(t: SensorReading): String = t.id}

在主函数中调用：

val conf = new FlinkJedisPoolConfig.Builder().setHost("localhost").setPort(6379).build()dataStream.addSink( new RedisSink[SensorReading](conf, new MyRedisMapper) )

5.4.3 Elasticsearch

pom.xml

    org.apache.flink    flink-connector-elasticsearch6_2.11    1.7.2

在主函数中调用：

val httpHosts = new util.ArrayList[HttpHost]()httpHosts.add(new HttpHost("localhost", 9200))val esSinkBuilder = new ElasticsearchSink.Builder[SensorReading]( httpHosts, new ElasticsearchSinkFunction[SensorReading] {  override def process(t: SensorReading, runtimeContext: RuntimeContext, requestIndexer: RequestIndexer): Unit = {    println("saving data: " + t)    val json = new util.HashMap[String, String]()    json.put("data", t.toString)    val indexRequest = Requests.indexRequest().index("sensor").`type`("readingData").source(json)    requestIndexer.add(indexRequest)    println("saved successfully")  }} )dataStream.addSink( esSinkBuilder.build() )

5.4.4 JDBC 自定义 sink

    mysql    mysql-connector-java    5.1.44    com.alibaba    druid    1.1.10

添加 MyJdbcSink

class MyJdbcSink(sql:String ) extends  RichSinkFunction[Array[Any]] {  val driver="com.mysql.jdbc.Driver"  val url="jdbc:mysql://localhost:3306/sensor?useSSL=false"  val username="root"  val password="123456"  val maxActive="20"  var connection:Connection=null;  //创建连接  override def open(parameters: Configuration): Unit = {    val properties = new Properties()    properties.put("driverClassName",driver)    properties.put("url",url)    properties.put("username",username)    properties.put("password",password)    properties.put("maxActive",maxActive)    val dataSource: DataSource = DruidDataSourceFactory.createDataSource(properties)    connection = dataSource.getConnection()  }  //反复调用连接，执行 sql  override def invoke(values: Array[Any]): Unit = {    // 预编译器    val ps: PreparedStatement = connection.prepareStatement(sql )    println(values.mkString(","))    for (i <- 0 until values.length) {    // 坐标从 1 开始      ps.setObject(i + 1, values(i))    }    // 执行操作    ps.executeUpdate()  }  override def close(): Unit = {    if(connection!=null){      connection.close()    }  }}

在 main 方法中增加，把明细保存到 mysql 中

val jdbcSink = new MyJdbcSink("insert into sensorReading values(?,?,?)")dataDstream.map(data=>Array(data.id,data.timestamp,data.temperature)).addSink(jdbcSink)

第六章 Time 与 Window

6.1 Time

在 Flink 的流式处理中，会涉及到时间的不同概念，如下图所示：图 Flink 时间概念

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

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

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

一个例子——电影《星球大战》：例如，一条日志进入 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

对于业务来说，要统计 1min 内的故障日志个数，哪个时间是最有意义的？—— eventTime，因为我们要根据日志的生成时间进行统计。

6.2 Window

6.2.1 Window 概述

streaming 流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而 window 是一种切割无限数据为有限块进行处理的手段。

Window 是无限数据流处理的核心，Window 将一个无限的 stream 拆分成有限大小的”buckets”桶，我们可以在这些桶上做计算操作。

6.2.2 Window 类型

Window 可以分成两类：

• CountWindow：按照指定的数据条数生成一个 Window，与时间无关。

• TimeWindow：按照时间生成 Window。

对于 TimeWindow，可以根据窗口实现原理的不同分成三类：滚动窗口（Tumbling Window）、滑动窗口（Sliding Window）和会话窗口（Session Window）。

1. 滚动窗口（Tumbling Windows）

将数据依据固定的窗口长度对数据进行切片。

特点：时间对齐，窗口长度固定，没有重叠。

滚动窗口分配器将每个元素分配到一个指定窗口大小的窗口中，滚动窗口有一个固定的大小，并且不会出现重叠。例如：如果你指定了一个 5 分钟大小的滚动窗口，窗口的创建如下图所示：图 滚动窗口

适用场景：适合做 BI 统计等（做每个时间段的聚合计算）。

1. 滑动窗口（Sliding Windows）

滑动窗口是固定窗口的更广义的一种形式，滑动窗口由固定的窗口长度和滑动间隔组成。

特点：时间对齐，窗口长度固定，有重叠。

滑动窗口分配器将元素分配到固定长度的窗口中，与滚动窗口类似，窗口的大小由窗口大小参数来配置，另一个窗口滑动参数控制滑动窗口开始的频率。因此，滑动窗口如果滑动参数小于窗口大小的话，窗口是可以重叠的，在这种情况下元素会被分配到多个窗口中。

例如，你有 10 分钟的窗口和 5 分钟的滑动，那么每个窗口中 5 分钟的窗口里包含着上个 10 分钟产生的数据，如下图所示：图 滑动窗口

适用场景：对最近一个时间段内的统计（求某接口最近 5min 的失败率来决定是否要报警）。

1. 会话窗口（Session Windows）

由一系列事件组合一个指定时间长度的 timeout 间隙组成，类似于 web 应用的 session，也就是一段时间没有接收到新数据就会生成新的窗口。

特点：时间无对齐。

session 窗口分配器通过 session 活动来对元素进行分组，session 窗口跟滚动窗口和滑动窗口相比，不会有重叠和固定的开始时间和结束时间的情况，相反，当它在一个固定的时间周期内不再收到元素，即非活动间隔产生，那个这个窗口就会关闭。一个 session 窗口通过一个 session 间隔来配置，这个 session 间隔定义了非活跃周期的长度，当这个非活跃周期产生，那么当前的 session 将关闭并且后续的元素将被分配到新的 session 窗口中去。图 会话窗口

6.3 Window API

6.3.1 TimeWindow

TimeWindow 是将指定时间范围内的所有数据组成一个 window，一次对一个 window 里面的所有数据进行计算。

1. 滚动窗口

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

val minTempPerWindow = dataStream  .map(r => (r.id, r.temperature))  .keyBy(_._1)  .timeWindow(Time.seconds(15))  .reduce((r1, r2) => (r1._1, r1._2.min(r2._2)))

时间间隔可以通过 Time.milliseconds(x)，Time.seconds(x)，Time.minutes(x)等其中的一个来指定。

1. 滑动窗口（SlidingEventTimeWindows）

滑动窗口和滚动窗口的函数名是完全一致的，只是在传参数时需要传入两个参数，一个是 windowsize，一个是 slidingsize。

下面代码中的 sliding_size 设置为了 5s，也就是说，窗口每 5s 就计算一次，每一次计算的 window 范围是 15s 内的所有元素。

val minTempPerWindow: DataStream[(String, Double)] = dataStream  .map(r => (r.id, r.temperature))  .keyBy(_._1)  .timeWindow(Time.seconds(15), Time.seconds(5))  .reduce((r1, r2) => (r1._1, r1._2.min(r2._2)))

时间间隔可以通过 Time.milliseconds(x)，Time.seconds(x)，Time.minutes(x)等其中的一个来指定。

6.3.2 CountWindow

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

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

1. 滚动窗口

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

val minTempPerWindow: DataStream[(String, Double)] = dataStream  .map(r => (r.id, r.temperature))  .keyBy(_._1)  .countWindow(5)  .reduce((r1, r2) => (r1._1, r1._2.max(r2._2)))

1. 滑动窗口

滑动窗口和滚动窗口的函数名是完全一致的，只是在传参数时需要传入两个参数，一个是 windowsize，一个是 slidingsize。

下面代码中的 sliding_size 设置为了 2，也就是说，每收到两个相同 key 的数据就计算一次，每一次计算的 window 范围是 5 个元素。

val keyedStream: KeyedStream[(String, Int), Tuple] = startUplogDstream.map(startuplog=>(startuplog.ch,1)).keyBy(0)//每当某一个 key 的个数达到 2 的时候,触发计算，计算最近该 key 最近 10 个元素的内容val windowedStream: WindowedStream[(String, Int), Tuple, GlobalWindow] = keyedStream.countWindow(10,2)val sumDstream: DataStream[(String, Int)] = windowedStream.sum(1)

第七章 EventTime 与 Window

7.1 EventTime 的引入

在 Flink 的流式处理中，绝大部分的业务都会使用 eventTime，一般只在 eventTime 无法使用时，才会被迫使用 ProcessingTime 或者 IngestionTime。

如果要使用 EventTime，那么需要引入 EventTime 的时间属性，引入方式如下所示：

val env = StreamExecutionEnvironment.getExecutionEnvironment// 从调用时刻开始给 env 创建的每一个 stream 追加时间特征env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

7.2 Watermark

7.2.1 基本概念

我们知道，流处理从事件产生，到流经 source，再到 operator，中间是有一个过程和时间的，虽然大部分情况下，流到 operator 的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络、分布式等原因，导致乱序的产生，所谓乱序，就是指 Flink 接收到的事件的先后顺序不是严格按照事件的 Event Time 顺序排列的。图 数据的乱序

那么此时出现一个问题，一旦出现乱序，如果只根据 eventTime 决定 window 的运行，我们不能明确数据是否全部到位，但又不能无限期的等下去，此时必须要有个机制来保证一个特定的时间后，必须触发 window 去进行计算了，这个特别的机制，就是 Watermark。

• Watermark 是一种衡量 Event Time 进展的机制，它是数据本身的一个隐藏属性，数据本身携带着对应的 Watermark。

• Watermark 是用于处理乱序事件的，而正确的处理乱序事件，通常用 Watermark 机制结合 window 来实现。

• 数据流中的 Watermark 用于表示 timestamp 小于 Watermark 的数据，都已经到达了，因此，window 的执行也是由 Watermark 触发的。

• Watermark 可以理解成一个延迟触发机制，我们可以设置 Watermark 的延时时长 t，每次系统会校验已经到达的数据中最大的 maxEventTime，然后认定 eventTime 小于 maxEventTime - t 的所有数据都已经到达，如果有窗口的停止时间等于 maxEventTime – t，那么这个窗口被触发执行。

有序流的 Watermarker 如下图所示：（Watermark 设置为 0）图 有序数据的 Watermark

乱序流的 Watermarker 如下图所示：（Watermark 设置为 2）图 无序数据的 Watermark

当 Flink 接收到每一条数据时，都会产生一条 Watermark，这条 Watermark 就等于当前所有到达数据中的 maxEventTime - 延迟时长，也就是说，Watermark 是由数据携带的，一旦数据携带的 Watermark 比当前未触发的窗口的停止时间要晚，那么就会触发相应窗口的执行。由于 Watermark 是由数据携带的，因此，如果运行过程中无法获取新的数据，那么没有被触发的窗口将永远都不被触发。

上图中，我们设置的允许最大延迟到达时间为 2s，所以时间戳为 7s 的事件对应的 Watermark 是 5s，时间戳为 12s 的事件的 Watermark 是 10s，如果我们的窗口 1 是 1s~5s，窗口 2 是 6s~10s，那么时间戳为 7s 的事件到达时的 Watermarker 恰好触发窗口 1，时间戳为 12s 的事件到达时的 Watermark 恰好触发窗口 2。

Watermark 就是触发前一窗口的“关窗时间”，一旦触发关门那么以当前时刻为准在窗口范围内的所有所有数据都会收入窗中。

只要没有达到水位那么不管现实中的时间推进了多久都不会触发关窗。

7.2.2 Watermark 的引入

dataStream.assignTimestampsAndWatermarks( new BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.milliseconds(1000)) {  override def extractTimestamp(element: SensorReading): Long = {    element.timestamp * 1000  }} )

7.3 EvnetTimeWindow API

7.3.1 滚动窗口（TumblingEventTimeWindows）

def main(args: Array[String]): Unit = {    //  环境    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)    env.setParallelism(1)    val dstream: DataStream[String] = env.socketTextStream("localhost",7777)    val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map { text =>      val arr: Array[String] = text.split(" ")      (arr(0), arr(1).toLong, 1)    }    val textWithEventTimeDstream: DataStream[(String, Long, Int)] = textWithTsDstream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Int)](Time.milliseconds(1000)) {      override def extractTimestamp(element: (String, Long, Int)): Long = {       return  element._2      }    })    val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = textWithEventTimeDstream.keyBy(0)    textKeyStream.print("textkey:")    val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] = textKeyStream.window(TumblingEventTimeWindows.of(Time.seconds(2)))    val groupDstream: DataStream[mutable.HashSet[Long]] = windowStream.fold(new mutable.HashSet[Long]()) { case (set, (key, ts, count)) =>      set += ts    }    groupDstream.print("window::::").setParallelism(1)    env.execute()  }}

结果是按照 Event Time 的时间窗口计算得出的，而无关系统的时间（包括输入的快慢）。

7.3.2 滑动窗口（SlidingEventTimeWindows）

def main(args: Array[String]): Unit = {  //  环境  val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment  env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)  env.setParallelism(1)  val dstream: DataStream[String] = env.socketTextStream("localhost",7777)  val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map { text =>    val arr: Array[String] = text.split(" ")    (arr(0), arr(1).toLong, 1)  }  val textWithEventTimeDstream: DataStream[(String, Long, Int)] = textWithTsDstream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Int)](Time.milliseconds(1000)) {    override def extractTimestamp(element: (String, Long, Int)): Long = {     return  element._2    }  })  val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = textWithEventTimeDstream.keyBy(0)  textKeyStream.print("textkey:")  val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] = textKeyStream.window(SlidingEventTimeWindows.of(Time.seconds(2),Time.milliseconds(500)))  val groupDstream: DataStream[mutable.HashSet[Long]] = windowStream.fold(new mutable.HashSet[Long]()) { case (set, (key, ts, count)) =>    set += ts  }  groupDstream.print("window::::").setParallelism(1)  env.execute()}

7.3.3 会话窗口（EventTimeSessionWindows）

相邻两次数据的 EventTime 的时间差超过指定的时间间隔就会触发执行。如果加入 Watermark， 会在符合窗口触发的情况下进行延迟。到达延迟水位再进行窗口触发。

def main(args: Array[String]): Unit = {    //  环境    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)    env.setParallelism(1)    val dstream: DataStream[String] = env.socketTextStream("localhost",7777)    val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map { text =>      val arr: Array[String] = text.split(" ")      (arr(0), arr(1).toLong, 1)    }    val textWithEventTimeDstream: DataStream[(String, Long, Int)] = textWithTsDstream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Int)](Time.milliseconds(1000)) {      override def extractTimestamp(element: (String, Long, Int)): Long = {       return  element._2      }    })    val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = textWithEventTimeDstream.keyBy(0)    textKeyStream.print("textkey:")    val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] = textKeyStream.window(EventTimeSessionWindows.withGap(Time.milliseconds(500)) )     windowStream.reduce((text1,text2)=>      (  text1._1,0L,text1._3+text2._3)    )  .map(_._3).print("windows:::").setParallelism(1)    env.execute()  }

第八章 Table API 与 SQL

Table API 是流处理和批处理通用的关系型 API，Table API 可以基于流输入或者批输入来运行而不需要进行任何修改。Table API 是 SQL 语言的超集并专门为 Apache Flink 设计的，Table API 是 Scala 和 Java 语言集成式的 API。与常规 SQL 语言中将查询指定为字符串不同，Table API 查询是以 Java 或 Scala 中的语言嵌入样式来定义的，具有 IDE 支持如:自动完成和语法检测。

8.1 需要引入的 pom 依赖

    org.apache.flink    flink-table_2.11    1.7.0

8.2 构造表环境

def main(args: Array[String]): Unit = {  val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment  val myKafkaConsumer: FlinkKafkaConsumer011[String] = MyKafkaUtil.getConsumer("GMALL_STARTUP")  val dstream: DataStream[String] = env.addSource(myKafkaConsumer)  val tableEnv: StreamTableEnvironment = TableEnvironment.getTableEnvironment(env)  val startupLogDstream: DataStream[StartupLog] = dstream.map{ jsonString =>JSON.parseObject(jsonString,classOf[StartupLog]) }  val startupLogTable: Table = tableEnv.fromDataStream(startupLogDstream)   val table: Table = startupLogTable.select("mid,ch").filter("ch ='appstore'")  val midchDataStream: DataStream[(String, String)] = table.toAppendStream[(String,String)]  midchDataStream.print()  env.execute()}

8.2.1 动态表

如果流中的数据类型是 case class 可以直接根据 case class 的结构生成 table

tableEnv.fromDataStream(startupLogDstream)  

或者根据字段顺序单独命名

tableEnv.fromDataStream(startupLogDstream,’mid,’uid  .......)  

最后的动态表可以转换为流进行输出

table.toAppendStream[(String,String)]

8.2.2 字段

用一个单引放到字段前面 来标识字段名, 如 ‘name , ‘mid ,’amount 等

8.3 TableAPI

8.3.1 通过一个例子 了解 TableAPI

//每 10 秒中渠道为 appstore 的个数def main(args: Array[String]): Unit = {  //sparkcontext  val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment  //时间特性改为 eventTime  env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)  val myKafkaConsumer: FlinkKafkaConsumer011[String] = MyKafkaUtil.getConsumer("GMALL_STARTUP")  val dstream: DataStream[String] = env.addSource(myKafkaConsumer)  val startupLogDstream: DataStream[StartupLog] = dstream.map{ jsonString =>JSON.parseObject(jsonString,classOf[StartupLog]) }  //告知 watermark 和 eventTime 如何提取  val startupLogWithEventTimeDStream: DataStream[StartupLog] = startupLogDstream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[StartupLog](Time.seconds(0L)) {    override def extractTimestamp(element: StartupLog): Long = {      element.ts    }  }).setParallelism(1)  //SparkSession  val tableEnv: StreamTableEnvironment = TableEnvironment.getTableEnvironment(env)  //把数据流转化成 Table  val startupTable: Table = tableEnv.fromDataStream(startupLogWithEventTimeDStream , 'mid,'uid,'appid,'area,'os,'ch,'logType,'vs,'logDate,'logHour,'logHourMinute,'ts.rowtime)  //通过 table api 进行操作  // 每 10 秒 统计一次各个渠道的个数 table api 解决  //1 groupby  2 要用 window   3 用 eventtime 来确定开窗时间  val resultTable: Table = startupTable.window(Tumble over 10000.millis on 'ts as 'tt).groupBy('ch,'tt ).select( 'ch, 'ch.count)   //把 Table 转化成数据流  //val appstoreDStream: DataStream[(String, String, Long)] = appstoreTable.toAppendStream[(String,String,Long)]  val resultDstream: DataStream[(Boolean, (String, Long))] = resultSQLTable.toRetractStream[(String,Long)]  resultDstream.filter(_._1).print()  env.execute()}

8.3.2 关于 group by

1. 如果使用 groupby table 转换为流的时候只能用 toRetractDstream

  val rDstream: DataStream[(Boolean, (String, Long))] = table.toRetractStream[(String,Long)]

1. toRetractDstream 得到的第一个 boolean 型字段标识 true 就是最新的数据，false 表示过期老数据

  val rDstream: DataStream[(Boolean, (String, Long))] = table.toRetractStream[(String,Long)]  rDstream.filter(_._1).print()

1. 如果使用的 api 包括时间窗口，那么时间的字段必须，包含在 group by 中。

  val table: Table = startupLogTable.filter("ch ='appstore'").window(Tumble over 10000.millis on 'ts as 'tt).groupBy('ch ,'tt).select("ch,ch.count ")

8.3.3 关于时间窗口

1. 用到时间窗口，必须提前声明时间字段，如果是 processTime 直接在创建动态表时进行追加就可以。

val startupLogTable: Table = tableEnv.fromDataStream(startupLogWithEtDstream,'mid,'uid,'appid,'area,'os,'ch,'logType,'vs,'logDate,'logHour,'logHourMinute,'ts.rowtime)

1. 如果是 EventTime 要在创建动态表时声明

val startupLogTable: Table = tableEnv.fromDataStream(startupLogWithEtDstream,'mid,'uid,'appid,'area,'os,'ch,'logType,'vs,'logDate,'logHour,'logHourMinute,'ps.processtime)

1. 滚动窗口可以使用 Tumble over 10000.millis on

  val table: Table = startupLogTable.filter("ch ='appstore'").window(Tumble over 10000.millis on 'ts as 'tt).groupBy('ch ,'tt).select("ch,ch.count ")

8.4 SQL 如何编写

def main(args: Array[String]): Unit = {  //sparkcontext  val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment  //时间特性改为 eventTime  env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)  val myKafkaConsumer: FlinkKafkaConsumer011[String] = MyKafkaUtil.getConsumer("GMALL_STARTUP")  val dstream: DataStream[String] = env.addSource(myKafkaConsumer)  val startupLogDstream: DataStream[StartupLog] = dstream.map{ jsonString =>JSON.parseObject(jsonString,classOf[StartupLog]) }  //告知 watermark 和 eventTime 如何提取  val startupLogWithEventTimeDStream: DataStream[StartupLog] = startupLogDstream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[StartupLog](Time.seconds(0L)) {    override def extractTimestamp(element: StartupLog): Long = {      element.ts    }  }).setParallelism(1)  //SparkSession  val tableEnv: StreamTableEnvironment = TableEnvironment.getTableEnvironment(env)  //把数据流转化成 Table  val startupTable: Table = tableEnv.fromDataStream(startupLogWithEventTimeDStream , 'mid,'uid,'appid,'area,'os,'ch,'logType,'vs,'logDate,'logHour,'logHourMinute,'ts.rowtime)  //通过 table api 进行操作  // 每 10 秒 统计一次各个渠道的个数 table api 解决  //1 groupby  2 要用 window   3 用 eventtime 来确定开窗时间  val resultTable: Table = startupTable.window(Tumble over 10000.millis on 'ts as 'tt).groupBy('ch,'tt ).select( 'ch, 'ch.count) // 通过 sql 进行操作  val resultSQLTable : Table = tableEnv.sqlQuery( "select ch ,count(ch)   from "+startupTable+"  group by ch   ,Tumble(ts,interval '10' SECOND )")  //把 Table 转化成数据流  //val appstoreDStream: DataStream[(String, String, Long)] = appstoreTable.toAppendStream[(String,String,Long)]  val resultDstream: DataStream[(Boolean, (String, Long))] = resultSQLTable.toRetractStream[(String,Long)]  resultDstream.filter(_._1).print()  env.execute()}

第九章 Flink CEP 简介

9.1 什么是复杂事件 CEP

一个或多个由简单事件构成的事件流通过一定的规则匹配，然后输出用户想得到的数据，满足规则的复杂事件。

特征：

• 目标：从有序的简单事件流中发现一些高阶特征

• 输入：一个或多个由简单事件构成的事件流

• 处理：识别简单事件之间的内在联系，多个符合一定规则的简单事件构成复杂事件

• 输出：满足规则的复杂事件CEP 用于分析低延迟、频繁产生的不同来源的事件流。CEP 可以帮助在复杂的、不相关的事件流中找出有意义的模式和复杂的关系，以接近实时或准实时的获得通知并阻止一些行为。

CEP 支持在流上进行模式匹配，根据模式的条件不同，分为连续的条件或不连续的条件；模式的条件允许有时间的限制，当在条件范围内没有达到满足的条件时，会导致模式匹配超时。

看起来很简单，但是它有很多不同的功能：

• 输入的流数据，尽快产生结果

• 在 2 个 event 流上，基于时间进行聚合类的计算

• 提供实时/准实时的警告和通知

• 在多样的数据源中产生关联并分析模式

• 高吞吐、低延迟的处理

市场上有多种 CEP 的解决方案，例如 Spark、Samza、Beam 等，但他们都没有提供专门的 library 支持。但是 Flink 提供了专门的 CEP library。

9.2 Flink CEP

Flink 为 CEP 提供了专门的 Flink CEP library，它包含如下组件：

• Event Stream

• pattern 定义

• pattern 检测

• 生成 Alert首先，开发人员要在 DataStream 流上定义出模式条件，之后 Flink CEP 引擎进行模式检测，必要时生成告警。

为了使用 Flink CEP，我们需要导入依赖：

  org.apache.flink  flink-cep_{scala.binary.version}  {flink.version} 

Event Streams

登陆事件流

case class LoginEvent(userId: String, ip: String, eventType: String, eventTime: String) val env = StreamExecutionEnvironment.getExecutionEnvironment env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime) env.setParallelism(1) val loginEventStream = env.fromCollection(List(  LoginEvent("1", "192.168.0.1", "fail", "1558430842"),  LoginEvent("1", "192.168.0.2", "fail", "1558430843"),  LoginEvent("1", "192.168.0.3", "fail", "1558430844"),  LoginEvent("2", "192.168.10.10", "success", "1558430845") )).assignAscendingTimestamps(_.eventTime.toLong)

Pattern API

每个 Pattern 都应该包含几个步骤，或者叫做 state。从一个 state 到另一个 state，通常我们需要定义一些条件，例如下列的代码：

val loginFailPattern = Pattern.begin[LoginEvent]("begin")  .where(_.eventType.equals("fail"))  .next("next")  .where(_.eventType.equals("fail"))  .within(Time.seconds(10)

每个 state 都应该有一个标示：例如 begin[LoginEvent]("begin")中的"begin"

每个 state 都需要有一个唯一的名字，而且需要一个 filter 来过滤条件，这个过滤条件定义事件需要符合的条件，例如:

.where(_.eventType.equals("fail"))

我们也可以通过 subtype 来限制 event 的子类型：

start.subtype(SubEvent.class).where(...);

事实上，你可以多次调用 subtype 和 where 方法；而且如果 where 条件是不相关的，你可以通过 or 来指定一个单独的 filter 函数：

pattern.where(...).or(...);

之后，我们可以在此条件基础上，通过 next 或者 followedBy 方法切换到下一个 state，next 的意思是说上一步符合条件的元素之后紧挨着的元素；而 followedBy 并不要求一定是挨着的元素。这两者分别称为严格近邻和非严格近邻。

val strictNext = start.next("middle")val nonStrictNext = start.followedBy("middle")

最后，我们可以将所有的 Pattern 的条件限定在一定的时间范围内：

next.within(Time.seconds(10))

这个时间可以是 Processing Time，也可以是 Event Time。

Pattern 检测

通过一个 input DataStream 以及刚刚我们定义的 Pattern，我们可以创建一个 PatternStream：

val input = ...val pattern = ...val patternStream = CEP.pattern(input, pattern)val patternStream = CEP.pattern(loginEventStream.keyBy(_.userId), loginFailPattern)

一旦获得 PatternStream，我们就可以通过 select 或 flatSelect，从一个 Map 序列找到我们需要的告警信息。

select

select 方法需要实现一个 PatternSelectFunction，通过 select 方法来输出需要的警告。它接受一个 Map 对，包含 string/event，其中 key 为 state 的名字，event 则为真是的 Event。

val loginFailDataStream = patternStream.select((pattern: Map[String, Iterable[LoginEvent]]) => {   val first = pattern.getOrElse("begin", null).iterator.next()   val second = pattern.getOrElse("next", null).iterator.next()   (second.userId, second.ip, second.eventType)  })

其返回值仅为 1 条记录。

flatSelect

通过实现 PatternFlatSelectFunction，实现与 select 相似的功能。唯一的区别就是 flatSelect 方法可以返回多条记录。

9.3 Flink CEP 案例

9.3.1 案例简介

需求：同一设备，5 分钟内连续三次用不同账号登录并领取优惠劵，并且在登录到领劵过程中没有浏览商品。产生一条预警日志。

复杂事件（Complex Event Process）的特点就是它不是由单一某一个事件来确定的，而是有多种事件组合而成的一种事件模式。

传统的聚合分析都是针对某一种事件进行统计分析，即使这类事件条件复杂，但是只要依据本次事件的信息都可以单独筛选出某一事件。而复杂事件还有根据前后事件出现情况，通过多个事件组合才能筛选分析。

以上的需求可以分解成几个要素：

• 同一设备

• 登录并领取优惠券，并且其间没有浏览商品

• 连续三次

• 5 分钟内

• 不同用户 id

9.3.2 首先构建数据流

object StreamCEP2 {  def main(args: Array[String]): Unit = {    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment    val socketDstream: DataStream[String] = env.socketTextStream("hadoop1",7788)    socketDstream.print("text==")    val eventStream: DataStream[ActionEvent] = socketDstream.map(text => {        val textArr: Array[String] = text.split(" ")         ActionEvent(textArr(0), textArr(1),textArr(2),textArr(3).toLong)    }   //   TestEvent(text.split(" ")(0), text.split(" ")(1))    )    env.execute()      }}

增加一个 bean

case class ActionEvent(mid:String,uid:String,action:String ,ts:Long) {}

9.3.3 分组 -- 需求元素一： 同一设备

以 mid 为 key 进行分组

def main(args: Array[String]): Unit = {    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment    val socketDstream: DataStream[String] = env.socketTextStream("hadoop1",7788)    socketDstream.print("text==")    val eventStream: DataStream[ActionEvent] = socketDstream.map(text => {        val textArr: Array[String] = text.split(" ")         ActionEvent(textArr(0), textArr(1),textArr(2),textArr(3).toLong)    }   //   TestEvent(text.split(" ")(0), text.split(" ")(1))    )    val midKeyedStream: KeyedStream[ActionEvent, Tuple] = eventTsStream.keyBy("mid")    env.execute()  }

9.3.4 编写 Pattern --需求元素二：登录并领取优惠券，并且其间没有浏览商品

这个确实是一个用户 session 下的三个行为分别是

• 登录

• 没有浏览商品详情

• 领取了优惠券

这三个动作，没有办法通过一个 event 进行判断，即使通过开窗口的方式判断起来也是非常麻烦的，但是如果使用 FlinkCEP 进行处理就变的非常容易。

引入 pom.xml 的依赖

    org.apache.flink    flink-cep-scala_2.11    1.7.0

这三个动作一个用一个表达式来表达：

val pattern = Pattern.begin[ActionEvent]("start" ).where(_.action.equals("login"))  .notFollowedBy("without").where(_.action=="item").followedBy("follow").where(_.action=="coupon")

解释：

begin\notFollowedBy\followedBy 表示事件的类型

begin: 事件的起始

next: 紧挨着的事件

followedBy： 在之后的事件（但不一定紧接着）

notNext: 紧挨着没有发生的事件

notFollowedBy: 之后再也没有发生

start\without\follow 部分：为该事件取名字，用于之后提取该阶段匹配到的相关事件

login\item\coupon 部分：返回一个 boolean 类型，通过流中数据来判断是否匹配事件

表达式最好以后通过如下代码得到一个模式流

val  patternStream:  PatternStream[ActionEvent] = CEP.pattern(midKeyedStream,pattern) 

简单打印：

val  alertDstream: DataStream[String] = patternStream.select { pMap =>  pMap.mkString(",")}  alertDstream.print("alert:::") 

9.3.5 触发次数--需求元素三: 连续三次

val midKeyedStream: KeyedStream[ActionEvent, Tuple] = eventTsStream.keyBy("mid")val strategy: SkipPastLastStrategy = AfterMatchSkipStrategy.skipPastLastEvent()val subpattern = Pattern.begin[ActionEvent]("start" ).where(_.action.equals("login")).notFollowedBy("without").where(_.action=="item").followedBy("follow").where(_.action=="coupon")val pattern: Pattern[ActionEvent, ActionEvent] = Pattern.begin(subpattern,strategy).times(3)

把原来的 patten 封装到新的 pattern 中的 begin 里并且标识要是触发 3 次

另外：设定跳过测量，为了避免 login、login、coupon 这种情况会触发两次，所以第一个 login 与 coupon 完成匹配的话，第一个 login 与 coupon 之间的其他 login 会被跳过。

9.3.6 时间间隔--需求元素四：五分钟内

首先，如果是指 processingTime 的 5 分钟的话直接，在 times(3)后面接 within 就可以了。

val pattern: Pattern[ActionEvent, ActionEvent] = Pattern.begin (subpattern,strategy ) .times(2).within(Time.minutes(5))

如果是 EventTime 的话，请设定环境的时间特性，并告知 EventTime 的时间字段。

env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)val eventTsStream: DataStream[ActionEvent] = eventStream.assignAscendingTimestamps(actionEvent=>actionEvent.ts).setParallelism(1)

9.3.7 收集过滤--需求元素五：不同用户 id

把流中的数据提取成为一个新的预警事件流

经过筛选后，选出事件中 uid 各不相同的情况，输出 alter 到预警流中

val alterDstream: DataStream[AlertEvent] = patternStream.flatSelect { (patternMap, collector: Collector[AlertEvent]) =>      println(patternMap)      val startEvents: Iterable[ActionEvent] = patternMap.getOrElse("start", null)      if(startEvents!=null && startEvents.size>0){           val startList: List[ActionEvent] = startEvents.toList           val firstEvent: ActionEvent = startList(0)           val uidSet: Set[String] = startList.map(_.uid).toSet           if(uidSet.size == startList.size) {                collector.collect(AlertEvent(firstEvent.mid, AlertType.CouponFraud, uidSet.mkString(","), firstEvent.ts))            }       }  }     

添加预警事件

object AlertType extends Enumeration{  val CouponFraud =Value(1,"优惠券欺诈")  val Other = Value(2,"其他")}case class AlertEvent(mid:String,alterType:AlertType.Value ,uids:String,startTs:Long) {}

9.3.8 最后完整代码

def main(args: Array[String]): Unit = {    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)    val socketDstream: DataStream[String] = env.socketTextStream("hadoop1",8888)    socketDstream.print("text==")    val eventStream: DataStream[ActionEvent] = socketDstream.map(text => {        val textArr: Array[String] = text.split(" ")         ActionEvent(textArr(0), textArr(1),textArr(2),textArr(3).toLong)    }   //   TestEvent(text.split(" ")(0), text.split(" ")(1))    )    val eventTsStream: DataStream[ActionEvent] = eventStream.assignAscendingTimestamps(actionEvent=>actionEvent.ts).setParallelism(1)    val midKeyedStream: KeyedStream[ActionEvent, Tuple] = eventTsStream.keyBy("mid")    val strategy: SkipPastLastStrategy = AfterMatchSkipStrategy.skipPastLastEvent()    val subpattern = Pattern.begin[ActionEvent]("start" ).where(_.action.equals("login")).notFollowedBy("without").where(_.action=="item").followedBy("follow").where(_.action=="coupon")    val pattern: Pattern[ActionEvent, ActionEvent] = Pattern.begin (subpattern,strategy ) .times(3).within(Time.minutes(5))    //.within(Time.seconds(10))     val patternStream: PatternStream[ActionEvent] = CEP.pattern(midKeyedStream,pattern)    val alterDstream: DataStream[AlertEvent] = patternStream.flatSelect { (patternMap, collector: Collector[AlertEvent]) => println(patternMap)      val startEvents: Iterable[ActionEvent] = patternMap.getOrElse("start", null)      if(startEvents!=null && startEvents.size>0){        val startList: List[ActionEvent] = startEvents.toList        val firstEvent: ActionEvent = startList(0)        val uidSet: Set[String] = startList.map(_.uid).toSet        if (uidSet.size == startList.size){            collector.collect(AlertEvent(firstEvent.mid, AlertType.CouponFraud, uidSet.mkString(","), firstEvent.ts))        }      }    }    alterDstream.print("alert:::")    env.execute()      }

阅读全文: http://gitbook.cn/gitchat/activity/5de886e9d8585b701daac21d

您还可以下载 CSDN 旗下精品原创内容社区 GitChat App ，阅读更多 GitChat 专享技术内容哦。