【大数据面试题大全】大数据真实面试题（持续更新）_大数据高频面试题

### 1.36.利用 Flink 把 Kafka 中的表和 DB 数据库中的表进行 join 的时候，一开始 Flink 可以查到数据，但是过了一段时间后就查询不到数据了，解决方案


检查数据源是否堆积，还有就是检查 Flink 是否有数据积压，通过 FlinkWebUI 端口号查看进行中的任务(8081)，查看是否出现了反压，webUI 提供了可视化的反压监控功能。


### 1.37.Flink 或 Spark 怎么保证不重复消费


Flink 有 exactly-once 一致性语义，spark 不能做到恰好一次消费，可能需要整合其他框架如 redis 等。


### 1.38.Flink 中 watermark 的原理


Flink 中 watermark 通常与 window 窗口进行结合使用，正常情况下数据全部到达 window 中后，才对数据进行分析处理，但是无法避免有延迟的数据，watermark 就是为了解决这个问题，watermark 可以保证数据尽量完整的到达 window 窗口中(当事件进入窗口中，会根据事件最大的事件时间产生watermark时间戳)


* watermark 的 window是怎么触发窗口函数的?

 watermark>=窗口结束时间即可触发
* 如何计算 watermark 的值?

 watermark=事件时间-最大允许的延迟时间


### 1.39.Flink 设置了多个并行度的时候取最大值还是最小值


最小值


### 1.40.Flink 中 sink 到不同的存储介质，是怎么保证数据不丢失的


checkpoint+exactly-once


### 1.41.checkpoint 和 savecheckpoint 有什么区别


* checkpoint：

 有一些 barriers 机制，主要是做分布式快照，对状态和计算过程进行快照存储，防止计算过程中状态的丢失导致数据要重新计算，容错机制 Flink 重新在服务器启动的时候，要基于 checkpoint 重新启动。
* savepoint：

 savepoint 是 checkpoint 的一种特殊实现，底层其实也是使用的是 checkpoint 的机制，savepoint 的用户一般使用手动命令的方式来触发 checkpoint，并且将结果持久化到指定的存储路径中（hdfs 路径），其重要的目的就是帮助用户在升级或者维护集群过程中保存系统中的状态数据，避免防止运维的一些正常操作使作业无法恢复到原有的计算状态，从而无法实现端到端的 Excatly-Once 的语义保证。

 SavePoint 的路径需要在 `flink-conf.yaml` 中配置。

 state.savepoints.dir：`hdfs://node01:8020/flink/state/savepoint`


系统大规模的升级维护的时候用到，先手动执行savepoint，然后停止job，然后重启job


### 1.42.Flink 的 checkpoint 的 state 大小大概多大，Flink 的 checkpoint 运行一次的时间大概多久


checkpoint 就是数据跟着 barriers 走，一般运行一次的时间就是流式数据执行一条数据的时间，一般是秒级，state 的大小 300M 左右即可。


checkpoint 执行一次的时间根据数据量来决定，一般 Flink on Hive 中，数据量较小的 checkpoint 可以达到秒级，数据量较大时要达到几分钟级。


## 2）Spark


### 2.1.Spark 提交任务的流程


首先 Driver 启动创建 SparkContext，sc 向 ClusterManager 注册资源，CM 向 Worker 分配资源，Worker 启动 executor 进程，然后 executor 等待 task 的提交，Driver 构建 DAG，DAG 提交到 DAGSchedule 进行划分 Stage，然后到 TaskSchedule 提交 task 到 executor 中，最后注销资源。


### 2.2.对 Spark 中并行度的理解


Spark 的并行度取决于 Stage 中的 task 的数量，代表各个阶段 Stage 的并行度，一般 task 的数量为 SparkCore 总数的2~3倍最佳。


### 2.3.Spark 有几种部署方式


* local 本地，通常是测试的时候用。
* standalone，Spark 自己模拟作为一个调度系统，任务提交给 Master。
* SparkonYarn 交给Yarn来进行资源调度，有 yarn-cluster 和 yarn-client 两种模式。
* mesos 一般国外用的较多，国内都是用 SparkonYarn 较多。


### 2.4.Sparkonyarn 作业执行流程，yarn-client 和 yarncluster 有什么区别


* client 是将 driver 运行在本地，然后和 yarn 集群进行远程通信，所以说有远程通信带来的资源的损耗，但是好处是运行结果可以再本地显示出来。
* cluster 是将 driver 分配到 yarn 集群中，减少了远程传输带来的资源的损耗，结果不能再本地显示，但是可以通过 webUI8088 中的 application 中的 log 文件中查看结果。


### 2.5.Spark 提交作业时候的基本参数（重点）


driver-core：默认是1


driver-memory：driver的内存大小，默认是512M


executor-core：默认是1官方建议2~5个，我们是4个


num-executor：默认是2个，设置可以为10个


executor-memory：executor的内存大小，默认为1G


提交的样板：



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

spark-submit
–masterlocal[5]
–driver-cores2
–driver-memory8g
–executor-cores4
–num-executors10
–executor-memory8g
–classPackageName.ClassNameXXXX.jar
–name"SparkJobName"
InputPath
OutputPath

### 2.6.为什么使用 Yarn 来部署 Spark


首先 Yarn 是支持动态的资源分配，而 Sparkalone 的资源分配是固定的，按照 job 顺序依次分配资源，资源不够的时候就排队，而且 Sparkalone 具有单点故障的问题，最后 Yarn 作为一个成熟的资源调度平台不光可以对 Spark 提供资源调度，还有Hadoop，MR，Hive等。


### 2.7.对于 Spark 中的数据倾斜有什么解决方案


* 可以改变并行度进行调整，因为一改变并行度可能让原本分配到 task 上的 key 进行另一种分配方式，有可能就解决了数据倾斜问题
* 自定义 partitioner，想怎么分区就怎么分区
* 让 map 端的 join 代替 reduce 端的 join，比如通过 Spark 的 Broadcast 机制，避免 shuffle 从而解决数据倾斜
* 对 key 进行处理，比如加上随机前缀/后缀等


### 2.8.如何理解 Spark 中的血统概念（RDD）


血统可以用来进行容错，Spark 中的 RDD 之间存在依赖关系，一旦某个 RDD 的数据发生丢失，可以从父 RDD 中进行重新计算，不用进行整个的计算。


### 2.9.简述 Spark 的宽窄依赖，以及 Spark 如何划分 stage，每个 stage 又根据什么决定 task 个数?（笔试重点)


* 宽依赖：一个父RDD被多个子RDD所依赖
* 窄依赖：一个父RDD只被一个子RDD所依赖
* Spark中划分stage是遇到宽依赖就进行划分
* stage就是多个task组成的TaskSet，stage根据分区数划分成一个个的task


### 2.10.例举 Spark 中的 Transformation 和 Action 算子，还有进行 Shuffle 的算子


* Transformation

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

map
flatMap
reduceByKey
groupByKey
filter
mapPartition
combineByKey
aggregateByKey
union
coalesce
persist
cache
join
leftOutJoin
rightOutJoin
textFile
mapValues
flatMapValues

* Action–触发Job的算子

 
1
2
3

first
take
top
reduce
saveAsTextFile
count
countByKey
countByValue
collect
foreach
foreachPartition
distinct

* Shuffle–产生Stage划分的算子

 
1
2
3

reduceByKey
groupByKey
join
coalesce
repartition

### 


### 2.11.Repartition 和 Coalesce 关系与区别


repartition 的底层就是 coalesce，但是试讲 shuffle 开启的，coalesce 是根据传入的参数来决定 shuffle 是否开启，一般增大 rdd 的分区数用 repartition，减少 rdd 的分区数用 coalesce。


### 2.12.groupByKey 和 reduceByKey 的区别


两个都有 shuffle 的操作，都是按照 key 进行分区，但是 reduceByKey 在 shuffle 之前进行了预聚合，在使用中 reduceByKey 是优于 groupByKey 的。


### 2.13.分别简述 Spark 中的缓存机制（cache 和 persist）与 checkpoint 机制，并指出两者的区别与联系


* cache的底层就是persist，但是persist是缓存到内存中的，checkpoint是持久化到磁盘的
* persist使用后要使用unpersist进行内存的释放，而checkpoint不需要
* persist保留着RDD之间的依赖关系，而checkpoint切断了血缘关系
* cache只有一种缓存就是MEMORY\_ONLY，但是persist可以根据需求进行不同的缓存位置


### 2.14.简述 Spark 中共享变量（广播变量和累加器）的基本原理与用途（重点）


累加器是一种分布式的变量的机制，记录分布式的改变，并聚合这些改变，通常用于记录事件变化的次数。


共享变量就是由于Spark是分布式的，如果有一个数据集，集合中的每一个任务都要用到这个数据集，那么可以用共享变量的方式将变量分布到每一个机器中，减少了数据的远程传输带来的资源损耗。


### 2.15.广播变量使用需要注意什么


* 广播变量只能由 Driver 端定义
* 在每个 executor 端只能读取不能修改
* 只能在 Driver 端进行修改
* 广播变量使用 BlockManager 进行管理，存在每个 executor 的内存中


### 2.16.Spark 中的任务的概念


每次遇到一个 action 都会生成一个 job，用户提交的 job 会提交给 DAGScheduler，job 会被分解成 Stage 和 Task。


### 2.17.SparkRDD 是怎么容错的，基本原理是什么


可以从血统或者窄依赖这个角度进行分析，还有就是 checkpoint。


### 2.18.说说 worker 和 executor 有什么区别


worker 就是每个节点上启动的进程，负责管理本节点的进程，其实也可以理解为就是程序真正运行的节点，executor 是 Spark 程序启动之后启动的一个进程，一旦 Spark 程序结束了那么 executor 也会随之消失，和 Spark 程序有着相同的生命周期。


### 2.19.说说 Spark 中的 Master


Master 是在 Local 模式和 Standalone 下的负责分配资源的和资源管理工作的进程。


### 2.20.Spark 中的预写日志


当 Spark 进行相对应的操作的时候，Spark 会将操作记录在一个日志中，然后执行操作，一旦执行的过程中操作出现了中断，那么就重新读取日志，重新进行日志中的操作即可。


### 2.21.Driver 是什么，作用是什么


Driver 是程序启动后启动的一个进行，里面带有程序的 main 方法，是程序的入口点


Driver 的作用是，如果是 Master 模式就向 Master 申请资源注册资源，如果是 Yarn 模式就向 Yarn 集群进行资源的申请，生成 Stage，并调度 Task 到 executor 上。


### 2.22.Spark 为什么比 MR 快


首先是基于内存进行计算的，减少了大量的磁盘交互，其次是高效的调度方法，基于 DAG 进行任务执行，有 Lingage 血统容错机制，即使 Spark 不基于内存速度也会比 MR 块。


### 2.23.Spark 中的 RDD 介绍一下


RDD是一个分布式的数据集，是Spark中最基本的数据抽象，RDD有这么五个特点，分别是：


* 依赖性：RDD之间有依赖关系。
* 计算位置：RDD会自己选择最佳的计算位置，可以避免数据移动带来的开销。
* 计算函数：用来计算RDD各个分区上的数据。
* 分区列表：每个分区里是RDD的部分数据。
* 分区器(可选)：用于键/值类型的RDD，比如某个RDD是按散列来分区。


### 2.24.RDD 有哪些缺陷


RDD 不支持细粒度的写和更新操作，不支持迭代计算，Flink支持。


### 2.25.RDD 有几种操作


transformation 和 action;还有 crontroller，如 persist，cache 等控制算子，对性能效率有很好的支持。


### 2.26.RDD 创建有哪几种方式


1）使用程序中的集合创建rdd。


2）使用本地文件系统创建rdd。


3）使用hdfs创建rdd。


4）基于数据库db创建rdd。


5）基于Nosql创建rdd，如hbase。


6）基于s3创建rdd。


7）基于数据流，如socket创建rdd。


如果只回答了前面三种，是不够的，只能说明你的水平还是入门级的，实践过程中有很多种创建方式。


### 2.27.Spark 程序执行，有时候默认为什么会产生很多 task，怎么修改默认 task执行个数


首先输出多个小文件的时候会产生多个 task，还有就是分区数量影响 task 的数量，可以再配置文件中进行更改。


### 2.28.当 Spark 涉及到数据库的操作时，如何减少 Spark 运行中的数据库连接数


使用 foreachPartition 代替 foreach，因为 foreach 是有几个元素就进行几次连接，而 foreachPartition 是有几个分区进行几个连接，减少连接带来的资源的消耗。


### 2.29.Job 和 Task 怎么理解


Job 是每次触发 Action 函数的时候都会形成一个 Job，Task 是 Stage 中的 RDD 分区数是多少就有多少个 task。


### 2.30.Spark 中的 executor 内存（内存模型）分配


* executor内存：主要是记录一些shuffle等计算过程中的临时数据。
* storage内存：主要是cache/persist时的内存。
* 用户内存：主要是记录RDD之间的Transformation和依赖关系的地方。
* 预留内存：用来存储Spark内部对象。


### 2.31.Spark 中的本地小文件读取


使用wholeTextFile，读取目录下的所有小文件。


### 2.32.Spark 何时缓存数据


当一个 RDD 的计算过程比较复杂，并且这个 RDD 后续要被多次使用的时候进行缓存。


### 2.33.简述 SparkSQL 中 RDD、DataFrame、DataSet 三者的区别与联系（笔试重点）


* RDD 的好处是安全，编译时就能检查出类型的错误，面向对象的方式进行打点调方法，但是缺点就是进行大量的序列化和反序列化的操作，还会进行频繁的创建和销毁对象的操作，势必会增加 GC。
* DataFrame 在 RDD 的基础上加入了 schema 约束，让数据变得更加的结构化，减少了序列化和反序列化操作。
* DataSet 在 DataFrame 的基础上添加了泛型的操作。


三者转化：



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

//rdd->DF：
.toDF
//rdd->DS：
.toDS
//DS->rdd：
.rdd
//DF->rdd：
.rdd
//DF->DS：
.toDS
//DS->DF：
.as[泛型]

### 2.34.Hadoop 中，Mapreduce 操作的 mapper 和 reducer 阶段相当于spark 中的哪几个算子


相当于 map 和 reducebykey 算子，但是还是有一定的区别的，MR 是自动排序的，spark 要看用的是什么 partitioner。


### 2.35.什么是 shuffle，以及为什么需要 shuffle


shuffle翻译过来是洗牌的意思，将带有共同特征的数据汇聚到一个节点上进行计算时用shuffle。


### 2.36.spark.default.parallelism 这个参数有什么意义，实际生产中如何设置


并行度在 Spark 中非常重要，指的是 Stage 中可以并行执行的task的数量，官网建议的是 CPU 核数 \* executor 数量的 2~3 倍最佳。


### 2.37.使用 Spark 完成 WordCount



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

valconf=newSparkConf()
valsc=newSparkcontext(conf、setMaster(“locla[*]”)
valresult=sc.textFile(“xxx.txt”)
.flatMap(.split(“”))
.map((，1))
.reduceByKey(+)
.saveAsTextFile()//.foreach(println)
sc.stop()

### 2.38.cache 后面能不能接其他算子，它是不是 action 操作


cache 后面可以加其他算子，但是加了其他的算子就起不到缓存的作用了，因为会重新触发 cache，cache 不是 action 操作，是 transformation 操作。


### 2.39.Spark 提交你的 jar 包时所用的命令是什么


spark-submit


### 2.40.Spark 并行度是什么，如何合理的设置并行度


`https：//www.cnblogs.com/haozhengfei/p/e19171de913caf91228d9b432d0eeefb.html`


spark 的并行度就是 stage 上同时运行的task的数量，一般 spark 设置并行度和 cpu 的 core 相同即可，官方建议是 cpu 的 core 的 2~3 倍，但是一般设置相同即可。


### 2.41.SparkStreaming 的执行流程（大概）


SparkStreaming 的执行主要是靠 Driver 和 Executor之 间的相互协作进行的。


首先 Driver 端创建病启动 SparkContext 对象，SparkContext 对象中管理着 DStreamGraph 和 JobSchedule，DStreamGraph 主要是来定义 DStream 并且管理 DStream 之间的依赖关系，JobSchedule 主要是生成和调度 Job，executor 是在节点中的一个进程，是随着 Spark 程序的结束而消失的，可以说 executor 和 Spark 程序有着相同的生命周期。


executor 端不断地接收消息，调用 store() 方法，将数据存储，然后处理数据，处理数据就是生成 job，执行 job，job 是 DStreamGraph 根据 DStream 之间的依赖关系生成的，生成后会提交到 submitjobSet 中，然后执行 job，job 会根据我们编写的代码执行输出。


### 2.42.SparkStreaming 有哪几种方式消费 Kafka 中的数据，区别是什么


* receiver

 receiver 是使用 Kafka 的高层次的 Consumer-API 进行实现的，数据是存储在 executor 的内存中，如果数据短时间内大量增加，batch 数据堆积，可能会出现内存溢出问题，然后 SparkStreaming 会启动job处理这些数据，但是这种处理数据依然可能会因为失败而丢失数据，所以底层还会有预写日志机制，会将从 Kafka 处理的数据同步到 HDFS 上的，所以即使出现问题也是可以再日志中进行恢复的。
* direct

 Spark1.3 中引用了 direct 方式，摒弃了 receiver 这种方式，这种方式会周期性的查询 Kafka，获取 Topic+Partition 的 offset，通过 Kafka 简单的 Consumer-API，获取 Kafka 的 offset 区间的数据。
* 对比

 receiver 是使用 Kafka 高层次 Consumer-API 在 ZK 中保存消费过的 offset，这是消费 Kafka 数据的传统方式，这种方式要配合 WAL 机制，可以保证数据不丢失，但是无法保证数据只被处理一次，因为 Spark 和 ZK 无法做到同步，可能被处理多次，但是 direct 模式使用 Kafka 简单的 API，采用 SparkStreaming 自动追踪 offset，并保存在 checkpoint 中，Spark 自己本身肯定是能保证同步的，因此可以保证数据消费一次，生产中大多使用 direct 模式。


### 2.43.SparkStreaming 的窗口函数的原理


窗口用来处理指定时间内的数据，并且需要通过设置参数指定窗口滑动的步长，用来设置当前任务计算完成后，下次任务从什么时间进行计算。


### 2.44.Spark 中的 4040 端口有什么功能


Spark 的 Job 的运行信息


### 2.45.如何使用 Spark 实现 TopN



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

//TODO2.transformation
//RDD[(单词，数量)]
valresult：RDD[(String，Int)]=lines.filter(StringUtils.isNoneBlank())
.flatMap(.split(“”))
.map((，1))
.reduceByKey(+_)

//需求：对WordCount的结果进行排序，取出top3
valsortResult1：Array[(String，Int)]=result
.sortBy(_._2，false)//按照数量降序排列
.take(3)//取出前3个

//result.map(t=>(t._2，t._1))
valsortResult2：Array[(Int，String)]=result.map(_.swap)
.sortByKey(false)//按照数量降序排列
.take(3)//取出前3个

valsortResult3：Array[(String，Int)]=result.top(3)(Ordering.by(_._2))//topN默认就是降序

//TODO3.sink/输出
result.foreach(println)

sortResult1.foreach(println)

sortResult2.foreach(println)

sortResult3.foreach(println)

### 2.46.Spark 中的容错方法


* RDD 间的 lineage 机制，RDD 之间有依赖关系，宽依赖和窄依赖。
* checkpoint 机制，DAG 中的血缘过长，如果一旦重新计算消耗的资源太大，所以需要进行检查点的设置，另外在宽依赖上进行 checkpoint 获得的收益更大。


### 2.47.Spark 中的分区方式


* HashPartitioner（哈希分区）如：groupbykey，reducebykey。
* RangePartitioner（范围分区）如：sortby，sortbykey。


### 2.48.Spark-On-Hive



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

packagecn.itcast.sql

importorg.apache.spark.SparkContext
importorg.apache.spark.sql.expressions.UserDefinedFunction
importorg.apache.spark.sql.{Dataset，SparkSession}

/**
*Authoritcast
*Desc演示SparkSQL-使用SparkSQL-UDF将数据转为大写
*/
objectDemo09_Hive{
defmain(args：Array[String])：Unit={
//TODO0.准备环境—需要增加参数配置和开启hivesql语法支持
valspark：SparkSession=SparkSession.builder(、appName(“sparksql”、master(“local[*]”)
.config(“spark.sql.shuffle.partitions”，“4”)//本次测试时将分区数设置小一点，实际开发中可以根据集群规模调整大小，默认200
.config(“spark.sql.warehouse.dir”，“hdfs：//node1：8020/user/hive/warehouse”)//指定Hive数据库在HDFS上的位置
.config(“hive.metastore.uris”，“thrift：//node2：9083”)
.enableHiveSupport()//开启对hive语法的支持
.getOrCreate()
valsc：SparkContext=spark.sparkContext
sc.setLogLevel(“WARN”)
importspark.implicits._

//TODO1.操作Hive
spark.sql(“showdatabases”、show(false)
spark.sql(“showtables”、show(false)
spark.sql(“CREATETABLEperson4(idint，namestring，ageint)rowformatdelimitedfieldsterminatedby’'”)
spark.sql(“LOADDATALOCALINPATH’file：///D：/person.txt’INTOTABLEperson4”)
spark.sql(“showtables”、show(false)
spark.sql(“select*fromperson4”、show(false)

spark.stop()
}
}

## 3）Java


作为目前最火爆的开发语言，使用Java已经是大数据开发者的基本技能，很多大数据组件也适用于Java开发，如：Flink


### 3.1.Java 中的集合


[【Java-Java集合】Java集合详解与区别]( )


### 3.2.Java 中的多线程如何实现


1、继承Thread类。


2、实现Runnable接口。


3、实现Callable接口。


4、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。


详细：`https://www.cnblogs.com/big-keyboard/p/16813151.html`


### 3.3.Java 中的 JavaBean 怎么进行去重


1、利用 HashSet，泛型指定我们创建好的 JavaBean，通过 hashSet 中的 add() 方法，进行去重。



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public static void main(String[] args) {
Date date=new Date();
//获取创建好的javaBean对象并进行赋值
JavaBean t1 = new JavaBean();
t1.setLat(“121”);
t1.setLon(“30”);
t1.setMmsi(“11”);
t1.setUpdateTime(date);
//再创建一个javaBean对象,赋同样的值
JavaBean t2=new JavaBean();
t2.setLat(“121”);
t2.setLon(“30”);
t2.setMmsi(“11”);
t2.setUpdateTime(date);
//用HashSet
HashSet hashSet = new HashSet();
hashSet.add(t1);
hashSet.add(t2);
System.out.println(hashSet);
System.out.println();
for(JavaBean t:hashSet){
//只会出现一个值
System.out.println(t);
}

2、利用 ArrayList，泛型指定我们创建好的 javaBean，通过 ArrayList 中的 contain() 方法进行判断后去重。



1
2
3
4
5

//用List
List lists = new ArrayList();
if(!lists.contains(t1)){
lists.add(0, t1);
}

if(!lists.contains(t2)){//重写equals
	lists.add(0, t2);
}
1
2
3

System.out.println(“长度：”+lists.size());

### 3.4.Java 中 == 和 equals 有什么区别


`==`用来判断对象在内存中的地址是否相等，`equals`用来判断对象中的内容是否相等。


### 3.5.Java 中的任务定时调度器


1、Timer timer = new Timer() timer.schedule（重写 new TimerTask 方法）



1
2
3
4
5
6
7
8
9
10
11
12
13
14

//方式1:
Timer timer = new Timer();
//TimerTask task， 要定时执行的任务
//long delay，延迟多久开始执行
//long period，每隔多久执行延迟
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(“每隔1s执行一次”);
}
}， 5000，1000 );*/

2、Executors.newScheduleThreadPool（线程池数量）返回的对象 scheduleAtFixeRate，重写 run 方法。



1
2
3
4
5

//方式2:
ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
executorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println(“每隔1s执行一次”);
}
}，5，1， TimeUnit.SECONDS);

3、SprintBoot 中提供了定时任务的相关注解，使用起来特别方便，利用corn定义触发的规则。



1
2
3
4
5

@Component//表示该类是Spring的组件，会由Spring创建并管理
@EnableScheduling//表示开启定时任务扫描
public class TestTimedTask2 {
//https://cron.qqe2.com/
@Scheduled(cron = "0/3 * * * * ? ")
public void task(){
System.out.println(“每隔3s执行一次”);
}
}

## 4）SQL


SQL 作为计算机行业最基本的语言之一，也是必须要了解的。


### 4.1.SQL 中的聚合函数


`avg()，max()，min()，sum()，count()` 等


注意：


聚合函数不会自己使用，也不会和 where 一起使用，一般使用的时候都是和 group by 一起使用（分组必聚合），还有就是在 having 语句后面进行使用。


### 4.2.SQL 中的各种 join 与区别


`inner join`（内连接）：就是找到两个表中的交集。


`left join`（左外连接）：以左边的表为主，如果没有与右边的表相对应的用 null 补充在表中。


`right join`（右外连接）：以右边的表为主，同上。


`full join`（满外连接）：Hive 中特有的，MySQL 中没有，保留两边的表的所有内容，没有对应的互相都用 null 补充在表中。


### 4.3.简单说一下 MySQL 中的数据结构


MySQL的数据结构为 B + 树


[【计算机基本原理-数据结构】八大数据结构分类]( )


[【计算机基本原理-数据结构】数据结构中树的详解]( )


### 4.4.关系型数据库和大数据组件中的 nosql 数据库有什么区别


1、关系型数据库的特点：


* 结构化的存储
* 采用结构化的查询语言sql
* 操作数据要具有一致性，比如事务操作
* 可以进行join等复杂查询
* 无法进行大量数据的高并发读写


2、nosql数据库的特点：


* 非结构化的数据库
* 高并发大数据下读写能力强
* 事务性差
* join 的复杂操作能力弱


## 5）Linux


在大数据环境安装部署、提交 jar 包的时候，都会应用到 Linux 操作系统，所以了解需要了解 Linux 常用命令。


[【Linux-Linux常用命令】Linux常用命令总结]( )


## 6）Hadoop


### 6.1.Yarn


#### 6.1.1.Yarn 提交作业流程


1、由客户端向 RM 提交任务（MR，Spark…）


2、RM 接收任务，并根据任务随机找一台NM，启动 AppMaster，通知以 container 方式。



> 
> container：资源信息容器（节点信息，内存信息，CPU信息），运行：AppMaster
> 
> 
> 


3、指定 NM 启动 AppMaster，启动后和 RM 保持心跳机制，用于报告当前已经启动了，并且通过心跳来传递相关信息。


4、根据 RM 给定任务信息，根据任务信息，对任务进行分配，主要会分配出要启动多少个 map 和多少个 reduce，以及每个 map 和每个 reduce 需要使用多大资源空间，然后将资源申请相关信息发送给 RM（心跳发送）


5、RM 接收到资源申请信息后，将申请信息交给内部资源调度器，由资源调度器，根据相关的资源调度方案，进行资源分配即可，如果当下没有资源，在此处等待。


**注意：**


资源并不是一次性全部给到 AppMaster，一般会采用极可能满足方案，如果满足不了，会先给与一定资源进行运行，如果空闲资源连一个 container 都不足，就会将这些资源挂起，等待资源充足。


6、AppMaster 基于心跳机制，不断询问RM是否已经准备好了资源了，如果发现已经准备好了，然后直接将资源信息获取。


7、根据资源信息说明，到指定的 NM 上启动 container 资源容器，开始运行相关任务。


8、NM 接收启动的信息后，开始启动执行，此时会和 AppMaster 以及 RM 保持心跳连接。



> 
> ​ RM 将任务的相关信息根据心跳通知 AppMaster  
>    
>  ​ AppMaster 将资源的使用信息根据心跳通知 RM
> 
> 
> 


9、当 NM 运行完成后，会通知 AppMaster 并将资源使用完成情况通知给 RM。


10、AppMaster 告知给 RM 任务已经运行完成了， RM 回收资源，通知AppMaster进行自毁即可。


**注意：**


当 NM 在运行过程中，如果发生错误了，此时 RM 会立即将资源回收，此时 AppMaster 就需要重新和 RM 申请资源。


详情：[【Hadoop-Yarn】Yarn 的运行流程]( )


#### 6.1.2.Yarn 的资源调度


1、`FIFO scheduler` ：`先进先出调度方案`


当一个调度任务进入到调度器之后，那么调度器会优先满足第一个MR任务全部资源，此时就有可能将资源全部都获取到了，导致后续的任务本身的运行时间很短，但是由于第一个MR将资源全部抢走了， 导致后续任务全部等待。


此种调度器在生产中 一般不会使用，因为生产中yarn平台不是你自己的。


2、`Fair scheduler`：`公平调度器`


可以预先分配出多个队列, 相当于对资源进行预先的划分。


3、`capacity scheduler`：`容量调度器`


此种调度器是有 Yahoo 提供一种调度方案，同时也是当下Apache版本的hadoop默认调度方案。每个队列，可以指定占用多少的百分比的资源，从而保证，大的任务可以有单独的队列来运行，并且小的任务，也可以正常的运行。


#### 6.1.3.Yarn 成员


clustermanager、nodemanager、applicationmaster。


### 6.2.HDFS


#### 6.2.1.HDFS 读写流程


[【Hadoop-HDFS】HDFS的读写流程 & SNN的数据写入流程]( )


#### 6.2.2.HDFS 中小文件过多会有什么影响


HDFS 擅长存储大文件，我们知道，HDFS 中每个文件都有各自的元数据信息，如果 HDFS 中有大量的小文件，就会导致元数据爆炸，集群管理的元数据的内存压力会非常大（namenode 节点）


#### 6.2.3.HDFS 中小文件过多怎么处理


1、使用官方工具 parquet-tools 合并指定的 parquet 文件。



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

合并 HDFS 上的 parquet 文件

hadoop jar parquet-tools-1.9.0.jar merge /tmp/a.parquet /tmp/b.parquet

合并本地的 parquet 文件

java -jar parquet-tools-1.9.0.jar merge /tmp/a.parquet /tmp/b.parquet

2、合并本地的小文件，上传到 HDFS（通过 HDFS 客户端的 appendToFile 命令对小文件进行合并上传）



1
2
3
4
5

hdfs dfs -appendToFile user1.txt user2.txt /test/upload/merged_user.txt

3、合并 HDFS 的小文件，下载到本地，可以通过 HDFS 客户端的 getmerge 命令，将很多小文件合并成一个大文件，然后下载到本地，最后重新上传至 HDFS。



1
2
3
4
5

hdfs dfs -getmerge /test/upload/user*.txt ./merged_user.txt

4、Hadoop Archives （HAR files）是在 0.18.0 版本中引入到 HDFS 中的，它的出现就是为了缓解大量小文件消耗 NameNode 内存的问题。


HAR 文件是通过在 HDFS 上构建一个分层文件系统来工作。HAR 文件通过 hadoop archive 命令来创建，而这个命令实际上是运行 MapReduce 作业来将小文件打包成少量的 HDFS 文件（将小文件进行合并成几个大文件）



1
2
3
4
5
6
7
8

Usage: hadoop archive -archiveName name -p

har命令说明

参数 “-p” 为 src path 的前缀，src 可以写多个 path

归档文件：

hadoop archive -archiveName m3_monitor.har -p /tmp/test/archive_test/m3_monitor/20220809 /tmp/test/archive

删除数据源目录：

hdfs dfs -rm -r /tmp/test/archive_test/m3_monitor/20220809
​

查看归档文件：

hdfs dfs -ls -R har:///tmp/test/archive/m3_monitor.har
​

解归档：将归档文件内容拷贝到另一个目录

hdfs dfs -cp har:///tmp/test/archive/m3_monitor.har/part-1-7.gz /tmp/test/

#### 6.2.4.HDFS 成员


namenode、datanode、secondarynamenode；namenode 有 active 和 standby。


#### 6.2.5.NameNode 和 SecondaryNameNode 的区别与联系


SecondaryNameNode 并不是 NameNode 的备份节点，主要是将内存中的 Fsimage 和磁盘上的 Fsimage 文件进行合并。


#### 6.2.6.HDFS 中 Fsimage 与 Edits 详解


[【Hadoop-HDFS】HDFS中Fsimage与Edits详解]( )


### 6.3.MapReduce


#### 6.3.1.map 阶段的工作机制


[【Hadoop-MapReduce】MapReduce编程步骤及工作原理]( )（详见标题4：map 阶段的工作机制）


#### 6.3.2.reduce 阶段的工作机制


[【Hadoop-MapReduce】MapReduce编程步骤及工作原理]( )（详见标题5：reduce 阶段的工作机制）


#### 6.3.3.MR 的优劣


​不管是 map 阶段还是 reduce 阶段，大量进行磁盘到内存，内存到磁盘相关的 IO 操作，主要目的能够解决处理海量数据计算问题。


* ​带来好处：能够处理海量的数据。
* 带来的弊端：造成大量的磁盘 IO 工作导致效率比较低。


#### 6.3.4.MR 的相关配置




| 配置 | 默认值 | 释义 |
| --- | --- | --- |
| mapreduce.task.io.sort.mb | 100 | 设置环型缓冲区的内存值大小 |
| mapreduce.map.sort.spill.percent | 0.8 | 设置溢写的比例 |
| mapreduce.cluster.local.dir | ${hadoop.tmp.dir}/mapred/local | 溢写数据目录 |
| mapreduce.task.io.sort.factor | 10 | 设置一次合并多少个溢写文件 |


## 7）Hive


### 7.1.Hive 相关数据的存储位置


Hive 的元数据存储在mysql中（默认derby，不支持多客户端访问），数据存储在 HDFS，执行引擎为 MR。


### 7.2.Hive 内外表的区别


1、建表时用 external 区分。


2、删除外表时删除元数据，删除内表是删除的是元数据和存储数据。


3、外表存储位置自己定，内表存储位置在 /uer/hive/warehouse 中。


### 7.3.Hive 如何实现分区


1、创建表时指定字段进行分区。


2、使用 alter table 对已经创建完成的表进行分区的增加和删除操作。



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

建表：

create table tablename(col1 string) partitioned by(col2 string);

添加分区：

alter table tablename add partition(col2=’202101’);

删除分区：

alter table tablename drop partition(col2=’202101’);

3、修改分区。



1
2
3
4
5

alter table db.tablename
set location ‘/warehouse/tablespace/external/hive/test.db/tablename’

### 7.4.Hive 装载数据



1
2
3
4
5

alter table db.tablename add if not exists partition (sample_date=‘20220102’,partition_name=‘r’) location ‘/tmp/db/tablename/sample_date=20220102/partition_name=r’;

### 7.5.Hive 修复分区数据



1
2
3
4
5

msck repair table test;

### 7.6.Hive 中的排序方式及对比


1、Hive 中的排序方式有：`order by，sort by，distribute by，cluster by`


2、四种排序方式的区别：


* `order by`： 对数据进行全局排序，只有一个 reduce 工作
* `sort by`： 一般和 distribute by 一起使用，当 task 为 1 时效果和 order by 一样
* `distribute by`： 对 key 进行分区，和 sort by 一起实现对分区内数据的排序工作
* `cluster by`： 当 order by 和 distribute by 的字段相同时可以用 cluster by 代替，但是只能升序


注意：


生产环境中使用 order by 比较少，容易造成 oom，使用 sort by 和 distribute by 较多。


### 7.7.row\_number()、rank()、dense\_rank() 的区别：


三者都是对数据进行标号排序


* `row_number()`：不会出现序号的增加或减少，当数值相同时也会有排名先后之分
* `rank()`：当排序相同时序号重复，总序不会变化
* `dense_rank()`：当排序相同时序号重复，总序会减少


### 7.8.Hive 如何实现数据的导入和导出


* 导入数据：

 ① load data 的方式可以对本地或HDFS上的数据进行导入

 ② Location方式

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

create external if not exists stu2 like student location ‘/user/hive/warehouse/student/student.txt’;

 ③ sqoop方式
* 导出数据：一般用sqoop方式


### 7.9.Hive 中 over() 的使用


## 8）Sqoop


### 8.1.Sqoop 常用命令


[【Sqoop-命令】Sqoop相关了解及命令]( )


### 8.2.Sqoop 如何进行空值处理


导出数据时采用 `--input-null-string` 和 `--input-null-non-string` 两个参数。


导入数据时采用 `--null-string` 和 `--null-non-string`。


### 8.3.Sqoop 如何处理特殊字符


Sqoop 中遇到特殊字符可以使用 `hive-drop-import-delims` 丢弃，也可以使用 `--hive-delims-replacement`，它会将特殊字符替换为我们设定的字符。


### 8.4.Sqoop 任务有 reduce 阶段吗


只有 map 阶段，没有 reduce 阶段的任务。默认是 4 个 MapTask。


## 9）Oozie


1、Oozie 一般不单独使用，因为需要配置 xml 文件很麻烦。


2、Oozie 一般与 Hue 一起使用，可以调度各种任务比如 Shell，MR，Hive等。


3、无论是单独使用还是与 Hue 集成，Oozie中最重要的点都在于 workflow 的配置。


4、与 Hue 整合时在 Schedule 中配置定时任务的时间，在 workflow 中配置任务的相关位置信息。


## 10）Azkaban


1、元数据存储在 Mysql 中。


2、有三种部署模式： solo-server（所有服务在一台服务器上）， tow-server（web，executor在不同服务器上），multiple-executor-server（一般不常用）。


3、azkaban的任务调度：


* Hive脚本： test.sql

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use default;
drop table aztest;
create table aztest(id int，name string) row format delimited fields terminated by ‘，’;
load data inpath ‘/aztest/hiveinput’ into table aztest;c
reate table azres as select * from aztest;insert overwrite directory ‘/aztest/hiveoutput’ select count(1) from aztest;

* hive.job（名称.job）

 
1
2
3

type=command #固定
dependencies=xx #有依赖的任务的时候添加这个
command=/home/hadoop/apps/hive/bin/hive -f ‘test.sql’

* 将所有文件打包成 zip 包上传到 Azkaban 上，然后点击 summary，然后选择 schedule 进行时间的配置。


## 11）Flume


Flume 是一个用来实时采集流数据的分布式数据采集系统，容错性强，可靠性高。


### 11.1.Flume 的架构组件


（source，channel，sink）


1、Flume 中的 agent：包含 source，channel，sink 的统称。


2、source：是用来采集数据的组件，可以监控一个文件的变化，可以监控一个目录下新文件的变化，可以监控一个目录下所有文件的内容变化，也可以自定义数据源，在配置的时候要配置 source 的名称。


3、channnel：可以配置两种方式进行数据的缓存，一种是内存，另一种是以生成文件的方式。


4、sink：支持 HDFS，Kafka，自定义目标源等，还可以支持下一个 agent。


5、event：Flume 将采集到的数据封装到 event 中进行传输，本质上是一个字节数组。


### 11.2.Flume 的多种架构


1、Flume 可以以 agent 的方式进行串联。


2、Flume 可以并联，将多个 agent 的 sink 传输到新的 agent 的 source 中。


3、Flume 可以 串联＋并联＋多sink 等。


### 11.3.Flume 的相关配置


1、source，channel，sink 的名称。


2、channel 是基于内存还是基于文件。


3、sink 对应的 channel。


4、sink 到 kafka 的话要配置 kafka 的 topic，端口号，ack 等。


## 12）Kafka


### 12.1.Kafka为什么这么快


1、查询速度快


* 分区，文件分段。
* 二分查找法定位消息在哪个段（文件）中。


2、写入速度快


* 顺序写入。
* 零拷贝：数据直接从磁盘文件复制到网卡设备中，不需要经过应用程序之手。零拷贝技术通过 DMA 技术，将文件内容复制到内核模式下的 ReadBuffer，直接将数据内核的数据传递到网卡设备中，所以零拷贝是针对于内核，数据再内核模式下实现了零拷贝。
* 批量发送：通过 batch.size 参数来设置批量提交数据的大小，默认是16K，当数据积压到这一值时就会统一发送，数据会发送到一个分区中。
* 数据压缩：Producer 端压缩，Broker 端保持，Consumer 端解压缩。


### 12.2.Kafka 怎么避免重复消费


可以利用两阶段事务提交（Flink）或者容器去重（HashSet，Redis，布隆过滤器）


### 12.3.Kafka 怎么保证顺序消费


Kafka 是全局无序但是局部有序，只要我们在推送消息的时候都推送到同一个分区，消费时也指定一个分区消费即可。


### 12.4.Kafka 分区有什么作用


提升读写效率 + 方便集群扩容 + 消费者负载均衡


### 12.5.Kafka 如何保证数据不丢失


1、生产者端，设置 ack（0、1、-1 / all）



> 
> `0`：生产者端不会等到 Broker 端返回 ack，继续生产数据。  
>    
>  `1`：当 Broker 中的 Leader 端收到数据就返回 ack。  
>    
>  `-1 / all`：当 Broker 中的 Leader 和 所有的Follower 都接收到数据才返回 ack。
> 
> 
> 


2、消费者端，采用先消费后提交的方式，宁愿重复消费也不能让数据丢失。


3、Broker 端：有副本机制保证数据安全性。


### 12.6.消费者与消费者组之间的关系


同一时间一条消息，只能被同一个消费者组的一个消费者消费，不能被同一个消费者组的其他消费者消费。但是可以被不同消费者的消费者组所消费。


### 12.7.Kafka 架构及基本原理


[【Kafka-架构及基本原理】Kafka生产者、消费者、Broker原理解析 & Kafka原理流程图]( )


## 13）HBase


### 13.1.HBase 的架构组成


* HMaster
* HRegionServer
* Region
* zookeeper


HBase：Client -> Zookeeper -> HRegionServer -> HLog -> Region -> store -> memorystore -> storeFile -> HFile


### 13.2.HBase 的读写流程


[【HBase-读写流程】HBase的读写流程与内部执行机制]( )


### 13.3.HBase 中 rowkey 的设计


* Hash
* 时间戳倒转


### 13.4.Region 的分区和预分区


* HBase 在创建表的时候可以指定预分区规则。
* HBase 建表后和可以通过 split 命令进行分区的更改。
* HBase 也可以再建表的时候通过 split.txt 文件中的信息通过 SPLIT\_FILE 命令进行预分区。


### 13.5.HBase 优缺点


* 优点：


	+ 支持非结构化数据的存储
	+ 相对于关系型数据库HBase采用列式存储，写入的效率很快
	+ HBase中的null值不会被记录在内，节省空间并提高了读写性能
	+ 支持高并发的读写
	+ 支持大量数据的存储工作
* 缺点：


	+ 本身并不支持sql查询
	+ 不适合大范围的扫描查询


## 14）ClickHouse


### 14.1.ClickHouse 建表时要注意什么


CH 建表时要指定引擎。


### 14.2.ClickHouse 进行表数据更新或删除操作时候的 SQL 语句


更新：`Alter table update (xx="xx") where 主键 = ?`


删除：`Alter table delete where 主键= ?`


写入：`insert into table() values()`


### 14.3.ClickHouse 引擎分类及特点


* **MergeTree：**


	+ MergeTree引擎共同特点：
	
	 用插入来表示数据的更新。因为在 CH 中，主键列不是唯一的，仅仅是为了创建索引，提高我们的查询效率，再次插入数据，数据重复。在 MergeTree 引擎中，后台会有一个进程，在定期执行数据合并操作，但是什么时候不知道。
	+ 注意：
	
	 如果在插入了一条数据之后，马上使用 `select * from tablename`，这个操作不会读取到最新的数据，要等后台合并之后查询到的数据才是最新的，因此为了确保每次查询都是最新的数据有两种解决办法：
	
	 1、手动触发后台进程合并操作：`optimize table 表名 final` 手动合并，但是如果大量数据进行合并会变慢，而且合并过程中表不可以（不推荐）
	
	 2、每次查询的时候对数据进行`分组聚合`操作，已达到去重的目的。
* **日志引擎：**


	+ TinyLog：
	
	 TinyLog 最小最轻量级的引擎，当我们需要快速写入小表（100w 行以内），以后整体读取它们这个引擎是最高效的，追加的方式。
	+ TinyLog缺点：
	
	 没有并发控制，同时读取和写入的时候，读取操作报异常，同时写入多个表，数据会被破坏，不支持索引。
* **集成引擎：**

 Kafka，MySQL，HDFS，ODBC，JDBC，与其他存储数据库或者存储介质进行整合时使用。


	+ 项目没使用集成MySQL的引擎原因：
	
	 因为 CH 是映射 MySQL 的表，本质上还是在 MySQL 中做 select 查询，对数据库造成访问压力。
	+ 注意：
	
	 使用了 MySQL 引擎关联 MySQL 中指定的库，那么在 CH 中就会出现一个库，这个库中是用 MySQL 的 sql 语法来进行操作的。
* **其他特定功能引擎**（用的比较少）


### 14.4.MergerTree 引擎分类


* **MergeTree**：

 1、orderby 一般用于排序主键，使用了 orderby 就不用 primary by 了。

 2、建表后，在指定的目录下，会按照分区进行分文件夹，分区中每个列都是一个 .bin 文件，是一个列被压缩的表现，.idx 文件代表主键索引，.mrk 保存块偏移量。
* **ReplacingMergeTree**：

 1、如果表会进行进行修改使用此引擎，但是此引擎只保证数据最终被修改，无法保证查询过程中主键重复 。

 2、`ENGINE=ReplacingMergeTree([ver])`，ver 为版本，如果 ver 没有指定，那么会保留最后一次修改的内容，如果 ver 指定，保留第一次的内容。
* **SummingMergeTree**：

 1、聚合功能，只能进行sum聚合。

 2、`SummingMergeTree([columns])`，如果指定了 columns，那么所选列不能是主键和非数值类型，如果没有选，会自动把非主键列中的数值列进行聚合。

 3、如果不手动刷新，就要等待后台自动进行聚合，或者使用分组聚合的 sql 查询可以得到刷新后的结果。
* **AggregatingMergeTree**：

 1、聚合功能，功能更加全面，除了 sum 外还有别的聚合功能。

 2、一般和 MergeTree 一起使用，把明细数据存放到 MergeTree 中，然后 insert into 插入到 AggregatingMergeTree 表中，然后再使用分组聚合查询就能得到聚合后的结果。
* **CollapsinMergeTree**：

 CH 中不支持 update 和 delete 操作（不能使用标准的更新和删除语法操作 CH），因此 CH 推荐的方式使用 CollapsinMergeTree 进行删除，在表中增加一个字段 sign，1 表示状态行，-1 表示取消行，用取消行来表示状态行的数据被干掉了，当触发合并操作之后，会对 1 和 -1 进行折叠操作，也就是同时删除了这两条数据。

 状态行和取消行不折叠的两种情况：

 1、由于合并机制是后台发生的，具体的执行时间无法预测，所以可能会出现数据冗余的情况。

 2、如果是先出现的取消行，然后出现的状态行，也无法进行折叠。

 3、CH不能保证数据插入的时候相同主键落到同一个节点上，不同节点上的数据是无法进行折叠的。

 解决方式：在查询数据的时候，使用 sum 将 sign 字段求和，having 出大于 0 的数据即可。

 注意：取消行的特点是除了 sign 列其他的数据都是状态行的拷贝，状态行的数据可以来自于 ogg 和 canal，但是取消行的数据我们难道要通过根据主键查询 CH 表的数据，然后复制拼接取消行数据的 sql 语句吗？

 答案：不需要，ogg 中的删除操作有 before 字段可以直接作为取消行插入到 CH 表中，canal 中的删除操作有 data 字段可以直接作为取消行插入到 CH 表中。
* **VersionCollapsinMergeTree**：

 相对于 CollapsinMergeTree 来说对状态行和取消行插入的顺序没有严格的要求了，但是不仅要添加 sign 列还要增加一个 version 列，用上一条数据的 update 时间来作为 version 的值。

 1、查询依旧使用分组聚合的方式。

 2、或者使用 `select * from tablename final`，此操作并没有真正触发合并，而是后台将数据计算好了呈现出来的效果（这是一个非常低效的方式来选择数据，尽量不要用来查询数据量较大的表）


### 14.5.ClickHouse 表的分类


本地表：部署在单机环境下


集群表：部署在集群环境下


### 14.6.ClickHouse 中的 Update、Delete 操作


在 CH 中不能使用常规的 sql 语句进行 update 和 delete 操作，而是要使用 alter table 进行操作。


* 如何查看操作的数据：

 在CH的system库mutations表中，记录着CH修改操作的记录
* mutation 具体过程：

 首先用 where 条件找到具体的分区，重建每个分区，用新的分区覆盖老的分区，分区一旦被替换，不可退回（即使修改一条数据，也会覆盖，所以效率上来说比较慢）


### 14.7.OLAP 组件分类


* ROLAP：（对明细层的数据进行实时聚合计算查询）

 impala、presto
* MOLAP：（对数据进行多维预聚合加工，然后对预聚合数据进行实时计算查询）

 Druid、Kylin
* HyBirdOLAP：（ROLAP+MOLAP）

 TiDB


### 14.8.ClickHouse 属于 OLAP 还是 OLTP


ClickHouse 属于 ROLAP，但是也可以做 MOLAP（通过物化视图的方式进行预聚合）


CH 与其他 OLAP 的区别：


`Druid`：


实时查询，但是不支持复杂sql查询，不支持数据更新操作。


`Kylin`：


亚秒级查询，支持复杂sql查询，但是会构建 cube，容易出现维度爆炸，维度控制在10个左右，不支持数据更新操作。


`ClickHouse`：


1、即可以对明细数据进行实时OLAP分析，也可以对数据进行预聚合计算。


2、单表查询优势巨大。


3、支持数据更新操作。


4、支持sql查询，多表联查等操作（不支持窗口函数以及相关子查询）


## 15）Kudu


### 15.1.Kudu 的建表


Kudu 的建表必须要有主键。


### 15.2.Kudu 依赖 Hadoop 吗


Kudu 不需要依赖 Hadoop 集群，Kudu 有自己的存储机制。


### 15.3.Kudu 的分区方式一共有几种


hash、range、hash&range（混合分区）三种方式，项目中使用hash方式进行分区。


### 15.4.Kudu 的存储依赖 HDFS 吗


Kudu 不依赖 HDFS。


### 15.5.Kudu 的架构体系（角色）


* master：

 负责管理从节点，并且存储数据在从节点中的位置，也就是元数据。
* catelog：

 元数据的存储位置，无法直接访问，只能通过 API 查询，记录着表的结构，表的位置，状态，以及各个 tablet 开始和结束的 key（分区）


	+ 作用：
	
	 管理元数据，负载均衡，监听 tablet-server 状态。
* tablet-server：

 只负责存储数据，类似于 datanode。


### 15.6.Kudu 的架构体系（特点）


1、Kudu 的存储是以表的形式，有分区，有列名，列的类型，列值，类似于一个关系型数据库，但是还不是关系型数据库。


2、Kudu 是主从结构，有 master 和 tablet-server，主节点又分为 action 和 wait 两个。


3、Kudu 的表分区，分区的副本存在于各个节点上，类似于 Kafka。


4、Kudu 的分区类似于 HBase 的 Region，一张表按照一定间隔规则分成若干个分区。


5、Kudu 的主从节点分工类似于 HDFS 中的 datanode 和 namenode。


6、Kudu 表（tablet-server）中的一个分区会被拆分成多个 tablet，每一个分区对应一个 tablet，分区有三种方式：Hash、Range、Hash+Range。


### 15.7.项目中如何创建 Kudu 表（Spark）


根据DataFrame建表：


* 创建KuduContext对象（DataFrame，SparkConf）
* kuduContext.tableExists(tableName)


	+ dataFream.schema()，返回变结构 StructType。


**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数大数据工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。**
![img](https://img-blog.csdnimg.cn/img_convert/47d64c60ab56172c3a2ec3d20d895f0b.png)
![img](https://img-blog.csdnimg.cn/img_convert/e427bae6970f487cbf4a49305fa5329a.png)
![img](https://img-blog.csdnimg.cn/img_convert/b1449dffc8287522cd64ca264b720f7b.png)
![img](https://img-blog.csdnimg.cn/img_convert/84174a4fbba7e80d08fe668d01f876d4.png)
![img](https://img-blog.csdnimg.cn/img_convert/347a7a082a788d1705246aeca8ec1daa.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上大数据开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注大数据获取）**
![img](https://img-blog.csdnimg.cn/img_convert/8ec044f01c1d7193555fba5fc6fd6911.png)

## 15.2.Kudu 依赖 Hadoop 吗


Kudu 不需要依赖 Hadoop 集群，Kudu 有自己的存储机制。


### 15.3.Kudu 的分区方式一共有几种


hash、range、hash&range（混合分区）三种方式，项目中使用hash方式进行分区。


### 15.4.Kudu 的存储依赖 HDFS 吗


Kudu 不依赖 HDFS。


### 15.5.Kudu 的架构体系（角色）


* master：

 负责管理从节点，并且存储数据在从节点中的位置，也就是元数据。
* catelog：

 元数据的存储位置，无法直接访问，只能通过 API 查询，记录着表的结构，表的位置，状态，以及各个 tablet 开始和结束的 key（分区）


	+ 作用：
	
	 管理元数据，负载均衡，监听 tablet-server 状态。
* tablet-server：

 只负责存储数据，类似于 datanode。


### 15.6.Kudu 的架构体系（特点）


1、Kudu 的存储是以表的形式，有分区，有列名，列的类型，列值，类似于一个关系型数据库，但是还不是关系型数据库。


2、Kudu 是主从结构，有 master 和 tablet-server，主节点又分为 action 和 wait 两个。


3、Kudu 的表分区，分区的副本存在于各个节点上，类似于 Kafka。


4、Kudu 的分区类似于 HBase 的 Region，一张表按照一定间隔规则分成若干个分区。


5、Kudu 的主从节点分工类似于 HDFS 中的 datanode 和 namenode。


6、Kudu 表（tablet-server）中的一个分区会被拆分成多个 tablet，每一个分区对应一个 tablet，分区有三种方式：Hash、Range、Hash+Range。


### 15.7.项目中如何创建 Kudu 表（Spark）


根据DataFrame建表：


* 创建KuduContext对象（DataFrame，SparkConf）
* kuduContext.tableExists(tableName)


	+ dataFream.schema()，返回变结构 StructType。


**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数大数据工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。**
[外链图片转存中...(img-f58d5Tk6-1712871056020)]
[外链图片转存中...(img-WwX3WkPv-1712871056021)]
[外链图片转存中...(img-KlsW2Gxo-1712871056021)]
[外链图片转存中...(img-bsyoV0I5-1712871056021)]
[外链图片转存中...(img-9gT28Qje-1712871056022)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上大数据开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注大数据获取）**
[外链图片转存中...(img-vzvZbVAK-1712871056022)]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558