devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

尚硅谷大数据Flink1.17实战教程-笔记01【Flink概述、Flink快速上手】_尚硅谷 flink

作者：凡人多烦事01 | 2024-05-08 13:30:29

赞

踩

尚硅谷 flink
  1. 尚硅谷大数据Flink1.17实战教程-笔记01【Flink概述、Flink快速上手】
  2. 尚硅谷大数据Flink1.17实战教程-笔记02【Flink部署】
  3. 尚硅谷大数据Flink1.17实战教程-笔记03【】
  4. 尚硅谷大数据Flink1.17实战教程-笔记04【】
  5. 尚硅谷大数据Flink1.17实战教程-笔记05【】
  6. 尚硅谷大数据Flink1.17实战教程-笔记06【】
  7. 尚硅谷大数据Flink1.17实战教程-笔记07【】
  8. 尚硅谷大数据Flink1.17实战教程-笔记08【】
  9. 尚硅谷大数据Flink1.17实战教程-笔记09【】
  10. 尚硅谷大数据Flink1.17实战教程-笔记10【】
  11. 尚硅谷大数据Flink1.17实战教程-笔记11【】

目录

基础篇

第01章-Flink概述

P001【001_课程介绍】09:18

第1章 Flink概述

P002【002_Flink概述_Flink是什么】14:13

P003【003_Flink概述_Flink发展历史&特点】08:14

P004【004_Flink概述_与SparkStreaming的区别&应用场景&分层API】12:50

第2章 Flink快速上手

P005【005_Flink快速上手_创建Maven工程&导入依赖】03:49

P006【006_Flink快速上手_批处理实现WordCount】18:00

P007【007_Flink快速上手_流处理实现WordCount_编码】13:13

P008【008_Flink快速上手_流处理实现WordCount_演示&对比】06:03

P009【009_Flink快速上手_流处理实现WordCount_无界流_编码】13:57

P010【010_Flink快速上手_流处理实现WordCount_无界流_演示&对比】05:14

本套教程基于Flink新版1.17进行讲解，共分四大篇章：基础篇、核心篇、高阶篇、SQL篇。教程通过动画讲解、实战案例演示，带你掌握Flink构建可靠、高效的数据处理应用。

基础篇

P001【001_课程介绍】09:18

谁在用Flink？答：腾讯、华为、滴滴、阿里巴巴、快手、亚马逊等大厂都在用。

Flink特点

  1. 批流统一
    1. 同一套代码，可以跑流也可以跑批
    2. 同一个SQL，可以跑流也可以跑批
  2. 性能卓越
    1. 高吞吐
    2. 低时延
  3. 规模计算
    1. 支持水平扩展架构
    2. 支持超大状态与增量检查点机制
    3. 大公司使用情况：
      1. 每天处理数万亿的事件
      2. 应用维护几TB大小的状态
      3. 应用在数千个CPU核心上运行
  4. 生态兼容
    1. 支持与Yarn集成
    2. 支持与Kubernetes集成
    3. 支持单机模式运行
  5. 高容错
    1. 故障自动重试
    2. 一致性检查点
    3. 保证故障场景下精确一次的状态一致性

课程特点

  1. 由浅入深
  2. 动图讲解重难点
  3. 全新版本
  4. 内容详实

第01章-Flink概述

P002【002_Flink概述_Flink是什么】14:13

Flink的官网主页地址：https://flink.apache.org/

Flink核心目标，是“数据流上的有状态计算”（Stateful Computations over Data Streams）。

具体说明：Apache Flink是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。

P003【003_Flink概述_Flink发展历史&特点】08:14

我们处理数据的目标是：低延迟、高吞吐、结果的准确性和良好的容错性。

Flink主要特点如下：

  1. 高吞吐和低延迟。每秒处理数百万个事件，毫秒级延迟。
  2. 结果的准确性。Flink提供了事件时间（event-time）和处理时间（processing-time）语义。对于乱序事件流，事件时间语义仍然能提供一致且准确的结果。
  3. 精确一次（exactly-once）的状态一致性保证。
  4. 可以连接到最常用的外部系统，如Kafka、Hive、JDBC、HDFS、Redis等。
  5. 高可用。本身高可用的设置，加上与K8s，YARN和Mesos的紧密集成，再加上从故障中快速恢复和动态扩展任务的能力，Flink能做到以极少的停机时间7×24全天候运行。

P004【004_Flink概述_与SparkStreaming的区别&应用场景&分层API】12:50

表 Flink 和 Streaming 对比

Flink

Streaming

计算模型

流计算

微批处理

时间语义

事件时间、处理时间

处理时间

窗口

多、灵活

少、不灵活（窗口必须是批次的整数倍）

状态

有

没有

流式SQL

有

没有

第02章-Flink快速上手

P005【005_Flink快速上手_创建Maven工程&导入依赖】03:49

  1.     <properties>
  2.         <flink.version>1.17.0</flink.version>
  3.     </properties>
  4.  
  5.     <dependencies>
  6.         <dependency>
  7.             <groupId>org.apache.flink</groupId>
  8.             <artifactId>flink-streaming-java</artifactId>
  9.             <version>${flink.version}</version>
  10.         </dependency>
  11.  
  12.         <dependency>
  13.             <groupId>org.apache.flink</groupId>
  14.             <artifactId>flink-clients</artifactId>
  15.             <version>${flink.version}</version>
  16.         </dependency>
  17.     </dependencies>

P006【006_Flink快速上手_批处理实现WordCount】18:00

ctrl + p：查看传参方式。

  1. hello flink
  2. hello world
  3. hello java

  1. package com.atguigu.wc;
  2.  
  3. import org.apache.flink.api.common.functions.FlatMapFunction;
  4. import org.apache.flink.api.java.ExecutionEnvironment;
  5. import org.apache.flink.api.java.operators.AggregateOperator;
  6. import org.apache.flink.api.java.operators.DataSource;
  7. import org.apache.flink.api.java.operators.FlatMapOperator;
  8. import org.apache.flink.api.java.operators.UnsortedGrouping;
  9. import org.apache.flink.api.java.tuple.Tuple2;
  10. import org.apache.flink.util.Collector;
  11.  
  12. /**
  13.  * TODO DataSet API 实现 wordCount
  14.  */
  15. public class WordCountBatchDemo {
  16.     public static void main(String[] args) throws Exception {
  17.         // TODO 1.创建执行环境
  18.         ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
  19.  
  20.         // TODO 2.读取文件：从文件中读取
  21.         DataSource<String> lineDS = env.readTextFile("input/word.txt");
  22.  
  23.         // TODO 3.切分、转换（word, 1）
  24.         FlatMapOperator<String, Tuple2<String, Integer>> wordAndOne = lineDS.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
  25.             @Override
  26.             public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception {
  27.                 // TODO 3.1 按照空格切分单词
  28.                 String[] words = value.split(" ");
  29.                 // TODO 3.2 将单词转换为(word, 1)格式
  30.                 for (String word : words) {
  31.                     Tuple2<String, Integer> wordTuple2 = Tuple2.of(word, 1);
  32.                     // TODO 3.3 使用Collector向下游发送数据
  33.                     out.collect(wordTuple2);
  34.                 }
  35.             }
  36.         });
  37.  
  38.         // TODO 4.按照word分组
  39.         UnsortedGrouping<Tuple2<String, Integer>> wordAndOneGroupBy = wordAndOne.groupBy(0);
  40.  
  41.         // TODO 5.各分组内聚合
  42.         AggregateOperator<Tuple2<String, Integer>> sum = wordAndOneGroupBy.sum(1); //1是位置，表示第二个元素
  43.  
  44.         // TODO 6.输出
  45.         sum.print();
  46.     }
  47. }

P007【007_Flink快速上手_流处理实现WordCount_编码】13:13

2.2.2 流处理

  1. package com.atguigu.wc;
  2.  
  3. import org.apache.flink.api.common.functions.FlatMapFunction;
  4. import org.apache.flink.api.java.functions.KeySelector;
  5. import org.apache.flink.api.java.tuple.Tuple2;
  6. import org.apache.flink.streaming.api.datastream.DataStreamSource;
  7. import org.apache.flink.streaming.api.datastream.KeyedStream;
  8. import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
  9. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
  10. import org.apache.flink.util.Collector;
  11.  
  12. /**
  13.  * TODO DataStream实现Wordcount：读文件（有界流）
  14.  *
  15.  */
  16. public class WordCountStreamDemo {
  17.     public static void main(String[] args) throws Exception {
  18.         // TODO 1.创建执行环境
  19.         StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  20.  
  21.         // TODO 2.读取数据:从文件读
  22.         DataStreamSource<String> lineDS = env.readTextFile("input/word.txt");
  23.  
  24.         // TODO 3.处理数据: 切分、转换、分组、聚合
  25.         // TODO 3.1 切分、转换
  26.         SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOneDS = lineDS //<输入类型, 输出类型>
  27.                 .flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
  28.                     @Override
  29.                     public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception {
  30.                         // 按照 空格 切分
  31.                         String[] words = value.split(" ");
  32.                         for (String word : words) {
  33.                             // 转换成 二元组 （word，1）
  34.                             Tuple2<String, Integer> wordsAndOne = Tuple2.of(word, 1);
  35.                             // 通过 采集器 向下游发送数据
  36.                             out.collect(wordsAndOne);
  37.                         }
  38.                     }
  39.                 });
  40.         // TODO 3.2 分组
  41.         KeyedStream<Tuple2<String, Integer>, String> wordAndOneKS = wordAndOneDS.keyBy(
  42.                 new KeySelector<Tuple2<String, Integer>, String>() {
  43.                     @Override
  44.                     public String getKey(Tuple2<String, Integer> value) throws Exception {
  45.                         return value.f0;
  46.                     }
  47.                 }
  48.         );
  49.         // TODO 3.3 聚合
  50.         SingleOutputStreamOperator<Tuple2<String, Integer>> sumDS = wordAndOneKS.sum(1);
  51.  
  52.         // TODO 4.输出数据
  53.         sumDS.print();
  54.  
  55.         // TODO 5.执行：类似 sparkstreaming最后 ssc.start()
  56.         env.execute();
  57.     }
  58. }
  59.  
  60. /**
  61.  * 接口 A，里面有一个方法a()
  62.  * 1、正常实现接口步骤：
  63.  * <p>
  64.  * 1.1 定义一个class B  实现 接口A、方法a()
  65.  * 1.2 创建B的对象：   B b = new B()
  66.  * <p>
  67.  * <p>
  68.  * 2、接口的匿名实现类：
  69.  * new A(){
  70.  * a(){
  71.  * <p>
  72.  * }
  73.  * }
  74.  */

P008【008_Flink快速上手_流处理实现WordCount_演示&对比】06:03

主要观察与批处理程序 BatchWordCount 的不同：

  1. 创建执行环境的不同，流处理程序使用的是 StreamExecutionEnvironment。
  2. 转换处理之后，得到的数据对象类型不同。
  3. 分组操作调用的是 keyBy 方法，可以传入一个匿名函数作为键选择器（KeySelector）， 指定当前分组的 key 是什么。
  4. 代码末尾需要调用 env 的 execute 方法，开始执行任务。

P009【009_Flink快速上手_流处理实现WordCount_无界流_编码】13:57

2）读取 socket 文本流

在实际的生产环境中，真正的数据流其实是无界的，有开始却没有结束，这就要求我们需要持续地处理捕获的数据。为了模拟这种场景，可以监听 socket 端口，然后向该端口不断地发送数据。

[atguigu@node001 ~]$ sudo yum install -y netcat

[atguigu@node001 ~]$ nc -lk 7777

  1. package com.atguigu.wc;
  2.  
  3. import org.apache.flink.api.common.typeinfo.TypeHint;
  4. import org.apache.flink.api.common.typeinfo.TypeInformation;
  5. import org.apache.flink.api.common.typeinfo.Types;
  6. import org.apache.flink.api.java.tuple.Tuple2;
  7. import org.apache.flink.configuration.Configuration;
  8. import org.apache.flink.streaming.api.datastream.DataStreamSource;
  9. import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
  10. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
  11. import org.apache.flink.util.Collector;
  12.  
  13. /**
  14.  * TODO DataStream实现Wordcount：读socket（无界流）
  15.  *
  16.  */
  17. public class WordCountStreamUnboundedDemo {
  18.     public static void main(String[] args) throws Exception {
  19.         // TODO 1. 创建执行环境
  20.         StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  21.         // IDEA运行时，也可以看到webui，一般用于本地测试
  22.         // 需要引入一个依赖 flink-runtime-web
  23.         // 在idea运行，不指定并行度，默认就是 电脑的 线程数
  24.         // StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
  25.  
  26.         env.setParallelism(3);
  27.  
  28.         // TODO 2. 读取数据： socket
  29.         DataStreamSource<String> socketDS = env.socketTextStream("node001", 7777);
  30.  
  31.         // TODO 3. 处理数据: 切换、转换、分组、聚合
  32.         SingleOutputStreamOperator<Tuple2<String, Integer>> sum = socketDS
  33.                 .flatMap(
  34.                         (String value, Collector<Tuple2<String, Integer>> out) -> {
  35.                             String[] words = value.split(" ");
  36.                             for (String word : words) {
  37.                                 out.collect(Tuple2.of(word, 1));
  38.                             }
  39.                         }
  40.                 )
  41.                 .setParallelism(2)
  42.                 .returns(Types.TUPLE(Types.STRING, Types.INT))
  43.                 // .returns(new TypeHint<Tuple2<String, Integer>>() {})
  44.                 .keyBy(value -> value.f0)
  45.                 .sum(1);
  46.  
  47.         // TODO 4. 输出
  48.         sum.print();
  49.  
  50.         // TODO 5. 执行
  51.         env.execute();
  52.     }
  53. }
  54.  
  55. /**
  56.  * 并行度的优先级：
  57.  * 代码：算子 > 代码：env > 提交时指定 > 配置文件
  58.  */

P010【010_Flink快速上手_流处理实现WordCount_无界流_演示&对比】05:14

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/554819
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号