Flink-简单了解及入门WordCount

阳光穿透心脏的1/2处 2022-09-07 14:52 215阅读 0赞

# Flink简介 #

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

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

流数据处理以及批处理的差别：流处理是更低延迟的批处理。

比如设备的实时数据采集和显示、实时告警等都可以使用Flink，可以做实时结算和通知推送,实时检测异常行为等。

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

storm：第一代大数据流式处理框架，保证了低延迟，但是不能保证数据的有序；

Spark-Streaming：通过批处理演变得到的，能够做到高吞吐，且能够保证结果的正确性，对于时间乱序的数据集无法处理。

Flink包含了以上所有的优点。

## Flink 的重要特点 ##

### 事件驱动型(Event-driven) ###

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

与之不同的就是 SparkStreaming 微批次,如图:

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

事件驱动型:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NsZWFybHhq_size_16_color_FFFFFF_t_70]

### 流与批的世界观 ###

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

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

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

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

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

**有界数据流** :有界数据流有明确定义的开始和 结束,可以在执行任何 计算之前通过获取所有数据来 处 理有界流,处理有界 流 不需要有序获取,因 为 可以始终对有界数据集进行排序,有界流的处理也称为批处理。

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

**这种以流为世界观的架构,获得的最大好处就是具有极低的延迟。**

### 分层 api ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NsZWFybHhq_size_16_color_FFFFFF_t_70 1]

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

实际上,大多数应用并不需要上述的底层抽象,而是针对核心 API(Core APIs)进行编程,比如 DataStream API(有界或无界流数据)以及 DataSet API(有界数据集)。这些 API 为数据处理提供了通用的构建模块,比如由用户定义的多种形式的转换(transformations),连接(joins),聚合(aggregations),窗口操作(windows)等 等。

DataSet API 为有 界数 据集提 供了 额外的 支持 ,例如 循环与 迭代 。这 些 API处理的数据类型以类(classes)的形式由各自的编程语言所表示。

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

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

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

**DataStream是用于流数据处理的，DataSet是用于批处理的。**

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

目前 Flink 作为批处理还不是主流,不如 Spark 成熟,所以 DataSet 使用的并不是很多。

Flink Table API 和 Flink SQL 也并不完善,大多都由各大厂商自己定制。所以主要学习 DataStream API 的使用。实际上 Flink 作为最接近 Google DataFlow模型的实现,是流批统一的观点,所以基本上使用 DataStream 就可以了。

Flink 几大模块

Flink Table & SQL(还没开发完)  
Flink Gelly(图计算)  
Flink CEP(复杂事件处理)

Flink 的其它特点

• 支持事件时间(event-time)和处理时间(processing-time)语义

• 精确一次(exactly-once)的状态一致性保证，就是处理结果的正确

• 低延迟,每秒处理数百万个事件,毫秒级延迟

• 与众多常用存储系统的连接

• 高可用,动态扩展,实现7\*24小时全天候运行

Flink和Spark

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NsZWFybHhq_size_16_color_FFFFFF_t_70 2]

**数据模型**

– spark 采用 RDD 模型,spark streaming 的 DStream 实际上也就是一组 组小批数据 RDD 的集合

– flink 基本数据模型是数据流,以及事件(Event)序列

**运行时架构**

– spark 是批计算,将 DAG 划分为不同的 stage,一个完成后才可以计算下一个

– flink 是标准的流执行模式,一个事件在一个节点处理完后可以直接发往下一个节点进行处理

## 快速上手 ##

pom 文件

<dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>1.10.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.12</artifactId>
            <version>1.10.1</version>
        </dependency>
    </dependencies>

### 批处理 wordcount ###

public class WordCount { 
    
        public static void main(String[] args) throws Exception { 
    
            // 创建执行环境
            ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
    
            // 从文件中读取数据
            String path = "/home/lxj/workspace/Flink/src/main/resources/hello.txt";
            DataSource<String> inputDataSet = env.readTextFile(path);
    
            // 对数据集进行处理，按空格展开，转换成（word,1）的二元组，进行统计
            DataSet<Tuple2<String, Integer>> resultSet = inputDataSet.flatMap(new MyFlatMapper())
                    .groupBy(0) // 按照第一个位置的word分组
                    .sum(1);// 将第二个位置上的数据求和
    
            resultSet.print();
    
        }
    
        public static class MyFlatMapper implements FlatMapFunction<String, Tuple2<String, Integer>> { 
    
            @Override
            public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception { 
    
                // 按空格分词
                String[] words = value.split(" ");
    
                // 遍历所有word，包成二元组输出
                for (String word : words) { 
                    out.collect(new Tuple2<String, Integer>(word, 1));
                }
            }
        }
    }
    
    // 从文本中获取的结果如下
    (flink,2)
    (hadoop,1)
    (scala,1)
    (spark,1)
    (word,2)
    (hello,5)

### 流处理wordcount ###

public class WordCountStream { 
    
        public static void main(String[] args) throws Exception { 
    
            // 创建流处理执行环境
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            // 设置并行度
            // env.setParallelism(10);
            
            // 用Parameter tool工具从程序启动参数中提取配置项
            // ParameterTool parameterTool = ParameterTool.fromArgs(args);
            // String host = parameterTool.get("host");
            // int port = parameterTool.getInt("port");
    
            // 从文件中读取数据
            // String path = "/home/lxj/workspace/Flink/src/main/resources/hello.txt";
            // DataStream<String> inputDataStream = env.readTextFile(path);
            
            // 从socket文本流读取数据
            DataStreamSource<String> inputDataStream = env.socketTextStream("localhost", 7777);
    
            // 基于数据流记性转换计算
            DataStream<Tuple2<String, Integer>> resultStream = inputDataStream.flatMap(new WordCountBatch.MyFlatMapper())
                    .keyBy(0)
                    .sum(1);
    
            resultStream.print();
    
            // 执行任务
            env.execute();
        }
    }
    
    // 文本读取结果如下
    // 前面的数字是开发环境下处理数据的分区号，默认是电脑的CPU核数；也就是数据处理的并行度
    5> (word,1)
    5> (flink,1)
    2> (hello,1)
    6> (hadoop,1)
    2> (hello,2)
    5> (flink,2)
    1> (scala,1)
    2> (hello,3)
    1> (spark,1)
    5> (word,2)
    2> (hello,4)
    2> (hello,5)
        
    // 监听端口数据如下
    lxj@lxj:$ nc -lk 7777
    hello word
    hello spark
    
    3> (hello,1)
    8> (word,1)
    1> (spark,1)
    3> (hello,2)

[23a590828f964dbab830e51c48d7ca2d.png]: /images/20220829/8d6843d9611c4ea9b1591d2f2a32ac59.png
[3071d66ea624490faaba2aa2467f382a.png]: /images/20220829/44783d2611ee4e5dac015ecd208ad28a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NsZWFybHhq_size_16_color_FFFFFF_t_70]: /images/20220829/e501fb78ef3746388ff2000f64daf572.png
[324645a3b52a42f49479704d8ad90be1.png]: /images/20220829/1631e1ee6b3248b9a7e6d367e46b9811.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NsZWFybHhq_size_16_color_FFFFFF_t_70 1]: /images/20220829/7ed7cc279477448e93e309b9ff1d40b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NsZWFybHhq_size_16_color_FFFFFF_t_70 2]: /images/20220829/388c6d08ebbf4b7fbe2a80ea3eb57e6f.png