Flink1.12-2021黑马 1-6原理+算子+窗口+容错

╰半夏微凉° 2022-11-07 04:06 135阅读 0赞

**课程课件和源码**

链接：https://pan.baidu.com/s/1ZzBpgR21XGaBZHPMvF0\_GQ  
提取码：o0wm  
复制这段内容后打开百度网盘手机App，操作更方便哦–来自百度网盘超级会员V5的分享

代码示例pom

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>cn.itcast</groupId>
        <artifactId>flink_study_47</artifactId>
        <version>1.0-SNAPSHOT</version>
        
        <repositories>
            <repository>
                <id>aliyun</id>
                <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            </repository>
            <repository>
                <id>apache</id>
                <url>https://repository.apache.org/content/repositories/snapshots/</url>
            </repository>
            <repository>
                <id>cloudera</id>
                <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
            </repository>
        </repositories>
    
        <properties>
            <encoding>UTF-8</encoding>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
            <java.version>1.8</java.version>
            <scala.version>2.12</scala.version>
            <flink.version>1.12.0</flink.version>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-clients_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-scala_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-java</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-streaming-scala_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-streaming-java_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-table-api-scala-bridge_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-table-api-java-bridge_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-table-planner_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-table-planner-blink_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-table-common</artifactId>
                <version>${flink.version}</version>
            </dependency>
    
            
    
            
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-connector-kafka_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-sql-connector-kafka_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-connector-jdbc_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-csv</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-json</artifactId>
                <version>${flink.version}</version>
            </dependency>
    
            
            
            
            
    
    
            <dependency>
                <groupId>org.apache.bahir</groupId>
                <artifactId>flink-connector-redis_2.11</artifactId>
                <version>1.0</version>
                <exclusions>
                    <exclusion>
                        <artifactId>flink-streaming-java_2.11</artifactId>
                        <groupId>org.apache.flink</groupId>
                    </exclusion>
                    <exclusion>
                        <artifactId>flink-runtime_2.11</artifactId>
                        <groupId>org.apache.flink</groupId>
                    </exclusion>
                    <exclusion>
                        <artifactId>flink-core</artifactId>
                        <groupId>org.apache.flink</groupId>
                    </exclusion>
                    <exclusion>
                        <artifactId>flink-java</artifactId>
                        <groupId>org.apache.flink</groupId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-connector-hive_2.12</artifactId>
                <version>${flink.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.hive</groupId>
                <artifactId>hive-metastore</artifactId>
                <version>2.1.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.hive</groupId>
                <artifactId>hive-exec</artifactId>
                <version>2.1.0</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.flink</groupId>
                <artifactId>flink-shaded-hadoop-2-uber</artifactId>
                <version>2.7.5-10.0</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-client</artifactId>
                <version>2.1.0</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.38</version>
                
            </dependency>
    
            
            <dependency>
                <groupId>io.vertx</groupId>
                <artifactId>vertx-core</artifactId>
                <version>3.9.0</version>
            </dependency>
            <dependency>
                <groupId>io.vertx</groupId>
                <artifactId>vertx-jdbc-client</artifactId>
                <version>3.9.0</version>
            </dependency>
            <dependency>
                <groupId>io.vertx</groupId>
                <artifactId>vertx-redis-client</artifactId>
                <version>3.9.0</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.7</version>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
                <scope>runtime</scope>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.44</version>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.2</version>
                <scope>provided</scope>
            </dependency>
    
            
            
            
            
    
        </dependencies>
    
        <build>
            <sourceDirectory>src/main/java</sourceDirectory>
            <plugins>
                
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.5.1</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.18.1</version>
                    <configuration>
                        <useFile>false</useFile>
                        <disableXmlReport>true</disableXmlReport>
                        <includes>
                            <include>**/*Test.*</include>
                            <include>**/*Suite.*</include>
                        </includes>
                    </configuration>
                </plugin>
                
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.3</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <filters>
                                    <filter>
                                        <artifact>*:*</artifact>
                                        <excludes>
                                            
                                            <exclude>META-INF/*.SF</exclude>
                                            <exclude>META-INF/*.DSA</exclude>
                                            <exclude>META-INF/*.RSA</exclude>
                                        </excludes>
                                    </filter>
                                </filters>
                                <transformers>
                                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                        
                                        <mainClass></mainClass>
                                    </transformer>
                                </transformers>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </project>

# 1.Flink介绍 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70]  
**组件栈**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 1]  
**应用场景**  
所有的流式计算  
\#２.Flink安装部署

## local本地模式-了解 ##

原理  
本地模式是以多线程的方式模拟各个角色  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 2]  
**操作**

1.下载安装包

https://archive.apache.org/dist/flink/

2.上传flink-1.12.0-bin-scala\_2.12.tgz到node1的指定目录  
3.解压

tar -zxvf flink-1.12.0-bin-scala_2.12.tgz

4.如果出现权限问题，需要修改权限

chown -R root:root /export/server/flink-1.12.0

5.改名或创建软链接

mv flink-1.12.0 flink

ln -s /export/server/flink-1.12.0 /export/server/flink

**测试**  
1.准备文件/root/words.txt

vim /root/words.txt

随便写入一下内容

hello me you her
    hello me you
    hello me
    hello

2.启动Flink本地“集群”

/export/server/flink/bin/start-cluster.sh

3.使用jps可以查看到下面两个进程

*  TaskManagerRunner
 *  StandaloneSessionClusterEntrypoint

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 3]  
4.访问Flink的Web UI

http://node1:8081/\#/overview  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 4]  
slot在Flink里面可以认为是资源组，Flink是通过将任务分成子任务并且将这些子任务分配到slot来并行执行程序。

5.执行官方示例

/export/server/flink/bin/flink run /export/server/flink/examples/batch/WordCount.jar --input /root/words.txt --output /root/out  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][20210310194145216.png]  
6.停止Flink

/export/server/flink/bin/stop-cluster.sh

启动shell交互式窗口(目前所有Scala 2.12版本的安装包暂时都不支持 Scala Shell)

/export/server/flink/bin/start-scala-shell.sh local

执行如下命令

benv.readTextFile("/root/words.txt").flatMap(_.split(" ")).map((_,1)).groupBy(0).sum(1).print()

退出shell

:quit

## Standalone独立集群模式-了解 ##

缺点：存在单点故障问题  
原理  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 7]

## Standalone-HA高可用集群模式-了解 ##

缺点：一个集群挂了，另一个集群需要一会才能被切换工作，存在对外不提供服务时间  
原理  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 8]

## Flink-On-Yarn(实际生产使用) ##

**把Flink的字节码运行在yarn的jvm中**

3.4.1.1 为什么使用Flink On Yarn?  
在实际开发中，使用Flink时，更多的使用方式是Flink On Yarn模式，原因如下：  
\-1.Yarn的资源可以按需使用，提高集群的资源利用率  
\-2.Yarn的任务有优先级，根据优先级运行作业  
\-3.基于Yarn调度系统，能够自动化地处理各个角色的 Failover(容错)  
○ JobManager 进程和 TaskManager 进程都由 Yarn NodeManager 监控  
○ 如果 JobManager 进程异常退出，则 Yarn ResourceManager 会重新调度 JobManager 到其他机器  
○ 如果 TaskManager 进程异常退出，JobManager 会收到消息并重新向 Yarn ResourceManager 申请资源，重新启动 TaskManager

原理：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 10]  
**两种模式**

Session会话模式：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][20210310201914124.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 12]  
Job分离模式：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 14]

**操作：**  
1.关闭yarn的内存检查

因为flink在工作中需要大量的内存  
vim /export/server/hadoop/etc/hadoop/yarn-site.xml

<property>
            <name>yarn.nodemanager.pmem-check-enabled</name>
            <value>false</value>
        </property>
        <property>
            <name>yarn.nodemanager.vmem-check-enabled</name>
            <value>false</value>
        </property>

2.分发

scp -r /export/server/hadoop/etc/hadoop/yarn-site.xml node2:/export/server/hadoop/etc/hadoop/yarn-site.xml
    scp -r /export/server/hadoop/etc/hadoop/yarn-site.xml node3:/export/server/hadoop/etc/hadoop/yarn-site.xml

3.重启yarn

/export/server/hadoop/sbin/stop-yarn.sh
    
    /export/server/hadoop/sbin/start-yarn.sh

**测试：**

Session会话模式：  
在Yarn上启动一个Flink集群,并重复使用该集群,后续提交的任务都是给该集群,资源会被一直占用,除非手动关闭该集群----适用于大量的小任务

1.在yarn上启动一个Flink集群/会话，node1上执行以下命令

/export/server/flink/bin/yarn-session.sh -n 2 -tm 800 -s 1 -d

参数说明:

申请2个CPU、1600M内存

\-n 表示申请2个容器，这里指的就是多少个taskmanager

\-tm 表示每个TaskManager的内存大小

\-s 表示每个TaskManager的slots数量

\-d 表示以后台程序方式运行

注意:

该警告不用管

WARN org.apache.hadoop.hdfs.DFSClient - Caught exception

java.lang.InterruptedException

2.查看UI界面  
http://node1:8088/cluster  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 15]  
3.使用flink run提交任务：

/export/server/flink/bin/flink run /export/server/flink/examples/batch/WordCount.jar

运行完之后可以继续运行其他的小任务

/export/server/flink/bin/flink run /export/server/flink/examples/batch/WordCount.jar

4.通过上方的ApplicationMaster可以进入Flink的管理界面  
![在这里插入图片描述][20210310202149390.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 16]  
5.关闭yarn-session：  
yarn application -kill application\_1599402747874\_0001

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 17]  
rm -rf /tmp/.yarn-properties-root

**Job分离模式–用的更多**

针对每个Flink任务在Yarn上启动一个独立的Flink集群并运行,结束后自动关闭并释放资源,----适用于大任务

1.直接提交job  
/export/server/flink/bin/flink run -m yarn-cluster -yjm 1024 -ytm 1024 /export/server/flink/examples/batch/WordCount.jar  
参数说明：  
\-m jobmanager的地址  
\-yjm 1024 指定jobmanager的内存信息  
\-ytm 1024 指定taskmanager的内存信息

2.查看UI界面  
http://node1:8088/cluster

![在这里插入图片描述][20210310202441871.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 18]  
3.注意：  
在之前版本中如果使用的是flink on yarn方式，想切换回standalone模式的话，如果报错需要删除：【/tmp/.yarn-properties-root】  
rm -rf /tmp/.yarn-properties-root  
因为默认查找当前yarn集群中已有的yarn-session信息中的jobmanager

# 2.Flink入门案例 #

4.1.1 API

Flink提供了多个层次的API供开发者使用，越往上抽象程度越高，使用起来越方便；越往下越底层，使用起来难度越大  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 19]  
**注意:1.1.2开始DataSet官网不再建议使用被软启用 , 建议使用流批一体的DataStream**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 21]

https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/batch/

**4.2 准备工程**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 22]

4.2.1 pom文件

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 24]  
代码实现-DataSet-了解  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 25]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 26]

package cn.itcast.hello;
    
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.api.java.DataSet;
    import org.apache.flink.api.java.ExecutionEnvironment;
    import org.apache.flink.api.java.operators.AggregateOperator;
    import org.apache.flink.api.java.operators.UnsortedGrouping;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.util.Collector;
    
    /** * Author itcast * Desc 演示Flink-DataSet-API-实现WordCount */
    public class WordCount { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
            //TODO 1.source
            DataSet<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
    
            //TODO 2.transformation
            //切割
            /* @FunctionalInterface public interface FlatMapFunction<T, O> extends Function, Serializable { void flatMap(T value, Collector<O> out) throws Exception; } */
            DataSet<String> words = lines.flatMap(new FlatMapFunction<String, String>() { 
                @Override
                public void flatMap(String value, Collector<String> out) throws Exception { 
                    //value表示每一行数据
                    String[] arr = value.split(" ");
                    for (String word : arr) { 
                        out.collect(word);
                    }
                }
            });
    
            //记为1
            /* @FunctionalInterface public interface MapFunction<T, O> extends Function, Serializable { O map(T value) throws Exception; } */
            DataSet<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public Tuple2<String, Integer> map(String value) throws Exception { 
                    //value就是每一个单词
                    return Tuple2.of(value, 1);
                }
            });
    
            //分组
            UnsortedGrouping<Tuple2<String, Integer>> grouped = wordAndOne.groupBy(0);
    
            //聚合
            AggregateOperator<Tuple2<String, Integer>> result = grouped.sum(1);
    
            //TODO 3.sink
            result.print();
    
        }
    }

## DataStream API ##

https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/datastream\_api.html  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 27]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 28]

**代码实现-DataStream-匿名内部类-处理批**

package cn.itcast.hello;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    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;
    
    /** * Author itcast * Desc 演示Flink-DataStream-API-实现WordCount * 注意:在Flink1.12中DataStream既支持流处理也支持批处理,如何区分? */
    public class WordCount2 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
           // env.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理
            env.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理
           //env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批,如果数据源是有限数据就是用batch如果数据源是无限数据就使用stream
    
            //TODO 1.source
            DataStream<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
    
            //TODO 2.transformation
            //切割
    
            DataStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() { 
                @Override
                public void flatMap(String value, Collector<String> out) throws Exception { 
                    //value就是每一行数据
                    String[] arr = value.split(" ");
                    for (String word : arr) { 
                        out.collect(word);
                    }
                }
            });
    
            //记为1
    
            DataStream<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public Tuple2<String, Integer> map(String value) throws Exception { 
                    //value就是一个个单词
                    return Tuple2.of(value, 1);
                }
            });
    
            //分组:注意DataSet中分组是groupBy,DataStream分组是keyBy
    
            KeyedStream<Tuple2<String, Integer>, String> grouped = wordAndOne.keyBy(t -> t.f0);
    
            //聚合
            SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.sum(1);
    
            //TODO 3.sink
            result.print();
    
            //TODO 4.execute/启动并等待程序结束
            env.execute();
        }
    }

使用批(batch)处理的结果  
env.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理  
![在这里插入图片描述][20210311195154769.png]  
使用批(stream)处理的结果  
env.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理

\*\*建议使用AUTOMATIC，\*\*数据源是批可以使用流处理，但是流数据不可以直接使用批处理，需要画窗口。  
//env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批,如果数据源是有限数据就是用batch如果数据源是无限数据就使用stream  
以后的开发中把一切数据源都当做流处理即可。

**代码实现-DataStream-匿名内部类-处理流**

package cn.itcast.hello;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    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;
    
    /** * Author itcast * Desc 演示Flink-DataStream-API-实现WordCount * 注意:在Flink1.12中DataStream既支持流处理也支持批处理,如何区分? */
    public class WordCount3 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            //ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            //env.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理
            //env.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批
    
            //TODO 1.source
            //DataSet<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
            //DataStream<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
            DataStream<String> lines = env.socketTextStream("node1", 9999);
    
            //TODO 2.transformation
            //切割
            /* @FunctionalInterface public interface FlatMapFunction<T, O> extends Function, Serializable { void flatMap(T value, Collector<O> out) throws Exception; } */
            DataStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() { 
                @Override
                public void flatMap(String value, Collector<String> out) throws Exception { 
                    //value就是每一行数据
                    String[] arr = value.split(" ");
                    for (String word : arr) { 
                        out.collect(word);
                    }
                }
            });
    
            //记为1
            /* @FunctionalInterface public interface MapFunction<T, O> extends Function, Serializable { O map(T value) throws Exception; } */
            DataStream<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public Tuple2<String, Integer> map(String value) throws Exception { 
                    //value就是一个个单词
                    return Tuple2.of(value, 1);
                }
            });
    
            //分组:注意DataSet中分组是groupBy,DataStream分组是keyBy
            //wordAndOne.keyBy(0);
            /* @FunctionalInterface public interface KeySelector<IN, KEY> extends Function, Serializable { KEY getKey(IN value) throws Exception; } */
            KeyedStream<Tuple2<String, Integer>, String> grouped = wordAndOne.keyBy(t -> t.f0);
    
            //聚合
            SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.sum(1);
    
            //TODO 3.sink
            result.print();
    
            //TODO 4.execute/启动并等待程序结束
            env.execute();
        }
    }

**代码实现-DataStream-Lambda**

package cn.itcast.hello;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.typeinfo.Types;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    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;
    
    import java.util.Arrays;
    
    /** * Author itcast * Desc 演示Flink-DataStream-API-实现WordCount * 注意:在Flink1.12中DataStream既支持流处理也支持批处理,如何区分? */
    public class WordCount4 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            //ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            //env.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理
            //env.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批
    
            //TODO 1.source
            //DataSet<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
            DataStream<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
    
            //TODO 2.transformation
            //切割
            /* @FunctionalInterface public interface FlatMapFunction<T, O> extends Function, Serializable { void flatMap(T value, Collector<O> out) throws Exception; } */
            /*DataStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() { @Override public void flatMap(String value, Collector<String> out) throws Exception { //value就是每一行数据 String[] arr = value.split(" "); for (String word : arr) { out.collect(word); } } });*/
            SingleOutputStreamOperator<String> words = lines.flatMap(
                    (String value, Collector<String> out) -> Arrays.stream(value.split(" ")).forEach(out::collect)
            ).returns(Types.STRING);
    
    
            //记为1
            /* @FunctionalInterface public interface MapFunction<T, O> extends Function, Serializable { O map(T value) throws Exception; } */
            /*DataStream<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() { @Override public Tuple2<String, Integer> map(String value) throws Exception { //value就是一个个单词 return Tuple2.of(value, 1); } });*/
            DataStream<Tuple2<String, Integer>> wordAndOne = words.map(
                    (String value) -> Tuple2.of(value, 1)
            ).returns(Types.TUPLE(Types.STRING,Types.INT));
    
            //分组:注意DataSet中分组是groupBy,DataStream分组是keyBy
            //wordAndOne.keyBy(0);
            /* @FunctionalInterface public interface KeySelector<IN, KEY> extends Function, Serializable { KEY getKey(IN value) throws Exception; } */
            KeyedStream<Tuple2<String, Integer>, String> grouped = wordAndOne.keyBy(t -> t.f0);
    
            //聚合
            SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.sum(1);
    
            //TODO 3.sink
            result.print();
    
            //TODO 4.execute/启动并等待程序结束
            env.execute();
        }
    }

**代码实现-On-Yarn-掌握**

package cn.itcast.hello;
    
    import org.apache.flink.api.common.typeinfo.Types;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.api.java.utils.ParameterTool;
    import org.apache.flink.streaming.api.datastream.DataStream;
    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;
    
    import java.util.Arrays;
    
    /** * Author itcast * Desc 演示Flink-DataStream-API-实现WordCount * 注意:在Flink1.12中DataStream既支持流处理也支持批处理,如何区分? */
    public class WordCount5_Yarn { 
        public static void main(String[] args) throws Exception { 
            ParameterTool parameterTool = ParameterTool.fromArgs(args);
            String output = "";
            if (parameterTool.has("output")) { 
                output = parameterTool.get("output");
                System.out.println("指定了输出路径使用:" + output);
            } else { 
                output = "hdfs://node1:8020/wordcount/output47_";
                System.out.println("可以指定输出路径使用 --output ,没有指定使用默认的:" + output);
            }
    
            //TODO 0.env
            //ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            //env.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理
            //env.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理
            //env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批
    
            //TODO 1.source
            //DataSet<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
            DataStream<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
    
            //TODO 2.transformation
            //切割
            /* @FunctionalInterface public interface FlatMapFunction<T, O> extends Function, Serializable { void flatMap(T value, Collector<O> out) throws Exception; } */
            /*DataStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() { @Override public void flatMap(String value, Collector<String> out) throws Exception { //value就是每一行数据 String[] arr = value.split(" "); for (String word : arr) { out.collect(word); } } });*/
            SingleOutputStreamOperator<String> words = lines.flatMap(
                    (String value, Collector<String> out) -> Arrays.stream(value.split(" ")).forEach(out::collect)
            ).returns(Types.STRING);
    
    
            //记为1
            /* @FunctionalInterface public interface MapFunction<T, O> extends Function, Serializable { O map(T value) throws Exception; } */
            /*DataStream<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() { @Override public Tuple2<String, Integer> map(String value) throws Exception { //value就是一个个单词 return Tuple2.of(value, 1); } });*/
            DataStream<Tuple2<String, Integer>> wordAndOne = words.map(
                    (String value) -> Tuple2.of(value, 1)
            ).returns(Types.TUPLE(Types.STRING, Types.INT));
    
            //分组:注意DataSet中分组是groupBy,DataStream分组是keyBy
            //wordAndOne.keyBy(0);
            /* @FunctionalInterface public interface KeySelector<IN, KEY> extends Function, Serializable { KEY getKey(IN value) throws Exception; } */
            KeyedStream<Tuple2<String, Integer>, String> grouped = wordAndOne.keyBy(t -> t.f0);
    
            //聚合
            SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.sum(1);
    
            //TODO 3.sink
            //如果执行报hdfs权限相关错误,可以执行 hadoop fs -chmod -R 777 /
            System.setProperty("HADOOP_USER_NAME", "root");//设置用户名
            //result.print();
            //result.writeAsText("hdfs://node1:8020/wordcount/output47_"+System.currentTimeMillis()).setParallelism(1);
            result.writeAsText(output + System.currentTimeMillis()).setParallelism(1);
    
            //TODO 4.execute/启动并等待程序结束
            env.execute();
        }
    }

**打包改名上传**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 29]  
**提交**

/export/server/flink/bin/flink run -Dexecution.runtime-mode=BATCH -m yarn-cluster -yjm 1024 -ytm 1024 -c cn.itcast.hello.WordCount5_Yarn /root/wc.jar --output hdfs://node1:8020/wordcount/output_xx

**注意**

RuntimeExecutionMode.BATCH//使用DataStream实现批处理
    RuntimeExecutionMode.STREAMING//使用DataStream实现流处理
    RuntimeExecutionMode.AUTOMATIC//使用DataStream根据数据源自动选择使用流还是批
    //如果不指定,默认是流

在后续的Flink开发中,把一切数据源看做流即可或者使用AUTOMATIC就行了

# 3.Flink原理初探-慢慢理解/消化 #

## 5.1 Flink角色分工 ##

在实际生产中，Flink 都是以集群在运行，在运行的过程中包含了两类进程。

*  JobManager：  
    它扮演的是集群管理者的角色，负责调度任务、协调 checkpoints、协调故障恢复、收集 Job 的状态信息，并管理 Flink 集群中的从节点 TaskManager。
 *  TaskManager：  
    实际负责执行计算的 Worker，在其上执行 Flink Job 的一组 Task；TaskManager 还是所在节点的管理员，它负责把该节点上的服务器信息比如内存、磁盘、任务运行情况等向 JobManager 汇报。
 *  Client：  
    用户在提交编写好的 Flink 工程时，会先创建一个客户端再进行提交，这个客户端就是 Client  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 30]

## 5.2 Flink执行流程 ##

https://blog.csdn.net/sxiaobei/article/details/80861070  
https://blog.csdn.net/super\_wj0820/article/details/90726768  
https://ci.apache.org/projects/flink/flink-docs-release-1.11/ops/deployment/yarn\_setup.html

**5.2.2 On Yarn版**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 31]  
1.Client向HDFS上传Flink的Jar包和配置  
2.Client向Yarn ResourceManager提交任务并申请资源  
3.ResourceManager分配Container资源并启动ApplicationMaster,然后AppMaster加载Flink的Jar包和配置构建环境,启动JobManager  
4.ApplicationMaster向ResourceManager申请工作资源,NodeManager加载Flink的Jar包和配置构建环境并启动TaskManager  
5.TaskManager启动后向JobManager发送心跳包，并等待JobManager向其分配任务

## 5.3 Flink Streaming Dataflow(数据流) ##

**5.3.1 Dataflow、Operator、Partition、SubTask、Parallelism**  
1.Dataflow:Flink程序在执行的时候会被映射成一个数据流模型  
2.Operator:数据流模型中的每一个操作被称作Operator,Operator分为:Source/Transform/Sink  
3.Partition:数据流模型是分布式的和并行的,执行中会形成1~n个分区  
4.Subtask:多个分区任务可以并行,每一个都是独立运行在一个线程中的,也就是一个Subtask子任务  
5.Parallelism:并行度,就是可以同时真正执行的子任务数/分区数

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 32]

### 5.3.2 Operator传递模式 ###

数据在两个operator(算子)之间传递的时候有两种模式：  
**1.One to One模式：**  
两个operator用此模式传递的时候，会保持数据的分区数和数据的排序；如上图中的Source1到Map1，它就保留的Source的分区特性，以及分区元素处理的有序性。–类似于Spark中的窄依赖  
**2.Redistributing 模式：**  
这种模式会改变数据的分区数；每个一个operator subtask会根据选择transformation把数据发送到不同的目标subtasks,比如keyBy()会通过hashcode重新分区,broadcast()和rebalance()方法会随机重新分区。–类似于Spark中的宽依赖

### 5.3.3 Operator Chain(执行链) ###

OperatorChain和Task  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 33]

### 5.3.4 TaskSlot And Slot Sharing ###

*  任务槽(TaskSlot)  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 34]  
    每个TaskManager是一个JVM的进程, 为了控制一个TaskManager(worker)能接收多少个task，Flink通过Task Slot来进行控制。TaskSlot数量是用来限制一个TaskManager工作进程中可以同时运行多少个工作线程，TaskSlot 是一个 TaskManager 中的最小资源分配单位，一个 TaskManager 中有多少个 TaskSlot 就意味着能支持多少并发的Task处理。

Flink将进程的内存进行了划分到多个slot中，内存被划分到不同的slot之后可以获得如下好处:

*  TaskManager最多能同时并发执行的子任务数是可以通过TaskSolt数量来控制的
 *  TaskSolt有独占的内存空间，这样在一个TaskManager中可以运行多个不同的作业，作业之间不受影响。

\-槽共享(Slot Sharing)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 35]

Flink允许子任务共享插槽，即使它们是不同任务(阶段)的子任务(subTask)，只要它们来自同一个作业。  
比如图左下角中的map和keyBy和sink 在一个 TaskSlot 里执行以达到资源共享的目的。

允许插槽共享有两个主要好处：

*  资源分配更加公平，如果有比较空闲的slot可以将更多的任务分配给它。
 *  有了任务槽共享，可以提高资源的利用率。

注意:  
slot是静态的概念，是指taskmanager具有的并发执行能力  
parallelism是动态的概念，是指程序运行时实际使用的并发能力

## 5.4 Flink运行时组件 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 36]  
Flink运行时架构主要包括四个不同的组件，它们会在运行流处理应用程序时协同工作：  
作业管理器（JobManager）：分配任务、调度checkpoint做快照  
任务管理器（TaskManager）：主要干活的  
资源管理器（ResourceManager）：管理分配资源  
分发器（Dispatcher）：方便递交任务的接口，WebUI  
因为Flink是用Java和Scala实现的，所以所有组件都会运行在Java虚拟机上。每个组件的职责如下：  
1.作业管理器（JobManager）  
控制一个应用程序执行的主进程，也就是说，每个应用程序都会被一个不同的JobManager 所控制执行。  
JobManager 会先接收到要执行的应用程序，这个应用程序会包括：作业图（JobGraph）、逻辑数据流图（logical dataflow graph）和打包了所有的类、库和其它资源的JAR包。  
JobManager 会把JobGraph转换成一个物理层面的数据流图，这个图被叫做“执行图”（ExecutionGraph），包含了所有可以并发执行的任务。  
JobManager 会向资源管理器（ResourceManager）请求执行任务必要的资源，也就是任务管理器（TaskManager）上的插槽（slot）。一旦它获取到了足够的资源，就会将执行图分发到真正运行它们的TaskManager上。而在运行过程中，JobManager会负责所有需要中央协调的操作，比如说检查点（checkpoints）的协调。  
2.任务管理器（TaskManager）  
Flink中的工作进程。通常在Flink中会有多个TaskManager运行，每一个TaskManager都包含了一定数量的插槽（slots）。插槽的数量限制了TaskManager能够执行的任务数量。  
启动之后，TaskManager会向资源管理器注册它的插槽；收到资源管理器的指令后，TaskManager就会将一个或者多个插槽提供给JobManager调用。JobManager就可以向插槽分配任务（tasks）来执行了。  
在执行过程中，一个TaskManager可以跟其它运行同一应用程序的TaskManager交换数据。  
3.资源管理器（ResourceManager）  
主要负责管理任务管理器（TaskManager）的插槽（slot），TaskManger 插槽是Flink中定义的处理资源单元。  
Flink为不同的环境和资源管理工具提供了不同资源管理器，比如YARN、Mesos、K8s，以及standalone部署。  
当JobManager申请插槽资源时，ResourceManager会将有空闲插槽的TaskManager分配给JobManager。如果ResourceManager没有足够的插槽来满足JobManager的请求，它还可以向资源提供平台发起会话，以提供启动TaskManager进程的容器。  
4.分发器（Dispatcher）  
可以跨作业运行，它为应用提交提供了REST接口。  
当一个应用被提交执行时，分发器就会启动并将应用移交给一个JobManager。  
Dispatcher也会启动一个Web UI，用来方便地展示和监控作业执行的信息。  
Dispatcher在架构中可能并不是必需的，这取决于应用提交运行的方式。

## 5.5 Flink执行图（ExecutionGraph） ##

由Flink程序直接映射成的数据流图是StreamGraph，也被称为逻辑流图，因为它们表示的是计算逻辑的高级视图。为了执行一个流处理程序，Flink需要将逻辑流图转换为物理数据流图（也叫执行图），详细说明程序的执行方式。  
Flink 中的执行图可以分成四层：StreamGraph -> JobGraph -> ExecutionGraph -> 物理执行图。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 37]

原理介绍  
Flink执行executor会自动根据程序代码生成DAG数据流图  
Flink 中的执行图可以分成四层：StreamGraph -> JobGraph -> ExecutionGraph -> 物理执行图。  
StreamGraph：是根据用户通过 Stream API 编写的代码生成的最初的图。表示程序的拓扑结构。  
JobGraph：StreamGraph经过优化后生成了 JobGraph，提交给 JobManager 的数据结构。主要的优化为，将多个符合条件的节点 chain 在一起作为一个节点，这样可以减少数据在节点之间流动所需要的序列化/反序列化/传输消耗。  
ExecutionGraph：JobManager 根据 JobGraph 生成ExecutionGraph。ExecutionGraph是JobGraph的并行化版本，是调度层最核心的数据结构。  
物理执行图：JobManager 根据 ExecutionGraph 对 Job 进行调度后，在各个TaskManager 上部署 Task 后形成的“图”，并不是一个具体的数据结构。

# 4.Flink-流批一体API #

## 1. 流处理相关概念 ##

**1.1 数据的时效性**  
日常工作中，我们一般会先把数据存储在表，然后对表的数据进行加工、分析。既然先存储在表中，那就会涉及到时效性概念。  
如果我们处理以年，月为单位的级别的数据处理，进行统计分析，个性化推荐，那么数据的的最新日期离当前有几个甚至上月都没有问题。但是如果我们处理的是以天为级别，或者一小时甚至更小粒度的数据处理，那么就要求数据的时效性更高了。比如：对网站的实时监控、对异常日志的监控，这些场景需要工作人员立即响应，这样的场景下，传统的统一收集数据，再存到数据库中，再取出来进行分析就无法满足高时效性的需求了。  
**1.2 流处理和批处理**  
**流处理说明:**  
在flink中一切都看做是流处只是分为有边界和无边界的流：  
有边界的流bounded stream:批数据  
无边界的流unbounded stream:真正的流数据(kafka)

https://ci.apache.org/projects/flink/flink-docs-release-1.12/learn-flink/  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 38]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 39]

*  Batch Analytics，右边是 Streaming Analytics。批量计算: 统一收集数据->存储到DB->对数据进行批量处理，就是传统意义上使用类似于 Map Reduce、Hive、Spark Batch 等，对作业进行分析、处理、生成离线报表
 *  Streaming Analytics 流式计算，顾名思义，就是对数据流进行处理，如使用流式分析引擎如 Storm，Flink 实时处理分析数据，应用较多的场景如实时大屏、**实时报表。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 40]

## 1.3 流批一体API ##

**Flink流批一体API主要包含:**

1.  SourceAPI,数据来源
2.  Transformation API 数据计算处理
3.  Sink API 数据发送到哪里
4.  connectors API Fink 内置提供的一些连接外部source和sinkAPI  
    **编程模型**  
    Flink 应用程序结构主要包含三部分,Source/Transformation/Sink,如下图所示：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 41]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 42]

DataStream API 支持批执行模式  
Flink 的核心 API 最初是针对特定的场景设计的，尽管 Table API / SQL 针对流处理和批处理已经实现了统一的 API，但当用户使用较底层的 API 时，仍然需要在批处理（DataSet API）和流处理（DataStream API）这两种不同的 API 之间进行选择。鉴于批处理是流处理的一种特例，将这两种 API 合并成统一的 API，有一些非常明显的好处，比如：

可复用性：作业可以在流和批这两种执行模式之间自由地切换，而无需重写任何代码。因此，用户可以复用同一个作业，来处理实时数据和历史数据。  
维护简单：统一的 API 意味着流和批可以共用同一组 connector，维护同一套代码，并能够轻松地实现流批混合执行，例如 backfilling 之类的场景。

考虑到这些优点，社区已朝着流批统一的 DataStream API 迈出了第一步：支持高效的批处理（FLIP-134）。从长远来看，这意味着 DataSet API 将被弃用（FLIP-131），其功能将被包含在 DataStream API 和 Table API / SQL 中。

API  
Flink提供了多个层次的API供开发者使用，越往上抽象程度越高，使用起来越方便；越往下越底层，使用起来难度越大

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 43]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 44]  
**注意：在Flink1.12时支持流批一体，DataSetAPI已经不推荐使用了，所以课程中除了个别案例使用DataSet外，后续其他案例都会优先使用DataStream流式API，既支持无界数据处理/流处理，也支持有界数据处理/批处理！当然Table&SQL-API会单独学习**  
https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/batch/  
https://developer.aliyun.com/article/780123?spm=a2c6h.12873581.0.0.1e3e46ccbYFFrC

## 2.1 预定义Source ##

### 2.1.1 基于集合的Source ###

API  
一般用于学习测试时编造数据时使用  
1.env.fromElements(可变参数);  
2.env.fromColletion(各种集合);  
3.env.generateSequence(开始,结束);  
4.env.fromSequence(开始,结束);

package cn.itcast.source;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    
    import java.util.Arrays;
    
    /** * Author itcast * Desc 演示DataStream-Source-基于集合 */
    public class SourceDemo01_Collection { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> ds1 = env.fromElements("hadoop spark flink", "hadoop spark flink");
            DataStream<String> ds2 = env.fromCollection(Arrays.asList("hadoop spark flink", "hadoop spark flink"));
            DataStream<Long> ds3 = env.generateSequence(1, 100);
            DataStream<Long> ds4 = env.fromSequence(1, 100);
    
            //TODO 2.transformation
    
            //TODO 3.sink
            ds1.print();
            ds2.print();
            ds3.print();
            ds4.print();
    
            //TODO 4.execute
            env.execute();
        }
    }

### 2.1.2 基于文件的Source ###

API  
一般用于学习测试  
env.readTextFile(本地/HDFS文件/文件夹);//压缩文件也可以

package cn.itcast.source;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    
    /** * Author itcast * Desc 演示DataStream-Source-基于本地/HDFS的文件/文件夹/压缩文件 */
    public class SourceDemo02_File { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> ds1 = env.readTextFile("data/input/words.txt");
            DataStream<String> ds2 = env.readTextFile("data/input/dir");
            DataStream<String> ds3 = env.readTextFile("data/input/wordcount.txt.gz");
            //env.readTextFile(本地/HDFS文件/文件夹);//压缩文件也可以
    
            //TODO 2.transformation
    
            //TODO 3.sink
            ds1.print();
            ds2.print();
            ds3.print();
    
            //TODO 4.execute
            env.execute();
        }
    }

### 2.1.3 基于Socket的Source ###

一般用于学习测试  
需求:  
1.在node1上使用nc -lk 9999 向指定端口发送数据  
nc是netcat的简称，原本是用来设置路由器,我们可以利用它向某个端口发送数据  
如果没有该命令可以下安装

yum install -y nc

2.使用Flink编写流处理应用程序实时统计单词数量

代码实现:

package cn.itcast.source;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.util.Collector;
    
    /** * Author itcast * Desc 演示DataStream-Source-基于Socket */
    public class SourceDemo03_Socket { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> lines = env.socketTextStream("localhost", 9999);
    
    
            //TODO 2.transformation
            /*SingleOutputStreamOperator<String> words = lines.flatMap(new FlatMapFunction<String, String>() { @Override public void flatMap(String value, Collector<String> out) throws Exception { String[] arr = value.split(" "); for (String word : arr) { out.collect(word); } } }); words.map(new MapFunction<String, Tuple2<String,Integer>>() { @Override public Tuple2<String, Integer> map(String value) throws Exception { return Tuple2.of(value,1); } });*/
    
            //注意:下面的操作将上面的2步合成了1步,直接切割单词并记为1返回
            SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = lines.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception { 
                    String[] arr = value.split(" ");
                    for (String word : arr) { 
                        out.collect(Tuple2.of(word, 1));
                    }
                }
            });
    
            SingleOutputStreamOperator<Tuple2<String, Integer>> result = wordAndOne.keyBy(t -> t.f0).sum(1);
    
            //TODO 3.sink
            result.print();
    
            //TODO 4.execute
            env.execute();
        }
    }

先运行一个nc输入  
![在这里插入图片描述][20210313110633949.png]  
代码输出  
![在这里插入图片描述][20210313110918930.png]

## 2.2 自定义Source ##

API  
一般用于学习测试,模拟生成一些数据  
Flink还提供了数据源接口,我们实现该接口就可以实现自定义数据源，不同的接口有不同的功能，分类如下：  
**SourceFunction:非并行数据源(并行度只能=1)  
RichSourceFunction:多功能非并行数据源(并行度只能=1)  
ParallelSourceFunction:并行数据源(并行度能够>=1)  
RichParallelSourceFunction:多功能并行数据源(并行度能够>=1)–后续学习的Kafka数据源使用的就是该接口**

### 2.2.1 随机生成数据 ###

需求  
每隔1秒随机生成一条订单信息(订单ID、用户ID、订单金额、时间戳)  
要求:

*  随机生成订单ID(UUID)
 *  随机生成用户ID(0-2)
 *  随机生成订单金额(0-100)
 *  时间戳为当前系统时间

RichParallelSourceFunction

package cn.itcast.source;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.source.RichParallelSourceFunction;
    
    import java.util.Random;
    import java.util.UUID;
    
    /** * Author itcast * Desc 演示DataStream-Source-自定义数据源 * 需求: */
    public class SourceDemo04_Customer { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<Order> orderDS = env.addSource(new MyOrderSource()).setParallelism(2);
    
            //TODO 2.transformation
    
            //TODO 3.sink
            orderDS.print();
    
            //TODO 4.execute
            env.execute();
        }
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        public static class Order{ 
            private String id;
            private Integer userId;
            private Integer money;
            private Long createTime;
        }
        public static class MyOrderSource extends RichParallelSourceFunction<Order>{ 
            private Boolean flag = true;
            //执行并生成数据
            @Override
            public void run(SourceContext<Order> ctx) throws Exception { 
                Random random = new Random();
                while (flag) { 
                    String oid = UUID.randomUUID().toString();
                    int userId = random.nextInt(3);
                    int money = random.nextInt(101);
                    long createTime = System.currentTimeMillis();
                    ctx.collect(new Order(oid,userId,money,createTime));
                    Thread.sleep(1000);
                }
            }
    
            //执行cancel命令的时候执行
            @Override
            public void cancel() { 
                flag = false;
            }
        }
    }

### 2.2.2 MySQL ###

需求:  
实际开发中,经常会实时接收一些数据,要和MySQL中存储的一些规则进行匹配,那么这时候就可以使用Flink自定义数据源从MySQL中读取数据  
那么现在先完成一个简单的需求:  
从MySQL中实时加载数据  
要求MySQL中的数据有变化,也能被实时加载出来

准备数据

CREATE TABLE `t_student` (
        `id` int(11) NOT NULL AUTO_INCREMENT,
        `name` varchar(255) DEFAULT NULL,
        `age` int(11) DEFAULT NULL,
        PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
    
    INSERT INTO `t_student` VALUES ('1', 'jack', '18');
    INSERT INTO `t_student` VALUES ('2', 'tom', '19');
    INSERT INTO `t_student` VALUES ('3', 'rose', '20');
    INSERT INTO `t_student` VALUES ('4', 'tom', '19');
    INSERT INTO `t_student` VALUES ('5', 'jack', '18');
    INSERT INTO `t_student` VALUES ('6', 'rose', '20');

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 45]

pom

<dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.38</version>
                
            </dependency>

package cn.itcast.source;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.configuration.Configuration;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.source.RichParallelSourceFunction;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    /** * Author itcast * Desc 演示DataStream-Source-自定义数据源-MySQL * 需求: */
    public class SourceDemo05_Customer_MySQL { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<Student> studentDS = env.addSource(new MySQLSource()).setParallelism(1);
    
            //TODO 2.transformation
    
            //TODO 3.sink
            studentDS.print();
    
            //TODO 4.execute
            env.execute();
        }
    
    
        @Data
        @NoArgsConstructor
        @AllArgsConstructor
        public static class Student { 
            private Integer id;
            private String name;
            private Integer age;
        }
    
        public static class MySQLSource extends RichParallelSourceFunction<Student> { 
            private boolean flag = true;
            private Connection conn = null;
            private PreparedStatement ps =null;
            private ResultSet rs  = null;
            //open只执行一次,适合开启资源
            @Override
            public void open(Configuration parameters) throws Exception { 
              conn = DriverManager.getConnection("jdbc:mysql://10.139.12.149:3306/book1", "root", "Test2016@");
                String sql = "select id,name,age from t_student";
                ps = conn.prepareStatement(sql);
            }
    
            @Override
            public void run(SourceContext<Student> ctx) throws Exception { 
                while (flag) { 
                    rs = ps.executeQuery();//执行查询
                    while (rs.next()) { 
                        int id = rs.getInt("id");
                        String name = rs.getString("name");
                        int age  = rs.getInt("age");
                        ctx.collect(new Student(id,name,age));
                    }
                    Thread.sleep(5000);
                }
            }
    
            //接收到cancel命令时取消数据生成
            @Override
            public void cancel() { 
                flag = false;
            }
    
            //close里面关闭资源
            @Override
            public void close() throws Exception { 
                if(conn != null) conn.close();
                if(ps != null) ps.close();
                if(rs != null) rs.close();
            }
        }
    
    }

# 3. Transformation(计算) #

3.1 官网API列表

https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/stream/operators/

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 46]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 47]  
**整体来说，流式数据上的操作可以分为四类。**

*  第一类是对于单条记录的操作，比如筛除掉不符合要求的记录（Filter 操作），或者将每条记录都做一个转换（Map 操作）
 *  第二类是对多条记录的操作。比如说统计一个小时内的订单总成交量，就需要将一个小时内的所有订单记录的成交量加到一起。为了支持这种类型的操作，就得通过 Window 将需要的记录关联到一起进行处理
 *  第三类是对多个流进行操作并转换为单个流。例如，多个流可以通过 Union、Join 或 Connect 等操作合到一起。这些操作合并的逻辑不同，但是它们最终都会产生了一个新的统一的流，从而可以进行一些跨流的操作。
 *  最后， DataStream 还支持与合并对称的拆分操作，即把一个流按一定规则拆分为多个流（Split 操作），每个流是之前流的一个子集，这样我们就可以对不同的流作不同的处理。

## 3.2 基本操作 ##

### 3.2.1 map ###

API  
map:将函数作用在集合中的每一个元素上,并返回作用后的结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 48]

### 3.2.2 flatMap ###

API  
flatMap:将集合中的每个元素变成一个或多个元素,并返回扁平化之后的结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 49]

### 3.2.3 keyBy ###

按照指定的key来对流中的数据进行分组，前面入门案例中已经演示过  
注意:  
流处理中没有groupBy,而是keyBy

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 50]

### 3.2.4 filter ###

API  
filter:按照指定的条件对集合中的元素进行过滤,过滤出返回true/符合条件的元素

### 3.2.5 sum ###

API  
sum:按照指定的字段对集合中的元素进行求和

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 51]

### 3.2.6 reduce ###

API  
reduce:对集合中的元素进行聚合  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 52]

### 3.2.7 代码演示(基本操作) ###

**map/flatMap/filter/keyBy/sum/reduce…**

和之前学习的Scala/Spark里面的一样的意思  
需求

对流数据中的单词进行统计，排除敏感词TMD(Theater Missile Defense 战区导弹防御)

package com.example.kafkaflinkdemo.transformation;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FilterFunction;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.api.common.functions.ReduceFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.KeyedStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.util.Collector;
    
    public class TransformationDemo01 { 
      public static void main(String[] args) throws Exception { 
    
        //TODO 0.env
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
    //TODO 1.source
        DataStream<String> lines = env.socketTextStream("127.0.0.1",9999);
    
        //TODO 2.transformation
        DataStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() { 
          @Override
          public void flatMap(String value, Collector<String> out) throws Exception { 
            String[] arr = value.split(" ");
            for(String word : arr) { 
              out.collect(word);
            }
           }
        });
    
        DataStream<String> filted = words.filter(new FilterFunction<String>() { 
          @Override
          public boolean filter(String value) throws Exception { 
            return !value.equals("TTT");
          }
        });
    
        DataStream<Tuple2<String, Integer>> wordAndOne = filted.map(new MapFunction<String, Tuple2<String, Integer>>() { 
          @Override
          public Tuple2<String, Integer> map(String value) throws Exception { 
    
            return Tuple2.of(value, 1);
          }
        });
    
        KeyedStream<Tuple2<String, Integer>,String> grouped = wordAndOne.keyBy(t->t.f0);
    
        DataStream<Tuple2<String, Integer>> result = grouped.reduce(new ReduceFunction<Tuple2<String, Integer>>() { 
          @Override
          public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1, Tuple2<String, Integer> value2) throws Exception { 
            //Tuple2<String, Integer> value1 :进来的(单词,历史值)
            //Tuple2<String, Integer> value2 :进来的(单词,1)
            //需要返回(单词,数量)
            return  Tuple2.of(value1.f0, value1.f1+value2.f1);
          }
        });
    
        result.print();
        env.execute();
      }
    
    }

package cn.itcast.transformation;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FilterFunction;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.api.common.functions.ReduceFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    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;
    
    /** * Author itcast * Desc 演示DataStream-Transformation-基本操作 */
    public class TransformationDemo01 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> lines = env.socketTextStream("localhost", 9999);
    
    
            //TODO 2.transformation 
            //先切割
            DataStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() { 
                @Override
                public void flatMap(String value, Collector<String> out) throws Exception { 
                    String[] arr = value.split(" ");
                    for (String word : arr) { 
                        out.collect(word);
                    }
                }
            });
            //过滤
            DataStream<String> filted = words.filter(new FilterFunction<String>() { 
                @Override
                public boolean filter(String value) throws Exception { 
                    return !value.equals("TMD");//如果是TMD则返回false表示过滤掉
                }
            });
            //如果filted 返回true 返回单词
            SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = filted.map(new MapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public Tuple2<String, Integer> map(String value) throws Exception { 
                    return Tuple2.of(value, 1);
                }
            });
    		//分组
            KeyedStream<Tuple2<String, Integer>, String> grouped = wordAndOne.keyBy(t -> t.f0);
           //统计方法一: 使用sum统计相同单词的个数
            //SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.sum(1);
           //统计统计方法二: 使用reduce统计相同单词的个数
            SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.reduce(new ReduceFunction<Tuple2<String, Integer>>() { 
                @Override
                public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1, Tuple2<String, Integer> value2) throws Exception { 
                    //Tuple2<String, Integer> value1 :进来的(单词,历史值)
                    //Tuple2<String, Integer> value2 :进来的(单词,1)
                    //需要返回(单词,数量)
                    return Tuple2.of(value1.f0, value1.f1 + value2.f1); //_+_
                }
            });
    
            //TODO 3.sink
            result.print();
    
            //TODO 4.execute
            env.execute();
        }
    }

![在这里插入图片描述][20210313142828702.png]  
代码执行结果：TMD被过滤掉了

![在这里插入图片描述][20210313142816146.png]

需求:  
对流数据中的单词进行统计，排除敏感词heihei

代码演示

package cn.itcast.transformation;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FilterFunction;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.api.common.functions.ReduceFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.KeyedStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.util.Collector;
    
    /** * Author itcast * Desc */
    public class TransformationDemo01 { 
        public static void main(String[] args) throws Exception { 
            //1.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
            //2.source
            DataStream<String> linesDS = env.socketTextStream("node1", 9999);
    
            //3.处理数据-transformation
            DataStream<String> wordsDS = linesDS.flatMap(new FlatMapFunction<String, String>() { 
                @Override
                public void flatMap(String value, Collector<String> out) throws Exception { 
                    //value就是一行行的数据
                    String[] words = value.split(" ");
                    for (String word : words) { 
                        out.collect(word);//将切割处理的一个个的单词收集起来并返回
                    }
                }
            });
            DataStream<String> filtedDS = wordsDS.filter(new FilterFunction<String>() { 
                @Override
                public boolean filter(String value) throws Exception { 
                    return !value.equals("heihei");
                }
            });
            DataStream<Tuple2<String, Integer>> wordAndOnesDS = filtedDS.map(new MapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public Tuple2<String, Integer> map(String value) throws Exception { 
                    //value就是进来一个个的单词
                    return Tuple2.of(value, 1);
                }
            });
            //KeyedStream<Tuple2<String, Integer>, Tuple> groupedDS = wordAndOnesDS.keyBy(0);
            KeyedStream<Tuple2<String, Integer>, String> groupedDS = wordAndOnesDS.keyBy(t -> t.f0);
    
            DataStream<Tuple2<String, Integer>> result1 = groupedDS.sum(1);
            DataStream<Tuple2<String, Integer>> result2 = groupedDS.reduce(new ReduceFunction<Tuple2<String, Integer>>() { 
                @Override
                public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1, Tuple2<String, Integer> value2) throws Exception { 
                    return Tuple2.of(value1.f0, value1.f1 + value1.f1);
                }
            });
    
            //4.输出结果-sink
            result1.print("result1");
            result2.print("result2");
    
            //5.触发执行-execute
            env.execute();
        }
    }

## 3.3 合并-拆分 ##

#### 3.3.1 合并 union和connect ####

API  
union：合并  
union算子可以合并多个同类型的数据流，并生成同类型的数据流，即可以将多个DataStream\[T\]合并为一个新的DataStream\[T\]。数据将按照先进先出（First In First Out）的模式合并，且不去重。

union一次就可以合并多个流，union能合并同类型的流，union之后可以直接输出  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 53]

connect：  
connect提供了和union类似的功能，用来连接两个数据流，它与union的区别在于：  
connect只能连接两个数据流，union可以连接多个数据流。  
connect所连接的两个数据流的数据类型可以不一致，union所连接的两个数据流的数据类型必须一致。  
两个DataStream经过connect之后被转化为ConnectedStreams，ConnectedStreams会对两个流的数据应用不同的处理方法，且双流之间可以共享状态。

connect一次只能合并2个流，connet可以合并同类型和不同类型的流，connect之后需要做其他的处理,不能直接输出  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 54]

package cn.itcast.transformation;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.streaming.api.datastream.ConnectedStreams;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.co.CoMapFunction;
    
    /** * Author itcast * Desc 演示DataStream-Transformation-合并和连接操作 */
    public class TransformationDemo02 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> ds1 = env.fromElements("hadoop", "spark", "flink");
            DataStream<String> ds2 = env.fromElements("hadoop", "spark", "flink");
            DataStream<Long> ds3 = env.fromElements(1L, 2L, 3L);
    
            //TODO 2.transformation
            DataStream<String> result1 = ds1.union(ds2);//注意union能合并同类型
            //ds1.union(ds3);//注意union不可以合并不同类型
            ConnectedStreams<String, String> result2 = ds1.connect(ds2);//注意:connet可以合并同类型
            ConnectedStreams<String, Long> result3 = ds1.connect(ds3);//注意connet可以合并不同类型
    
            /* public interface CoMapFunction<IN1, IN2, OUT> extends Function, Serializable { OUT map1(IN1 value) throws Exception; OUT map2(IN2 value) throws Exception; } */
            SingleOutputStreamOperator<String> result = result3.map(new CoMapFunction<String, Long, String>() { 
                @Override
                public String map1(String value) throws Exception { 
                    return "String:" + value;
                }
    
                @Override
                public String map2(Long value) throws Exception { 
                    return "Long:" + value;
                }
            });
    
    
            //TODO 3.sink
            result1.print();
            //result2.print();//注意:connect之后需要做其他的处理,不能直接输出
            //result3.print();//注意:connect之后需要做其他的处理,不能直接输出
            result.print();
    
            //TODO 4.execute
            env.execute();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 55]

### 3.3.2 拆分 split、select和Side Outputs ###

API  
flink1.12及新版  
Side Outputs：可以使用process方法对流中数据进行处理，并针对不同的处理结果将数据收集到不同的OutputTag中

旧版  
Split就是将一个流分成多个流  
Select就是获取分流后对应的数据  
拆分(split)和选择(select)操作  
**注意split和select在flink1.12中已经过期并移除了**  
**所以得使用outPutTag和process来实现**

需求:  
对流中的数据按照奇数和偶数进行分流，并获取分流后的数据

代码实现:

![在这里插入图片描述][20210313144808216.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 56]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 57]

package cn.itcast.transformation;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.typeinfo.TypeInformation;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.DataStreamSource;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.ProcessFunction;
    import org.apache.flink.util.Collector;
    import org.apache.flink.util.OutputTag;
    
    /** * Author itcast * Desc 演示DataStream-Transformation-拆分(split)和选择(select)操作 * 注意split和select在flink1.12中已经过期并移除了 * 所以得使用outPutTag和process来实现 * 需求:对流中的数据按照奇数和偶数拆分并选择 */
    public class TransformationDemo03 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStreamSource<Integer> ds = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    
            //TODO 2.transformation
            //需求:对流中的数据按照奇数和偶数拆分并选择
            OutputTag<Integer> oddTag = new OutputTag<>("奇数", TypeInformation.of(Integer.class));
            OutputTag<Integer> evenTag = new OutputTag<>("偶数",TypeInformation.of(Integer.class));
    
            /* public abstract class ProcessFunction<I, O> extends AbstractRichFunction { public abstract void processElement(I value, ProcessFunction.Context ctx, Collector<O> out) throws Exception; } */
            SingleOutputStreamOperator<Integer> result = ds.process(new ProcessFunction<Integer, Integer>() { 
                @Override
                public void processElement(Integer value, Context ctx, Collector<Integer> out) throws Exception { 
                    //out收集完的还是放在一起的,ctx可以将数据放到不同的OutputTag
                    if (value % 2 == 0) { 
                        ctx.output(evenTag, value);
                    } else { 
                        ctx.output(oddTag, value);
                    }
                }
            });
    
            DataStream<Integer> oddResult = result.getSideOutput(oddTag);
            DataStream<Integer> evenResult = result.getSideOutput(evenTag);
    
            //TODO 3.sink
            System.out.println(oddTag);//OutputTag(Integer, 奇数)
            System.out.println(evenTag);//OutputTag(Integer, 偶数)
            oddResult.print("奇数:");//打印时添加前缀
            evenResult.print("偶数:");
    
            //TODO 4.execute
            env.execute();
        }
    }

![在这里插入图片描述][20210313145224846.png]

## 3.4 分区 ##

### 3.4.1 rebalance重平衡分区(解决数据倾斜) ###

API  
类似于Spark中的repartition,但是功能更强大,可以直接解决数据倾斜  
Flink也有数据倾斜的时候，比如当前有数据量大概10亿条数据需要处理，在处理过程中可能会发生如图所示的状况，出现了数据倾斜，其他3台机器执行完毕也要等待机器1执行完毕后才算整体将任务完成；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 58]  
所以在实际的工作中，出现这种情况flink比较好的解决方案就是rebalance(内部使用round robin方法将数据均匀打散)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 59]  
代码演示:

package com.example.kafkaflinkdemo.transformation;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FilterFunction;
    import org.apache.flink.api.common.functions.RichMapFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    
    public class TransformationDemo04 { 
    
      public static void main(String[] args) throws Exception { 
        //TODO 0.env
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
         env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
        //TODO 1.source
        DataStream<Long> longDS = env.fromSequence(0,10000);
    
        //下面的操作相当于将数据随机分配一下,有可能出现数据倾斜
        DataStream<Long> filterDs =longDS.filter(new FilterFunction<Long>() { 
          @Override
          public boolean filter(Long value) throws Exception { 
            return value > 9000;
          }
        });
    
        //TODO 2.transformation
        //没有经过rebalance有可能出现数据倾斜
        SingleOutputStreamOperator<Tuple2<String, Integer>> result1 = filterDs.map(new RichMapFunction<Long, Tuple2<String, Integer>>() { 
          @Override
          public Tuple2<String, Integer> map(Long value) throws Exception { 
            int subTasId = getRuntimeContext().getIndexOfThisSubtask();//子任务id/分区编号
            return Tuple2.of("subTasId: "+subTasId, 1);
          }//按照子任务id/分区编号分组,并统计每个子任务/分区中有几个元素
        }).keyBy(t -> t.f0).sum(1);
    
        //调用了rebalance解决了数据倾斜
        SingleOutputStreamOperator<Tuple2<String, Integer>> result2  = filterDs.rebalance().map(new RichMapFunction<Long, Tuple2<String, Integer>>() { 
          @Override
          public Tuple2<String, Integer> map(Long value) throws Exception { 
            int subTasId = getRuntimeContext().getIndexOfThisSubtask();//子任务id/分区编号
            return Tuple2.of("re-subTasId: "+subTasId, 1);
          }
        }).keyBy(t -> t.f0).sum(1);
    
    //TODO 3.sink
        result1.print();
        result2.print();
        //TODO 4.execute
        env.execute();
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 60]

### 3.4.2 其他分区 ###

API

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 61]

目前Flink支持8种分区策略：  
GlobalPartitioner： 数据会被分发到下游算子的第一个实例中进行处理。  
ShufflePartitioner ：数据会被随机分发到下游算子的每一个实例中进行。  
RebalancePartitioner： 数据会被循环发送到下游的每一个实例中进行处理。  
RescalePartitioner ：这种分区器会根据上下游算子的并行度，循环的方式输出到下游算子的每个实例。这里有点难以理解，假设上游并行度为 2，编号为 A 和 B。下游并行度为 4，编号为 1，2，3，4。那么 A 则把数据循环发送给 1 和 2，B 则把数据循环发送给 3 和 4。假设上游并行度为 4，编号为 A，B，C，D。下游并行度为 2，编号为 1，2。那么 A 和 B 则把数据发送给 1，C 和 D 则把数据发送给 2。  
BroadcastPartitioner ：广播分区会将上游数据输出到下游算子的每个实例中。适合于大数据集和小数据集做Jion的场景。  
ForwardPartitioner：用于将记录输出到下游本地的算子实例。它要求上下游算子并行度一样。简单的说，ForwardPartitioner用来做数据的控制台打印。  
KeyGroupStreamPartitioner ：Hash 分区器。会将数据按Key的Hash值输出到下游算子实例中。  
CustomPartitionerWrapper：用户自定义分区器。需要用户自己实现 Partitioner 接口，来定义自己的分区逻辑。

static class CustomPartitioner implements Partitioner<String> {  
        @Override 
        public int partition(String key, int numPartitions) {  
            switch (key){  
                case "1": return 1;
                case "2": return 2;
                case "3": return 3;
                default : return 4;
            }
        }
    }

说明:  
recale分区。基于上下游Operator的并行度，将记录以循环的方式输出到下游Operator的每个实例。  
举例:  
上游并行度是2，下游是4，则上游一个并行度以循环的方式将记录输出到下游的两个并行度上;上游另一个并行度以循环的方式将记录输出到下游另两个并行度上。若上游并行度是4，下游并行度是2，则上游两个并行度将记录输出到下游一个并行度上；上游另两个并行度将记录输出到下游另一个并行度上。

需求:  
对流中的元素使用各种分区,并输出

代码实现

package cn.itcast.transformation;
    
            import org.apache.flink.api.common.RuntimeExecutionMode;
            import org.apache.flink.api.common.functions.FlatMapFunction;
            import org.apache.flink.api.common.functions.Partitioner;
            import org.apache.flink.api.java.tuple.Tuple2;
            import org.apache.flink.streaming.api.datastream.DataStream;
            import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
            import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
            import org.apache.flink.util.Collector;
    
    /** * Author itcast * Desc 演示DataStream-Transformation-各种分区 */
    public class TransformationDemo05 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> linesDS = env.readTextFile("data/input/words.txt");
            SingleOutputStreamOperator<Tuple2<String, Integer>> tupleDS = linesDS.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception { 
                    String[] words = value.split(" ");
                    for (String word : words) { 
                        out.collect(Tuple2.of(word, 1));
                    }
                }
            });
    
            //TODO 2.transformation
            DataStream<Tuple2<String, Integer>> result1 = tupleDS.global();
            DataStream<Tuple2<String, Integer>> result2 = tupleDS.broadcast();
            DataStream<Tuple2<String, Integer>> result3 = tupleDS.forward();
            DataStream<Tuple2<String, Integer>> result4 = tupleDS.shuffle();
            DataStream<Tuple2<String, Integer>> result5 = tupleDS.rebalance();
            DataStream<Tuple2<String, Integer>> result6 = tupleDS.rescale();
            DataStream<Tuple2<String, Integer>> result7 = tupleDS.partitionCustom(new MyPartitioner(), t -> t.f0);
    
    
            //TODO 3.sink
            result1.print("result1");
            result2.print("result2");
            result3.print("result3");
            result4.print("result4");
            result5.print("result5");
            result6.print("result6");
            result7.print("result7");
    
    
            //TODO 4.execute
            env.execute();
        }
        public static class MyPartitioner implements Partitioner<String>{ 
            @Override
            public int partition(String key, int numPartitions) { 
                //if(key.equals("北京")) return 0; 这里写自己的分区逻辑即可
                return 0;
            }
        }
    }

# 4. Sink(输出) #

## 4.1 预定义Sink ##

### 4.1.1 基于控制台和文件的Sink ###

API  
1.ds.print 直接输出到控制台  
2.ds.printToErr() 直接输出到控制台,用红色  
3.ds.writeAsText(“本地/HDFS的path”,WriteMode.OVERWRITE).setParallelism(1)

注意:  
在输出到path的时候,可以在前面设置并行度,如果  
并行度>1,则path为目录  
并行度=1,则path为文件名

代码演示

package cn.itcast.sink;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    
    /** * Author itcast * Desc 演示DataStream-Sink-基于控制台和文件 */
    public class SinkDemo01 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> ds = env.readTextFile("data/input/words.txt");
    
            //TODO 2.transformation
            //TODO 3.sink
            ds.print();
            ds.print("输出标识");
            ds.printToErr();//会在控制台上以红色输出
            ds.printToErr("输出标识");//会在控制台上以红色输出
            ds.writeAsText("data/output/result1").setParallelism(1);
            ds.writeAsText("data/output/result2").setParallelism(2);
    
            //TODO 4.execute
            env.execute();
        }
    }

## 4.2 自定义Sink ##

### 4.2.1 MySQL ###

需求:  
将Flink集合中的数据通过自定义Sink保存到MySQL

代码实现:

package cn.itcast.sink;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.configuration.Configuration;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    
    /** * Author itcast * Desc 演示DataStream-Sink-自定义Sink */
    public class SinkDemo02 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<Student> studentDS = env.fromElements(new Student(null, "vvvv", 18));
            //TODO 2.transformation
            //TODO 3.sink
            studentDS.addSink(new MySQLSink());
    
            //TODO 4.execute
            env.execute();
        }
        @Data
        @NoArgsConstructor
        @AllArgsConstructor
        public static class Student { 
            private Integer id;
            private String name;
            private Integer age;
        }
    
        public static class MySQLSink extends RichSinkFunction<Student> { 
            private Connection conn = null;
            private PreparedStatement ps =null;
    
            @Override
            public void open(Configuration parameters) throws Exception { 
                conn = DriverManager.getConnection("jdbc:mysql://10.139.12.149:3306/book1", "root", "Test2016@");
                String sql = "INSERT INTO `t_student` (`id`, `name`, `age`) VALUES (null, ?, ?);";
                ps = conn.prepareStatement(sql);
            }
    
            @Override
            public void invoke(Student value, Context context) throws Exception { 
                //设置?占位符参数值
                ps.setString(1,value.getName());
                ps.setInt(2,value.getAge());
                //执行sql
                ps.executeUpdate();
            }
            @Override
            public void close() throws Exception { 
                if(conn != null) conn.close();
                if(ps != null) ps.close();
            }
        }
    }

## 5. Connectors(官方提供的第三方sink工具) ##

https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/connectors/  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 62]

pom依赖

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

### 5.1 JDBC(数据库) ###

https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/connectors/jdbc.html

package cn.itcast.connectors;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.connector.jdbc.JdbcConnectionOptions;
    import org.apache.flink.connector.jdbc.JdbcSink;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    
    /** * Author itcast * Desc 演示Flink官方提供的JdbcSink */
    public class JDBCDemo { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<Student> studentDS = env.fromElements(new Student(null, "tony2", 18));
            //TODO 2.transformation
            //TODO 3.sink
            studentDS.addSink(JdbcSink.sink(
                    "INSERT INTO `t_student` (`id`, `name`, `age`) VALUES (null, ?, ?)",
                    (ps, value) -> { 
                        ps.setString(1, value.getName());
                        ps.setInt(2, value.getAge());
                    }, new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
                            .withUrl("jdbc:mysql://10.139.12.149:3306/book1")
                            .withUsername("root")
                            .withPassword("Test2016@")
                            .withDriverName("com.mysql.jdbc.Driver")
                            .build()));
    
            //TODO 4.execute
            env.execute();
        }
    
        @Data
        @NoArgsConstructor
        @AllArgsConstructor
        public static class Student { 
            private Integer id;
            private String name;
            private Integer age;
        }
    
    }

## 5.2 Kafka ##

### 5.2.1 pom依赖 ###

Flink 里已经提供了一些绑定的 Connector，例如 kafka source 和 sink，Es sink 等。读写 kafka、es、rabbitMQ 时可以直接使用相应 connector 的 api 即可，虽然该部分是 Flink 项目源代码里的一部分，但是真正意义上不算作 Flink 引擎相关逻辑，并且该部分没有打包在二进制的发布包里面。所以在提交 Job 时候需要注意， job 代码 jar 包中一定要将相应的 connetor 相关类打包进去，否则在提交作业时就会失败，提示找不到相应的类，或初始化某些类异常。  
https://ci.apache.org/projects/flink/flink-docs-stable/dev/connectors/kafka.html

### 5.2.2 参数设置 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 63]

以下参数都必须/建议设置上  
1.订阅的主题  
2.反序列化规则  
3.消费者属性-集群地址  
4.消费者属性-消费者组id(如果不设置,会有默认的,但是默认的不方便管理)  
5.消费者属性-offset重置规则,如earliest/latest…  
6.动态分区检测(当kafka的分区数变化/增加时,Flink能够检测到!)  
7.如果没有设置Checkpoint,那么可以设置自动提交offset,后续学习了Checkpoint会把offset随着做Checkpoint的时候提交到Checkpoint和默认主题中

### 5.2.3 参数说明 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 64]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 65]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 66]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 67]  
实际的生产环境中可能有这样一些需求，比如：  
场景一：有一个 Flink 作业需要将五份数据聚合到一起，五份数据对应五个 kafka topic，随着业务增长，新增一类数据，同时新增了一个 kafka topic，如何在不重启作业的情况下作业自动感知新的 topic。  
场景二：作业从一个固定的 kafka topic 读数据，开始该 topic 有 10 个 partition，但随着业务的增长数据量变大，需要对 kafka partition 个数进行扩容，由 10 个扩容到 20。该情况下如何在不重启作业情况下动态感知新扩容的 partition？  
针对上面的两种场景，首先需要在构建 FlinkKafkaConsumer 时的 properties 中设置 flink.partition-discovery.interval-millis 参数为非负值，表示开启动态发现的开关，以及设置的时间间隔。此时 FlinkKafkaConsumer 内部会启动一个单独的线程定期去 kafka 获取最新的 meta 信息。  
针对场景一，还需在构建 FlinkKafkaConsumer 时，topic 的描述可以传一个正则表达式描述的 pattern。每次获取最新 kafka meta 时获取正则匹配的最新 topic 列表。  
针对场景二，设置前面的动态发现参数，在定期获取 kafka 最新 meta 信息时会匹配新的 partition。为了保证数据的正确性，新发现的 partition 从最早的位置开始读取。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 68]  
注意:  
开启 checkpoint 时 offset 是 Flink 通过状态 state 管理和恢复的，并不是从 kafka 的 offset 位置恢复。在 checkpoint 机制下，作业从最近一次checkpoint 恢复，本身是会回放部分历史数据，导致部分数据重复消费，Flink 引擎仅保证计算状态的精准一次，要想做到端到端精准一次需要依赖一些幂等的存储系统或者事务操作。

5.2.5 代码实现-Kafka Consumer(Flink source)  
props.setProperty(“flink.partition-discovery.interval-millis”,“5000”);//会开启一个后台线程每隔5s检测一下Kafka的分区情况,实现动态分区检测

package cn.itcast.connectors;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.serialization.SimpleStringSchema;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
    
    import java.util.Properties;
    
    /** * Author itcast * Desc 演示Flink-Connectors-KafkaComsumer/Source */
    public class KafkaComsumerDemo { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            //准备kafka连接参数
            Properties props  = new Properties();
            props.setProperty("bootstrap.servers", "kafka1:6667,kafka2:6667,kafka3:6667");//集群地址
            props.setProperty("group.id", "flink");//消费者组id
            props.setProperty("auto.offset.reset","latest");//latest有offset记录从记录位置开始消费,没有记录从最新的/最后的消息开始消费 /earliest有offset记录从记录位置开始消费,没有记录从最早的/最开始的消息开始消费
            props.setProperty("flink.partition-discovery.interval-millis","5000");//会开启一个后台线程每隔5s检测一下Kafka的分区情况,实现动态分区检测
            props.setProperty("enable.auto.commit", "true");//自动提交(提交到默认主题,后续学习了Checkpoint后随着Checkpoint存储在Checkpoint和默认主题中)
            props.setProperty("auto.commit.interval.ms", "2000");//自动提交的时间间隔
            //使用连接参数创建FlinkKafkaConsumer/kafkaSource
            FlinkKafkaConsumer<String> kafkaSource = new FlinkKafkaConsumer<String>("topic0223-3", new SimpleStringSchema(), props);
            //使用kafkaSource
            DataStream<String> kafkaDS = env.addSource(kafkaSource);
    
            //TODO 2.transformation
    
            //TODO 3.sink
            kafkaDS.print();
    
            //TODO 4.execute
            env.execute();
        }
    }
    //准备主题 /export/server/kafka/bin/kafka-topics.sh --create --zookeeper node1:2181 --replication-factor 2 --partitions 3 --topic flink_kafka
    //启动控制台生产者发送数据 /export/server/kafka/bin/kafka-console-producer.sh --broker-list node1:9092 --topic flink_kafka
    //启动程序FlinkKafkaConsumer
    //观察控制台输出结果

### 5.2.6 代码实现-Kafka Producer(flink sink) ###

package cn.itcast.connectors;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FilterFunction;
    import org.apache.flink.api.common.serialization.SimpleStringSchema;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
    import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;
    
    import java.util.Properties;
    
    /** * Author itcast * Desc 演示Flink-Connectors-KafkaComsumer/Source + KafkaProducer/Sink */
    public class KafkaSinkDemo { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            //准备kafka连接参数
            Properties props  = new Properties();
            props.setProperty("bootstrap.servers", "kafka1:6667,kafka2:6667,kafka3:6667");//集群地址
            props.setProperty("group.id", "flink");//消费者组id
            props.setProperty("auto.offset.reset","latest");//latest有offset记录从记录位置开始消费,没有记录从最新的/最后的消息开始消费 /earliest有offset记录从记录位置开始消费,没有记录从最早的/最开始的消息开始消费
            props.setProperty("flink.partition-discovery.interval-millis","5000");//会开启一个后台线程每隔5s检测一下Kafka的分区情况,实现动态分区检测
            props.setProperty("enable.auto.commit", "true");//自动提交(提交到默认主题,后续学习了Checkpoint后随着Checkpoint存储在Checkpoint和默认主题中)
            props.setProperty("auto.commit.interval.ms", "2000");//自动提交的时间间隔
            //使用连接参数创建FlinkKafkaConsumer/kafkaSource
            FlinkKafkaConsumer<String> kafkaSource = new FlinkKafkaConsumer<String>("topic0223-3", new SimpleStringSchema(), props);
            //使用kafkaSource
            DataStream<String> kafkaDS = env.addSource(kafkaSource);
    
            //TODO 2.transformation
    /* SingleOutputStreamOperator<String> etlDS = kafkaDS.filter(new FilterFunction<String>() { @Override public boolean filter(String value) throws Exception { return value.contains("success"); } }); //TODO 3.sink etlDS.print();*/
    
            Properties props2 = new Properties();
            props2.setProperty("bootstrap.servers", "kafka1:6667,kafka2:6667,kafka3:6667");
            FlinkKafkaProducer<String> kafkaSink = new FlinkKafkaProducer<>("flinkreadkafka", new SimpleStringSchema(), props2);
            kafkaDS.addSink(kafkaSink);
            kafkaDS.print();
            //TODO 4.execute
            env.execute();
        }
    }
    //控制台生成者 ---> flink_kafka主题 --> Flink -->etl ---> flink_kafka2主题--->控制台消费者
    //准备主题 /export/server/kafka/bin/kafka-topics.sh --create --zookeeper node1:2181 --replication-factor 2 --partitions 3 --topic flink_kafka
    //准备主题 /export/server/kafka/bin/kafka-topics.sh --create --zookeeper node1:2181 --replication-factor 2 --partitions 3 --topic flink_kafka2
    //启动控制台生产者发送数据 /export/server/kafka/bin/kafka-console-producer.sh --broker-list node1:9092 --topic flink_kafka
    //log:2020-10-10 success xxx
    //log:2020-10-10 success xxx
    //log:2020-10-10 success xxx
    //log:2020-10-10 fail xxx
    //启动控制台消费者消费数据 /export/server/kafka/bin/kafka-console-consumer.sh --bootstrap-server node1:9092 --topic flink_kafka2 --from-beginning
    //启动程序FlinkKafkaConsumer
    //观察控制台输出结果

## 5.3 Redis ##

API  
通过flink 操作redis 其实我们可以通过传统的redis 连接池Jpoools 进行redis 的相关操作，但是flink 提供了专门操作redis 的RedisSink，使用起来更方便，而且不用我们考虑性能的问题，接下来将主要介绍RedisSink 如何使用。  
https://bahir.apache.org/docs/flink/current/flink-streaming-redis/

RedisSink 核心类是RedisMapper 是一个接口，使用时我们要编写自己的redis 操作类实现这个接口中的三个方法，如下所示  
1.getCommandDescription() ：  
设置使用的redis 数据结构类型，和key 的名称，通过RedisCommand 设置数据结构类型  
2.String getKeyFromData(T data)：  
设置value 中的键值对key的值  
3.String getValueFromData(T data);  
设置value 中的键值对value的值

使用RedisCommand设置数据结构类型时和redis结构对应关系  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 69]

package cn.itcast.connectors;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.connectors.redis.RedisSink;
    import org.apache.flink.streaming.connectors.redis.common.config.FlinkJedisPoolConfig;
    import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommand;
    import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommandDescription;
    import org.apache.flink.streaming.connectors.redis.common.mapper.RedisMapper;
    import org.apache.flink.util.Collector;
    
    /** * Author itcast * Desc 演示Flink-Connectors-三方提供的RedisSink */
    public class RedisDemo { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> lines = env.socketTextStream("node1", 9999);
    
            //TODO 2.transformation
            SingleOutputStreamOperator<Tuple2<String, Integer>> result = lines.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception { 
                    String[] arr = value.split(" ");
                    for (String word : arr) { 
                        out.collect(Tuple2.of(word, 1));
                    }
                }
            }).keyBy(t -> t.f0).sum(1);
    
    
            //TODO 3.sink
            result.print();
    
            FlinkJedisPoolConfig conf = new FlinkJedisPoolConfig.Builder().setHost("127.0.0.1").build();
            RedisSink<Tuple2<String, Integer>> redisSink = new RedisSink<Tuple2<String, Integer>>(conf,new MyRedisMapper());
            result.addSink(redisSink);
    
            //TODO 4.execute
            env.execute();
        }
        public static class MyRedisMapper implements RedisMapper<Tuple2<String, Integer>>{ 
            @Override
            public RedisCommandDescription getCommandDescription() { 
                //我们选择的数据结构对应的是 key:String("wcresult"),value:Hash(单词,数量),命令为HSET
                return new RedisCommandDescription(RedisCommand.HSET,"wcresult");
            }
    
            @Override
            public String getKeyFromData(Tuple2<String, Integer> t) { 
                return  t.f0;
            }
    
            @Override
            public String getValueFromData(Tuple2<String, Integer> t) { 
                return t.f1.toString();
            }
        }
    }

# 5.Flink-高级API #

课程目标  
掌握Window操作  
掌握EventTime和Watermaker的使用  
掌握State管理  
掌握Checkpoint容错机制

## 1. Flink四大基石 ##

Flink之所以能这么流行，离不开它最重要的四个基石：Checkpoint、State、Time、Window。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 70]  
Checkpoint  
这是Flink最重要的一个特性。  
Flink基于Chandy-Lamport算法实现了一个分布式的一致性的快照，从而提供了一致性的语义。  
Chandy-Lamport算法实际上在1985年的时候已经被提出来，但并没有被很广泛的应用，而Flink则把这个算法发扬光大了。  
Spark最近在实现Continue streaming，Continue streaming的目的是为了降低处理的延时，其也需要提供这种一致性的语义，最终也采用了Chandy-Lamport这个算法，说明Chandy-Lamport算法在业界得到了一定的肯定。  
https://zhuanlan.zhihu.com/p/53482103  
State  
提供了一致性的语义之后，Flink为了让用户在编程时能够更轻松、更容易地去管理状态，还提供了一套非常简单明了的State API，包括ValueState、ListState、MapState，BroadcastState。  
Time  
除此之外，Flink还实现了Watermark的机制，能够支持基于事件的时间的处理，能够容忍迟到/乱序的数据。  
Window  
另外流计算中一般在对流数据进行操作之前都会先进行开窗，即基于一个什么样的窗口上做这个计算。Flink提供了开箱即用的各种窗口，比如滑动窗口、滚动窗口、会话窗口以及非常灵活的自定义的窗口。

## 2. Flink-Window操作 ##

### 2.1 为什么需要Window ###

在流处理应用中，数据是连续不断的，有时我们需要做一些聚合类的处理，例如：在过去的1分钟内有多少用户点击了我们的网页。  
在这种情况下，我们必须定义一个窗口(window)，用来收集最近1分钟内的数据，并对这个窗口内的数据进行计算。

## 2.2 Window的分类 ##

**主要分为按时间滑动和按数量滑动**

*  基于时间的滑动窗口(掌握)
 *  基于时间的滚动窗口(掌握)
 *  基于数量的滑动窗口(了解)
 *  基于数量的滚动窗口(了解)  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 71]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 72]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 73]

### 2.2.1 按照time和count分类 ###

time-window:时间窗口:根据时间划分窗口,如:每xx分钟统计最近xx分钟的数据  
count-window:数量窗口:根据数量划分窗口,如:每xx个数据统计最近xx个数据

![在这里插入图片描述][20210313172349904.png]

#### 2.2.2 按照slide和size分类 ####

窗口有两个重要的属性: 窗口大小size和滑动间隔slide,根据它们的大小关系可分为:  
tumbling-window:滚动窗口:size=slide,如:每隔10s统计最近10s的数据  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 74]  
sliding-window:滑动窗口:size>slide,如:每隔5s统计最近10s的数据  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 75]  
注意:当size<slide的时候,如每隔15s统计最近10s的数据,那么中间5s的数据会丢失,所有开发中不用

#### 2.2.3 总结 ####

按照上面窗口的分类方式进行组合,可以得出如下的窗口:  
1.基于时间的滚动窗口tumbling-time-window–用的较多 (每5秒钟统计一次，最近5秒钟内,没有重复)  
2.基于时间的滑动窗口sliding-time-window–用的较多(每5秒钟统计一次，最近10秒钟内,有重复)  
3.基于数量的滚动窗口tumbling-count-window–用的较少  
4.基于数量的滑动窗口sliding-count-window–用的较少  
注意:Flink还支持一个特殊的窗口:Session会话窗口,需要设置一个会话超时时间,如30s,则表示30s内没有数据到来,则触发上个窗口的计算

### 2.3 Window的API ###

#### 2.3.1 window和windowAll ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 76]

使用keyby的流,应该使用window方法  
未使用keyby的流,应该调用windowAll方法

#### 2.3.2 WindowAssigner ####

window/windowAll 方法接收的输入是一个 WindowAssigner， WindowAssigner 负责将每条输入的数据分发到正确的 window 中，  
Flink提供了很多各种场景用的WindowAssigner：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 77]  
如果需要自己定制数据分发策略，则可以实现一个 class，继承自 WindowAssigner。

#### 2.3.3 evictor–了解 ####

evictor 主要用于做一些数据的自定义操作，可以在执行用户代码之前，也可以在执行  
用户代码之后，更详细的描述可以参考org.apache.flink.streaming.api.windowing.evictors.Evictor 的 evicBefore 和 evicAfter两个方法。  
Flink 提供了如下三种通用的 evictor：

*  CountEvictor 保留指定数量的元素
 *  TimeEvictor 设定一个阈值 interval，删除所有不再 max\_ts - interval 范围内的元  
    素，其中 max\_ts 是窗口内时间戳的最大值。
 *  DeltaEvictor 通过执行用户给定的 DeltaFunction 以及预设的 theshold，判断是否删  
    除一个元素。

#### 2.3.4 trigger–了解 ####

trigger 用来判断一个窗口是否需要被触发，每个 WindowAssigner 都自带一个默认的trigger，  
如果默认的 trigger 不能满足你的需求，则可以自定义一个类，继承自Trigger 即可，我们详细描述下 Trigger 的接口以及含义：

*  onElement() 每次往 window 增加一个元素的时候都会触发
 *  onEventTime() 当 event-time timer 被触发的时候会调用
 *  onProcessingTime() 当 processing-time timer 被触发的时候会调用
 *  onMerge() 对两个 \`rigger 的 state 进行 merge 操作
 *  clear() window 销毁的时候被调用  
    上面的接口中前三个会返回一个 TriggerResult， TriggerResult 有如下几种可能的选  
    择：
 *  CONTINUE 不做任何事情
 *  FIRE 触发 window
 *  PURGE 清空整个 window 的元素并销毁窗口
 *  FIRE\_AND\_PURGE 触发窗口，然后销毁窗口
 *

#### 2.3.5 API调用示例 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 78]

source.keyBy(0).window(TumblingProcessingTimeWindows.of(Time.seconds(5)));
    或
    source.keyBy(0)..timeWindow(Time.seconds(5))

### 2.4 案例演示-基于时间的滚动和滑动窗口 ###

#### 2.4.1 需求 ####

nc -lk 9999  
有如下数据表示:  
信号灯编号和通过该信号灯的车的数量  
9,3  
9,2  
9,7  
4,9  
2,6  
1,5  
2,3  
5,7  
5,4  
需求1:每5秒钟统计一次，最近5秒钟内，各个路口通过红绿灯汽车的数量–基于时间的滚动窗口  
需求2:每5秒钟统计一次，最近10秒钟内，各个路口通过红绿灯汽车的数量–基于时间的滑动窗口

package cn.itcast.window;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.streaming.api.datastream.DataStream;
    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.streaming.api.windowing.assigners.SlidingProcessingTimeWindows;
    import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
    import org.apache.flink.streaming.api.windowing.time.Time;
    
    /** * Author itcast * Desc 演示基于时间的滚动和滑动窗口 */
    public class WindowDemo_1_2 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> lines = env.socketTextStream("localhost", 9999);
            //TODO 2.transformation
            SingleOutputStreamOperator<CartInfo> carDS = lines.map(new MapFunction<String, CartInfo>() { 
                @Override
                public CartInfo map(String value) throws Exception { 
                    String[] arr = value.split(",");
                    return new CartInfo(arr[0], Integer.parseInt(arr[1]));
                }
            });
    
            //注意: 需求中要求的是各个路口/红绿灯的结果,所以需要先分组
            //carDS.keyBy(car->car.getSensorId())
            KeyedStream<CartInfo, String> keyedDS = carDS.keyBy(CartInfo::getSensorId);
                    // * 需求1:每5秒钟统计一次，最近10秒钟内，各个路口通过红绿灯汽车的数量--基于时间的滑动窗口
            SingleOutputStreamOperator<CartInfo> result1 = keyedDS
                    //of(Time size, Time slide)
                    .window(SlidingProcessingTimeWindows.of(Time.seconds(10),Time.seconds(5)))
                    .sum("count");
            // * 需求2:每5秒钟统计一次，最近5秒钟内，各个路口通过红绿灯汽车的数量--基于时间的滚动窗口
            //keyedDS.timeWindow(Time.seconds(5))
            SingleOutputStreamOperator<CartInfo> result2 = keyedDS
                    .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
                    .sum("count");
            //TODO 3.sink
            //result1.print();
            result2.print();
    
            //TODO 4.execute
            env.execute();
        }
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        public static class CartInfo { 
            private String sensorId;//信号灯id
            private Integer count;//通过该信号灯的车的数量
        }
    }

窗口触发的条件是有时间到了并且数据和，不会出现统计为0，没有数据入数，统计的就是最后一次触发10s内的数据  
![在这里插入图片描述][20210313174931290.png]

### 2.5 案例演示-基于数量的滚动和滑动窗口（了解） ###

### 2.5.1 需求 ###

需求1:统计在最近5条消息中,各自路口通过的汽车数量,相同的key每出现5次进行统计–基于数量的滚动窗口  
需求2:统计在最近5条消息中,各自路口通过的汽车数量,相同的key每出现3次进行统计–基于数量的滑动窗口

package cn.itcast.window;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.KeyedStream;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    
    /** * Author itcast * Desc 演示基于数量的滚动和滑动窗口 */
    public class WindowDemo_3_4 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> lines = env.socketTextStream("node1", 9999);
    
            //TODO 2.transformation
            SingleOutputStreamOperator<CartInfo> carDS = lines.map(new MapFunction<String, CartInfo>() { 
                @Override
                public CartInfo map(String value) throws Exception { 
                    String[] arr = value.split(",");
                    return new CartInfo(arr[0], Integer.parseInt(arr[1]));
                }
            });
    
            //注意: 需求中要求的是各个路口/红绿灯的结果,所以需要先分组
            //carDS.keyBy(car->car.getSensorId())
            KeyedStream<CartInfo, String> keyedDS = carDS.keyBy(CartInfo::getSensorId);
    
            // * 需求1:统计在最近5条消息中,各自路口通过的汽车数量,相同的key每出现5次进行统计--基于数量的滚动窗口
            SingleOutputStreamOperator<CartInfo> result1 = keyedDS
                    .countWindow(5)
                    .sum("count");
            // * 需求2:统计在最近5条消息中,各自路口通过的汽车数量,相同的key每出现3次进行统计--基于数量的滑动窗口
            SingleOutputStreamOperator<CartInfo> result2 = keyedDS
                    .countWindow(5,3)
                    .sum("count");
    
            //TODO 3.sink
            //result1.print();
            /* 1,1 1,1 1,1 1,1 2,1 1,1 */
            result2.print();
            /* 1,1 1,1 2,1 1,1 2,1 3,1 4,1 */
    
            //TODO 4.execute
            env.execute();
        }
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        public static class CartInfo { 
            private String sensorId;//信号灯id
            private Integer count;//通过该信号灯的车的数量
        }
    }

### 2.6 案例演示-会话(session)窗口 ###

#### 2.6.1 需求 ####

设置会话超时时间为10s,10s内没有数据到来,则触发上个窗口的计算

package cn.itcast.window;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.streaming.api.datastream.DataStream;
    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.streaming.api.windowing.assigners.ProcessingTimeSessionWindows;
    import org.apache.flink.streaming.api.windowing.time.Time;
    
    /** * Author itcast * Desc 演示会话窗口 */
    public class WindowDemo_5 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStream<String> lines = env.socketTextStream("127.0.0.1", 9999);
    
            //TODO 2.transformation
            SingleOutputStreamOperator<CartInfo> carDS = lines.map(new MapFunction<String, CartInfo>() { 
                @Override
                public CartInfo map(String value) throws Exception { 
                    String[] arr = value.split(",");
                    return new CartInfo(arr[0], Integer.parseInt(arr[1]));
                }
            });
    
            //注意: 需求中要求的是各个路口/红绿灯的结果,所以需要先分组
            //carDS.keyBy(car->car.getSensorId())
            KeyedStream<CartInfo, String> keyedDS = carDS.keyBy(CartInfo::getSensorId);
    
            //需求:设置会话超时时间为10s,10s内没有数据到来,则触发上个窗口的计算(前提是上一个窗口得有数据!)
            SingleOutputStreamOperator<CartInfo> result = keyedDS.window(ProcessingTimeSessionWindows.withGap(Time.seconds(10)))
                    .sum("count");
    
            //TODO 3.sink
            result.print();
            /* 1,1 1,1 2,1 2,1 */
    
            //TODO 4.execute
            env.execute();
        }
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        public static class CartInfo { 
            private String sensorId;//信号灯id
            private Integer count;//通过该信号灯的车的数量
        }
    }

## 3. Flink-Time与Watermaker ##

### 3.1 Time分类 ###

在Flink的流式处理中，会涉及到时间的不同概念，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 79]  
事件时间EventTime: 事件真真正正发生产生的时间  
摄入时间IngestionTime: 事件到达Flink的时间  
处理时间ProcessingTime: 事件真正被处理/计算的时间

问题: 上面的三个时间,我们更关注哪一个?  
答案: 更关注事件时间 !  
因为: 事件时间更能反映事件的本质! 只要事件时间一产生就不会变化

### 3.2 EventTime的重要性 ###

3.2.1 示例1  
假设，你正在去往地下停车场的路上，并且打算用手机点一份外卖。选好了外卖后，你就用在线支付功能付款了，这个时候是11点59分。恰好这时，你走进了地下停车库，而这里并没有手机信号。因此外卖的在线支付并没有立刻成功，而支付系统一直在Retry重试“支付”这个操作。  
当你找到自己的车并且开出地下停车场的时候，已经是12点01分了。这个时候手机重新有了信号，手机上的支付数据成功发到了外卖在线支付系统，支付完成。

在上面这个场景中你可以看到，  
支付数据的事件时间是11点59分，而支付数据的处理时间是12点01分

问题:  
如果要统计12之前的订单金额,那么这笔交易是否应被统计?  
答案:  
应该被统计,因为该数据的真真正正的产生时间为11点59分,即该数据的事件时间为11点59分,  
事件时间能够真正反映/代表事件的本质! 所以一般在实际开发中会以事件时间作为计算标准

3.2.2 示例2  
一条错误日志的内容为：  
2020-11:11 22:59:00 error NullPointExcep --事件时间  
进入Flink的时间为2020-11:11 23:00:00 --摄入时间  
到达Window的时间为2020-11:11 23:00:10 --处理时间  
问题:  
对于业务来说，要统计1h内的故障日志个数，哪个时间是最有意义的？  
答案:  
EventTime事件时间，因为bug真真正正产生的时间就是事件时间,只有事件时间才能真正反映/代表事件的本质!

3.2.3 示例3  
某 App 会记录用户的所有点击行为，并回传日志（在网络不好的情况下，先保存在本地，延后回传）。  
A用户在 11:01:00 对 App 进行操作，B用户在 11:02:00 操作了 App，  
但是A用户的网络不太稳定，回传日志延迟了，导致我们在服务端先接受到B用户的消息，然后再接受到A用户的消息，消息乱序了。  
问题:  
如果这个是一个根据用户操作先后顺序,进行抢购的业务,那么是A用户成功还是B用户成功?  
答案:  
应该算A成功,因为A确实比B操作的早,但是实际中考虑到实现难度,可能直接按B成功算  
也就是说，实际开发中希望基于事件时间来处理数据，但因为数据可能因为网络延迟等原因，出现了乱序，按照事件时间处理起来有难度！

3.2.4 示例4  
在实际环境中，经常会出现，因为网络原因，数据有可能会延迟一会才到达Flink实时处理系统。我们先来设想一下下面这个场景:  
原本应该被该窗口计算的数据因为网络延迟等原因晚到了,就有可能丢失了

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 80]  
3.2.5 总结  
实际开发中我们希望基于事件时间来处理数据，但因为数据可能因为网络延迟等原因，出现了乱序或延迟到达，那么可能处理的结果不是我们想要的甚至出现数据丢失的情况，所以需要一种机制来**解决一定程度上的数据乱序或延迟到底的问题**！也就是我们接下来要学习 的Watermaker水印机制/水位线机制

### 3.3 Watermaker水印机制/水位线机制 ###

**水位线机制解决一定程度上(事件时间和处理时间间隔不能太大)的数据乱序或延迟到底的问题, 事件时间和处理时间间隔太大解决代价太大**

**触达条件：当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间 >= 窗口的结束时间。**  
**主题思想就是以事件时为基准，本次窗口计算等一下来的晚的再计算，来的太晚的就不等了，数据就丢掉了。**

3.3.1 什么是Watermaker？  
Watermaker就是给数据再**额外**的加的一个时间列，  
及Watermaker就是个时间戳!

3.3.2 如何计算Watermaker？  
Watermaker = 数据的事件时间 - 最大允许的延迟时间或乱序时间  
注意:后面通过源码会发现,准确来说:  
Watermaker = 当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间  
这样可以保证Watermaker水位线会一直上升(变大),不会下降

3.3.3 Watermaker有什么用？  
之前的窗口都是按照系统时间来触发计算的,如: \[10:00:00 ~ 10:00:10) 的窗口，  
一但系统时间到了10:00:10就会触发计算,那么可能会导致延迟到达的数据丢失!  
那么现在有了Watermaker,窗口就可以按照Watermaker来触发计算!  
**也就是说Watermaker是用来触发窗口计算的！及改变窗口触发的时机来解决数据一定程度的延迟或者乱序问题。  
通过改变窗口触发的时机来来解决数据一定程度的延迟或者乱序问题。**

3.3.4 Watermaker如何触发窗口计算的？  
窗口计算的触发条件为: 当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间 >= 窗口的结束时间  
1.窗口中有数据  
2.Watermaker >= 窗口的结束时间

因为前面说到  
Watermaker = 当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间  
也就是说只要不断有数据来,就可以保证Watermaker水位线是会一直上升/变大的,不会下降/减小的  
所以最终一定是会触发窗口计算的

注意:  
上面的触发公式进行如下变形:  
Watermaker >= 窗口的结束时间  
Watermaker = 当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间  
当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间 >= 窗口的结束时间  
当前窗口的最大的事件时间 >= 窗口的结束时间 + 最大允许的延迟时间或乱序时间

3.3.5 图解Watermaker

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 81]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 82]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 83]

就是本来窗口触发的时间是endtime(10:10:00)，有了watemaker机制后，触发时间可能会延迟。  
触达条件：当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间 >= 窗口的结束时间。  
**主题思想就是本次窗口计算等一下来的晚的再计算，来的太晚的就不等了，数据就丢掉了。**

### 3.4 Watermaker案例演示 ###

3.4.1 需求  
有订单数据,格式为: (订单ID，用户ID，时间戳/事件时间，订单金额)  
要求每隔5s,计算5秒内，每个用户的订单总金额  
并添加Watermaker来解决一定程度上的数据延迟和数据乱序问题。  
3.4.2 API  
https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/event\_timestamps\_watermarks.html  
![在这里插入图片描述][20210314154911436.png]  
注意:一般我们都是直接使用Flink提供好的BoundedOutOfOrdernessTimestampExtractor

3.4.3 代码实现-1-开发版-掌握  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 84]

package cn.itcast.watermaker;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.eventtime.WatermarkStrategy;
    import org.apache.flink.streaming.api.datastream.DataStreamSource;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.source.SourceFunction;
    import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
    import org.apache.flink.streaming.api.windowing.time.Time;
    
    import java.time.Duration;
    import java.util.Random;
    import java.util.UUID;
    
    /** * Author itcast * Desc 演示基于事件时间的窗口计算+Watermaker解决一定程度上的数据乱序/延迟到达的问题 */
    public class WatermakerDemo01 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStreamSource<Order> orderDS = env.addSource(new SourceFunction<Order>() { 
                private boolean flag = true;
    
                @Override
                public void run(SourceContext<Order> ctx) throws Exception { 
                    Random random = new Random();
                    while (flag) { 
                        String orderId = UUID.randomUUID().toString();
                        int userId = random.nextInt(2);
                        int money = random.nextInt(101);
                        //随机模拟延迟
                        long eventTime = System.currentTimeMillis() - random.nextInt(5) * 1000;
                        ctx.collect(new Order(orderId, userId, money, eventTime));
                        Thread.sleep(1000);
                    }
                }
    
                @Override
                public void cancel() { 
                    flag = false;
                }
            });
    
            //TODO 2.transformation
            //老版本API
            /*DataStream<Order> watermakerDS = orderDS.assignTimestampsAndWatermarks( new BoundedOutOfOrdernessTimestampExtractor<Order>(Time.seconds(3)) {//最大允许的延迟时间或乱序时间 @Override public long extractTimestamp(Order element) { return element.eventTime; //指定事件时间是哪一列,Flink底层会自动计算: //Watermaker = 当前最大的事件时间 - 最大允许的延迟时间或乱序时间 } });*/
            //注意:下面的代码使用的是Flink1.12中新的API
            //每隔5s计算最近5s的数据求每个用户的订单总金额,要求:基于事件时间进行窗口计算+Watermaker
            //env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);//在新版本中默认就是EventTime
            //设置Watermarker = 当前最大的事件时间 - 最大允许的延迟时间或乱序时间
            SingleOutputStreamOperator<Order> orderDSWithWatermark = orderDS.assignTimestampsAndWatermarks(
                    WatermarkStrategy.<Order>forBoundedOutOfOrderness(Duration.ofSeconds(3))//指定maxOutOfOrderness最大无序度(最大允许的延迟时间/乱序时间)
                            .withTimestampAssigner((order, timestamp) -> order.getEventTime())//指定事件时间列
            );
    
            SingleOutputStreamOperator<Order> result = orderDSWithWatermark.keyBy(Order::getUserId)
                    .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                    .sum("money");
    
            //TODO 3.sink
            result.print();
    
            //TODO 4.execute
            env.execute();
        }
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        public static class Order { 
            private String orderId;
            private Integer userId;
            private Integer money;
            private Long eventTime;
        }
    }

### 3.5 Allowed Lateness案例演示 ###

什么算丢数据：事件到达后，发现计算自己事件时间的窗口已经计算过关闭了。

\*\*watermaker只能一定程度上解决数据乱序或延迟到底的问题，因为允许延迟时间不宜设的太大，但是如果数据迟到时间太长又会造成丢数据(事件到达后，发现计算自己事件时间的窗口已经计算过关闭了)。  
Allowed Lateness就是来解决迟到时间太长又会造成丢数据的问题。  
Allowed Lateness单独收集延迟太久的数据，及开启watermaker后仍然丢的数据。  
\*\*

3.5.1 需求  
有订单数据,格式为: (订单ID，用户ID，时间戳/事件时间，订单金额)  
要求每隔5s,计算5秒内，每个用户的订单总金额  
并添加Watermaker来解决一定程度上的数据延迟和数据乱序问题。  
并使用OutputTag+allowedLateness解决数据丢失问题

**收集的迟到严重的数据，自己仔写业务处理（一天处理一次或一月处理一次）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 85]

package cn.itcast.watermaker;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.eventtime.WatermarkStrategy;
    import org.apache.flink.api.common.typeinfo.TypeInformation;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.DataStreamSource;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.source.SourceFunction;
    import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
    import org.apache.flink.streaming.api.windowing.time.Time;
    import org.apache.flink.util.OutputTag;
    
    import java.time.Duration;
    import java.util.Random;
    import java.util.UUID;
    
    /** * Author itcast * Desc 演示基于事件时间的窗口计算+Watermaker解决一定程度上的数据乱序/延迟到达的问题 * 并使用outputTag + allowedLateness来解决数据丢失问题(解决迟到/延迟严重的数据的丢失问题) */
    public class WatermakerDemo03 { 
        public static void main(String[] args) throws Exception { 
            //TODO 0.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO 1.source
            DataStreamSource<Order> orderDS = env.addSource(new SourceFunction<Order>() { 
                private boolean flag = true;
    
                @Override
                public void run(SourceContext<Order> ctx) throws Exception { 
                    Random random = new Random();
                    while (flag) { 
                        String orderId = UUID.randomUUID().toString();
                        int userId = random.nextInt(2);
                        int money = random.nextInt(101);
                        //随机模拟延迟-有可能会很严重
                        long eventTime = System.currentTimeMillis() - random.nextInt(20) * 1000;
                        ctx.collect(new Order(orderId, userId, money, eventTime));
                        Thread.sleep(1000);
                    }
                }
    
                @Override
                public void cancel() { 
                    flag = false;
                }
            });
    
            //TODO 2.transformation
            //注意:下面的代码使用的是Flink1.12中新的API
            //每隔5s计算最近5s的数据求每个用户的订单总金额,要求:基于事件时间进行窗口计算+Watermaker
            //env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);//在新版本中默认就是EventTime
            //设置Watermarker = 当前最大的事件时间 - 最大允许的延迟时间或乱序时间
            SingleOutputStreamOperator<Order> orderDSWithWatermark = orderDS.assignTimestampsAndWatermarks(
                    WatermarkStrategy.<Order>forBoundedOutOfOrderness(Duration.ofSeconds(3))//指定maxOutOfOrderness最大无序度/最大允许的延迟时间/乱序时间
                            .withTimestampAssigner((order, timestamp) -> order.getEventTime())//指定事件时间列
            );
    
            //业务操作
            //TODO 准备一个outputTag用来存放迟到严重的数据
            OutputTag<Order> seriousLateOutputTag = new OutputTag<Order>("seriousLate", TypeInformation.of(Order.class));
    
            SingleOutputStreamOperator<Order> result1 = orderDSWithWatermark
                    .keyBy(Order::getUserId)
                    .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                    .allowedLateness(Time.seconds(3))
                    .sideOutputLateData(seriousLateOutputTag)
                    .sum("money");
            DataStream<Order> result2 = result1.getSideOutput(seriousLateOutputTag);
    
            //TODO 3.sink
            result1.print("正常的/迟到不严重数据");
            result2.print("迟到严重的数据并丢弃后单独收集的数据");
    
            //TODO 4.execute
            env.execute();
        }
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        public static class Order { 
            private String orderId;
            private Integer userId;
            private Integer money;
            private Long eventTime;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 86]

## 4. Flink-状态管理 State ##

之前写的Flink代码中其实已经做好了状态自动管理,如

发送hello ,得出(hello,1)

再发送hello ,得出(hello,2)

说明Flink已经自动的将当前数据和历史状态/历史结果进行了聚合,做到了状态的自动管理

在实际开发中绝大多数情况下,我们直接使用自动管理即可

一些特殊情况才会使用手动的状态管理!

### 4.1 Flink中的有状态计算 ###

注意:  
Flink中已经对需要进行有状态计算的API,做了封装,底层已经维护好了状态!  
例如,之前下面代码,直接使用即可,不需要像SparkStreaming那样还得自己写updateStateByKey  
也就是说我们今天学习的State只需要掌握原理,实际开发中一般都是使用Flink底层维护好的状态或第三方维护好的状态(如Flink整合Kafka的offset维护底层就是使用的State,但是人家已经写好了的)

package cn.itcast.source;
    
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.KeyedStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.util.Collector;
    
    /** * Author itcast * Desc * SocketSource */
    public class SourceDemo03 { 
        public static void main(String[] args) throws Exception { 
            //1.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
            //2.source
            DataStream<String> linesDS = env.socketTextStream("node1", 9999);
    
            //3.处理数据-transformation
            //3.1每一行数据按照空格切分成一个个的单词组成一个集合
            DataStream<String> wordsDS = linesDS.flatMap(new FlatMapFunction<String, String>() { 
                @Override
                public void flatMap(String value, Collector<String> out) throws Exception { 
                    //value就是一行行的数据
                    String[] words = value.split(" ");
                    for (String word : words) { 
                        out.collect(word);//将切割处理的一个个的单词收集起来并返回
                    }
                }
            });
            //3.2对集合中的每个单词记为1
            DataStream<Tuple2<String, Integer>> wordAndOnesDS = wordsDS.map(new MapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public Tuple2<String, Integer> map(String value) throws Exception { 
                    //value就是进来一个个的单词
                    return Tuple2.of(value, 1);
                }
            });
    
            //3.3对数据按照单词(key)进行分组
            //KeyedStream<Tuple2<String, Integer>, Tuple> groupedDS = wordAndOnesDS.keyBy(0);
            KeyedStream<Tuple2<String, Integer>, String> groupedDS = wordAndOnesDS.keyBy(t -> t.f0);
            //3.4对各个组内的数据按照数量(value)进行聚合就是求sum
            DataStream<Tuple2<String, Integer>> result = groupedDS.sum(1);
    
            //4.输出结果-sink
            result.print();
    
            //5.触发执行-execute
            env.execute();
        }
    }

执行 netcat，然后在终端输入 hello world，执行程序会输出什么?  
答案很明显，(hello, 1)和 (word,1)  
那么问题来了，如果再次在终端输入 hello world，程序会输入什么?  
答案其实也很明显，(hello, 2)和(world, 2)。  
为什么 Flink 知道之前已经处理过一次 hello world，这就是 state 发挥作用了，这里是被称为 keyed state 存储了之前需要统计的数据，所以 Flink 知道 hello 和 world 分别出现过一次。

### 4.2 无状态计算和有状态计算 ###

#### 4.2.1 无状态计算 ####

不需要考虑历史数据  
相同的输入得到相同的输出就是无状态计算, 如map/flatMap/filter…

*  无状态：不需要考虑历史数据：

无状态计算,不需要考虑历史值, 如map  
发送hello ,得出(hello,1)  
再发送hello ,得出(hello,1)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 87]

#### 4.2.2 有状态计算 ####

需要考虑历史数据  
相同的输入得到不同的输出/不一定得到相同的输出,就是有状态计算,如:sum/reduce

有状态计算,需要考虑历史值,如:sum  
发送hello ,得出(hello,1)  
再发送hello ,得出(hello,2)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 88]

### 4.3 有状态计算的场景 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 89]  
什么场景会用到状态呢？下面列举了常见的 4 种：  
1.去重：比如上游的系统数据可能会有重复，落到下游系统时希望把重复的数据都去掉。去重需要先了解哪些数据来过，哪些数据还没有来，也就是把所有的主键都记录下来，当一条数据到来后，能够看到在主键当中是否存在。  
2.窗口计算：比如统计每分钟 Nginx 日志 API 被访问了多少次。窗口是一分钟计算一次，在窗口触发前，如 08:00 ~ 08:01 这个窗口，前59秒的数据来了需要先放入内存，即需要把这个窗口之内的数据先保留下来，等到 8:01 时一分钟后，再将整个窗口内触发的数据输出。未触发的窗口数据也是一种状态。  
3.机器学习/深度学习：如训练的模型以及当前模型的参数也是一种状态，机器学习可能每次都用有一个数据集，需要在数据集上进行学习，对模型进行一个反馈。  
4.访问历史数据：比如与昨天的数据进行对比，需要访问一些历史数据。如果每次从外部去读，对资源的消耗可能比较大，所以也希望把这些历史数据也放入状态中做对比。

### 4.4 state状态的分类(有状态) ###

#### 4.4.1 Managed State & Raw State ####

**State分为 Managed State 和 Raw State：**

*  ManagerState–开发中推荐使用 : Fink自动管理/优化,支持多种数据结构
    
     *  KeyState–只能在keyedStream上使用,支持多种数据结构
     *  OperatorState–一般用在Source上,支持ListState，例如用于flume或者kafka的source
 *  RawState–完全由用户自己管理,只支持byte\[\],只能在自定义Operator上使用
    
     *  OperatorState  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 90]

**分类详细图解:**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 91][]

**从Flink是否接管角度:可以分为  
ManagedState(托管状态)  
RawState(原始状态)**  
两者的区别如下：  
1.从状态管理方式的方式来说，Managed State 由 Flink Runtime 管理，自动存储，自动恢复，在内存管理上有优化；而 Raw State 需要用户自己管理，需要自己序列化，Flink 不知道 State 中存入的数据是什么结构，只有用户自己知道，需要最终序列化为可存储的数据结构。  
2.从状态数据结构来说，Managed State 支持已知的数据结构，如 Value、List、Map 等。而 Raw State只支持字节数组 ，所有状态都要转换为二进制字节数组才可以。  
3.从推荐使用场景来说，Managed State 大多数情况下均可使用，而 Raw State 是当 Managed State 不够用时，比如需要自定义 Operator 时，才会使用 Raw State。  
**在实际生产中，都只推荐使用ManagedState，后续将围绕该话题进行讨论。**

#### 4.4.2 Managed Seate: Keyed State & Operator State ####

**Managed State 分为两种，Keyed State 和 Operator State**  
(Raw State都是Operator State)  
**在实际生产中，都只推荐使用ManagedState，后续将围绕该话题进行讨论。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 90]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 92]

**Keyed State**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 93]  
**Operator State**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 94]  
这里的fromElements会调用FromElementsFunction的类，其中就使用了类型为 list state 的 operator state  
Operator State又称为 non-keyed state，与Key无关的State，每一个 operator state 都仅与一个 operator 的实例绑定。  
Operator State 可以用于所有算子，但一般常用于 Source

### 4.5 存储State的数据结构/API介绍 ###

前面说过有状态计算其实就是需要考虑历史数据  
而历史数据需要搞个地方存储起来  
Flink为了方便不同分类的State的存储和管理,提供了如下的API/数据结构来存储State!

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 95]  
**Keyed State 通过 RuntimeContext 访问，这需要 Operator 是一个RichFunction。  
保存Keyed state的数据结构:  
ValueState:即类型为T的单值状态。这个状态与对应的key绑定，是最简单的状态了。它可以通过update方法更新状态值，通过value()方法获取状态值，如求按用户id统计用户交易总额  
ListState:即key上的状态值为一个列表。可以通过add方法往列表中附加值；也可以通过get()方法返回一个Iterable来遍历状态值，如统计按用户id统计用户经常登录的Ip  
ReducingState:这种状态通过用户传入的reduceFunction，每次调用add方法添加值的时候，会调用reduceFunction，最后合并到一个单一的状态值  
MapState<UK, UV>:即状态值为一个map。用户通过put或putAll方法添加元素  
需要注意的是，以上所述的State对象，仅仅用于与状态进行交互(更新、删除、清空等)，而真正的状态值，有可能是存在内存、磁盘、或者其他分布式存储系统中。相当于我们只是持有了这个状态的句柄**  
Operator State 需要自己实现 CheckpointedFunction 或 ListCheckpointed 接口。  
保存Operator state的数据结构:  
ListState  
BroadcastState<K,V>  
举例来说，Flink中的FlinkKafkaConsumer，就使用了operator state。它会在每个connector实例中，保存该实例中消费topic的所有(partition, offset)映射  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 96]

### 4.6 State代码示例 ###

#### 4.6.1 Keyed State ####

下图就 word count 的 sum 所使用的StreamGroupedReduce类为例讲解了如何在代码中使用 keyed state：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 97]  
https://ci.apache.org/projects/flink/flink-docs-stable/dev/stream/state/state.html\#using-managed-keyed-state

需求:  
使用KeyState中的ValueState获取数据中的最大值(实际中直接使用maxBy即可)

编码步骤  
//-1.定义一个状态用来存放最大值  
private transient ValueState maxValueState;  
//-2.创建一个状态描述符对象  
ValueStateDescriptor descriptor = new ValueStateDescriptor(“maxValueState”, Long.class);  
//-3.根据状态描述符获取State  
maxValueState = getRuntimeContext().getState(maxValueStateDescriptor);  
//-4.使用State  
Long historyValue = maxValueState.value();  
//判断当前值和历史值谁大  
if (historyValue == null || currentValue > historyValue)  
//-5.更新状态  
maxValueState.update(currentValue);

代码示例  
**通过map求最大，当然flink api直接max()即可**

package cn.itcast.state;
    
    import org.apache.flink.api.common.functions.RichMapFunction;
    import org.apache.flink.api.common.state.ValueState;
    import org.apache.flink.api.common.state.ValueStateDescriptor;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.api.java.tuple.Tuple3;
    import org.apache.flink.configuration.Configuration;
    import org.apache.flink.streaming.api.datastream.DataStreamSource;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    
    /** * Author itcast * Desc * 使用KeyState中的ValueState获取流数据中的最大值(实际中直接使用maxBy即可) */
    public class StateDemo01_KeyedState { 
        public static void main(String[] args) throws Exception { 
            //1.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setParallelism(1);//方便观察
    
            //2.Source
            DataStreamSource<Tuple2<String, Long>> tupleDS = env.fromElements(
                    Tuple2.of("北京", 1L),
                    Tuple2.of("上海", 2L),
                    Tuple2.of("北京", 6L),
                    Tuple2.of("上海", 8L),
                    Tuple2.of("北京", 3L),
                    Tuple2.of("上海", 4L)
            );
    
            //3.Transformation
            //使用KeyState中的ValueState获取流数据中的最大值(实际中直接使用maxBy即可)
            //实现方式1:直接使用maxBy--开发中使用该方式即可
            //min只会求出最小的那个字段,其他的字段不管
            //minBy会求出最小的那个字段和对应的其他的字段
            //max只会求出最大的那个字段,其他的字段不管
            //maxBy会求出最大的那个字段和对应的其他的字段
            SingleOutputStreamOperator<Tuple2<String, Long>> result = tupleDS.keyBy(t -> t.f0)
                    .maxBy(1);
    
            //实现方式2:使用KeyState中的ValueState---学习测试时使用,或者后续项目中/实际开发中遇到复杂的Flink没有实现的逻辑,才用该方式!
            SingleOutputStreamOperator<Tuple3<String, Long, Long>> result2 = tupleDS.keyBy(t -> t.f0)
                    .map(new RichMapFunction<Tuple2<String, Long>, Tuple3<String, Long, Long>>() { 
                        //-1.定义状态用来存储最大值,假设只有一个分取，多个分区就需要使用Map<分区,offset>
                        private ValueState<Long> maxValueState = null;
    
                        @Override
                        public void open(Configuration parameters) throws Exception { 
                            //-2.创建状态描述器，描述状态的名称和里面的数据类型
                            ValueStateDescriptor descriptor = new ValueStateDescriptor("maxValueState", Long.class);
                            //-3.//根据状态描述器获取/初始化状态
                            maxValueState = getRuntimeContext().getState(descriptor);
                        }
    
                        @Override
                        public Tuple3<String, Long, Long> map(Tuple2<String, Long> value) throws Exception { 
                            //-4.使用State,取出State中的最大值/历史最大值
                            Long historyMaxValue = maxValueState.value();
                            Long currentValue = value.f1;
                            if (historyMaxValue == null || currentValue > historyMaxValue) { 
                                //5-更新状态,把当前的作为新的最大值存到状态中
                                maxValueState.update(currentValue);
                                return Tuple3.of(value.f0, currentValue, currentValue);
                            } else { 
                                return Tuple3.of(value.f0, currentValue, historyMaxValue);
                            }
                        }
                    });
    
    
            //4.Sink
            //result.print();
            result2.print();
    
            //5.execute
            env.execute();
        }
    }

#### 4.6.2 Operator State ####

下图对 word count 示例中的FromElementsFunction类进行详解并分享如何在代码中使用 operator state：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 98]  
官网代码示例  
https://ci.apache.org/projects/flink/flink-docs-stable/dev/stream/state/state.html\#using-managed-operator-state  
需求:  
使用ListState存储offset模拟Kafka的offset维护  
编码步骤:  
//-1.声明一个OperatorState来记录offset  
private ListState offsetState = null;  
private Long offset = 0L;  
//-2.创建状态描述器  
ListStateDescriptor descriptor = new ListStateDescriptor(“offsetState”, Long.class);  
//-3.根据状态描述器获取State  
offsetState = context.getOperatorStateStore().getListState(descriptor);

//-4.获取State中的值  
Iterator iterator = offsetState.get().iterator();  
if (iterator.hasNext()) \{//迭代器中有值  
offset = iterator.next();//取出的值就是offset  
\}  
offset += 1L;  
ctx.collect(“subTaskId:” + getRuntimeContext().getIndexOfThisSubtask() + “,当前的offset为:” + offset);  
if (offset % 5 == 0) \{//每隔5条消息,模拟一个异常  
//-5.保存State到Checkpoint中  
offsetState.clear();//清理内存中存储的offset到Checkpoint中  
//-6.将offset存入State中  
offsetState.add(offset);

代码示例

package cn.itcast.state;
    
    import org.apache.flink.api.common.restartstrategy.RestartStrategies;
    import org.apache.flink.api.common.state.ListState;
    import org.apache.flink.api.common.state.ListStateDescriptor;
    import org.apache.flink.runtime.state.FunctionInitializationContext;
    import org.apache.flink.runtime.state.FunctionSnapshotContext;
    import org.apache.flink.runtime.state.filesystem.FsStateBackend;
    import org.apache.flink.streaming.api.CheckpointingMode;
    import org.apache.flink.streaming.api.checkpoint.CheckpointedFunction;
    import org.apache.flink.streaming.api.datastream.DataStreamSource;
    import org.apache.flink.streaming.api.environment.CheckpointConfig;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.functions.source.RichParallelSourceFunction;
    
    import java.util.Iterator;
    import java.util.concurrent.TimeUnit;
    
    /** * Author itcast * Desc * 需求: * 使用OperatorState支持的数据结构ListState存储offset信息, 模拟Kafka的offset维护, * 其实就是FlinkKafkaConsumer底层对应offset的维护! */
    public class StateDemo02_OperatorState { 
        public static void main(String[] args) throws Exception { 
            //1.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setParallelism(1);
            //先直接使用下面的代码设置Checkpoint时间间隔和磁盘路径以及代码遇到异常后的重启策略,下午会学
            env.enableCheckpointing(1000);//每隔1s执行一次Checkpoint
            env.setStateBackend(new FsStateBackend("file:///D:/ckp"));
            env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
            env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
            //固定延迟重启策略: 程序出现异常的时候，重启2次，每次延迟3秒钟重启，超过2次，程序退出
            env.setRestartStrategy(RestartStrategies.fixedDelayRestart(2, 3000));
    
            //2.Source
            DataStreamSource<String> sourceData = env.addSource(new MyKafkaSource());
    
            //3.Transformation
            //4.Sink
            sourceData.print();
    
            //5.execute
            env.execute();
        }
    
        /** * MyKafkaSource就是模拟的FlinkKafkaConsumer并维护offset */
        public static class MyKafkaSource extends RichParallelSourceFunction<String> implements CheckpointedFunction { 
            //-1.声明一个OperatorState来记录offset
            private ListState<Long> offsetState = null;
            private Long offset = 0L;
            private boolean flag = true;
    
            @Override
            public void initializeState(FunctionInitializationContext context) throws Exception { 
                //-2.创建状态描述器, // 并行度设置为1方便观察，如果是多并行及kafka多分区,需要使用MapStateDescriptor
                ListStateDescriptor descriptor = new ListStateDescriptor("offsetState", Long.class);
                //-3.根据状态描述器初始化状态
                offsetState = context.getOperatorStateStore().getListState(descriptor);
            }
    
            @Override
            public void run(SourceContext<String> ctx) throws Exception { 
                //-4.获取并使用State中的值
                Iterator<Long> iterator = offsetState.get().iterator();
                if (iterator.hasNext()){ 
                    offset = iterator.next();
                }
                while (flag){ 
                    offset += 1;
                    int id = getRuntimeContext().getIndexOfThisSubtask();
                    ctx.collect("分区:"+id+"消费到的offset位置为:" + offset);//1 2 3 4 5 6
                    //Thread.sleep(1000);
                    TimeUnit.SECONDS.sleep(2);
                    if(offset % 5 == 0){ 
                        System.out.println("程序遇到异常了.....");
                        throw new Exception("程序遇到异常了.....");
                    }
                }
            }
    
            @Override
            public void cancel() { 
                flag = false;
            }
    
            /** * 下面的snapshotState方法会按照固定的时间间隔将State信息存储到Checkpoint/磁盘中,也就是在磁盘做快照! */
            @Override
            public void snapshotState(FunctionSnapshotContext context) throws Exception { 
                //-5.保存State到Checkpoint中
                offsetState.clear();//清理内存中存储的offset到Checkpoint中
                //-6.将offset存入State中
                offsetState.add(offset);
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 99]

## 5.Flink-容错机制 ##

### 5.1 Checkpoint ###

#### 5.1.1 State Vs Checkpoint ####

State:  
维护/存储的是**某一个Operator**的运行的状态/历史值,是维护在**内存**中!  
一般指一个具体的Operator的状态(operator的状态表示一些算子在运行的过程中会产生的一些历史结果,如前面的maxBy底层会维护当前的最大值,也就是会维护一个keyedOperator,这个State里面存放就是maxBy这个Operator中的最大值)  
State数据默认保存在Java的堆内存中/TaskManage节点的内存中  
State可以被记录，在失败的情况下数据还可以恢复  
Checkpoint:  
某一时刻,Flink中**所有的Operator**的当前State的全局快照,一般存在**磁盘**上  
表示了一个Flink Job在一个特定时刻的一份全局状态快照，即包含了所有Operator的状态  
可以理解为Checkpoint是把State数据定时持久化存储了  
比如KafkaConsumer算子中维护的Offset状态,当任务重新恢复的时候可以从Checkpoint中获取

注意:  
Flink中的Checkpoint底层使用了Chandy-Lamport algorithm分布式快照算法可以保证数据的在分布式环境下的一致性!  
https://zhuanlan.zhihu.com/p/53482103  
Chandy-Lamport (兰波特) 算法的作者也是ZK中Paxos 一致性算法的作者  
https://www.cnblogs.com/shenguanpu/p/4048660.html  
Flink中使用Chandy-Lamport algorithm分布式快照算法取得了成功,后续Spark的StructuredStreaming也借鉴了该算法

#### 5.1.2 Checkpoint执行流程 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 100]  
0.Flink的JobManager创建CheckpointCoordinator  
1.Coordinator向所有的SourceOperator发送Barrier栅栏(理解为执行Checkpoint的信号)  
2.SourceOperator接收到Barrier之后,暂停当前的操作(暂停的时间很短,因为后续的写快照是异步的),并制作State快照, 然后将自己的快照保存到指定的介质中(如HDFS), 一切 ok之后向Coordinator汇报并将Barrier发送给下游的其他Operator  
3.其他的如TransformationOperator接收到Barrier,重复第2步,最后将Barrier发送给Sink  
4.Sink接收到Barrier之后重复第2步  
5.Coordinator接收到所有的Operator的执行ok的汇报结果,认为本次快照执行成功

注意:  
1.在往介质(如HDFS)中写入快照数据的时候是异步的(为了提高效率)  
2.分布式快照执行时的数据一致性由Chandy-Lamport algorithm分布式快照算法保证!

##### 5.1.2.2 复杂流程–课后自行阅读 #####

下图左侧是 Checkpoint Coordinator，是整个 Checkpoint 的发起者，中间是由两个 source，一个 sink 组成的 Flink 作业，最右侧的是持久化存储，在大部分用户场景中对应 HDFS。  
1.Checkpoint Coordinator 向所有 source 节点 trigger Checkpoint。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 101]  
2.source 节点向下游广播 barrier，这个 barrier 就是实现 Chandy-Lamport （兰波特）分布式快照算法的核心，下游的 task 只有收到所有 input 的 barrier 才会执行相应的 Checkpoint。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 102]  
3.当 task 完成 state 备份后，会将备份数据的地址（state handle）通知给 Checkpoint coordinator。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 103]  
4.下游的 sink 节点收集齐上游两个 input 的 barrier 之后，会执行本地快照，(栅栏对齐)  
这里还展示了 RocksDB incremental Checkpoint (增量Checkpoint)的流程，首先 RocksDB 会全量刷数据到磁盘上（红色大三角表示），然后 Flink 框架会从中选择没有上传的文件进行持久化备份（紫色小三角）。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 104]  
5.同样的，sink 节点在完成自己的 Checkpoint 之后，会将 state handle 返回通知 Coordinator。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 105]  
6.最后，当 Checkpoint coordinator 收集齐所有 task 的 state handle，就认为这一次的 Checkpoint 全局完成了，向持久化存储中再备份一个 Checkpoint meta 文件。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 106]

#### 5.1.3 State状态后端/State存储介质 ####

注意:  
**前面学习了Checkpoint其实就是Flink中某一时刻,所有的Operator的全局快照,**  
**那么快照应该要有一个地方进行存储,而这个存储的地方叫做状态后端，一般是存在HDFS**

**Flink中的State状态后端有很多种:**

**5.1.3.1 MemStateBackend（存储在内存中）\[了解\]**

**不推荐在生产场景使用。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 107]

第一种是内存存储，即 MemoryStateBackend，构造方法是设置最大的StateSize，选择是否做异步快照，  
对于State状态存储在 TaskManager 节点也就是执行节点内存中的，因为内存有容量限制，所以单个 State maxStateSize 默认 5 M，且需要注意 maxStateSize <= akka.framesize 默认 10 M。  
对于Checkpoint 存储在 JobManager 内存中，因此总大小不超过 JobManager 的内存。  
推荐使用的场景为：本地测试、几乎无状态的作业，比如 ETL、JobManager 不容易挂，或挂掉影响不大的情况。

**5.1.3.2 FsStateBackend （存储在磁盘中）**

**可以在生产环境中使用，一般都是都是使用这种，实时性相对高**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 108]

另一种就是在文件系统上的 FsStateBackend 构建方法是需要传一个文件路径和是否异步快照。  
State 依然在 TaskManager 内存中，但不会像 MemoryStateBackend 是 5 M 的设置上限  
Checkpoint 存储在外部文件系统（本地或 HDFS），打破了总大小 Jobmanager 内存的限制。  
**推荐使用的场景为：常规使用状态的作业、例如分钟级窗口聚合或 join、需要开启HA的作业。**

如果使用HDFS，则初始化FsStateBackend时，需要传入以 “hdfs://”开头的路径(即: new FsStateBackend(“hdfs:///hacluster/checkpoint”))，  
如果使用本地文件，则需要传入以“file://”开头的路径(即:new FsStateBackend(“file:///Data”))。  
在分布式情况下，不推荐使用本地文件。因为如果某个算子在节点A上失败，在节点B上恢复，使用本地文件时，在B上无法读取节点 A上的数据，导致状态恢复失败。

**5.1.3.3 RocksDBStateBackend**

**可以在生产环境中使用，相对于FsStateBackend 实时性偏低**  
在这里插入图片描述  
还有一种存储为 RocksDBStateBackend ，  
RocksDB 是一个 key/value 的内存存储系统，和其他的 key/value 一样，先将状态放到内存中，如果内存快满时，则写入到磁盘中，  
但需要注意 RocksDB 不支持同步的 Checkpoint，构造方法中没有同步快照这个选项。  
不过 RocksDB 支持增量的 Checkpoint，意味着并不需要把所有 sst 文件上传到 Checkpoint 目录，仅需要上传新生成的 sst 文件即可。它的 Checkpoint 存储在外部文件系统（本地或HDFS），  
其容量限制只要单个 TaskManager 上 State 总量不超过它的内存+磁盘，单 Key最大 2G，总大小不超过配置的文件系统容量即可。  
**推荐使用的场景为：超大状态的作业，例如天级窗口聚合、需要开启 HA 的作业、最好是对状态读写性能要求不高的作业。**

使用RocksDBStateBackend方式存储依赖RocksDB数据库，需要引入RocksDB的依赖

<dependency>
           <groupId>org.apache.flink</groupId>
           <artifactId>flink-statebackend-rocksdb_2.12</artifactId>
           <version>1.12.0</version>
        </dependency>

#### 5.1.4 Checkpoint配置方式 ####

**5.1.4.1 全局配置**

可以通过修改flink-conf.yaml，会影响所有集群全局  
\#这里可以配置  
修改flink-conf.yaml  
\#这里可以配置  
\#jobmanager(即MemoryStateBackend),  
\#filesystem(即FsStateBackend),  
\#rocksdb(即RocksDBStateBackend)  
state.backend: filesystem  
state.checkpoints.dir: hdfs://namenode:8020/flink/checkpoints

5.1.4.2 在代码中配置  
也可以在代码中直接配置，代码中修改只影响单个的

//1.MemoryStateBackend--开发中不用
        env.setStateBackend(new MemoryStateBackend)
    //2.FsStateBackend--开发中可以使用--适合一般状态--秒级/分钟级窗口...
        env.setStateBackend(new FsStateBackend("hdfs路径或测试时的本地路径"))
    //3.RocksDBStateBackend--开发中可以使用--适合超大状态--天级窗口...
    env.setStateBackend(new RocksDBStateBackend(filebackend, true))

注意:RocksDBStateBackend还需要引入依赖

<dependency>
           <groupId>org.apache.flink</groupId>
           <artifactId>flink-statebackend-rocksdb_2.11</artifactId>
           <version>1.7.2</version>
        </dependency>

#### 5.1.5 代码演示 ####

https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/stream/state/checkpointing.html\#selecting-a-state-backend

package cn.itcast.checkpoint;
    
    import org.apache.commons.lang3.SystemUtils;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.RichMapFunction;
    import org.apache.flink.api.common.serialization.SimpleStringSchema;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.runtime.state.filesystem.FsStateBackend;
    import org.apache.flink.streaming.api.CheckpointingMode;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.KeyedStream;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.CheckpointConfig;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;
    import org.apache.flink.util.Collector;
    
    import java.util.Properties;
    
    /** * Author itcast * Desc 演示Flink-Checkpoint相关配置 */
    public class CheckpointDemo01 { 
        public static void main(String[] args) throws Exception { 
            //1.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO ===========Checkpoint参数设置====
            //===========类型1:必须参数=============
            //设置Checkpoint的时间间隔为1000ms做一次Checkpoint/其实就是每隔1000ms发一次Barrier!
            env.enableCheckpointing(1000);
            //设置State状态存储介质/状态后端
            //Memory:State存内存,Checkpoint存内存--开发不用!
            //Fs:State存内存,Checkpoint存FS(本地/HDFS)--一般情况下使用
            //RocksDB:State存RocksDB(内存+磁盘),Checkpoint存FS(本地/HDFS)--超大状态使用,但是对于状态的读写效率要低一点
            /*if(args.length > 0){ env.setStateBackend(new FsStateBackend(args[0])); }else { env.setStateBackend(new FsStateBackend("file:///D:\\d ata\\ckp")); }*/
            //如果在windowsc操作系统使用本地文件，linux用HDFS
            if (SystemUtils.IS_OS_WINDOWS) { 
                env.setStateBackend(new FsStateBackend("file:///D:/ckp"));
            } else { 
                env.setStateBackend(new FsStateBackend("hdfs://node1:8020/flink-checkpoint/checkpoint"));
            }
            //===========类型2:建议参数===========
            //设置两个Checkpoint 之间最少等待时间(两栅栏执行的间隔时间),如设置Checkpoint之间最少是要等 500ms(为了避免每隔1000ms做一次Checkpoint的时候,前一次太慢和后一次重叠到一起去了)
            //如:高速公路上,每隔1s关口放行一辆车,但是规定了两车之前的最小车距为500m
            env.getCheckpointConfig().setMinPauseBetweenCheckpoints(500);//默认是0
            //设置如果在做Checkpoint过程中出现错误，是否让整体任务失败：true是 false不是
            //env.getCheckpointConfig().setFailOnCheckpointingErrors(false);//默认是true
            env.getCheckpointConfig().setTolerableCheckpointFailureNumber(10);//默认值为0，表示不容忍任何检查点失败
            //设置是否清理检查点,表示 Cancel 时是否需要保留当前的 Checkpoint，默认 Checkpoint会在作业被Cancel时被删除
            //ExternalizedCheckpointCleanup.DELETE_ON_CANCELLATION：true,当作业被取消时，删除外部的checkpoint(默认值)
            //ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION：false,当作业被取消时，保留外部的checkpoint
            env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
    
            //===========类型3:直接使用默认的即可===============
            //设置checkpoint的执行模式为EXACTLY_ONCE(默认)
            env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
            //设置checkpoint的超时时间,如果 Checkpoint在 60s内尚未完成说明该次Checkpoint失败,则丢弃。
            env.getCheckpointConfig().setCheckpointTimeout(60000);//默认10分钟
            //设置同一时间有多少个checkpoint可以同时执行，如果setMinPauseBetweenCheckpoints>0 ,
            // 及允许对个checkpoint多个同时执行，下面的设置失效
            env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);//默认为1
    
            //2.Source
            DataStream<String> linesDS = env.socketTextStream("127.0.0.1", 9999);
    
            //3.Transformation
            //3.1切割出每个单词并直接记为1
            DataStream<Tuple2<String, Integer>> wordAndOneDS = linesDS.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception { 
                    //value就是每一行
                    String[] words = value.split(" ");
                    for (String word : words) { 
                        out.collect(Tuple2.of(word, 1));
                    }
                }
            });
            //3.2分组
            //注意:批处理的分组是groupBy,流处理的分组是keyBy
            KeyedStream<Tuple2<String, Integer>, String> groupedDS = wordAndOneDS.keyBy(t -> t.f0);
            //3.3聚合
            DataStream<Tuple2<String, Integer>> aggResult = groupedDS.sum(1);
    
            DataStream<String> result = (SingleOutputStreamOperator<String>) aggResult.map(new RichMapFunction<Tuple2<String, Integer>, String>() { 
                @Override
                public String map(Tuple2<String, Integer> value) throws Exception { 
                    return value.f0 + ":::" + value.f1;
                }
            });
    
            //4.sink
            result.print();
    
            Properties props = new Properties();
            props.setProperty("bootstrap.servers", "kafka1:6667,kafka2:6667,kafka3:6667");
            FlinkKafkaProducer<String> kafkaSink = new FlinkKafkaProducer<>("flinkreadkafka", new SimpleStringSchema(), props);
            result.addSink(kafkaSink);
    
            //5.execute
            env.execute();
    
            // /export/server/kafka/bin/kafka-console-consumer.sh --bootstrap-server node1:9092 --topic flink_kafka
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 109]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 110]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 111]

### 5.2 状态恢复和重启策略 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 112]

#### 5.2.1 自动重启策略和恢复 ####

**运行计算中(source阶段，Transformation阶段，sink阶段)发生异常，通过重启，重启后根据checkpoink的记录恢复计算。**

5.2.1.1 重启策略配置方式

配置文件中  
在flink-conf.yml中可以进行配置,示例如下:  
restart-strategy: fixed-delay  
restart-strategy.fixed-delay.attempts: 3  
restart-strategy.fixed-delay.delay: 10 s

代码中  
还可以在代码中针对该任务进行配置,示例如下:

env.setRestartStrategy(RestartStrategies.fixedDelayRestart(
    3, // 重启次数
    Time.of(10, TimeUnit.SECONDS) // 延迟时间间隔
     ))

5.2.1.2 重启策略分类

5.2.1.2.1 默认重启策略  
如果配置了Checkpoint,而没有配置重启策略,那么代码中出现了非致命错误时,程序会无限重启  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 113]  
![在这里插入图片描述][20210315235819956.png]  
**配置重启策略**

**固定延迟重启–开发中常用固定延迟重启–开发中常用**

//TODO ===配置重启策略:
            //1.配置了Checkpoint的情况下不做任务配置:默认是无限重启并自动恢复,可以解决小问题,但是可能会隐藏真正的bug
            //2.单独配置无重启策略
            //env.setRestartStrategy(RestartStrategies.noRestart());
            //3.固定延迟重启--开发中常用
            env.setRestartStrategy(RestartStrategies.fixedDelayRestart(
                    3, // 最多重启3次数
                    Time.of(5, TimeUnit.SECONDS) // 重启时间间隔
            ));
            //上面的设置表示:如果job失败,重启3次, 每次间隔5s
            //4.失败率重启--开发中偶尔使用
            /*env.setRestartStrategy(RestartStrategies.failureRateRestart( 3, // 每个测量阶段内最大失败次数 Time.of(1, TimeUnit.MINUTES), //失败率测量的时间间隔 Time.of(3, TimeUnit.SECONDS) // 两次连续重启的时间间隔 ));*/
            //上面的设置表示:如果1分钟内job失败不超过三次,自动重启,每次重启间隔3s (如果1分钟内程序失败达到3次,则程序退出)

package cn.itcast.checkpoint;
    
    import org.apache.commons.lang3.SystemUtils;
    import org.apache.flink.api.common.RuntimeExecutionMode;
    import org.apache.flink.api.common.functions.FlatMapFunction;
    import org.apache.flink.api.common.functions.RichMapFunction;
    import org.apache.flink.api.common.restartstrategy.RestartStrategies;
    import org.apache.flink.api.common.serialization.SimpleStringSchema;
    import org.apache.flink.api.common.time.Time;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.runtime.state.filesystem.FsStateBackend;
    import org.apache.flink.streaming.api.CheckpointingMode;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.datastream.KeyedStream;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.CheckpointConfig;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;
    import org.apache.flink.util.Collector;
    
    import java.util.Properties;
    import java.util.concurrent.TimeUnit;
    
    /** * Author itcast * Desc 演示Flink-Checkpoint+重启策略实现状态恢复 */
    public class CheckpointDemo02_Restart { 
        public static void main(String[] args) throws Exception { 
            //1.env
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
    
            //TODO ===========Checkpoint参数设置====
            //===========类型1:必须参数=============
            //设置Checkpoint的时间间隔为1000ms做一次Checkpoint/其实就是每隔1000ms发一次Barrier!
            env.enableCheckpointing(1000);
            //设置State状态存储介质/状态后端
            //Memory:State存内存,Checkpoint存内存--开发不用!
            //Fs:State存内存,Checkpoint存FS(本地/HDFS)--一般情况下使用
            //RocksDB:State存RocksDB(内存+磁盘),Checkpoint存FS(本地/HDFS)--超大状态使用,但是对于状态的读写效率要低一点
            /*if(args.length > 0){ env.setStateBackend(new FsStateBackend(args[0])); }else { env.setStateBackend(new FsStateBackend("file:///D:\\data\\ckp")); }*/
            if (SystemUtils.IS_OS_WINDOWS) { 
                env.setStateBackend(new FsStateBackend("file:///D:/ckp"));
            } else { 
                env.setStateBackend(new FsStateBackend("hdfs://node1:8020/flink-checkpoint/checkpoint"));
            }
            //===========类型2:建议参数===========
            //设置两个Checkpoint 之间最少等待时间,如设置Checkpoint之间最少是要等 500ms(为了避免每隔1000ms做一次Checkpoint的时候,前一次太慢和后一次重叠到一起去了)
            //如:高速公路上,每隔1s关口放行一辆车,但是规定了两车之前的最小车距为500m
            env.getCheckpointConfig().setMinPauseBetweenCheckpoints(500);//默认是0
            //设置如果在做Checkpoint过程中出现错误，是否让整体任务失败：true是 false不是
            //env.getCheckpointConfig().setFailOnCheckpointingErrors(false);//默认是true
            env.getCheckpointConfig().setTolerableCheckpointFailureNumber(10);//默认值为0，表示不容忍任何检查点失败
            //设置是否清理检查点,表示 Cancel 时是否需要保留当前的 Checkpoint，默认 Checkpoint会在作业被Cancel时被删除
            //ExternalizedCheckpointCleanup.DELETE_ON_CANCELLATION：true,当作业被取消时，删除外部的checkpoint(默认值)
            //ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION：false,当作业被取消时，保留外部的checkpoint
            env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
    
            //===========类型3:直接使用默认的即可===============
            //设置checkpoint的执行模式为EXACTLY_ONCE(默认)
            env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
            //设置checkpoint的超时时间,如果 Checkpoint在 60s内尚未完成说明该次Checkpoint失败,则丢弃。
            env.getCheckpointConfig().setCheckpointTimeout(60000);//默认10分钟
            //设置同一时间有多少个checkpoint可以同时执行
            env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);//默认为1
    
            //TODO ===配置重启策略:
            //1.配置了Checkpoint的情况下不做任务配置:默认是无限重启并自动恢复,可以解决小问题,但是可能会隐藏真正的bug
            //2.单独配置无重启策略
            //env.setRestartStrategy(RestartStrategies.noRestart());
            //3.固定延迟重启--开发中常用
            env.setRestartStrategy(RestartStrategies.fixedDelayRestart(
                    3, // 最多重启3次数
                    Time.of(5, TimeUnit.SECONDS) // 重启时间间隔
            ));
            //上面的设置表示:如果job失败,重启3次, 每次间隔5s
            //4.失败率重启--开发中偶尔使用
            /*env.setRestartStrategy(RestartStrategies.failureRateRestart( 3, // 每个测量阶段内最大失败次数 Time.of(1, TimeUnit.MINUTES), //失败率测量的时间间隔 Time.of(3, TimeUnit.SECONDS) // 两次连续重启的时间间隔 ));*/
            //上面的设置表示:如果1分钟内job失败不超过三次,自动重启,每次重启间隔3s (如果1分钟内程序失败达到3次,则程序退出)
    
    
            //2.Source
            DataStream<String> linesDS = env.socketTextStream("127.0.0.1", 9999);
    
            //3.Transformation
            //3.1切割出每个单词并直接记为1
            DataStream<Tuple2<String, Integer>> wordAndOneDS = linesDS.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() { 
                @Override
                public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception { 
                    //value就是每一行
                    String[] words = value.split(" ");
                    for (String word : words) { 
                        if (word.equals("bug")) { 
                            System.out.println("bug.....");
                            //，如果nc -lk 9999 发送 "bug" 字符串, 模拟发生异常
                            throw new Exception("bug.....");
                        }
                        out.collect(Tuple2.of(word, 1));
                    }
                }
            });
            //3.2分组
            //注意:批处理的分组是groupBy,流处理的分组是keyBy
            KeyedStream<Tuple2<String, Integer>, String> groupedDS = wordAndOneDS.keyBy(t -> t.f0);
            //3.3聚合
            DataStream<Tuple2<String, Integer>> aggResult = groupedDS.sum(1);
    
            DataStream<String> result = (SingleOutputStreamOperator<String>) aggResult.map(new RichMapFunction<Tuple2<String, Integer>, String>() { 
                @Override
                public String map(Tuple2<String, Integer> value) throws Exception { 
                    return value.f0 + ":::" + value.f1;
                }
            });
    
            //4.sink
            result.print();
    
            Properties props = new Properties();
            props.setProperty("bootstrap.servers", "kafka1:6667,kafka2:6667,kafka3:6667");
            FlinkKafkaProducer<String> kafkaSink = new FlinkKafkaProducer<>("flinkreadkafka", new SimpleStringSchema(), props);
            result.addSink(kafkaSink);
    
            //5.execute
            env.execute();
    
            // /export/server/kafka/bin/kafka-console-consumer.sh --bootstrap-server node1:9092 --topic flink_kafka
        }
    }

5.2.1.2.2 无重启策略 了解

### 5.3 Savepoint 了解 (手动的进行checkpoint) ###

5.3.1 Savepoint介绍  
Savepoint:保存点,类似于以前玩游戏的时候,遇到难关了/遇到boss了,赶紧手动存个档,然后接着玩,如果失败了,赶紧从上次的存档中恢复,然后接着玩

在实际开发中,可能会遇到这样的情况:如要对集群进行停机维护/扩容…  
那么这时候需要执行一次Savepoint也就是执行一次手动的Checkpoint/也就是手动的发一个barrier栅栏,那么这样的话,程序的所有状态都会被执行快照并保存,  
当维护/扩容完毕之后,可以从上一次Savepoint的目录中进行恢复!

#### 5.3.2 Savepoint VS Checkpoint ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 114]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 115]

#### 5.3.3 Savepoint演示 ####

# 启动yarn session
    /export/server/flink/bin/yarn-session.sh -n 2 -tm 800 -s 1 -d
    
    # 运行job-会自动执行Checkpoint
    /export/server/flink/bin/flink run --class cn.itcast.checkpoint.CheckpointDemo01 /root/ckp.jar
    
    # 手动创建savepoint--相当于手动做了一次Checkpoint
    /export/server/flink/bin/flink savepoint 0e921a10eb31bb0983b637929ec87a8a hdfs://node1:8020/flink-checkpoint/savepoint/
    
    # 停止job
    /export/server/flink/bin/flink cancel 0e921a10eb31bb0983b637929ec87a8a
    
    # 重新启动job,手动加载savepoint数据
    /export/server/flink/bin/flink run -s hdfs://node1:8020/flink-checkpoint/savepoint/savepoint-0e921a-1cac737bff7a --class cn.itcast.checkpoint.CheckpointDemo01 /root/ckp.jar 
    
    # 停止yarn session
    yarn application -kill application_1607782486484_0014

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70]: /images/20221023/6edfa1bf59a843bdbf87fafaeb3d68dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 1]: /images/20221023/af77af246cb24a69b5d145e374cb857b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 2]: /images/20221023/3bfa40733e304e4da10ea413d2be8c3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 3]: /images/20221023/c5c5d1ed22ca4e71a781eb0820e9f6db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 4]: /images/20221023/cf5624a0206f4cf4ae7d90e67d5c6e4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 5]: /images/20221023/d44c6e17774b4597a0e8c466f5bc70de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 6]: /images/20221023/72d103b6bbb94e44acc14b701e72cf4f.png
[20210310194145216.png]: /images/20221023/3ab49e11e7d7474d82c1d511e468b802.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 7]: /images/20221023/96bdfedfcc7a41ba9500bea632a438a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 8]: /images/20221023/928815eff8c94c669aa98efd4729025f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 9]: /images/20221023/deef7f872aec4003aa851bfd29d2f6ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 10]: /images/20221023/efd8b6c944c94e60b2377e89afaaa6df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 11]: /images/20221023/3b0b1afb392c42f6857f4c8e9f2660e1.png
[20210310201914124.png]: /images/20221023/ccbe4bb117704ddd84511dd6328d8408.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 12]: /images/20221023/2516555a6bd74434a8e126227a6d760c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 13]: /images/20221023/bfe242b27e594390a98ff49f371b9d4f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 14]: /images/20221023/1daf10af0e6a4697912e1a37458429b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 15]: /images/20221023/b99a79f439894029af72f3fc4c233107.png
[20210310202149390.png]: /images/20221023/d56ba8882d6f4c04a8cdef4ac7732683.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 16]: /images/20221023/25b19c2e975b4426990c0589193fc839.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 17]: /images/20221023/aca4388ebb98438b9388585d2c0dcb0f.png
[20210310202441871.png]: /images/20221023/a866043f3b9b41488c014599fc3b558e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 18]: /images/20221023/4795002204924653b2737d95343f9d81.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 19]: /images/20221023/ca90e2ca76fa46f482e118847534791d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 20]: /images/20221023/cfc94e161e9845a883825ef42de997af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 21]: /images/20221023/c115a3b62d4042a79846d167f2755251.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 22]: /images/20221023/98cf3b10bcca46aeb259aa88d5d62b61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 23]: /images/20221023/217d593549474b828061d1d8c9fc6f23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 24]: /images/20221023/c8370ed17f0948d3a45e837de1bcccc5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 25]: /images/20221023/6968e4b2851f4e5ebc3475b1897b3f52.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 26]: /images/20221023/13c2aa2cce1d4d3a8bf8439dfd7a58ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 27]: /images/20221023/6c8a35451e7a441d881829e0e4f575db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 28]: /images/20221023/6556d9e72dc54c4ba7203c5bb962bb07.png
[20210311195154769.png]: /images/20221023/8c34d4bfb1b1427298ed1eb5e544d882.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 29]: /images/20221023/7a9337d9576a4431b11ae4bb60e1948a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 30]: /images/20221023/a70cdeaf7f7c4ba3b229ae86d24f2028.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 31]: /images/20221023/e28b455f546040cd9e877e380df39423.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 32]: /images/20221023/4923fafc98a442cf9d7581fd01e199ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 33]: /images/20221023/c26a27f765864befbbb6c9056b43dad9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 34]: /images/20221023/d936a5e9d3574fe3b615133f53e53cf0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 35]: /images/20221023/2700931fe0e048388f0a55788fb544c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 36]: /images/20221023/68e1dfcd540b4b4ebdaedd7cd2cf4629.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 37]: /images/20221023/1d1311a6c61445cd9f2e71f20af940a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 38]: /images/20221023/b11a02f94ffd4c728376ef32de7d38ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 39]: /images/20221023/22b5b66f103d4491839261a5b06c4c3e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 40]: /images/20221023/7a87ba8443b2473d89a66276693510b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 41]: /images/20221023/a289201260014ce3971952cbb74b8b25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 42]: /images/20221023/1637dc8444114584a91c75bf97c120bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 43]: /images/20221023/05354da0443249a680f9d11c46c7c267.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 44]: /images/20221023/4a53778a664e47b9839989db72e72423.png
[20210313110633949.png]: /images/20221023/95cf0a80e743473f9212a1927ce2c455.png
[20210313110918930.png]: /images/20221023/633e9e1c136545e0a78219c8c47fc653.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 45]: /images/20221023/031b6227b48f49f9b050725470adccaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 46]: /images/20221023/0479278553fe4111a69346d9d845dac8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 47]: /images/20221023/13f027cc5f45417f91b05bb2f7a2e7e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 48]: /images/20221023/0b0a72c51f6444dbab814dc07d4b3b91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 49]: /images/20221023/8dbc3e6cf30f4921a3f07180c3cb7459.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 50]: /images/20221023/723e37258a6848ce9c7ee07f7838856f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 51]: /images/20221023/de0f9e9d383644209880001ec04c59cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 52]: /images/20221023/cede7c74496b4082b416b6803ec2f98e.png
[20210313142828702.png]: /images/20221023/6fa59fbfabd44e11a43dcb283dca59c6.png
[20210313142816146.png]: /images/20221023/33e2d75d7aea49f787bed483acbb93f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 53]: /images/20221023/2c93e64a41e240f59d779b29408cfbbe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 54]: /images/20221023/12d4e986d86644c8b3db28c954e21b16.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 55]: /images/20221023/e5798d1ba60f4e2d9dc71ab1a1ad1af0.png
[20210313144808216.png]: /images/20221023/6ec4821dccdc4a169c4731d5bcfcea9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 56]: /images/20221023/747fe0fecb7f4eb19841154f0653f8bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 57]: /images/20221023/0765ae2db26b46e183e05fb55aab4d29.png
[20210313145224846.png]: /images/20221023/54e6e66eafbd4af995cf817e44dc4b9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 58]: /images/20221023/4045e23c46c34c3ea7adcb74173d2588.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 59]: /images/20221023/d3292cc713e64fc2be426d49e1bacf02.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 60]: /images/20221023/6ba9aca11b084a38abed1525f62a2df3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 61]: /images/20221023/ea0b3399c8b345a4a52381b91fd6ad0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 62]: /images/20221023/f952a5c2c94043ceb1d71021aee9d24c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 63]: /images/20221023/e55fd764e479486eba4907bc16e9c104.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 64]: /images/20221023/cc39a34b08484a9a9eb1ee496ed3a107.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 65]: /images/20221023/50d7d1e66a444eb193f99df59ea9a606.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 66]: /images/20221023/a9691d7510744f6fbe6b051d0c99f98a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 67]: /images/20221023/fc34e516fc834d81b74dcd6b793ec236.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 68]: /images/20221023/3ec80ba1a79b4494bc48b6a294acaed6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 69]: /images/20221023/4c242902c1b641868a1b2843601869ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 70]: /images/20221023/5f1652a1d8824a7aa6a8014b41b64a0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 71]: /images/20221023/508b8cff9c034937b340aec5101e55a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 72]: /images/20221023/49d0a77fe3ef4d4895c50adfb6b03d0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 73]: /images/20221023/c5b55ec6c8714ff991264d1539204653.png
[20210313172349904.png]: /images/20221023/6fbea45178414a23b0feac066ee4d3c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 74]: /images/20221023/0cbff504bf9c47439b13eabd58be9339.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 75]: /images/20221023/2139f879d86f49fab6dd974ff662b8db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 76]: /images/20221023/746d0b58841f4423b1250b2a1026f400.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 77]: /images/20221023/7fbb74fbc3904d27a43476352d627867.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 78]: /images/20221023/baefb49115b44010833dad23e750a0c8.png
[20210313174931290.png]: /images/20221023/27b1752eb7b04db9bf0a5a25a7d7e1a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 79]: /images/20221023/28159bfa6833406e81a56a5e61ee6538.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 80]: /images/20221023/7071abe29ce94266bf9a833639401fef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 81]: /images/20221023/22f95da535154c1e96153bbedd85aee7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 82]: /images/20221023/48b3ff0e82314452b8ee8eb0bb75eee4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 83]: /images/20221023/074c8871bf614d309ea1dc0aba7b472d.png
[20210314154911436.png]: /images/20221023/c369bd03f2c94aab8fabab9d988b2ca2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 84]: /images/20221023/f715521cbdf942f1a27aa572310daca7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 85]: /images/20221023/e51c43d7b5ac4293873771581dacc3f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 86]: /images/20221023/f1fe8d89c984471b8cc425abe0a880ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 87]: /images/20221023/a819e5ecd3194df4bb86af4df57c76cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 88]: /images/20221023/a264cc17519d4d97a82c3898b1120f5d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 89]: /images/20221023/6c62380cb0904eccbb817a9b62624fca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 90]: /images/20221023/7c1718e2017046b8a6919b2fee104aef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 91]: /images/20221023/cd57dd2d48b74296a7a171463774a007.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 92]: /images/20221023/32a985975bff49d290b8f238f4f6d517.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 93]: /images/20221023/061364e10b12434b8d61335e47e0bd1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 94]: /images/20221023/03a47b8bf1d547009671ee4d2c31a69c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 95]: /images/20221023/35b44fe0719746d687baa8eb4d97a157.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 96]: /images/20221023/edd2b8955f6f4cab8946e67d1134c4a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 97]: /images/20221023/c9d4f39ea3cc4115ac7ddf5f72b8a698.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 98]: /images/20221023/88864f453cb2413f9519394801f901c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 99]: /images/20221023/89a8cd5162ba4e249d7075a8558483b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 100]: /images/20221023/3e5087360ee045dc86ba743c9f44eecf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 101]: /images/20221023/5065380ab1fe4e2ab061a19bf470afaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 102]: /images/20221023/72f55384c5b04a469f06b20d5a310065.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 103]: /images/20221023/1df4d3b6f57f42c8a71985cfbac93d0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 104]: /images/20221023/17eb2e7d2a77475cb235b35940de2f20.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 105]: /images/20221023/f6b49bfc91084b0eb1836a5a14e6df1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 106]: /images/20221023/d9dc7c8589e540658e4494dd575acafe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 107]: /images/20221023/2675ce13de0041ac9fe19b5eead8a1d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 108]: /images/20221023/ca31f581fe7b4318b4def1ec54997281.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 109]: /images/20221023/1b23c8e72c0b49ada9b02594c0084f70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 110]: /images/20221023/9c46febd65ca4c21a576e803ca3bda44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 111]: /images/20221023/87a13dd1b7044de6ae909ca453741724.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 112]: /images/20221023/c2243664281a4740b975e11abd9d9df4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 113]: /images/20221023/35853d59e95848719504df21637ccc2f.png
[20210315235819956.png]: /images/20221023/b15882c3002a40f69efb879070d98230.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 114]: /images/20221023/47f176dc466445aaa41d4bbdce18bda0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 115]: /images/20221023/f091183216774523b7df339b9c85a3c8.png