大数据复习

明月清风，良宵美酒

已于 2022-01-21 12:36:27 修改

阅读量828

点赞数

分类专栏：大数据技术栈文章标签：大数据

于 2019-12-28 17:13:49 首次发布

本文链接：https://blog.csdn.net/qq_40822132/article/details/103746592

版权

大数据技术栈专栏收录该内容

72 篇文章 32 订阅

订阅专栏

大数据复习

Linux基础命令

ls、mkdir、rm|rmdir、cp|scp、mv、touch、more|cat|head|tail、vi 、chmod、du|df、ps、top、grep
> 必须记住
ps - aux | grep 进程名
kill -9 `ps -aux | grep 进程 | awk ‘{print $1}'`
kill  -s TERM 进程号 优雅退出
系统：/etc/profile
用户：~/.bashrc
主机名：/etc/sysconfig/network
网卡：/etc/sysconfig/network-scripts/ifcfg-eth0
ip主机名映射：/etc/hosts
普通用户切换超级管理员：su
常见的软件安装：tar -zxvf|-zcvf 文件名、rpm -ivh|-Uvh rpm包、yum 联网、编译安装（./configure|make |make install）
              tomcat|maven|hadoop        jdk|mysql            tree|get|gcc     Nginx|Redis|FastDFS
SSH：Linux系统之间秘钥认证一种形式，用户无需输入密码即可登录目标主机
ssh-keygen -t rsa|dsa -P '' -f ./ssh/id_rsa  - 产生公私钥
ssh-copyid 目标主机
service 服务名 start|stop|restart|status
chkconfig 服务名 on|off

Hadoop生态圈

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LdV8S7zk-1577524345833)(assets/1572834301927.png)]

Kafka Message Queue √

消息队列数据关系形式

点对点：一则消息只能被一个消费者消费一次，不可以重复消费 - ActiveMQ

一对多：一则消息只能被n个消费者消费多次，可以重复消费 - Kafka

Kafka基本架构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-45p04WsO-1577524345834)(assets/1572834944273.png)]

Kafka如何保证高性能读写 √

写入性能：分区、磁盘顺序写入、Memory Map File（内核空间内存）
写出性能：分区、Zero Copy

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-90GXm8e8-1577524345835)(assets/1572837014129.png)]

Kafka 幂等性 | Kafka事务

Kafka数据同步机制 √

LEO（LogEndOffset）：表示每个Partition的Log的最后一条Message的位置
HW（High Watermark）：表示Partition各个replicas数据间同步且一致的offset位置，即表示allreplicas已经commit位置，每个Broker缓存中维护此信息，并不断更新，是指consumer能够看到的此partition位置。 ISR 集合中最小的LEO，即为分区的HW
ISR（In-Sync replicas）：处于同步中的副本集合，Kafka分区Leader维系了一份ISR列表，该列表会将一些慢节点移除

replica.lag.time.max.ms= 最大允许Replicas 同步时间间隔 大于该参数，该节点会被移除

https://www.cnblogs.com/yoke/p/11486196.html

https://blog.csdn.net/qq_36142114/article/details/80314947

Kafka Streaming

Kafka流计算基于应用端计算
Kafka流计算不存在阶段划分
Kafka流计算的并行度和分区保持一致，所需要资源由分区决定
不具备Shuffle功能，，不涉及任务间的通信
Kafka流计算的Shuffle基于Topic分区的特性实现

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n3lmcZ3l-1577524345835)(assets/1572840877733.png)]

HBase NoSQL

HBase 和 HDFS 关系
行存储 & 列存储 - IO利用率比较高
列簇、列、RowKey、版本概念
- RowKey 列簇列名时间
RowKey设计 √
- 固定格式：xxx-xxxx-xxxx
- 不可以随机生成或者使用UUID生成
- 一般将查询的数据作为RowKey组成成分
如何规避HBase热点写问题√
- 可以将RowKey设计为hash、随机、UUID 不采取
- 在HBase上嫁接MQ 充当缓冲区
- RowKey设计为hash+ Elasticsearch 充当二级索引
HBase 架构
- HMaster | HRegionServer | Zookeeper
- HRegionServer：负责管理Region、HLog（WAL）、MemStore、BlockCache
- Region：Store(列簇)-> MemStore -> HFile(StoreFile) - Compact - minor | major

Hadoop 准备

HDFS

1）NameNode 和 SecondaryNameNode区别？

2）块存储好处、HDFS默认块大小是多少？window block是多大 32MB

HDFS 为何不能存储小文件？

4）什么是Rack机架？
5） HDFS HA：NameNode、journalnode、zkfc、zookeeper、datanode

MapReduce

1）MapReduce任务执行11步骤：

运行Job

获取ApplicationID | JobID

Copy Job资源到HDFS - 切片、代码、配置

提交任务给Resource Manager

RM->NM 消耗一个Container资源，用于启动MRAppMaster

MRAppMaster初始化任务，完成任务调度前的准备工作

MRAppmaster 查询输入切片信息 | 配置，进而获取第1、2阶段任务并行度

MRAppmaster 连接RM获取计算资源

MRAppmaster 连接NM消耗Container | YarnChild

YarnChild获取代码片段和切片信息

YarnChild调用MapTask后者Reduce Task

2）如何书写一个Job提交

创建Job对象

指定输入输出格式类

指定输入和写出路径

设置Mapper|Reducer逻辑

设置Mapper和Reducer输出key-value类型

Job提交

注意：需要设定numReduceTasks数量 / 设置Mapper端输出压缩 / 如果任务支持Combiner、必须设置Combiner

3）MapReduce 切片计算方案：Split：0~140.8 MB Split – MapTask --JVM | Container

为什么说MapReduce不擅长处理小文件？
CombineTextInputFormat 专门处理小文件

4）MapReduce Shuffle √

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XkX3HoIf-1577524345836)(assets/1572922886478.png)]
5）什么是MapReduce计算中的数据倾斜？

6）MapReduce能否对key做全局排序？

Apache Storm

1）流与批处理区别

批：延迟高（30min ~ 几个小时）输入量极大 GB+ 静态数据阶段性计算 -最终终止离线

流：延迟低（亚秒、毫秒）输入数据量几十~几百 bytes 动态数据 7*24 小时持续计算实时计算

2）Storm都有哪些特性

数据处理延迟低 - 时效性好 PK Spark Streaming
Storm吞吐能力不如Spark Streaming
支持最多一次（没有任何保障）、至少一次（Tuple ACK机制重复）以及精准一次语义处理（不重不漏）

Low Level API Trident API

3）Storm 并行度理解

Numbus（master）、Supervisor（Slave）、Zookeeper
Topology - 任务 Worker进程、 Executor线程、Task（Bolt、Spout实例）

Tuple可靠性处理机制（ACK机制至少一次语义处理）

5）状态管理StatefulBolt（Redis | HBase）、MapState（Redis | HBase - 精准一次语义处理）

6）Storm window和watermeker机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4oT1AzBe-1577524345836)(assets/1572927094940.png)]

7）什么是流计算的back presure（背压机制）

Zookeeper

1）Zookeeper是AP还是CP的服务？CP

zookeeper强调一致性和分区容错性，zookeeper的集群中一般一定会有1个leader，其它的都是follower，leader接收所有的读写请求，follower也可以接收请求，但是底层都会将请求转发给leader。

2)Zookeeper底层Leader选举协议？

zookeeper底层使用ZAB选举协议，改协议分为3个阶段：
1）发现（Discover阶段）所有的节点都处于 LOOKING阶段
2）同步阶段：即选举完成后，Follower同步最新Leader的最新数据
3）广播阶段：当同步完成之后，接收客户端的请求，广播给所有的服务器，实现数据在集群中的多副本存储

Zookeeper使用场景都有哪些？

几乎所有Apache 软件，需要做协调或者是选举的时候，都会用到Zookeeper，HDFS-HA、HBase、Kafka、Storm、Spark、Flink
早期阿里巴巴Dubbo，使用Zookeeper节点发布与订阅消息，实现了注册中心
可以使用Zookeeper开发分布式锁

4）使用Redis开发分布式锁和使用Zookeeper开发分布式锁的区别是什么？

Redis setnx 开发分布式锁，无法保证线程顺序，有可能让某些线程一直处于等待状态（自己动手实现）
Zookeeper 开发分布式锁，主要借助Zookeeper的临时顺序节点（可以使用Curator-framework实现）

<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>2.7.1</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>2.7.1</version>
</dependency>

RetryPolicy retryPolicy=new ExponentialBackoffRetry(1000,5);
CuratorFramework client= CuratorFrameworkFactory
                                                .newClient("CentOS:2181",retryPolicy);
client.start();

    //String path = client.create().forPath("/baizhi", "hehe".getBytes());
    InterProcessReadWriteLock lock = new InterProcessReadWriteLock(client, "/com.baizhi.service.IUserService#update");
    InterProcessMutex readLock = lock.readLock();
    InterProcessMutex writeLock = lock.writeLock();

    writeLock.acquire();
    //...
    writeLock.release();

    readLock.acquire();
    //...
    readLock.release();

client.close();

4）Zookeeper中都有哪些节点？临时、持久、序列

是否了解Zookeeper的ACL？Access Control List

schema: id :permission

setAcl /baizhi schema:id:permission 
setAcl /baizhi ip:192.168.0.110:cwdra

Apache Hive(1.2.x)

Hive运行原理？ SQL -> MapReduce -> ResutSet

SQL->AST(Abstract Syntax Tree)->Task（MapReduceTask，FetchTask）->QueryPlan（Task集合）->Job（Yarn）

Hive 管理和外部表区别？
分区表指的是什么？有何作用？
你在项目中如何使用Hive的？

>./bin/hive        # 管理员模式
-----------
>./bin/hiveserver2 # 启动服务

> ./bin/beeline -u jdbc：hive2://CentOS:10000/xxxdb -n root

Spark 生态圈

Scala 编程

scala语言有什么特点？什么是函数式编程？

相比较于Java语言，Scala是纯粹面向对象编程，因为Scala没有基本类型。除此以外Scala还大量使用函数式编程用于集合计算。Scala中预定义function0~function22这些内置函数，在Scala 所有的方法其实都是function0~function22实例。该实例在编写的时候可以写成基本方法的形式使用def关键字，同时也可写成匿名函数形式，方法实现使用lambda表达式。函数式编程可以在网络传递方法对象，方法传递成本低。

什么是Scala|Javascript中的闭包

在变量定义作用域以外使用该变量，称为闭包

scala> def method(x:Int):(Int=>Int)={
     |   (y:Int)=> x*y
     | }
method: (x: Int)Int => Int

scala> var m= method(1)
m: Int => Int = <function1>

scala> m(2)
res14: Int = 2

scala中的柯里化

柯里化指的是将原来接受n个参数的函数变成新的接受一个参数的函数的过程

def mul(x:Int,y:Int) = x * y  //该函数接受两个参数
def mulOneAtTime(x:Int) = (y:Int) => x * y  //该函数接受一个参数生成另外一个接受单个参数的函数

什么是scala中的模式匹配
在Scala剔出switch-case取而代之使用 macth-case，将mach case称为模式匹配

x match{
    case 匹配模式 => 运行代码块
    _ => 默认匹配
}

case class和class的区别

case class 适用于建模使用模型类，所有属性都是val的不允许修改。其次创建样例类可以不使用new关键字，样例类 == 比较的是内容。

谈一谈 Scala中implicit & implicitly关键字的用法。

修饰变量隐式值 | 修饰参数隐式注入 | 修饰方法隐式转换 | 修饰class 隐式增强。其中implictly关键字用于获取上下文中的隐式值。

scala中的伴生类和伴生对象

在scala中，单例对象与类同名时，该对象被称为该类的伴生对象，该类被称为该对象的伴生类。伴生类和伴生对象要处在同一个源文件中。伴生对象和伴生类可以互相访问其私有成员。可以在伴生对象中定义apply工厂方法创建伴生类的实例。此时在创建伴生类的对象时候可以省略new关键字。

sealed、lazy、val、var 关键字用法

sealed 修饰类，要求该类已知子类必须和父类在同一源文件中

lazy懒加载，只用在使用的时候才会真正的执行。

val 用于修饰常量，不允许修改

var 修饰变量。

请使用Scala实现wordcount & 常见操作集合算子

scala> Array("this is a demo").flatMap(_.split(" "))
						      .map((_,1))
							  .groupBy(_._1)
							  .map(t=>(t._1,t._2.size))
                              .toList.sortBy(_._2)
res20: List[(String, Int)] = List((is,1), (a,1), (demo,1), (this,1))

Spark RDD（重点）

Spark 比 MapReduce 计算要快？

Spark	MapRedcue
内存计算	磁盘迭代
DAGScheduler - >stages-> Tasks	矢量计算只用 Map -> Reducde
Spark使用`线程`运行任务- 轻	Map Reduce使用进程YarnChild调度任务- 重
Spark有RDD Cache、缓存中间结果	-
计算之前先申请计算资源	计算过程中申请资源

因此在一些迭代计算中，迭代次数越多，Spark计算优势越明显。

介绍一些Spark任务计算流程。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dSdOUE97-1577524345837)(assets/1573009851204.png)]

1）创建SparkContext

2）初始化SparkContext，申请资源

3）创建DAGScheduler和TaskScheduler、SchedulerBackend（和计算节点通信），系统会将计算资源反向注册到Drvier

4）调用DAGScheduler对任务做Stage划分（RDD 宽窄依赖关系）

5）提交的stage，每个Stage会根据RDD的区分区，计算出任务的并行度，封装成Taskset提交给服务后端

6）Driver在真个计算过程中调度和协调各个阶段任务执行。

spark 提交模式 deploy-mode 参数 client和cluster分别表示什么含义。

如果是在Client模式运行，Driver是运行在本地提交任务的节点上，单一进程运行。如果是Cluster模式Driver运行在Worker节点上，处于一种并行计算的形式。

RDD都有哪些特性（5大特性）

A list of partitions- RDD都有分区
A function for computing each split - 按照分区实现并行计算
A list of dependencies on other RDDs - RDD存在相互依赖关系，-linage血统 shuffle|narrow
Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned) - 给k-v RDD 指定分区策略
Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file) - 更具数据块的位置，优化的计算，采取本地计算原则。

RDD中常见转换算子都有哪些，以及转换和动作算子区别？

map、filter、flatMap、mapPartition、mapPartitionwithIndex、coalesce、repartition、union、join、cogroup、reduceByKey、aggregateByKey。

所有的转换算子都是lazy执行的，只有在动作算子的时候任务会被提交。这个时候转换算子才会真正的执行。

转换算子的返回值是RDD、而动作算子返回值可以 Unit、Array，一个任务中只能有一个动作，多个转换。

map -> mapPartition coalesce、repartition reduceByKey reduce collect foreach区别
谈一谈 Spark 中Stage划分原则？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k8IaR2zG-1577524345837)(assets/1573011328004.png)]

Spark的计算核心是抽象了一个RDD，RDD存在分区和依赖关系。更具RDD的分区和子RDD分区的映射关系将RDD依赖分为宽依赖（ShuffleDependency|NarrowDependency）。系统在任务提交时的会调用DAGScheduler计算任务state。首先先根据FinalRDD创建一个ResultStage，然后调用了DAGScheduler#submitStage（state）方法。在Satge提交阶段，系统在提交当前stage需要逆向反退出当前ResultStage的所有父Stage（ShuffleMapStage）。在寻找父Stage的时候系统会更具RDD的宽窄依赖做Stage划分。当当前Satge没有父Stage的时候，系统会将当前的Stage所对应的任务提交。如果是ShuffleMapStage系统会更具分区计算出ShuffleMapTask并且将该Task封装成TaskSet提交。如果是ResultStage系统会更具分区计算出ResultTask并且将该Task封装成TaskSet提交。

RDD容错策略以及Cache和Checkpoint区别

重复计算``cache``checpoint

cache - 存储在内存或者磁盘 checpoint:检查点、持久化到磁盘，一般手动删除，系统在做计算的时候如果RDD需要Cache，那么计算结果会被立即缓存，但是如果RDD需要checpoint，系统先只是给当前RDD做标记，在计算完成后，再重复计算当前被标记checpoint的RDD.

Cache策略间区别？

cache()和persistent()区别。

StorageLevel.MEMORY_ONLY       # 直接将RDD只存储到内存，效率高，占用空间大
StorageLevel.MEMORY_ONLY_2     # 直接将RDD只存储到内存，效率高，占用空间大，并且存储两份
StorageLevel.MEMORY_ONLY_SER   # 将RDD先进行序列化，效率相对较低，占用空间稍微小
StorageLevel.MEMORY_ONLY_SER_2 # 将RDD先进行序列化，效率相对较低，占用空间稍微小，并且存储两份

StorageLevel.MEMORY_AND_DISK
StorageLevel.MEMORY_AND_DISK_2
StorageLevel.MEMORY_AND_DISK_SER
StorageLevel.MEMORY_AND_DISK_SER_2 # 不确定情况下，一般使用该种缓存策略

StorageLevel.DISK_ONLY             # 基于磁盘存储
StorageLevel.DISK_ONLY_2
StorageLevel.DISK_ONLY_SER
StorageLevel.DISK_ONLY_SER_2

什么是广播变量？

我们在Driver中定义了变量，在计算算子中我们常使用Driver中定义的变量，spark底层在执行的时候，仅仅是将Driver中定义的变量通过网络方式传递给计算节点，计算节点仅仅是copyDriver中定义的数据。事实上每个计算节点都维系了一个Driver中定义的变量的副本，并不会修改Driver中的变量。为了避免计算算子重复下载Driver中变量，Spark提供了变量广播机制。通过广播变量将需要下载的数据提前广播给所有的计算节点，这样后续所有计算在使用该变量的时候，直接从本地获取，节省了计算节点和Driver通讯的网络成本。

foreach的用法，请查看一下代码，指出不足，并且提出改进意见

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yu6DcBVQ-1577524345838)(assets/1573012085549.png)]

如何解决Spark在shuffle过程中出现了内存溢出该怎么办？

1）第一种情况：分区数太小，导致每个任务处理的分区数据太大，注意在shuffle之前增加RDD分区数。

2）第二种：分区数很多，但是由于分布不均匀，导致了数据倾斜，也会引发OOM，需要重新设计key，然后调用shuffle()

会将数据在分区中重新洗牌。
3）当计算超大集群规模大的数据，可以尝试先对数据做预处理|预分区，降低数据计算规模。

Spark Streaming

什么是DStream，它的全称叫什么？

DStream是构建RDD之上的流处理工具，通过多在时间轴上对RDD进行微批处理。它的全称为Discretized Stream.

什么是Spark流计算中背压，一起如何开启Spark背压。

背压也称为back presure，通常如果流计算接受数据的速率大于计算的速率，会导致数据在内存大量堆积，最终导致worker节点内存溢出。为了解决这个问题，所有流计算都自己的back presure机制，Spark -1.5之前的背压只通过限制Receviver接受数据的效率但是这种设置国语过于死板，用户很难把控接受速率，。因此在Spark-1.5以后的版本添加背压机制的实现PIDRateEstimator，默认情况下Spark是没有开启背压，需要用户配置spark.streaming.backpressure.enabled=true

Spark DStream是否支持Event-Time处理？

DStream因为构建离散流之上，所有窗口的划分时间都必须是微批的整数倍，也就意味着所有的时间都是计算节点的时间，因此Spark DStream只能基于Processing-Time。如果需要基于Event-time处理，用户可以使用Strucured Stream（Spark-2.0+）。

Spark Dstream 中updateStateByKey和mapWithState

这俩算子都是DStream中支持有状态计算，DStream[(key,value)]类型的流才可以使用，在使用时候必须checkpoint.

updateStateByKey:系统留存全量的状态数据，一旦有更新，所有数记录全部输出。

mapWithState ：系统留存全量的状态数据，但是只会输出那些更新的key的记录

Spark DStream是如何实现故障恢复的

val ssc:StreamingContext=StreamingContext.getOrCreate(checkpointDir,()=>{
    val streamingContext:StreamingContext=...
    streamingContext
})
ssc.sparkContext.setLogLevel("FATAL")//关闭日志输出
ssc.start()
ssc.awaitTermination()

对于Spark状态恢复，要求用户不能修改 checkpointFunction的实现，因此spark在做持久化的时候会将流计算的代码也会存储在检查点目录。

谈一下什么是Strucured Stream以及它和DStream的区别。

Strucured Stream构建在Spark SQL之上的一款流处理工具，可以让用户是用Dataset/Dataframe操作无界数据，同时支持多种处理模型，默认使用微批模型。但是这种流处理实现精准一次的语义的状态更新，同时增强窗口计算提供了基于Event-time的时间窗口，并且提出了水位线的概念，用于系统管理窗口状态。

解释一下在Strucured Stream中Complete、Update以及Append模式的使用场景和区别？

对于非窗口计算而言，Complete和Update都是用在有状态更新的场景，其中Complete表示全量输出和DStream的updateStateByKey类似。而Update只会输出那些存在更新key的记录和mapWithState 类似。Append主要用于在没有状态计算的输出场景，如果Update在没有状态的计算的场景中也可使用，此时该模式等价于Append模式。

窗口计算：一般在Strucured Stream的窗口计算都是基于Eventtime的窗口，因此一般需要指定watermarker，该watermarker主要是告知Spark设么时候可以丢弃窗口计算状态。在带有watermarker的窗口计算中，通常会使用Update模式和Append模式输出。其中Update模式，会导致窗口在水位线没有没过窗口的end时间的时候，会多次触发，但是如果是Append模式，当且仅当水位线没过窗口的时候，该窗口的聚合结果才会输出。

Strucured Stream是如何定义迟到，以及迟到的数据如何处理的？

在Spark的计算中，如果水位线没有没过窗口的截止时间，这个时候如果有迟到的数据（在其他的框架中，称为乱序数据），Spark会将迟到数据重新加入到窗口计算中。如果在Update模式下，水位线已经没过窗口，这个时候到达的数据Spark有可能会丢弃该数据，数据迟到越久，被处理几率越小。Spark仅仅保证的是水位线在没有没过窗口之前的所有状态都会留存，如果窗口一旦被水位线淹没,Spark就无法保证这些迟到的数据还能否参与计算。（spark并没有提供任何策略去处理too late的数据）。

介绍一下什么是Strucured Stream水位线？

水位线在spark只是为了告知Spark何时丢弃窗口计算状态。如果水位线越过窗口的end时间，Spark就可以删除该窗口的状态。

watermarker=max event time seen by compute node - alow late

Spark SQL

Spark SQL 运行原理（背）

Spark SQL构建在Spark RDD之上大数据分析工具，该工具使用了第三方的SQL解析引擎Catalyst，借助于Catalyst解析引擎尝试将SQL进行语法解析。解析步骤如下：

SQL - > UnReserved Logic Plan --> Logic Plain --> Optimized Logical Plan --> Physical Plans --> Cost Model --> Physical Plan -> RDD

SQL 语法分析根据表结构 Rule Based Optimized RBO|CBO 计算引擎代价模型最佳物理模型计算

SQL语句首先通过Parser模块被解析为语法树，此棵树称为Unresolved Logical Plan；Unresolved Logical Plan通过Analyzer模块借助于数据元数据解析为Logical Plan；此时再通过各种基于规则的优化策略进行深入优化，得到Optimized Logical Plan；优化后的逻辑执行计划依然是逻辑的，并不能被Spark系统理解，此时需要将此逻辑执行计划转换为Physical Plan；

参考：http://www.dataguru.cn/article-10731-1.html

Dataset和Dataframe区别

首先Dataset是一个加强版的RDD，处理拥有RDD所有算子操作，还提供基于命名列的操作，由于Dataset仅仅支持Java/Scala、因此Spark有封装了Dataframe，该API对编程语言兼容性更好，本质是一个特殊Dataset[Row].

如何自定义Spark　UDF

单行函数

spark.udf.register("annual_salary",(salary:Double,age:Int)=>{
    if(age>25){
        salary*12+5000
    }else{
        salary*12
    }
})

聚合函数

写一个class继承 UserDefinedAggregateFunction即可

Flink 复习

谈一谈你对Flink理解和认知？

Flink是一个纯粹的流处理框架，所有的计算都是有状态的。Flink提供强大的状态管理、完备窗口计算等策略。相比较于其它流处理框架而言，Flink具有延迟低，能够实现基于Event-Time 窗口状态计算，同时也提供了比较完善延迟数据的处理。

Flink这款框架在架构的设计上和Spark的宏观架构非常相似。Flink底层资源管理可以使用standalone、yarn、messos等，对于HDFS、HBASE存储也是完全兼容。Flink和Spark最大的区别在于底层计算引擎的实现方式，对于Spark而言底层使用RDD批处理模型实现所有计算，但是对于Flink而言底层计算引擎使用流计算。因此对已Spark而言在批处理引擎构建的流处理存在延迟高问题。Flink在流处理之上封装了Datastream / Dataset API 分别实现流计算和批处理模型。除此以外在Datastream / Dataset API 之上同样也提供了 Table API 类似 spark DStream 、Structured Stream 功能，除此以外，Flink 在Dataset API也提供了Flink ML、Gelly API这点类似Spark提供 Spark ML 和 GraphX 等组件。

Flink 主要擅长流处理 - 延迟低 Spark 比较擅长批处理 - 时间久

介绍一下Flink 计算流程。

在Flink中Client负责计算程序DataFlow Graph ，然后将计算好的DataFlow Graph 提交给JobManager.然后由JobManager更具任务中最大并行度，给该任务分配计算资源Task Slots.JobManage更具DataFlow Graph描述的Tasks（Stages）将Task根据并行度转换为SubTasks，然后将SubTasks任务提交相应的Task Manager进行执行。在整个计算过程中有JobManager负责任务调度、cheackpoint协调。

解释一下什么是Client、JobManager、TaskManager 、TaskManager、Task、Task Slot以及Spark区别？

Cleint ：类似Driver，但是不负责任务调度，Cleint负责计算Dataflow graph。

JobManager：类似 ClusterManager，但是他除了分配资源以外，还需要做任务调度、检查点协调。

TaskManager ：真正执行任务的节点、负责运行subtasks。

Task: Flink通过Operater Chain将若干个算子归到一个Task中，等价于Spark中Stage。

subTask：每一个Task都有并行度，SubTask就是更具Task并行度创建的一组线程，等价Spark 中TaskSet

Task Slot：任务槽、Flink通过Task Slot对TaskManager内存进行均分，每一个Task Slot只能分配给一个Job，但是一个Task Slot可以

执行同一个Job的不同Task的subTask任务。Task slot 类似Spark Cores

Flink中常见的分区策略都有哪些

GlobalPartitioner：上游的数据全部发送给下游实例的第一分区。

ShufflePartitioner：随机将上游任务的数据随机发送给下游。

RebalancePartitioner：将上游分区的数据分别以轮训方式发送给下游

RescalePartitioner：基于上下游Operator的并行度，将记录以循环的方式输出到下游Operator的每个实例。举例: 上游并行度是2，下游是4，则上游一个并行度以循环的方式将记录输出到下游的两个并行度上;上游另一个并行度以循环的方式将记录输出到下游另两个并行度上。若上游并行度是4，下游并行度是2，则上游两个并行度将记录输出到下游一个并行度上；上游另两个并行度将记录输出到下游另一个并行度上。
BroadcastPartitioner：上游所有分区数据广播给下游任务的每一个分区。

ForwardPartitioner：要求上下游分区数目一直，实现one to one 形式数据发送。

KeyGroupStreamPartitioner：基于Key的hash，保证相同的key发送给下游的同一个分区。

Flink支持哪几种重启策略？分别如何配置？

Flink支持：Fixed Delay Restart Strategy、Failure Rate Restart Strategy、No Restart Strategy、Fallback Restart Strategy

可以通过fllink-conf.ymal

restart-strategy: failure-rate
restart-strategy.failure-rate.max-failures-per-interval: 3
restart-strategy.failure-rate.failure-rate-interval: 5 min
restart-strategy.failure-rate.delay: 10s

或者

val env = ExecutionEnvironment.getExecutionEnvironment()
env.setRestartStrategy(RestartStrategies.failureRateRestart(
  3, // max failures per unit
  Time.of(5, TimeUnit.MINUTES), //time interval for measuring failure rate
  Time.of(10, TimeUnit.SECONDS) // delay
))

请问重启策略和故障恢复策略区别

重启策略规定的是否以及什么时间启动故障恢复策略，而故障恢复策略描绘的是如何恢复。故障恢复一般通过flink-conf.ymal配置

jobmanager.execution.failover-strategy: all|region

Flink的分布式缓存有什么作用？如何使用？

Flink中的分布式缓存等价于Spark 广播变量类似，系统会在计算之前将文件分发给所有TaskManager计算，未来所有的算子在使用的时候直接从TaskManager获取即可。

fsEnv.registerCachedFile("hdfs:///xxx.xxxx","jdbcCon")

在所有RichFunction

val cache = getRuntimeContext.getDistributedCache
val jdbcConFile = cache.getFile("jdbcCon")

Flink中的广播变量，使用广播变量需要注意什么事项？

这一一个用在批处理模型中的一种手段，等价于spark的广播变量。

val bEnv = ExecutionEnvironment.getExecutionEnvironment

val broad = bEnv.fromElements(1,2,3,4)

bEnv.fromElements("a b c")
.flatMap(_.split(" "))
.map(new RichMapFunction[String,(String,Int)] {
    override def map(value: String): (String, Int) = {
        val list = getRuntimeContext.getBroadcastVariable("nums")
        println(list)
        (value,0)
    }
}).withBroadcastSet(broad,"nums")
.print()

Flink的窗口分类，以及什么是Trigger&Evictor

滑动、滚动、回话、Global，Trigger 指定窗口触发时机、Evictor剔出窗口的元素。

. Flink 中的 State Backends是什么？有什么作用？分成哪几类？说说他们各自的优缺点？

memory、fs、rockdb

Flink中的时间种类有哪些？各自介绍一下？
WaterMark是什么？是用来解决什么问题？如何生成水印？水印的原理是什么？
Flink的容错机制

Flink基于分布式快照与可部分重发的数据源实现了容错。用户可自定义对整个Job进行快照的时间间隔，当任务失败时，Flink会将整个Job恢复到最近一次快照，并从数据源重发快照之后的数据。

checkpoint和savepoint区别
Flink Kafka如何保证精准一次的语义操作？

erride def map(value: String): (String, Int) = {
val list = getRuntimeContext.getBroadcastVariable(“nums”)
println(list)
(value,0)
}
}).withBroadcastSet(broad,“nums”)
.print()


- Flink的窗口分类，以及什么是Trigger&Evictor

滑动、滚动、回话、Global，Trigger 指定窗口触发时机、Evictor剔出窗口的元素。

- **. Flink 中的 State Backends是什么？有什么作用？分成哪几类？说说他们各自的优缺点？**

memory、fs、rockdb

- **Flink中的时间种类有哪些？各自介绍一下？**

- **WaterMark是什么？是用来解决什么问题？如何生成水印？水印的原理是什么？**

- **Flink的容错机制**

Flink基于分布式快照与可部分重发的数据源实现了容错。用户可自定义对整个Job进行快照的时间间隔，当任务失败时，Flink会将整个Job恢复到最近一次快照，并从数据源重发快照之后的数据。

**[外链图片转存中...(img-uNLQgKRG-1577524345838)]**

- checkpoint和savepoint区别

- Flink Kafka如何保证精准一次的语义操作？

<https://blog.csdn.net/u011750989/article/details/81568018>