左边有只汪

flink1.13(一)

1. 初识Flink

1.1 Flink是什么

Apache Flink 是一个框架和分布式处理引擎, 用于对无界和有界数据流进行状态计算. Flink框架处理流程如下图所示:

Flink的应用场景:

1.2 为什么选择Flink

批处理和流处理
流数据更真实地反应了我们的生活方式
我们的目标
- 低延迟
- 高吞吐
- 结果的准确性和良好的容错性

1.3 数据处理架构的发展

事务处理
分析处理, 如大数据框架hadoop和hive 都是离线的, 保存一定的数据量后进行处理
有状态的流式处理
lambda架构的流式处理

1.4 新一代流处理器Flink

核心特点:

高吞吐, 低延迟
结果的准确性
精确一次(exactly-once)的状态一致性保证
可以与众多常用存储系统连接
高可用, 支持动态扩展

1.5 Flink的应用场景

事件驱动型应用

事件驱动型应用是一类具有状态的应用，它从一个或多个事件流提取数据，并根据到来的事件触发计算、状态更新或其他外部动作。比较典型的就是以 Kafka 为代表的消息队列几乎都是事件驱动型应用。
这其实跟传统事务处理本质上是一样的，区别在于基于有状态流处理的事件驱动应用，不再需要查询远程数据库，而是在本地访问它们的数据，这样在吞吐量和延迟方面就可以有更好的性能。
另外远程持久性存储的检查点保证了应用可以从故障中恢复。检查点可以异步和增量地完成，因此对正常计算的影响非常小。
数据分析型应用

所谓的数据分析，就是从原始数据中提取信息和发掘规律。传统上，数据分析一般是先将数据复制到数据仓库（Data Warehouse），然后进行批量查询。如果数据有了更新，必须将最新数据添加到要分析的数据集中，然后重新运行查询或应用程序。
如今，Apache Hadoop 生态系统的组件，已经是许多企业大数据架构中不可或缺的组成部分。现在的做法一般是将大量数据（如日志文件）写入 Hadoop 的分布式文件系统（HDFS）、S3 或 HBase 等批量存储数据库，以较低的成本进行大容量存储。然后可以通过 SQL-on-Hadoop
类的引擎查询和处理数据，比如大家熟悉的 Hive。这种处理方式，是典型的批处理，特点是可以处理海量数据，但实时性较差，所以也叫离线分析。
如果我们有了一个复杂的流处理引擎，数据分析其实也可以实时执行。流式查询或应用程序不是读取有限的数据集，而是接收实时事件流，不断生成和更新结果。结果要么写入外部数据库，要么作为内部状态进行维护。
Apache Flink 同时支持流式与批处理的数据分析应用。
与批处理分析相比，流处理分析最大的优势就是低延迟，真正实现了实时。另外，流处理不需要去单独考虑新数据的导入和处理，实时更新本来就是流处理的基本模式。当前企业对流式数据处理的一个热点应用就是实时数仓，很多公司正是基于 Flink 来实现的。
数据管道型应用

ETL 也就是数据的提取、转换、加载，是在存储系统之间转换和移动数据的常用方法。在数据分析的应用中，通常会定期触发 ETL 任务，将数据从事务数据库系统复制到分析数据库或数据仓库。
所谓数据管道的作用与 ETL 类似。它们可以转换和扩展数据，也可以在存储系统之间移动数据。不过如果我们用流处理架构来搭建数据管道，这些工作就可以连续运行，而不需要再去周期性触发了。比如，数据管道可以用来监控文件系统目录中的新文件，将数据写入事件日志。连续数据管道的明显优势是减少了将数据移动到目的地的延迟，而且更加通用，可以用于更多的场景。如图所示展示了 ETL 与数据管道之间的区别。
有状态的流处理架构上其实并不复杂，很多用户基于这种思想开发出了自己的流处理系统，这就是第一代流处理器。Apache Storm 就是其中的代表。Storm 可以说是开源流处理的先锋，最早是由 Nathan Marz 和创业公司 BackType 的一个团队开发的，后来才成为 Apache 软
件基金会下属的项目。Storm 提供了低延迟的流处理，但是它也为实时性付出了代价：很难实现高吞吐，而且无法保证结果的正确性。用更专业的话说，它并不能保证“精确一次”
（exactly-once）；即便是它能够保证的一致性级别，开销也相当大。关于状态一致性和exactly-once，我们会在后续的章节中展开讨论。

Flink的分层API

在Flink1.12版本后, 用DataStreamAPI可以实现批流一体化, 现在基本上不用DataSetAPI了

2. Flink快速上手

2.1 创建一个Java项目

引入maven相关依赖

    <properties>
        <java.version>1.8java.version>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASEspring-boot.version>
        <flink.version>1.13.0flink.version>
        <java.version>1.8java.version>
        <scala.binary.version>2.12scala.binary.version>
        <slf4j.version>1.7.30slf4j.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starterartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>
        <dependency>
            <groupId>org.apache.flinkgroupId>
            <artifactId>flink-javaartifactId>
            <version>${flink.version}version>
        dependency>
        <dependency>
            <groupId>org.apache.flinkgroupId>
            <artifactId>flink-streaming-java_${scala.binary.version}artifactId>
            <version>${flink.version}version>
        dependency>
        <dependency>
            <groupId>org.apache.flinkgroupId>
            <artifactId>flink-clients_${scala.binary.version}artifactId>
            <version>${flink.version}version>
        dependency>
        
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-apiartifactId>
            <version>${slf4j.version}version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>${slf4j.version}version>
        dependency>
        <dependency>
            <groupId>org.apache.logging.log4jgroupId>
            <artifactId>log4j-to-slf4jartifactId>
            <version>2.14.0version>
        dependency>
    dependencies>

配置日志管理文件, 在resources下添加log4j.properties

log4j.rootLogger=error, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

2.2 批处理wordCount程序

新建一个Java类, 用来测试批处理WordCount程序. 在根目录下创建一个input文件夹, 内部放一个words.txt文件


package com.yangjunyi.flink.batch.wordCount;

import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.AggregateOperator;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.operators.FlatMapOperator;
import org.apache.flink.api.java.operators.UnsortedGrouping;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.Collector;

public class BatchWordCount {
    public static void main(String[] args) {
        // 1. 创建执行环境, 这里没有连接flink环境, 是因为数据源放在idea本地, 所以不需要连接到集群
        ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
        // 2. 获取数据源
        DataSource<String> strDS = env.readTextFile("input/words.txt");
        // 3. 转换数据格式, 需要把一行一行的字符串做扁平化处理 flatMap() 扁平化函数
        // flatMap后接一个函数式变成, String line 代表读到的一行数据, 后面的Collector>
        // 代表需要把line收集成一个tuple(元组类型) 数据结构类似于('hello',1) ('world',1) 这种格式
        // 返回值代表扁平化的算子, 代表对运算的结果的中间算术运算, 第一个泛型String, 代表数据源每一行都是String类型
        // 第二个泛型Tuple是最终算子的运算结果类型
        FlatMapOperator<String, Tuple2<String, Long>> wordAndOne = strDS.flatMap((String line, Collector<Tuple2<String, Long>> out) -> {
            // 在这里写如何对一个line进行操作, 使其变成多个元组
            String[] lineStrs = line.split(" ");
            for (String lineStr : lineStrs) {
                // 使用Collector收集器对循环出来的每一个字符串进行收集,
                // 每获得一个字符串就在元组中记录该字符串的数量为1
                out.collect(Tuple2.of(lineStr, 1L));
            }
            // 在函数式变成的最后, 声明返回值是一个Tuple类型, Tuple的泛型为String 和Long
        }).returns(Types.TUPLE(Types.STRING, Types.LONG));
        // 4. 按照word进行分组, 0这个参数是对元组中哪个索引位置的数据进行分组, 我们对tuple中的第一个位置String类型的word进行分组
        UnsortedGrouping<Tuple2<String, Long>> tuple2UnsortedGrouping = wordAndOne.groupBy(0);
        // 5. 进行聚合, 对tuple中索引为1的地方, 也就是word的count进行聚合, 聚合方式是sum加和
        AggregateOperator<Tuple2<String, Long>> sum = tuple2UnsortedGrouping.sum(1);
        // 该print会抛出异常, 所以需要处理该异常
        try {
            sum.print();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

我在运行这段代码时是报错的. 提示org.apache.flink.runtime.taskexecutor.slot.SlotNotFoundException: Could not find slot for dff66956ba77ffac489f5136cc27364b. 但是通过一步一步debug时 ,我发现是可以打印出来的, 但是输出的结果隐藏在一堆报错中间, 不太方便查看, 这个错误字面意思是不能找到某一个slot, 关于这个的具体原因我会边学边思考.

2.3 流处理wordCount程序

流式处理, 执行结果也是一条一条累加的, 注意:需要使用流式处理环境和最后的执行命令

package com.yangjunyi.flink.stream.wordCount;

import org.apache.flink.api.common.JobExecutionResult;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

public class StreamWordCount {
    public static void main(String[] args) throws Exception {
        // 创建一个流处理环境
        StreamExecutionEnvironment executionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> stringDataStreamSource = executionEnvironment.readTextFile("input/words.txt");
        // 对读出来的数据进行扁平化操作
        SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = stringDataStreamSource.flatMap((String line, Collector<Tuple2<String, Long>> wordCount) -> {
            String[] words = line.split(" ");
            for (String word : words) {
                wordCount.collect(Tuple2.of(word, 1L));
            }
        }).returns(Types.TUPLE(Types.STRING, Types.LONG));
        // 设置分组, 以word进行分组
        KeyedStream<Tuple2<String, Long>, String> tuple2StringKeyedStream = wordAndOne.keyBy(data -> data.f0);
        // 对tuple中的count进行求和
        SingleOutputStreamOperator<Tuple2<String, Long>> sum = tuple2StringKeyedStream.sum(1);
        sum.print();
        // 注意流式处理时, 因为是要一直读取的 所以多了一步启动的命令, 这里有异常, 先抛出去
        JobExecutionResult execute = executionEnvironment.execute();
    }
}

flink是并行执行的大数据框架, 不能保证对每一行的计算都是顺序执行的, 每一个数据是不断变化的, 可以看到依次叠加的过程, 因为流式处理, 数据是一条一条来的, 一共3个hello, 会被flink分配到一个执行单元去执行, 所以才会出现hello,1 hello,2 hello,3的现象. 在开发环境时, Idea用多线程来模拟flink集群, 并行的处理数据. 结果前面的数字, 代表本地以哪个线程来执行并输出任务的, flink中把最小的任务单位叫做任务槽(task slot)

2.4 无界流处理WordCount

正常情况下, 流应该是源源不断的状态过来的, 所以要保持一个监听, 时刻监听需要处理的流数据. 可以用Linux自带的netcat来模拟socket, 实时发送流数据. 在linux服务器中, 使用命令nc -lk 7777启动netcat 并使用7777端口来保持持续发送的功能, 如果没有nc命令的话, 使用yum install nc 来安装.

package com.yangjunyi.flink;

import org.apache.flink.api.common.JobExecutionResult;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

public class StreamWordCount {
    public static void main(String[] args) throws Exception {
        // 创建一个流处理环境
        StreamExecutionEnvironment executionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment();
//        DataStreamSource stringDataStreamSource = executionEnvironment.readTextFile("input/words.txt");
        // 读取一个socket文本流, 配置主机名, 端口号
        DataStreamSource<String> stringDataStreamSource = executionEnvironment.socketTextStream("192.168.0.105", 7777);
        // 对读出来的数据进行扁平化操作
        SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = stringDataStreamSource.flatMap((String line, Collector<Tuple2<String, Long>> wordCount) -> {
            String[] words = line.split(" ");
            for (String word : words) {
                wordCount.collect(Tuple2.of(word, 1L));
            }
        }).returns(Types.TUPLE(Types.STRING, Types.LONG));
        // 设置分组, 以word进行分组
        KeyedStream<Tuple2<String, Long>, String> tuple2StringKeyedStream = wordAndOne.keyBy(data -> data.f0);
        // 对tuple中的count进行求和
        SingleOutputStreamOperator<Tuple2<String, Long>> sum = tuple2StringKeyedStream.sum(1);
        sum.print();
        // 注意流式处理时, 因为是要一直读取的 所以多了一步启动的命令, 这里有异常, 先抛出去
        JobExecutionResult execute = executionEnvironment.execute();
    }
}

把直接读取文本流, 换成监听socket端口,其余操作不变
在socket中输入hello world

可以看到在idea中已经读取到了输入的行, 并按wordcount的方式输出了

2.5 通过运行时参数配置监听ip和端口

flink提供的通过main方法的args参数来提取参数的工具ParameterTool.formArgs()
把前面写死的ip和端口号通过参数的配置来读取出来

配置idea的启动命令参数

在netcat中输入文本后, 在idea中可以看到结果

3.Flink部署

在idea中启动flink流处理时, 不会已启动就执行相关代码的, 在启动时, 首先要把计算机模拟成一个flink集群, 然后把中间的代码打包成一个job发布到flink集群上, 在数据进来后才会依次执行.
这里需要提到 Flink 中的几个关键组件：客户端（Client）、作业管理器（JobManager）和任务管理器（TaskManager）。我们的代码，实际上是由客户端获取并做转换，之后提交给JobManger 的。所以 JobManager 就是 Flink 集群里的“管事人”，对作业进行中央调度管理；而它获取到要执行的作业后，会进一步处理转换，然后分发任务给众多的 TaskManager。这里的 TaskManager，就是真正“干活的人”，数据的处理操作都是它们来做的.

3.1 快速启动

3.1.1 环境配置

Flink 是一个分布式的流处理框架，所以实际应用一般都需要搭建集群环境。我们在进行Flink 安装部署的学习时，需要准备 3 台 Linux 机器。具体要求如下：

3.1.2 本地启动

最简单的启动方式，其实是不搭建集群，直接本地启动。本地部署非常简单，直接解压安装包就可以使用，不用进行任何配置；一般用来做一些简单的测试。

下载安装包
进入 Flink 官网，下载 1.13.0 版本安装包 flink-1.13.0-bin-scala_2.12.tgz，注意此处选用对
应 scala 版本为 scala 2.12 的安装包。
解压
在 hadoop102 节点服务器上创建安装目录/opt/module，将 flink 安装包放在该目录下，并
执行解压命令，解压至当前目录。
tar -zxvf flink-1.13.0-bin-scala_2.12.tgz -C /opt/module/
启动
进入解压后的目录，执行启动命令，并查看进程。

$ cd flink-1.13.0/
$ bin/start-cluster.sh 
Starting cluster.
Starting standalonesession daemon on host hadoop102.
Starting taskexecutor daemon on host hadoop102.
$ jps
10369 StandaloneSessionClusterEntrypoint
10680 TaskManagerRunner
10717 Jps

访问 Web UI
启动成功后，访问 http://hadoop102:8081，可以对 flink 集群和任务进行监控管理，如图 3-2
所示。
关闭集群
如果想要让 Flink 集群停止运行，可以执行以下命令：
bin/stop-cluster.sh

3.1.3 集群启动

Flink 是典型的 Master-Slave 架构的分布式数据处理框架，其中 Master 角色对应着JobManager，Slave 角色则对应 TaskManager。我们对三台节点服务器的角色分配如下所示。

下载并解压安装包
具体操作与上节相同。
修改集群配置
进入 conf 目录下，修改 flink-conf.yaml 文件，修改 jobmanager.rpc.address 参数为
hadoop102，如下所示：

cd conf/
vim flink-conf.yaml
# JobManager 节点地址.
jobmanager.rpc.address: hadoop102

这就指定了 hadoop102 节点服务器为 JobManager 节点。修改 workers 文件，将另外两台节点服务器添加为本 Flink 集群的 TaskManager 节点，具体修改如下：

vim workers 
hadoop103
hadoop104

这样就指定了 hadoop103 和 hadoop104 为 TaskManager 节点。
另外，在 flink-conf.yaml 文件中还可以对集群中的 JobManager 和 TaskManager 组件
进行优化配置，主要配置项如下：

jobmanager.memory.process.size：对 JobManager 进程可使用到的全部内存进行配置，
包括 JVM 元空间和其他开销，默认为 1600M，可以根据集群规模进行适当调整。
taskmanager.memory.process.size：对 TaskManager 进程可使用到的全部内存进行配置，
包括 JVM 元空间和其他开销，默认为 1600M，可以根据集群规模进行适当调整。
taskmanager.numberOfTaskSlots：对每个 TaskManager 能够分配的 Slot 数量进行配置，
默认为 1，可根据 TaskManager 所在的机器能够提供给 Flink 的 CPU 数量决定。所谓
Slot 就是 TaskManager 中具体运行一个任务所分配的计算资源。
parallelism.default：Flink 任务执行的默认并行度，优先级低于代码中进行的并行度配
置和任务提交时使用参数指定的并行度数量。

分发安装目录
配置修改完毕后，将 Flink 安装目录发给另外两个节点服务器。

$ scp -r ./flink-1.13.0 atguigu@hadoop103:/opt/module
$ scp -r ./flink-1.13.0 atguigu@hadoop104:/opt/module

启动集群
在 hadoop102 节点服务器上执行 start-cluster.sh 启动 Flink 集群：
bin/start-cluster.sh 使用jps查看进程启动情况
访问 Web UI
启动成功后，同样可以访问 http://hadoop102:8081 对 flink 集群和任务进行监控管理，如图
所示。
这里可以明显看到，当前集群的 TaskManager 数量为 2；由于默认每个 TaskManager 的 Slot
数量为 1，所以总 Slot 数和可用 Slot 数都为 2。
关闭集群
如果想要让 Flink 集群停止运行，可以执行以下命令：bin/stop-cluster.sh

3.1.4 向集群提交作业和取消作业

程序打包
（1）为方便自定义结构和定制依赖，我们可以引入插件 maven-assembly-plugin 进行打包。在 Flink项目的 pom.xml 文件中添加打包插件的配置，具体如下：

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-assembly-pluginartifactId>
                <version>3.0.0version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependenciesdescriptorRef>
                    descriptorRefs>
                configuration>
                <executions>
                    <execution>
                        <id>make-assemblyid>
                        <phase>packagephase>
                        <goals>
                            <goal>singlegoal>
                        goals>
                    execution>
                executions>
            plugin>
        plugins>
    build>

（2）插件配置完毕后，可以使用 IDEA 的 Maven 工具执行 package 命令，出现如下提示即
表示打包成功。
打包完成后，在 target 目录下即可找到所需 JAR 包， JAR 包会有两个，
FlinkTutorial-1.0-SNAPSHOT.jar 和 FlinkTutorial-1.0-SNAPSHOT-jar-with-dependencies.jar，因
为集群中已经具备任务运行所需的所有依赖，所以建议使用 Flink-1.0-SNAPSHOT.jar

在 Web UI 上提交作业
（1）任务打包完成后，我们打开 Flink 的 WEB UI 页面，在右侧导航栏点击“Submit New
Job”，然后点击按钮“+ Add New”，选择要上传运行的 JAR 包.
（2）点击该 JAR 包，出现任务配置页面，进行相应配置。主要配置程序入口主类的全类名，任务运行的并行度，任务运行所需的配置参数和保存点路径等，配置完成后，即可点击按钮“Submit”，将任务提交到集群运行。

（3）任务提交成功之后，可点击左侧导航栏的“Running Jobs”查看程序运行列表情况

启动报错了, 在jobManager中查看任务运行日志, 看到是没有启动nc,导致socket连接失败,启动nc后重新执行



在taskManager的控制台, 可以看到输出结果, 我们有两个taskManager并且任务的并行度是2, 所以这两个会同时输出.
（4）点击该任务，可以查看任务运行的具体情况，也可以通过点击“Cancel Job”结束任
务运行
使用命令行提交作业
除了通过 WEB UI 界面提交任务之外，也可以直接通过命令行来提交任务。这里为方便
起见，我们可以先把 jar 包直接上传到目录 flink-1.13.0 下. 先把控制台执行的task停止
再进入到 Flink 的安装路径下，在命令行使用 flink run 命令提交作业.
./bin/flink run -m TEST-BIGDATA-05:8081 -c com.yangjunyi.flink.StreamWordCount -p 2 ./flink-1.0-SNAPSHOT.jar --hostname 192.168.0.105 --port 7777
在命令行中ctrl+c退出后, 对正在运行的task没有影响
这里的参数 –m 指定了提交到的 JobManager，-c 指定了入口类, 如果想指定运行时参数, 在jar包后面添加相应的即可, 再去flink-ui中也可以看到用命令行提交应用的执行情况.
运行后, 当前的task slot变成了0

如果slot为0时,再次提交任务, 则提交时会直接报错Could not acquire the minimum required resources获取不到最小运行需要的资源

在命令行中取消正在执行的任务
./bin/flink cancel jobId jobId是命令行提交后输出的值

3.2 部署模式

在一些应用场景中，对于集群资源分配和占用的方式，可能会有特定的需求。Flink 为各种场景提供了不同的部署模式，主要有以下三种：

会话模式（Session Mode）
单作业模式（Per-Job Mode）
应用模式（Application Mode）
它们的区别主要在于：集群的生命周期以及资源的分配方式；以及应用的 main 方法到底在哪里执行是客户端（Client）还是 JobManager。接下来我们就做一个展开说明。

3.2.1 会话模式（Session Mode）

会话模式其实最符合常规思维。我们需要先启动一个集群，保持一个会话，在这个会话中通过客户端提交作业，如图所示。集群启动时所有资源就都已经确定，所以所有提交的作业会竞争集群中的资源。

这样的好处很明显，我们只需要一个集群，就像一个大箱子，所有的作业提交之后都塞进去；集群的生命周期是超越于作业之上的，铁打的营盘流水的兵，作业结束了就释放资源，集群依然正常运行。当然缺点也是显而易见的：因为资源是共享的，所以资源不够了，提交新的作业就会失败。另外，同一个 TaskManager 上可能运行了很多作业，如果其中一个发生故障导致 TaskManager 宕机，那么所有作业都会受到影响。之前先启动集群再提交作业, 这种方式就是会话模式. 会话模式比较适合于单个规模小, 执行时间短的大量作业

3.2.2 单作业模式（Per-Job Mode）

会话模式因为资源共享会导致很多问题，所以为了更好地隔离资源，我们可以考虑为每个
提交的作业启动一个集群，这就是所谓的单作业（Per-Job）模式，

单作业模式也很好理解，就是严格的一对一，集群只为这个作业而生。同样由客户端运行应用程序，然后启动集群，作业被提交给 JobManager，进而分发给 TaskManager 执行。作业作业完成后，集群就会关闭，所有资源也会释放。这样一来，每个作业都有它自己的 JobManager管理，占用独享的资源，即使发生故障，它的 TaskManager 宕机也不会影响其他作业。
这些特性使得单作业模式在生产环境运行更加稳定，所以是实际应用的首选模式。
需要注意的是，Flink 本身无法直接这样运行，所以单作业模式一般需要借助一些资源管理框架来启动集群，比如 YARN、Kubernetes。

3.3.3 应用模式（Application Mode）

前面提到的两种模式下，应用代码都是在客户端上执行，然后由客户端提交给 JobManager的。但是这种方式客户端需要占用大量网络带宽，去下载依赖和把二进制数据发送给JobManager；加上很多情况下我们提交作业用的是同一个客户端，就会加重客户端所在节点的资源消耗。
所以解决办法就是，我们不要客户端了，直接把应用提交到 JobManger 上运行。而这也就代表着，我们需要为每一个提交的应用单独启动一个 JobManager，也就是创建一个集群。这个 JobManager 只为执行这一个应用而存在，执行结束之后 JobManager 也就关闭了，这就是所谓的应用模式，

应用模式与单作业模式，都是提交作业之后才创建集群；单作业模式是通过客户端来提交的，客户端解析出的每一个作业对应一个集群；而应用模式下，是直接由 JobManager 执行应用程序的，并且即使应用包含了多个作业，也只创建一个集群。
总结一下，在会话模式下，集群的生命周期独立于集群上运行的任何作业的生命周期，并且提交的所有作业共享资源。而单作业模式为每个提交的作业创建一个集群，带来了更好的资源隔离，这时集群的生命周期与作业的生命周期绑定。最后，应用模式为每个应用程序创建一个会话集群，在 JobManager 上直接调用应用程序的 main()方法。
我们所讲到的部署模式，相对是比较抽象的概念。实际应用时，一般需要和资源管理平台结合起来，选择特定的模式来分配资源、部署应用。接下来，我们就针对不同的资源提供者（Resource Provider）的场景，具体介绍 Flink 的部署方式。

3.3 独立模式部署

独立模式部署使用的很少, 不再赘述了.

3.4 YARN模式部署

独立（Standalone）模式由 Flink 自身提供资源，无需其他框架，这种方式降低了和其他第三方资源框架的耦合性，独立性非常强。但我们知道，Flink 是大数据计算框架，不是资源调度框架，这并不是它的强项；所以还是应该让专业的框架做专业的事，和其他资源调度框架集成更靠谱。而在目前大数据生态中，国内应用最为广泛的资源管理平台就是 YARN 了。所以接下来我们就将学习，在强大的 YARN 平台上 Flink 是如何集成部署的。
整体来说，YARN 上部署的过程是：客户端把 Flink 应用提交给 Yarn 的 ResourceManager, Yarn 的ResourceManager 会向 Yarn 的 NodeManager 申请容器。在这些容器上，Flink 会部署JobManager 和 TaskManager 的实例，从而启动集群。Flink 会根据运行在 JobManger 上的作业所需要的 Slot 数量动态分配 TaskManager 资源。

3.4.1 相关准备和配置

在 Flink1.8.0 之前的版本，想要以 YARN 模式部署 Flink 任务时，需要 Flink 是有 Hadoop支持的。从 Flink 1.8 版本开始，不再提供基于 Hadoop 编译的安装包，若需要 Hadoop 的环境支持，需要自行在官网下载 Hadoop 相关版本的组件 flink-shaded-hadoop-2-uber-2.7.5-10.0.jar，并将该组件上传至 Flink 的 lib 目录下。在 Flink 1.11.0 版本之后，增加了很多重要新特性，其中就包括增加了对Hadoop3.0.0以及更高版本Hadoop的支持，不再提供“flink-shaded-hadoop-*”jar 包，而是通过配置环境变量完成与 YARN 集群的对接。
在将 Flink 任务部署至 YARN 集群之前，需要确认集群是否安装有 Hadoop，保证 Hadoop版本至少在 2.2 以上，并且集群中安装有 HDFS 服务。
具体配置步骤如下：
（1）按照 3.1 节所述，下载并解压安装包，并将解压后的安装包重命名为 flink-1.13.0-yarn，
本节的相关操作都将默认在此安装路径下执行。
（2）配置环境变量，增加环境变量配置如下：

 vim /etc/profile.d/my_env.sh
HADOOP_HOME=/opt/module/hadoop-2.7.5
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin
export HADOOP_CONF_DIR=${HADOOP_HOME}/etc/hadoop
export HADOOP_CLASSPATH=`hadoop classpath`

这里必须保证设置了环境变量 HADOOP_CLASSPATH
（3）启动 Hadoop 集群，包括 HDFS 和 YARN。

 start-dfs.sh
 start-yarn.sh

分别在 3 台节点服务器查看进程启动情况。
（4）进入 flink的conf 目录，修改 flink-conf.yaml 文件，修改以下配置，这些配置项的含义在进
行 Standalone 模式配置的时候进行过讲解，若在提交命令中不特定指明，这些配置将作为默认
配置。

 cd /opt/module/flink-1.13.0-yarn/conf/
$ vim flink-conf.yaml
jobmanager.memory.process.size: 1600m
taskmanager.memory.process.size: 1728m
taskmanager.numberOfTaskSlots: 8
parallelism.default: 1

3.4.2 会话模式部署(常用)

YARN 的会话模式与独立集群略有不同，需要首先申请一个 YARN 会话（YARN session）来启动 Flink 集群。具体步骤如下：

启动集群
（1）启动 hadoop 集群(HDFS, YARN)。
（2）执行脚本命令向 YARN 集群申请资源，开启一个 YARN 会话，启动 Flink 集群。 bin/yarn-session.sh -nm test -d
可用参数解读：
-d：分离模式，如果你不想让 Flink YARN 客户端一直前台运行，可以使用这个参数，即使关掉当前对话窗口，YARN session 也可以后台运行。
-jm(–jobManagerMemory)：配置 JobManager 所需内存，默认单位 MB。
-nm(–name)：配置在 YARN UI 界面上显示的任务名。
-qu(–queue)：指定 YARN 队列名。
-tm(–taskManager)：配置每个 TaskManager 所使用内存。
注意：Flink1.11.0 版本不再使用-n 参数和-s 参数分别指定 TaskManager 数量和 slot 数量，
YARN 会按照需求动态分配 TaskManager 和 slot。所以从这个意义上讲，YARN 的会话模式也
不会把集群资源固定，同样是动态分配的。
YARN Session 启动之后会给出一个 web UI 地址以及一个 YARN application ID，如下所示，
用户可以通过 web UI 或者命令行两种方式提交作业。
提交作业
（1）通过 Web UI 提交作业这种方式比较简单，与上文所述 Standalone 部署模式基本相同。
（2）通过命令行提交作业, 将 Standalone 模式讲解中打包好的任务运行 JAR 包上传至集群,执行以下命令将该任务提交到已经开启的 Yarn-Session 中运行。 bin/flink run -c com.atguigu.wc.StreamWordCount FlinkTutorial-1.0-SNAPSHOT.jar
客户端可以自行确定 JobManager 的地址，也可以通过-m 或者-jobmanager 参数指定
JobManager 的地址，JobManager 的地址在 YARN Session 的启动页面中可以找到。
任务提交成功后，可在 YARN 的 Web UI 界面查看运行情况。

从图中可以看到我们创建的 Yarn-Session 实际上是一个 Yarn 的Application，并且有唯一的 Application ID。也可以通过 Flink 的 Web UI 页面查看提交任务的运行情况

3.4.3 单作业模式部署

这里的 application_XXXX_YY 是当前应用的 ID，是作业的 ID。注意如果取消作业，整个 Flink 集群也会停掉。

3.4.4 应用模式部署

3.4.5 高可用

YARN 模式的高可用和独立模式（Standalone）的高可用原理不一样。
Standalone 模式中, 同时启动多个 JobManager, 一个为“领导者”（leader），其他为“后备”（standby）, 当 leader 挂了, 其他的才会有一个成为 leader。
而 YARN 的高可用是只启动一个 Jobmanager, 当这个 Jobmanager 挂了之后, YARN 会再次启动一个, 所以其实是利用的 YARN 的重试次数来实现的高可用。
（1）在 yarn-site.xml 中配置。

<property>
 <name>yarn.resourcemanager.am.max-attemptsname>
 <value>4value>
 <description>
 The maximum number of application master execution attempts.
 description>
property>

注意: 配置完不要忘记分发, 和重启 YARN。
（2）在 flink-conf.yaml 中配置。

yarn.application-attempts: 3
high-availability: zookeeper
high-availability.storageDir: hdfs://hadoop102:9820/flink/yarn/ha
high-availability.zookeeper.quorum: 
hadoop102:2181,hadoop103:2181,hadoop104:2181
high-availability.zookeeper.path.root: /flink-yarn

（3）启动 yarn-session。
（4）杀死 JobManager, 查看复活情况。
注意: yarn-site.xml 中配置的是 JobManager 重启次数的上限, flink-conf.xml 中的次数应该小于这个值。

4. Flink运行时架构

4.1 Flink系统架构

4.1.1 整体构成

4.1.2 作业管理器JobManager

4.1.3 任务管理器TaskManager

4.2 Flink作业提交流程

4.2.1 高层级抽象视角

4.2.2 独立模式（Standalone）

4.2.3 YARN 集群

4.3 一些重要概念

4.3.1 数据流图(DataFlow Graph)

4.3.2 并行度(Parallelism)

4.3.3 算子链（Operator Chain）

4.3.4 作业图（JobGraph）和执行图（ExecutionGraph）

4.3.5 任务(Task)和任务槽(Task Slots)

5. DataStreamAPI(基础篇)

5.1 执行环境(Execution Environment)

5.1.1 创建执行环境

getExecutionEnvironment
最简单的方式，就是直接调用 getExecutionEnvironment 方法。它会根据当前运行的上下文直接得到正确的结果：如果程序是独立运行的，就返回一个本地执行环境；如果是创建了 jar包，然后从命令行调用它并提交到集群执行，那么就返回集群的执行环境。也就是说，这个方法会根据当前运行的方式，自行决定该返回什么样的运行环境。
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
这种“智能”的方式不需要我们额外做判断，用起来简单高效，是最常用的一种创建执行环境的方式.
createLocalEnvironment
这个方法返回一个本地执行环境。可以在调用时传入一个参数，指定默认的并行度；如果
不传入，则默认并行度就是本地的 CPU 核心数
StreamExecutionEnvironment localEnv = StreamExecutionEnvironment.createLocalEnvironment();
createRemoteEnvironment
这个方法返回集群执行环境。需要在调用时指定 JobManager 的主机名和端口号，并指定
要在集群中运行的 Jar 包。

StreamExecutionEnvironment remoteEnv = StreamExecutionEnvironment
 			.createRemoteEnvironment(
 				"host", // JobManager 主机名
 				1234, // JobManager 进程端口号
 				"path/to/jarFile.jar" // 提交给 JobManager 的 JAR 包
);

在获取到程序执行环境后，我们还可以对执行环境进行灵活的设置。比如可以全局设置程
序的并行度、禁用算子链，还可以定义程序的时间语义、配置容错机制。关于时间语义和容错
机制，我们会在后续的章节介绍。

5.1.2 执行模式(Execution Mode)

上节中我们获取到的执行环境，是一个 StreamExecutionEnvironment，顾名思义它应该是做流处理的。那对于批处理，又应该怎么获取执行环境呢？
在之前的 Flink 版本中，批处理的执行环境与流处理类似，是调用类 ExecutionEnvironment的静态方法，返回它的对象：

// 批处理环境
ExecutionEnvironment batchEnv = ExecutionEnvironment.getExecutionEnvironment();
// 流处理环境
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

基于 ExecutionEnvironment 读入数据创建的数据集合，就是 DataSet；对应的调用的一整套转换方法，就是 DataSet API。这些我们在第二章的批处理 word count 程序中已经有了基本了解。
而从 1.12.0 版本起，Flink 实现了 API 上的流批统一。DataStream API 新增了一个重要特性：可以支持不同的“执行模式”（execution mode），通过简单的设置就可以让一段 Flink 程序在流处理和批处理之间切换。这样一来，DataSet API 也就没有存在的必要了。

BATCH 模式的配置方法
由于 Flink 程序默认是 STREAMING 模式，我们这里重点介绍一下 BATCH 模式的配置。
主要有两种方式：
（1）通过命令行配置 bin/flink run -Dexecution.runtime-mode=BATCH ... 在提交作业时，增加 execution.runtime-mode 参数，指定值为 BATCH。
（2）通过代码配置

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setRuntimeMode(RuntimeExecutionMode.BATCH);

在代码中，直接基于执行环境调用 setRuntimeMode 方法，传入 BATCH 模式。
建议: 不要在代码中配置，而是使用命令行。这同设置并行度是类似的：在提交作业时指定参数可以更加灵活，同一段应用程序写好之后，既可以用于批处理也可以用于流处理。而在代码中硬编码（hard code）的方式可扩展性比较差，一般都不推荐。

什么时候选择 BATCH 模式

5.1.3 触发程序执行

5.2 源算子

5.2.1 准备工作

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
// 链式赋值
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
public class Event {
    private String user;
    private String url;
    private Long timestamp;
}

5.2.2 从集合/元素/文件中获取数据

最简单的读取数据的方式，就是在代码中直接创建一个 Java 集合，然后调用执行环境的fromCollection 方法进行读取。这相当于将数据临时存储到内存中，形成特殊的数据结构后，作为数据源使用，一般用于测试。

import com.yangjunyi.flink.entity.Event;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.ArrayList;
import java.util.List;

public class SourceTest {
    public static void main(String[] args) throws Exception {
        // 创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 1. 从文件中读取数据
        DataStreamSource<String> stream1 = env.readTextFile("input/clicks.txt");
        // 2.从集合中读取数据
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(2);
        nums.add(5);
        DataStreamSource<Integer> numStream = env.fromCollection(nums);

        ArrayList<Event> events = new ArrayList<>();
        events.add(new Event("Mary","./home",1000L));
        events.add(new Event("Bob","./cart",2000L));
        DataStreamSource<Event> stream2 = env.fromCollection(events);

        // 3. 从元素读取数据
        DataStreamSource<Event> elementStream = env.fromElements(
                new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L)
        );
        stream1.print("stream1");
        numStream.print("numStream");
        stream2.print("stream2");
        elementStream.print("elementStream");
        env.execute();

    }
}

如果要从hdfs中读取数据的话

5.2.3 从socket中读取数据

5.2.4 从Kafka读取数据

<dependency>
 	<groupId>org.apache.flinkgroupId>
	<artifactId>flink-connector-kafka_${scala.binary.version}artifactId>
 	<version>${flink.version}version>
dependency>

    // 创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        Properties properties = new Properties();
        // kafka连接节点
        properties.setProperty("bootstrap.servers","192.168.0.75:9092");
        // groupId
        properties.setProperty("group.id","flinktest");
        // 消费者key序列化
        properties.setProperty("key.deserializer","org.apache.kafka.common.serialization.StringSerializer");
        // 消费者value序列化
        properties.setProperty("value.deserializer","org.apache.kafka.common.serialization.StringSerializer");
        // 偏移量设置
        properties.setProperty("auto.offset.reset","latest");
        // 从kafka中读取数据 第一个参数:topic 第二个参数: value序列化模式, 第三个参数:kafka连接properties参数
        DataStreamSource<String> kafkaStream = env.addSource(new FlinkKafkaConsumer<String>("X429Deplane", new SimpleStringSchema(), properties));
        kafkaStream.print();
        env.execute();

5.2.5 自定义Source

public class ClickSource implements SourceFunction<Event> {
    // 声明一个标志位,在下面的run中不停的生成数据, 直到running为false. running什么时候才能置成false呢, 就是在调用cancel方法的时候
    private boolean running = true;
    @Override
    public void run(SourceContext<Event> sourceContext) throws Exception {
        // 随机生成数据
        Random random = new Random();
        // 定义字段选取数据范围
        String[] users = {"Mary", "Alice", "Bob", "Cary"};
        String[] urls = {"./home", "./cart", "./fav", "./prod?id=1", "./prod?id=2"};
        while (running) {
            String user = users[random.nextInt(users.length)];
            String url = urls[random.nextInt(users.length)];
            Long timestamp = Calendar.getInstance().getTimeInMillis();
            sourceContext.collect(new Event(user,url,timestamp));
            Thread.sleep(1000);
        }
    }

    @Override
    public void cancel() {
        this.running = false;
    }
}

link使用自定义source作为源算子

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStreamSource<Event> objectDataStreamSource = env.addSource(new ClickSource());
        objectDataStreamSource.print();
        env.execute();
    }

这里要注意的是 SourceFunction 接口定义的数据源，并行度只能设置为 1，如果数据源设置为大于 1 的并行度，则会抛出异常。如果想要设置并行的数据源, 需要实现ParallelSourceFunction接口

public class ParallelCustomSource implements ParallelSourceFunction<Integer> {

    private boolean running = true;
    Random random = new Random();
    @Override
    public void run(SourceContext<Integer> sourceContext) throws Exception {
        while(running) {
            sourceContext.collect(random.nextInt());
            Thread.sleep(1000);
        }
    }

    @Override
    public void cancel() {
        this.running= false;
    }
}

接下来再把并行度调高就可以了

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStreamSource<Integer> objectDataStreamSource = env.addSource(new ParallelCustomSource()).setParallelism(2);
        objectDataStreamSource.print();
        env.execute();
    }

5.2.6 Flink支持的数据类型

再次强调一下Flink对POJO类的定义, 类必须是公共的(public)和独立的(没有非静态的内部类). 类必须有公共的无参构造方法, 类内部的字段是public且非final的, 或者有公共的getter和setter方法, 且满足Java命名规范

5.3 转换算子(Transformation)

5.3.1 基本转换算子

在基本转换算子后, 如果lambda中使用了泛型, 需要在后面跟一个returns方法

映射(map)

public class TransformMapTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.addSource(new ClickSource());
        // 进行map转换计算, 提取user字段
        // 1.使用自定义类实现MapFunction接口
        //SingleOutputStreamOperator map = streamSource.map(new MyMapper());
        // 2.使用匿名类实现MapFunction接口
        /*SingleOutputStreamOperator map = streamSource.map(new MapFunction() {
            @Override
            public String map(Event event) throws Exception {
                return event.getUser();
            }
        });*/
        // 3.使用lambda表达式
        SingleOutputStreamOperator<String> map = streamSource.map(data -> data.getUser());
        map.print();
        env.execute();

    }
    // 自定义mapFunction
    public static class MyMapper implements MapFunction<Event,String>{
        @Override
        public String map(Event event) throws Exception {
            return event.getUser();
        }
    }
}

过滤(filter)

public class TransformFliterTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.addSource(new ClickSource());
        // 1. 传入一个实现了filterFunction的自定义类对象
        //SingleOutputStreamOperator filter = streamSource.filter(new MyFilter());
        // 2. 传入一个匿名类
        /*SingleOutputStreamOperator filter = streamSource.filter(new FilterFunction() {
            @Override
            public boolean filter(Event event) throws Exception {
                return "Mary".equals(event.getUser());
            }
        });*/
        // 3. 传入lambda表达式
        SingleOutputStreamOperator<Event> filter = streamSource.filter(data -> "Mary".equals(data.getUser()));
        filter.print();
        env.execute();
    }
    public static class MyFilter implements FilterFunction<Event>{
        @Override
        public boolean filter(Event event) throws Exception {
            return "Mary".equals(event.getUser());
        }
    }
}

扁平映射(flatMap)

public class TransformFlatMapTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.addSource(new ClickSource());
        // 1. 传入一个实现了flatMapFunction的自定义类对象
//        SingleOutputStreamOperator flatMap = streamSource.flatMap(new MyFlatMap());
        // 3. 传入lambda表达式
        SingleOutputStreamOperator<String> flatMap = streamSource.flatMap((Event value, Collector<String> out) -> {
            if("Mary".equals(value.getUser())) {
                out.collect(value.getUser());
            }else if("Bob".equals(value.getUrl())){
                out.collect(value.getUser());
                out.collect(value.getUrl());
                out.collect(value.getTimestamp().toString());
            }
            // 不是Mary和Bob以外的其他数据, 这里不做任何处理, 相当于是被过滤掉了
             // 这里还是会出现Java Lambda的泛型擦除. 因为在Lambda里使用了泛型, 当输出时Java会把泛型擦除, 所以这里需要手动添加return
        }).returns(new TypeHint<String>() {});
        flatMap.print();
        env.execute();
    }
    public static class MyFlatMap implements FlatMapFunction<Event, String> {
        @Override
        public void flatMap(Event event, Collector<String> collector) throws Exception {
            collector.collect(event.getUser());
            collector.collect(event.getUrl());
            collector.collect(event.getTimestamp().toString());
        }
    }
}

如果不加returns方法指定返回类型的话, 这里会报错

5.3.2 聚合算子（Aggregation）

按键分区(key by)

public class AggregationKeyByTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.fromElements(new Event("Mary","./home",1000L),
                new Event("Bob","./cart",2000L),
                new Event("Alice","./prod?id=100",3000L),
                new Event("Bob","./prod?id=200",3400L)
        );
        // 按键分析后进行聚合
        KeyedStream<Event, String> keyedStream = streamSource.keyBy(( event -> event.getUser()));
        SingleOutputStreamOperator<Event> operatorMax = keyedStream.max("timestamp");
        SingleOutputStreamOperator<Event> operatorMaxBy = keyedStream.maxBy("timestamp");
        // max方法除了修改了timestamp的值以外, 对其他的参数还是使用最初的值, 而maxby除了对timestamp修改了以外, 也对其他的值取最新的数据
        operatorMax.print("max");
        operatorMaxBy.print("maxBy");
        env.execute();
    }
}

简单聚合

规约聚合

public class AggregationReduceTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=2", 3200L),
                new Event("Bob", "./prod?id=200", 3400L),
                new Event("Bob", "./home", 3300L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L)
        );
        // 统计访问量最大的用户和访问量
        // 1. 统计每个用户的访问频次
        // 在这里的map使用匿名内部类的形式不会出现泛型擦除, 如果使用lambda会出现泛型擦除, 所以在转换操作后, 尽量跟一个returns方法
        SingleOutputStreamOperator<Tuple2<String, Long>> reduce = streamSource.map( event -> Tuple2.of(event.getUser(), 1L))
                .returns(new TypeHint<Tuple2<String, Long>>() {})
                .keyBy(data -> data.f0)
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    // 规约时, 第一个参数value1是前面规约后得到的数据, 后面的value2是新进来的数据,
                    // 所以我们要做的操作是,tuple的f0是user,而user名字都是相同的, 因为之前keyBy就是根据名字进行的
                    // tuple的f1是访问次数, 所以需要把value1的数字和value2的数字相加, 就是之前规约得到的数字加上新进来的数据的数字
                    @Override
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                        return Tuple2.of(value1.f0, value1.f1 + value2.f1);
                    }
                });
        // 2. 根据当前的个数, 选取当前最活跃的用户
        // 这里keyBy给定了一个写死的字符串, 代表所有的数据都分配到相同的key中, 都会被分配到同一个分区
        reduce.keyBy(data -> "key")
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                        // value1的数量和value2的数量谁大就返回谁
                        return value1.f1 > value2.f1 ? value1 : value2;
                    }
                }).print();

        env.execute();
    }

}

5.3.3 用户自定义函数(UDF)

函数类
匿名函数(Lambda)

这些方法对于其它泛型擦除的场景同样适用。
富函数类（Rich Function Classes）

public class TransformRichFunction {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=2", 3200L),
                new Event("Bob", "./prod?id=200", 3400L),
                new Event("Bob", "./home", 3300L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L)
        );
        streamSource.map(new MyRichMapFunction()).print();

        env.execute();
    }
    public static class MyRichMapFunction extends RichMapFunction<Event,Integer>{
        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            System.out.println("open生命周期" + getRuntimeContext().getIndexOfThisSubtask() + "号任务");
        }

        @Override
        public void close() throws Exception {
            super.close();
            System.out.println("close生命周期" + getRuntimeContext().getIndexOfThisSubtask() + "号任务结束");

        }

        @Override
        public Integer map(Event event) throws Exception {
            return event.getUrl().length();
        }
    }
}

5.3.4 物理分区(Physical Partitioning)

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=2", 3200L),
                new Event("Bob", "./prod?id=200", 3400L),
                new Event("Bob", "./home", 3300L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L)
        );
        streamSource.shuffle().print().setParallelism(4);
        env.execute();

整体来看没有什么规律, 在数据量很多的情况下, 会大概率变成均匀分布

streamSource.rebalance().print().setParallelism(4);

可以看到8条数据被均匀的分给了四个并行算子上,每个slot上都输出了2条数据, 如果不指定物理分区操作, Flink底层默认会使用rebalance分区策略

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 从自定义流中读取数据
        env.fromElements(1,2,3,4,5,6,7,8)
                .partitionCustom(new Partitioner<Integer>() {
                    @Override
                    public int partition(Integer o, int i) {
                        return  o % 2;
                    }
                }, new KeySelector<Integer, Integer>() {
                    @Override
                    public Integer getKey(Integer integer) throws Exception {
                        return integer;
                    }
                }).print().setParallelism(4);
        // 自定义重分区
        env.execute();

5.4 输出算子(Sink)

5.4.1 连接到外部系统

5.4.2 输出到文件

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=2", 3200L),
                new Event("Bob", "./prod?id=200", 3400L),
                new Event("Bob", "./home", 3300L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L)
        );
        StreamingFileSink<String> streamingFileSink = StreamingFileSink.<String>forRowFormat(new Path("./output"),
                new SimpleStringEncoder<>("UTF-8"))
                // 设置文件归档策略, 使用默认的滚动归档策略即可
                .withRollingPolicy(DefaultRollingPolicy
                        .builder()
                        // 文件的最大大小单位字节 此处为1G
                        .withMaxPartSize(1024*1024*1024)
                        // 设置每隔多长时间进行归档 单位ms 此处为15分钟
                        .withRolloverInterval(TimeUnit.MINUTES.toMillis(15))
                        // 设置无操作(不活跃)后多长时间进行归档 此处为5分钟
                        .withInactivityInterval(TimeUnit.MINUTES.toMillis(5))
                        .build())
                .build();
        // 因为streamSource的泛型为Event, 我们这里要转换成String进行归档写入文件, 所以要加一个map转换的操作
        streamSource.map(data -> data.toString()).addSink(streamingFileSink);
        env.execute();
    }

因为设置了4个并行子任务来执行写入, 而且还设置了滚动策略. 所以输出路径如下图所示

5.4.3 输出到Kafka

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 读取Kafka数据
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers","hadoop102:9092");
        DataStreamSource<String> kafkaStream = env.addSource(new FlinkKafkaConsumer<String>("clicks", new SimpleStringSchema(), properties));

        // 2. 用flink进行转换处理
        SingleOutputStreamOperator<String> map = kafkaStream.map(new MapFunction<String, String>() {
            @Override
            public String map(String s) throws Exception {
                String[] fields = s.split(",");
                return new Event(fields[0].trim(), fields[1].trim(), Long.valueOf(fields[2].trim())).toString();
            }
        });
        // 3.输出到kafka
        map.addSink(new FlinkKafkaProducer<String>("hadoop102:9092","events",new SimpleStringSchema()));
        env.execute();
    }

5.4.4 输出到Redis

导入redis连接器依赖

<dependency>
 	<groupId>org.apache.bahirgroupId>
 	<artifactId>flink-connector-redis_2.11artifactId>
 	<version>1.0version>
dependency>

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStreamSource<Event> stream = env.addSource(new ClickSource());

        // 创建一个jedis连接配置
        FlinkJedisPoolConfig config = new FlinkJedisPoolConfig.Builder()
                .setHost("hadoop102")
                .build();
        stream.addSink(new RedisSink<>(config, new MyRedisMapper()));
        env.execute();

 // 自定义类实现RedisMapper接口
    public static class MyRedisMapper implements RedisMapper<Event> {
        @Override
        public RedisCommandDescription getCommandDescription() {
            return new RedisCommandDescription(RedisCommand.HSET,"clicks");
        }

        @Override
        public String getKeyFromData(Event event) {
            return event.getUser();
        }

        @Override
        public String getValueFromData(Event event) {
            return event.getUrl();
        }
    }

5.4.5 输出到ElasticSearch

添加ElasticSearch连接器依赖

<dependency>
 	<groupId>org.apache.flinkgroupId>
 	<artifactId>flink-connector-elasticsearch7_${scala.binary.version}artifactId>
 	<version>${flink.version}version>
dependency>

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=2", 3200L),
                new Event("Bob", "./prod?id=200", 3400L),
                new Event("Bob", "./home", 3300L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L)
        );
        // 定义hosts的列表
        ArrayList<HttpHost> httpHosts = new ArrayList<>();
        httpHosts.add(new HttpHost("hadoop102",9200));
        // 定义ElasticSearchSinkFunction 处理数据
        ElasticsearchSinkFunction<Event> elasticsearchSinkFunction = new ElasticsearchSinkFunction<Event>() {
            @Override
            public void process(Event event, RuntimeContext runtimeContext, RequestIndexer requestIndexer) {
                HashMap<String, String> map = new HashMap<>();
                map.put(event.getUser(),event.getUrl());

                // 构建一个IndexRequest
                IndexRequest clicks = Requests.indexRequest()
                        .index("clicks")
                        .source(map);
                
                requestIndexer.add(clicks);
            }
        };
        streamSource.addSink(new ElasticsearchSink.Builder<>(httpHosts,elasticsearchSinkFunction ).build());
        env.execute();
    }

5.4.6 输出到MYSQL(jdbc)

<dependency>
 	<groupId>org.apache.flink</groupId>
 	<artifactId>flink-connector-jdbc_${scala.binary.version}</artifactId>
 	<version>${flink.version}</version>
</dependency>
<dependency>
 	<groupId>mysql</groupId>
 	<artifactId>mysql-connector-java</artifactId>
 	<version>5.1.47</version>
</dependency>

5.4.7 自定义Sink输出如HBase

<dependency>
 	<groupId>org.apache.hbasegroupId>
 	<artifactId>hbase-clientartifactId>
 	<version>${hbase.version}version>
dependency>

（2）编写输出到 HBase 的示例代码

package com.yangjunyi.flink.sink;

package com.yangjunyi.flink.sink;

import com.yangjunyi.flink.entity.Event;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.connector.jdbc.JdbcConnectionOptions;
import org.apache.flink.connector.jdbc.JdbcSink;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;

import java.nio.charset.StandardCharsets;
import java.sql.PreparedStatement;

public class SinkToHBase {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env =
                StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        env.fromElements("hello", "world")
                .addSink(
                        new RichSinkFunction<String>() {
                            public org.apache.hadoop.conf.Configuration configuration; // 管理 Hbase 的配置信息,这里因为 Configuration 的重名问题，将类以完整路径导入
                            public Connection connection; // 管理 Hbase 连接
                            @Override
                            public void open(Configuration parameters) throws Exception {
                                super.open(parameters);
                                configuration = HBaseConfiguration.create();
                                configuration.set("hbase.zookeeper.quorum", "hadoop102:2181");
                                connection = ConnectionFactory.createConnection(configuration);
                            }

                            @Override
                            public void invoke(String value, Context context) throws Exception {
                                Table table = connection.getTable(TableName.valueOf("test")); // 表名为 test
                                Put put = new Put("rowkey".getBytes(StandardCharsets.UTF_8)); // 指定 rowkey
                                put.addColumn("info".getBytes(StandardCharsets.UTF_8) // 指定列名
                                        , value.getBytes(StandardCharsets.UTF_8) // 写入的数据
                                        , "1".getBytes(StandardCharsets.UTF_8)); // 写入的数据
                                table.put(put); // 执行 put 操作
                                table.close(); // 将表关闭
                            }
                            @Override
                            public void close() throws Exception {
                                super.close();
                                connection.close(); // 关闭连接
                            }
                        }
                );
        env.execute();
    }
}



public class SinkToHBase {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env =
                StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        env.fromElements("hello", "world")
                .addSink(
                        new RichSinkFunction<String>() {
                            public org.apache.hadoop.conf.Configuration configuration; // 管理 Hbase 的配置信息,这里因为 Configuration 的重名问题，将类以完整路径导入
                            public Connection connection; // 管理 Hbase 连接
                            @Override
                            public void open(Configuration parameters) throws Exception {
                                super.open(parameters);
                                configuration = HBaseConfiguration.create();
                                configuration.set("hbase.zookeeper.quorum", "hadoop102:2181");
                                connection = ConnectionFactory.createConnection(configuration);
                            }

                            @Override
                            public void invoke(String value, Context context) throws Exception {
                                Table table = connection.getTable(TableName.valueOf("test")); // 表名为 test
                                Put put = new Put("rowkey".getBytes(StandardCharsets.UTF_8)); // 指定 rowkey
                                put.addColumn("info".getBytes(StandardCharsets.UTF_8) // 指定列名
                                        , value.getBytes(StandardCharsets.UTF_8) // 写入的数据
                                        , "1".getBytes(StandardCharsets.UTF_8)); // 写入的数据
                                table.put(put); // 执行 put 操作
                                table.close(); // 将表关闭
                            }
                            @Override
                            public void close() throws Exception {
                                super.close();
                                connection.close(); // 关闭连接
                            }
                        }
                );
        env.execute();
    }
}

6.Flink中的时间和窗口

6.1 时间语义

6.1.1 Flink中的时间语义

6.1.2 哪种时间语义更重要

6.2 水位线

6.2.1 事件时间和窗口

6.2.2 什么是水位线

6.2.3 如何生成水位线

水位线的周期性生成间隔时间设置env.getConfig().setAutoWatermarkInterval(100L) 单位是ms表示每隔100ms生成一次水位线, 默认值是200ms

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 设置水位线自动生成时间间隔为100ms 默认值是200ms
        env.getConfig().setAutoWatermarkInterval(100L);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=2", 3200L),
                new Event("Bob", "./prod?id=200", 3400L),
                new Event("Bob", "./home", 3300L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L)
        );
        // 水位线生成策略建议离source算子越近越好, 因为在source处设置了水位线, 后续的其他算子都可以用到
        // 有序流额watermark生成,有序流就是基于自增长的时间戳作为水位线即可
        SingleOutputStreamOperator<Event> stream1 = streamSource.assignTimestampsAndWatermarks(
                WatermarkStrategy.<Event>forMonotonousTimestamps()
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event event, long recordTimestamp) {
                                return event.getTimestamp();
                            }
                        })
        );

        // 乱序流watermark生成
        SingleOutputStreamOperator<Event> stream2 = streamSource.assignTimestampsAndWatermarks(
                // 设置水位线延时2秒
                WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2L))
                        // 设置水位线基于时间戳数据
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event event, long recordTimestamp) {
                                return event.getTimestamp();
                            }
                        })
        );

        env.execute();
    }

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        env.addSource(new ClickSource())
                .assignTimestampsAndWatermarks(new CustomWatermarkStrategy())
                .print();
        env.execute();
    }

    public static class CustomWatermarkStrategy implements WatermarkStrategy<Event> {
        @Override
        public TimestampAssigner<Event> createTimestampAssigner(TimestampAssignerSupplier.Context context) {
            return new SerializableTimestampAssigner<Event>() {
                @Override
                public long extractTimestamp(Event element, long recordTimestamp) {
                    return element.getTimestamp(); // 告诉程序数据源里的时间戳是哪一个字段
                }
            };
        }

        @Override
        public WatermarkGenerator<Event> createWatermarkGenerator(WatermarkGeneratorSupplier.Context context) {
            return new CustomPeriodicGenerator();
        }
    }

    public static class CustomPeriodicGenerator implements WatermarkGenerator<Event> {
        private Long delayTime = 5000L; // 延迟时间
        private Long maxTs = Long.MIN_VALUE + delayTime + 1L; // 观察到的最大时间戳

        @Override
        public void onEvent(Event event, long eventTimestamp, WatermarkOutput output) {
            // 每来一条数据就调用一次
            maxTs = Math.max(event.getTimestamp(), maxTs); // 更新最大时间戳
        }

        @Override
        public void onPeriodicEmit(WatermarkOutput output) {
            // 发射水位线，默认 200ms 调用一次
            output.emitWatermark(new Watermark(maxTs - delayTime - 1L));
        }
    }

public class CustomPunctuatedGenerator implements WatermarkGenerator<Event> {
 	@Override
 	public void onEvent(Event r, long eventTimestamp, WatermarkOutput output) {
		// 只有在遇到特定的 itemId 时，才发出水位线
 		if (r.user.equals("Mary")) {
 			output.emitWatermark(new Watermark(r.timestamp - 1));
 		}
 }
 	@Override
 	public void onPeriodicEmit(WatermarkOutput output) {
 	// 不需要做任何事情，因为我们在 onEvent 方法中发射了水位线
 	}
}

6.2.4 水位线的传递

6.3 窗口

6.3.1 窗口的概念

6.3.2 窗口的分类

按照驱动类型分类

（1）时间窗口（Time Window）

（2）计数窗口（Count Window）
按照窗口分配数据的规则分类

（1）滚动窗口（Tumbling Windows）

（2）滑动窗口（Sliding Windows）

（3）会话窗口（Session Windows）

（4）全局窗口（Global Windows）

6.3.3 窗口API概览

6.3.4 窗口分配器(Window Assigners)

时间窗口
计数窗口
全局窗口

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 设置水位线自动生成时间间隔为100ms 默认值是200ms
        env.getConfig().setAutoWatermarkInterval(100L);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=2", 3200L),
                new Event("Bob", "./prod?id=200", 3400L),
                new Event("Bob", "./home", 3300L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L)
        );
        // 乱序流watermark生成
        SingleOutputStreamOperator<Event> stream = streamSource.assignTimestampsAndWatermarks(
                // 设置水位线延时2秒
                WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2L))
                        // 设置水位线基于时间戳数据
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event event, long recordTimestamp) {
                                return event.getTimestamp();
                            }
                        })
        );
        // 注意开窗前必须指定水位线
        stream.keyBy(data -> data.getUser())
                // 滚动事件时间窗口, 指定事件时间1小时的窗口
                //.window(TumblingEventTimeWindows.of(Time.hours(1)))
                // 时间窗口都有一个参数是offset偏移量,我们时区为东8区, 代码获取的时间应该减去8小时才是我们的时间
                // 这样才可以得到北京时间每天 0 点开启的滚动窗口
                //.window(TumblingEventTimeWindows.of(Time.days(1),Time.hours(-8)))
                // 滑动事件时间窗口, 指定事件时间窗口大小为1小时, 每5分钟滑动一次
                //.window(SlidingEventTimeWindows.of(Time.hours(1),Time.minutes(5)))
                // 事件时间会话窗口
                //.window(EventTimeSessionWindows.withGap(Time.seconds(2)))
                // countWindow计数窗口, 一个参数的就是滚动窗口, 2个参数的就是滑动窗口
                .countWindow(10L);
        // 注意所有的开窗都不是一个完整的算子, 只能算是一个中间步骤返回值是WindowedStream, 只有开窗函数+窗口函数完成后才返回的是完整的算子


        env.execute();
    }

6.3.5窗口函数

对WindowStream进行窗口函数后, 才能得到一个DataStream

增量聚合函数（incremental aggregation functions）流处理思路增量的计算

（1）归约函数（ReduceFunction）

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 设置水位线自动生成时间间隔为100ms 默认值是200ms
        env.getConfig().setAutoWatermarkInterval(100L);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.addSource(new ClickSource());
        // 乱序流watermark生成
        SingleOutputStreamOperator<Event> stream = streamSource.assignTimestampsAndWatermarks(
                // 设置水位线延时2秒
                WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2L))
                        // 设置水位线基于时间戳数据
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event event, long recordTimestamp) {
                                return event.getTimestamp();
                            }
                        })
        );
        // 把点击数据转换成二元组 用户名和点击次数1次
        stream.map(data -> Tuple2.of(data.getUser(), 1L))
                // 指定返回值二元组
                .returns(new TypeHint<Tuple2<String, Long>>() {})
                // 对user进行分组
                .keyBy(data -> data.f0)
                // 开窗函数 指定滚动事件时间窗口, 窗口大小为10秒
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                // 窗口函数 增量聚合函数 实现规约操作, 把每个人的点击数字相加, 得到每个人最终的点击次数
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                        return Tuple2.of(value1.f0,value1.f1 + value2.f1);
                    }
                }).print();
        env.execute();
    }

（2）聚合函数（AggregateFunction）重要

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        // 设置水位线自动生成时间间隔为100ms 默认值是200ms
        env.getConfig().setAutoWatermarkInterval(100L);
        // 从自定义流中读取数据
        DataStreamSource<Event> streamSource = env.addSource(new ClickSource());
        // 乱序流watermark生成
        SingleOutputStreamOperator<Event> stream = streamSource.assignTimestampsAndWatermarks(
                // 设置水位线延时2秒
                WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2L))
                        // 设置水位线基于时间戳数据
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event event, long recordTimestamp) {
                                return event.getTimestamp();
                            }
                        })
        );
        // keyBy
        stream.keyBy(date -> date.getUser())
                // 开窗
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                // 三个参数, 第一个参数输入对象,
                // 第二个参数累加器我们这里要求timestamp的平均, 所以一个是Long类型的timestamp的和  另一个是count,最后保存user
                // 第三个参数,以什么样的形式返回, 我们需要user,平均数 这样的二元组返回
                .aggregate(new AggregateFunction<Event, Tuple3<Long,Integer,String>, Tuple2<String,String>>() {
                    @Override
                    public Tuple3<Long, Integer,String> createAccumulator() {
                        // 创建一个累加器, 这里给一个初始值就行
                        return Tuple3.of(0L,0,"");
                    }

                    @Override
                    public Tuple3<Long, Integer,String> add(Event event, Tuple3<Long, Integer,String> accumulator) {
                        // 每来一个数据就要调用当前add方法, event当前到来的数据, accumulator当前累加器的状态
                        // 累加器add时, 我们需要把timestamp累加, 并把count + 1
                        return Tuple3.of(accumulator.f0 + event.getTimestamp(),accumulator.f1 + 1,event.getUser());
                    }

                    @Override
                    public Tuple2<String, String> getResult(Tuple3<Long, Integer,String> accumulator) {
                        // 获取最终结果, 把当前累加器中得到的数据计算成想要的结果
                        return Tuple2.of(accumulator.f2,new Timestamp(accumulator.f0/accumulator.f1).toString());
                    }

                    @Override
                    public Tuple3<Long, Integer,String> merge(Tuple3<Long, Integer,String> accumulator1, Tuple3<Long, Integer,String> accumulator2) {
                        // 合并两个累加器, 在会话窗口有实际意义, 这里是滚动窗口, 不实现也可以
                        return Tuple3.of(accumulator1.f0+accumulator2.f0, accumulator2.f1 + accumulator2.f1, accumulator1.f2);
                    }
                }).print();
        env.execute();
    }

public static void main(String[] args) throws Exception {
        // 开窗统计pv和uv, 两者相除得到平均用户活跃度
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 设置全局并行度
        env.setParallelism(1);
        // 设置自动水位线生成时间间隔为100ms
        env.getConfig().setAutoWatermarkInterval(100);
        DataStreamSource<Event> stream = env.addSource(new ClickSource());
        // 设置串行流的时间戳
        SingleOutputStreamOperator<Event> operator = stream.assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forMonotonousTimestamps()
                .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                    @Override
                    public long extractTimestamp(Event event, long recordTime) {
                        return event.getTimestamp();
                    }
                }));
        operator.print();
        // 所有数据放在一起统计
        operator.keyBy(data -> true)
                // 设置一个基于事件时间的滑动窗口, 窗口大小为10s 偏移量为2s , 每隔2s统计一次上10s的数据情况
                .window(SlidingEventTimeWindows.of(Time.seconds(10),Time.seconds(2)))
                .aggregate(new MyAggregate())
                .print();

        env.execute();
    }
    // 自定义一个AggregateFunction, 用long保存pv个数, 用hashset做uv去重
    public static class MyAggregate implements AggregateFunction<Event, Tuple2<Long, HashSet<String>>,Double>{

        @Override
        public Tuple2<Long, HashSet<String>> createAccumulator() {
            return Tuple2.of(0L,new HashSet<>());
        }

        @Override
        public Tuple2<Long, HashSet<String>> add(Event event, Tuple2<Long, HashSet<String>> accumulator) {
            // 每来一条数据, pv个数+1 将user放入HashSet中
            accumulator.f1.add(event.getUser());
            return Tuple2.of(accumulator.f0 + 1,accumulator.f1);
        }

        @Override
        public Double getResult(Tuple2<Long, HashSet<String>> accumulator) {
            // 窗口结束时., 输出pv和uv的比值, 这里有可能会有除0的风险, 实际开发中需要判断
            return (double)accumulator.f0/accumulator.f1.size();
        }

        @Override
        public Tuple2<Long, HashSet<String>> merge(Tuple2<Long, HashSet<String>> longHashSetTuple2, Tuple2<Long, HashSet<String>> acc1) {
            return null;
        }
    }

全窗口函数（full window functions）批处理思路攒一波最后计算

（1）窗口函数（WindowFunction）不推荐使用


（2）处理窗口函数（ProcessWindowFunction）推荐使用

public static void main(String[] args) throws Exception {
        // 开窗统计pv和uv, 两者相除得到平均用户活跃度
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 设置全局并行度
        env.setParallelism(1);
        // 设置自动水位线生成时间间隔为100ms
        env.getConfig().setAutoWatermarkInterval(100);
        DataStreamSource<Event> stream = env.addSource(new ClickSource());
        // 设置串行流的时间戳
        SingleOutputStreamOperator<Event> operator = stream.assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forMonotonousTimestamps()
                .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                    @Override
                    public long extractTimestamp(Event event, long recordTime) {
                        return event.getTimestamp();
                    }
                }));
        operator.print();
        // 使用processWindowFunction计算uv
        operator.keyBy(data -> true)
                // 设置一个基于事件时间的滑动窗口, 窗口大小为10s 偏移量为2s , 每隔2s统计一次上10s的数据情况
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(new MyProcessWindowFunction())
                .print();

        env.execute();
    }

    public static class MyProcessWindowFunction extends ProcessWindowFunction<Event, String,Boolean, TimeWindow> {
        @Override
        public void process(Boolean key, Context context, Iterable<Event> in, Collector<String> out) throws Exception {
            // 用一个HashSet保存user
            HashSet<String> userSet = new HashSet<>();
            // 从in中遍历数据, 放入userSet
            for (Event event : in) {
                userSet.add(event.getUser());
            }
            Long uv = (long) userSet.size();
            // 结合窗口信息输出
            Long start = context.window().getStart();
            Long end = context.window().getEnd();
            out.collect("窗口"+new Timestamp(start) + "~" + new Timestamp(end) + "uv值为" + uv );
        }
    }

增量聚合和全窗口函数的结合使用

在aggregate和processWindowFunction一起使用时, aggregate的返回值会传递processWindowFunction的输入Iterable中

public static void main(String[] args) throws Exception {
        // 开窗统计pv和uv, 两者相除得到平均用户活跃度
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 设置全局并行度
        env.setParallelism(1);
        // 设置自动水位线生成时间间隔为100ms
        env.getConfig().setAutoWatermarkInterval(100);
        DataStreamSource<Event> stream = env.addSource(new ClickSource());
        // 设置串行流的时间戳
        SingleOutputStreamOperator<Event> operator = stream.assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forMonotonousTimestamps()
                .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                    @Override
                    public long extractTimestamp(Event event, long recordTime) {
                        return event.getTimestamp();
                    }
                }));
        operator.print();
        // 使用aggregate和processWindowFunction结合计算uv
        operator.keyBy(data -> true)
                // 设置一个基于事件时间的滑动窗口, 窗口大小为10s 偏移量为2s , 每隔2s统计一次上10s的数据情况
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .aggregate(new MyAggregate(),new MyProcessWindowFunction())
                .print();

        env.execute();
    }
    // 自定义实现processWindowFunction, 包装窗口信息输出
    public static class MyProcessWindowFunction extends ProcessWindowFunction<Integer, String,Boolean, TimeWindow> {
        @Override
        public void process(Boolean key, Context context, Iterable<Integer> in, Collector<String> out) throws Exception {
            Integer uv =in.iterator().next();
            // 结合窗口信息输出
            Long start = context.window().getStart();
            Long end = context.window().getEnd();
            out.collect("窗口"+new Timestamp(start) + "~" + new Timestamp(end) + "uv值为" + uv );
        }
    }
    // 自定义一个AggregateFunction, 增量聚合计算uv值
    public static class MyAggregate implements AggregateFunction<Event,  HashSet<String>,Integer> {
        @Override
        public HashSet<String> createAccumulator() {
            return new HashSet<>();
        }

        @Override
        public HashSet<String> add(Event event, HashSet<String> accumulator) {
            accumulator.add(event.getUser());
            return accumulator;
        }

        @Override
        public Integer getResult(HashSet<String> accumulator) {
            return accumulator.size();
        }

        @Override
        public HashSet<String> merge(HashSet<String> strings, HashSet<String> acc1) {
            return null;
        }
    }

public static void main(String[] args) throws Exception {
        // 开窗统计pv和uv, 两者相除得到平均用户活跃度
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 设置全局并行度
        env.setParallelism(1);
        // 设置自动水位线生成时间间隔为100ms
        env.getConfig().setAutoWatermarkInterval(100);
        DataStreamSource<Event> stream = env.addSource(new ClickSource());
        // 设置串行流的时间戳
        SingleOutputStreamOperator<Event> operator = stream.assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forMonotonousTimestamps()
                .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                    @Override
                    public long extractTimestamp(Event event, long recordTime) {
                        return event.getTimestamp();
                    }
                }));
        operator.print();
        // 统计每个url的访问量
        operator.keyBy(data -> data.getUrl())
                // 设置一个基于事件时间的滑动窗口, 窗口大小为10s 偏移量为2s , 每隔2s统计一次上10s的数据情况
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .aggregate(new UrlViewCountAgg(),new UrlViewCountResult())
                .print();

        env.execute();
    }
    // 泛型 Long是输入是aggregate的结果, UrlViewCount是输出,我们需要输出一个自定义类,
    // String是key的类型, 因为是根据url进行keyBy的, 所以是String类型, TimeWindow是当前开窗类型, 按时间进行开窗
    public static class UrlViewCountResult extends ProcessWindowFunction<Long, UrlViewCount,String, TimeWindow> {
        @Override
        public void process(String key, Context context, Iterable<Long> in, Collector<UrlViewCount> out) throws Exception {
            Long start = context.window().getStart();
            Long end = context.window().getEnd();
            out.collect(new UrlViewCount(key,in.iterator().next(),start,end));
        }
    }
    // 泛型Event对象 累加器计算个数所以是Long 结果是Long类型
    public static class UrlViewCountAgg implements AggregateFunction<Event, Long,Long> {
        @Override
        public Long createAccumulator() {
            return 0L;
        }

        @Override
        public Long add(Event event, Long accumulator) {
            return accumulator + 1;
        }

        @Override
        public Long getResult(Long accumulator) {
            return accumulator;
        }

        @Override
        public Long merge(Long aLong, Long acc1) {
            return null;
        }
    }

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UrlViewCount {
    private String url;
    private Long count;
    private Long windowStart;
    private Long windowEnd;

    @Override
    public String toString() {
        return "UrlViewCount{" +
                "url='" + url + '\'' +
                ", count=" + count +
                ", windowStart=" + new Timestamp(windowStart) +
                ", windowEnd=" + new Timestamp(windowEnd) +
                '}';
    }
}

6.3.6 其他API

6.3.7 Flink处理迟到数据

方式1: 设置 watermark 延迟时间，2 秒钟
方式2: 允许窗口处理迟到数据，设置 1 分钟的等待时间
方式3: 定义侧输出流并将最后的迟到数据输出到侧输出流

public static void main(String[] args) throws Exception {
        // 开窗统计pv和uv, 两者相除得到平均用户活跃度
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 设置全局并行度
        env.setParallelism(1);
        // 设置自动水位线生成时间间隔为100ms
        env.getConfig().setAutoWatermarkInterval(100);
        DataStreamSource<String> stream = env.socketTextStream("hadoop102", 7777);
        SingleOutputStreamOperator<Event> operator = stream.map(new MapFunction<String, Event>() {
            @Override
            public Event map(String event) throws Exception {
                String[] split = event.split(",");
                return new Event(split[0].trim(), split[1].trim(), Long.valueOf(split[2].trim()));
            }
        });

        // 设置无序流的时间戳并给定waterMarks的延迟时间为2秒
        // 处理迟到数据方式一：设置 watermark 延迟时间，2 秒钟
        SingleOutputStreamOperator<Event> watermarks = operator
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2L))
                .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                    @Override
                    public long extractTimestamp(Event event, long recordTime) {
                        return event.getTimestamp();
                    }
                }));
        operator.print();

        // 定义测输出流标签,注意这个地方需要指定一个匿名内部类, 否则会有泛型擦除问题
        OutputTag<Event> late = new OutputTag<Event>("late"){};
        // 统计每个url的访问量
        SingleOutputStreamOperator<UrlViewCount> result = operator.keyBy(data -> data.getUrl())
                // 设置一个基于事件时间的滑动窗口, 窗口大小为10s 偏移量为2s , 每隔2s统计一次上10s的数据情况
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                //  方式二：允许窗口处理迟到数据，设置 1 分钟的等待时间
                .allowedLateness(Time.minutes(1))
                // 方式三：将最后的迟到数据输出到侧输出流 注意需要定义侧输出流标签
                .sideOutputLateData(late)
                .aggregate(new UrlCountExample.UrlViewCountAgg(), new UrlCountExample.UrlViewCountResult());

        result.print("result");
        // 最后要把侧输出流的执行的操作绑定到窗口函数算子上
        result.getSideOutput(late).print("late");
        env.execute();
    }
    // 泛型 Long是输入是aggregate的结果, UrlViewCount是输出,我们需要输出一个自定义类,
    // String是key的类型, 因为是根据url进行keyBy的, 所以是String类型, TimeWindow是当前开窗类型, 按时间进行开窗
    public static class UrlViewCountResult extends ProcessWindowFunction<Long, UrlViewCount,String, TimeWindow> {
        @Override
        public void process(String key, Context context, Iterable<Long> in, Collector<UrlViewCount> out) throws Exception {
            Long start = context.window().getStart();
            Long end = context.window().getEnd();
            out.collect(new UrlViewCount(key,in.iterator().next(),start,end));
        }
    }
    // 泛型Event对象 累加器计算个数所以是Long 结果是Long类型
    public static class UrlViewCountAgg implements AggregateFunction<Event, Long,Long> {
        @Override
        public Long createAccumulator() {
            return 0L;
        }

        @Override
        public Long add(Event event, Long accumulator) {
            return accumulator + 1;
        }

        @Override
        public Long getResult(Long accumulator) {
            return accumulator;
        }

        @Override
        public Long merge(Long aLong, Long acc1) {
            return null;
        }
    }

你可能感兴趣的:(flink)

Flink中的SQL Client和SQL Gateway BigDataMLApplication flink flink sql gateway
Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
Flink算子通用状态应用测试样例公子乂 flink java servlet
Flink算子通用状态应用测试样例1.获取Flink执行环境finalStreamExecutionEnvironmentenv=StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism(1);2.创建数据源，生成随机数据DataStream>source=env.addSource(newSourceFunct
关于HDP的20道高级运维面试题编织幻境的妖运维
1.描述HDP的主要组件及其作用。HDP（HortonworksDataPlatform）的主要组件包括Hadoop框架、HDFS、MapReduce、YARN以及Hadoop生态系统中的其他关键工具，如Spark、Flink、Hive、HBase等。以下是对这些组件及其作用的具体描述：Hadoop框架:Hadoop是一个开源的分布式计算框架，用Java语言编写，用于存储和处理大规模数据集。它广义
Flink 面试题总结及答案 wending-Y Flink 入门到实践 flink 大数据
基础state的分类keystate和operatestatestate的重分布Flink状态管理详解：KeyedState和OperatorListState深度解析-掘金checkpoint和savepointhttps://zhuanlan.zhihu.com/p/79526638flinkjob的容错策略如果在没有持续消息输出的情况下，如何定时输出主要是现实有可能不会一直有消息输入，但是要
Flink 批作业消费kafka wending-Y Flink 入门到实践 flink kafka 大数据
文章目录示例代码原理总是kafka数据源可以是有界数据源，也可以是无界数据源示例代码publicstaticvoidmain(String[]args){StreamExecutionEnvironmentenv=StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism
Flink源码-6-JobMaster 启动任务 wending-Y Flink 入门到实践 flink
JobMasterjobmaster负责执行整个任务入口类org.apache.flink.runtime.jobmaster.JobMasterpublicCompletableFuturestart(finalJobMasterIdnewJobMasterId)throwsException{//makesurewereceiveRPCandasynccallsstart();returnca
【大数据面试题】014 Flink CDC 用过吗，请简要描述 Jiweilai1 一天一道面试题 flink 大数据面试 flink cdc
一步一个脚印，一天一道面试题。FlinkCDC的诞生背景FlinkCDC的全称是ChangeDataCapture（变更数据捕获）每一项技术的诞生都是为了解决某个问题，某个痛点。而FlinkCDC的诞生就是为了解决在读取，监控MySQL这样的数据库时，不会因为读取数据库，对数据库本身造成压力，影响性能。同时，保证了数据源的准确，正确。FlinkCDC原理方式一：通过查询来获取更新的数据。如查询数据
pyflink1.18.0 报错 TypeError: cannot pickle ‘_thread.lock‘ object Thomas2143 总结 pyflink
完整报错Traceback(mostrecentcalllast):File"/Users//1.py",line851,inds1=my_datastream.key_by(lambdax:x[0]).process(MyProcessFunction())#返回元组即:f0f1f2三列File"/Users/thomas990p/bigdataSoft/minicondaarm/minicon
【Flink SQL】Flink SQL 基础概念（五）：SQL 时区问题 G皮T #Flink SQL flink sql 大数据时区 TIMESTAMP_LTZ TIMESTAMP
《FlinkSQL基础概念》系列，共包含以下5篇文章：FlinkSQL基础概念（一）：SQL&Table运行环境、基本概念及常用APIFlinkSQL基础概念（二）：数据类型FlinkSQL基础概念（三）：SQL动态表&连续查询FlinkSQL基础概念（四）：SQL的时间属性FlinkSQL基础概念（五）：SQL时区问题如果您觉得这篇文章有用✔️的话，请给博主一个一键三连吧（点赞、关注、收藏）！！
【大数据】Flink SQL 语法篇（五）：Regular Join、Interval Join G皮T #Flink SQL 大数据 flink sql Regular Join Interval Join 双流Join
《FlinkSQL语法篇》系列，共包含以下10篇文章：FlinkSQL语法篇（一）：CREATEFlinkSQL语法篇（二）：WITH、SELECT&WHERE、SELECTDISTINCTFlinkSQL语法篇（三）：窗口聚合（TUMBLE、HOP、SESSION、CUMULATE）FlinkSQL语法篇（四）：Group聚合、Over聚合FlinkSQL语法篇（五）：RegularJoin、I
大数据开发（Kafka面试真题-卷一） Key-Key 大数据 kafka 面试
大数据开发（Kafka面试真题）1、请解释以下ApacheKafka是什么？它在大数据系统中的角色是什么？2、请解释以下Kafka的工作原理和它与传统消息队列服务的不同之处？3、解释以下ApacheKafka的作用以及它与常见消息队列系统（如RabbitMQ）之间的区别？4、如何使用ApacheKafka来实现实时数据流处理？5、Flinkcheckpoint和Kafkaoffset的关联是什么？
flink: 自定义表函数的用法 amadeus_liu2 flink flink python 大数据
packagecn.edu.tju.demo3;importorg.apache.flink.api.common.functions.MapFunction;importorg.apache.flink.api.java.tuple.Tuple2;importorg.apache.flink.streaming.api.datastream.DataStream;importorg.apache
flink:自定义函数的简单用法 amadeus_liu2 flink flink 大数据
packagecn.edu.tju.demo3;importorg.apache.flink.api.common.functions.MapFunction;importorg.apache.flink.streaming.api.datastream.DataStream;importorg.apache.flink.streaming.api.datastream.SingleOutputS
flink状态后端和检查点的关系后季暖 flink 大数据
在ApacheFlink中，检查点（Checkpoints）和状态后端（StateBackend）是两个核心概念，它们之间有着紧密的联系。为了更好地理解这种联系，我们首先需要分别了解这两个概念。检查点（Checkpoints）：检查点是Flink用来实现容错和状态一致性的机制。当Flink应用程序运行时，它会定期地创建检查点，这些检查点包含了当前任务的状态信息。如果某个任务失败，Flink可以利用
Flink异步io关联Hbase //承续缘_纪录片 #Flink flink hbase 大数据
主程序publicstaticvoidmain(String[]args)throwsException{//1.获取流执行环境StreamExecutionEnvironmentenv=StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism(1);SimpleDateFormatformatter=newSi
flink重温笔记（十五）： flinkSQL 顶层 API ——实时数据流转化为SQL表的操作那就学有所成吧(˵¯͒¯͒˵) Flink重温笔记 flink 笔记 sql 大数据学习方法数据库 KAFKA
Flink学习笔记前言：今天是学习flink的第15天啦！学习了flinkSQL基础入门，主要是解决大数据领域数据处理采用表的方式，而不是写复杂代码逻辑，学会了如何初始化环境，鹅湖将流数据转化为表数据，以及如何查询表数据，结合自己实验猜想和代码实践，总结了很多自己的理解和想法，希望和大家多多交流！Tips："分享是快乐的源泉，在我的博客里，不仅有知识的海洋，还有满满的正能量加持，快来和我一起分享这
FlinkCDC快速搭建实现数据监控 tianqi11 flink java
引入依赖4.0.0com.sandflinkcdc1.0-SNAPSHOTjarFlinkQuickstartJobUTF-81.17.11.14.4-->1.82.12${target.java.version}${target.java.version}2.17.1apache.snapshotsApacheDevelopmentSnapshotRepositoryhttps://reposi
Apache Paimon 使用之Creating Catalogs 猫猫爱吃小鱼粮 Paimon apache hive hadoop
PaimonCatalog目前支持两种类型的metastores：filesystemmetastore(default)，在文件系统中存储元数据和表文件。hivemetastore，将metadata存储在Hivemetastore中。用户可以直接从Hive访问表。1.使用FilesystemMetastore创建CatalogFlink引擎FlinkSQL注册并使用名为my_catalog的P
Flink 学习 | 在集群上的，部署模式及运行模式狻猊来当程序媛 flink 学习大数据
Client将作业提交给JobManager，JobManager将作业分发给很多个TaskManager开始干活。部署模式有三种（会话模式_session，单作业模式_per_job，应用模式_application）主要区别是生命周期及资源的分配方式，以及应用的main方法到底在哪里执行，是客户端还是JobManager。会话模式需要先启动一个集群，保持一个会话。但启动集群时，资源是共享的，会
sprintboot集成flink快速入门demo AskHarries flink 大数据
一、flink介绍Flink是一个批处理和流处理结合的统一计算框架，其核心是一个提供了数据分发以及并行化计算的流数据处理引擎。它的最大亮点是流处理，是业界最顶级的开源流处理引擎。Flink最适合的应用场景是低时延的数据处理（DataProcessing）场景：高并发pipeline处理数据，时延毫秒级，且兼具可靠性。二、环境搭建安装flinkhttps://nightlies.apache.org
【大数据】Flink SQL 语法篇（七）：Lookup Join、Array Expansion、Table Function G皮T #Flink SQL 大数据 flink sql Lookup Join Array Expansion Table Function 维表 Join
《FlinkSQL语法篇》系列，共包含以下10篇文章：FlinkSQL语法篇（一）：CREATEFlinkSQL语法篇（二）：WITH、SELECT&WHERE、SELECTDISTINCTFlinkSQL语法篇（三）：窗口聚合（TUMBLE、HOP、SESSION、CUMULATE）FlinkSQL语法篇（四）：Group聚合、Over聚合FlinkSQL语法篇（五）：RegularJoin、I
【Flink精讲】Flink单机安装步骤话数Science Flink Flink精讲大数据 flink 大数据
Flink单机安装步骤获取Flink安装包：Indexof/flink解压缩：tar-zxvfflink-1.17.2-bin-scala_2.12.tgz修改配置文件：conf/flink-conf.yaml启动命令：./bin/start-cluster.sh终止命令：./bin/stop-cluster.sh启动SQLClient：./bin/sql-client.shembedded如果w
EMR StarRocks实战——Mysql数据实时同步到SR 爱吃辣条byte #StarRocks 数仓建设大数据数据仓库
文章摘抄阿里云EMR上的StarRocks实践：《基于实时计算Flink使用CTAS&CDAS功能同步MySQL数据至StarRocks》前言CTAS可以实现单表的结构和数据同步，CDAS可以实现整库同步或者同一库中的多表结构和数据同步。下文主要介绍如何使用Flink平台和E-MapReduceStarRocks，通过CTAS&CDAS功能实现实时数仓中TP（TransactionProcessi
flink如何利用checkpoint保证数据状态一致性 Direction_Wind flink技术原理 flink 大数据
flink数据状态一致性1状态一致性级别1.1AT-MOST-ONCE(最多一次)：1.2AT-LEAST-ONCE(至少一次)：1.3EXACTLY-ONCE(精确一次)：1.4分布式快照与至少一次事件传递和重复数据删除的比较2flink内部实现状态一致性3端到端的一致性3.1Source3.2Sink3.2.1幂等写入3.2.2事务写入3.2.2.1两阶段提交3.2.2.2flink的两阶段提
记一次 Flink 作业启动缓慢卢说 Hadoop 大数据 Flink flink 大数据 hadoop hdfs
记一次Flink作业启动缓慢背景应用发现，Hadoop集群的hdfs较之前更加缓慢，且离线ELT任务也以前晚半个多小时才能跑完。此前一直没有找到突破口所以没有管他，推测应该重启一下Hadoop集群就可以了。今天突然要重启一个Flink作业，发现有一个过程卡了五分钟。现象由上图可知09:36到09:41这两个过程中间花了五分钟，这两条都是Flink的日志，所以推测中间是Flink的某些过程卡住了。那
【天衍系列 03】深入理解Flink的Watermark：实时流处理的时间概念与乱序处理浅夏的猫 Flink专栏 flink 大数据 java apache
文章目录01基本概念02工作原理03优势与劣势04核心组件05Watermark生成器使用06应用场景07注意事项08案例分析8.1窗口统计数据不准8.2水印是如何解决延迟与乱序问题？8.3详细分析09项目实战demo9.1pom依赖9.2log4j2.properties配置9.3Watermark水印作业01基本概念Watermark是用于处理事件时间的一种机制，用于表示事件时间流的进展。在流
【天衍系列 01】深入理解Flink的 FileSource 组件：实现大规模数据文件处理浅夏的猫 Flink专栏 flink apache 大数据 java
文章目录01基本概念02工作原理03数据流实现04项目实战4.1项目结构4.2maven依赖4.3StreamFormat读取文件数据4.4BulkFormat读取文件数据4.5使用小结05数据源比较06总结01基本概念ApacheFlink是一个流式处理框架，被广泛应用于大数据领域的实时数据处理和分析任务中。在Flink中，FileSource是一个重要的组件，用于从文件系统中读取数据并将其转换
【天衍系列 04】深入理解Flink的ElasticsearchSink组件：实时数据流如何无缝地流向Elasticsearch 浅夏的猫 Flink专栏 flink elasticsearch java 大数据 apache
文章目录01ElasticsearchSink基础概念02ElasticsearchSink工作原理03ElasticsearchSink核心组件04ElasticsearchSink配置参数05ElasticsearchSink依赖管理06ElasticsearchSink初阶实战07ElasticsearchSink进阶实战7.1包结构&项目配置项目配置application.properti
Flink理论—Flink架构设计不二人生 #Flink 理论 flink 大数据
Flink架构设计Flink是一个分布式系统，需要有效分配和管理计算资源才能执行流应用程序。它集成了所有常见的集群资源管理器，例如HadoopYARN，但也可以设置作为独立集群甚至库运行,例如Spark的StandaloneMode本节概述了Flink架构，并且描述了其主要组件如何交互以执行应用程序和从故障中恢复。Flink集群剖析Flink运行时由两种类型的进程组成：一个JobManager和一
一种Hudi on Flink动态同步元数据变化的方法 0x3E6 flink 大数据 ApacheHudi flink big data 大数据
文章目录一、背景二、官方SchemaEvolution例子三、Flink+Hudi实现SchemaEvolution四、`HoodieFlinkStreamer`流程浅析及扩展方法4.1FlinkKafkaConsumer4.2RowDataToHoodieFunction4.3StreamWriteFunction4.4StreamWriteOperatorCoordinator4.5Compa
解线性方程组 qiuwanchi
package gaodai.matrix; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner scanner = new Sc
在mysql内部存储代码 annan211 性能 mysql 存储过程触发器
在mysql内部存储代码在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。先看优点： 1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。 2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。 3 可以简化代码的维护和版本更新。 4 可以帮助提升安全，比如提供更细
Android使用Asynchronous Http Client完成登录保存cookie的问题 hotsunshine android
Asynchronous Http Client是android中非常好的异步请求工具除了异步之外还有很多封装比如json的处理，cookie的处理引用 Persistent Cookie Storage with PersistentCookieStore This library also includes a PersistentCookieStore whi
java面试题 Array_06 java 面试
java面试题第一，谈谈final, finally, finalize的区别。 final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
网站加速 oloz 网站加速
前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 2、采用Gzip对网页进行压缩； GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
正确书写单例模式随意而生 java 设计模式单例
　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。　　懒汉式，线程不安全　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
单例模式香水浓 java
懒汉调用getInstance方法时实例化 public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if(null == ins
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" AdyZhang apache http server
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。解决方法确保几处： 1、停止IIS启动 2、把端口80改成其它（譬如90，800，，，什么数字都好） 3、防火墙(关掉试试) 在运行处输入 cmd 回车，转到apa
如何在android 文件选择器中选择多个图片或者视频？ aijuans android
我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传但是android原生态的sdk中，只能一个一个的进行选择和上传。我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个处理方法官方的图片选择器(但是不支持所有版本的androi，只支持API Level
mysql中查询生日提醒的日期相关的sql baalwolf mysql
SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(), dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
MongoDB索引文件破坏后导致查询错误的问题 BigBird2012 mongodb
问题描述： MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。解决方案：使用脚本，重建MongoDB所有表的索引。 var names = db.getCollectionNames(); for( var i in names ){ var name = names[i]; print(name);
Javascript Promise bijian1013 JavaScript Promise
Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。一.认识Promises “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
[Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程 bit1129 zookeeper
Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是 public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
【Java命令三】jstack bit1129 jstack
jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump [hadoop@hadoop sbin]$ jstack Usage: jstack [-l] <pid> (to connect to running process) jstack -F
jboss 5.1启停脚本　动静分离部署 ronin47
以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename -b ip -g clustername -u broatcast jboss.messaging.ServerPeerID=int -Djboss.service.binding.set=p
UI之如何打磨设计能力? brotherlamp UI ui教程 ui自学 ui资料 ui视频
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 1.找到自己的方式如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
三色旗算法 bylijinnan java 算法
import java.util.Arrays; /** 问题：假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。网上的解法大多类似：在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
警告:No configuration found for the specified action: \'s chiangfai configuration
1.index.jsp页面form标签未指定namespace属性。  <%@taglib prefix="s" uri="/struts-tags"%> ... <s:form action="submit" method="post"&g
redis -- hash_max_zipmap_entries设置过大有问题 chenchao051 redis hash
使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑 #define ZIPMAP_BIGLEN 254 #define ZIPMAP_END 255 /* Return th
select into outfile access deny问题 daizj mysql txt 导出数据到文件
本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。授权的语句如下： grant select on armory.* to rn
phpexcel导出excel表简单入门示例 dcj3sjt126com PHP Excel phpexcel
<?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE); if (PHP_SAPI == 'cli') die('This example should only be run from a Web Brows
美国电影超短200句 dcj3sjt126com 电影
1. I see．我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too．我也是。5. My god! 天哪!6. No way! 不行!7. Come on．来吧(赶快)8. Hold on．等一等。9. I agree。我同意。10. Not bad．还不错。11. Not yet．还没。12. See you．再见。13. Shut up!
Java访问远程服务 dyy_gusi httpclient webservice get post
随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
Maven的settings.xml配置 geeksun settings.xml
settings.xml是Maven的配置文件，下面解释一下其中的配置含义： settings.xml存在于两个地方： 1.安装的地方：$M2_HOME/conf/settings.xml 2.用户的目录：${user.home}/.m2/settings.xml 前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。
ubuntu的init与系统服务设置 hongtoushizi ubuntu
转载自： http://iysm.net/?p=178 init Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。运行
跟我学Nginx+Lua开发目录贴 jinnianshilongnian nginx lua
使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。目录第一章安装Nginx+Lua开发环境第二章 Nginx+Lua开发入门第三章 Redis/SSDB+Twemproxy安装与使用第四章 L
php位运算符注意事项 home198979 位运算 PHP &
$a = $b = $c = 0; $a & $b = 1; $b | $c = 1 问a,b,c最终为多少? 当看到这题时，我犯了一个低级错误，误以为位运算符会改变变量的值。所以得出结果是1 1 0 但是位运算符是不会改变变量的值的，例如： $a=1;$b=2; $a&$b; 这样a,b的值不会有任何改变
Linux shell数组建立和使用技巧 pda158 linux
1.数组定义　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。　　 2.数组读取与赋值　　得到长度：　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
hotspot源码(JDK7) ol_beta java HotSpot jvm
源码结构图，方便理解： ├─agent Serviceab
Oracle基本事务和ForAll执行批量DML练习 vipbooks oracle sql
基本事务的使用：从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 select * from account; -- 创建一张账户表 create table account( -- 账户ID id number(3) not null, -- 账户名称 nam