【无标题】_电商 增量同步 容错机制

java面试题
冒泡排序
int[] arr = {5,8,1,3,2,9,6};//7个
for (int i = 0; i < arr.length-1; i++) {//6次
//j依次循环6，5，4，3，2，1
for (int j = 0; j < arr.length-1-i; j++) {
if (arr[j]>arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}

for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+“\t”);
}

选择排序
int[] arr = {5,8,1,3,2,9,6};//7个
int temp = 0;
for (int i = 0; i < arr.length; i++) {//7次
for (int j = 0; j < arr.length-1; j++) {//6次
if (arr[i]<arr[j]){
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}

for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+“\t”);
}

二分查找
int key = 10;
int[] arr = {10,20,30,40,50,60};
int low = 0;
int high = arr.length-1;
while (low<=high){
int mid = (low+high)/2;
if (key>arr[mid]){
low = mid+1;
}else if (key<arr[mid]){
high = mid-1;
}else {
System.out.println(“在第”+(mid+1)+“位”);
break;
}
}
if (low>high){
System.out.println(“查无此数”);
}

熟悉java吗
java会用，在大数据项目过程中经常用到java 的一些常用的方法和api，纯java的使用不太熟悉

int和Integer的区别
1、Integer是int的包装类，int则是java的一种基本数据类型
2、Integer变量必须实例化后才能使用，而int变量不需要
3、Integer的默认值是null，int的默认值是0

java自带哪几种线程池
1、newCachedThreadPool：可缓存线程池，可以灵活回收线程
2、newFixedThreadPool：创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化
3、newSingleThreadExecutor：创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它，保证顺利执行
4、newScheduleThreadPoolExecutor：创建一个固定长度的线程池，而且以延迟或定时的方式来执行任务

守护线程是什么
服务其他线程的线程

解释内存中的栈(stack)、堆(heap)和方法区(static area)的用法
堆区：专门用来保存对象的实例，但只保存对象实例的属性值，并不保存对象的方法（方法是指令，保存在栈中）
栈区：对象实例在堆中分配好以后，需要在栈中保存一个4字节的堆内存地址，用来定位该对象实例在堆中的位置，便于找到该对象实例。
方法区：包含所有的class和static变量。

Java有没有goto
在C/C++中，goto常被用于跳出多重循环。
1、java有goto
2、但是java的goto是保留字，意思就是不排除以后会启用，变成关键字。

进程和线程的联系与区别
进程：系统中正在运行的一个应用程序，是资源分配的最小单位。
线程：进程中一个最小的独立执行单位

线程的生命周期
1、创建：创建一个线程对象
2、就绪：创建好的线程调用start方法
3、运行：竞争到cpu的运行资源
4、阻塞：调用sleep方法，等待结束会进入就绪状态
5、死亡：当线程任务执行完

线程的创建方式
1、继承Thread类
2、实现Runnable接口
3、实现Callable接口

jdk和jre有什么区别
jdk：开发者工具包，提供java的开发环境和运行环境
jre：java运行环境

== 和 equals的区别
对于基本数据类型，==比较的是值是否相同
对于引用数据类型，比较的是地址是否相同
equals是比较引用数据类型的值是否相同

final在java中有什么作用
final修饰的类是最终类，不能被继承
final修饰的方法不能被重写
final修饰的变量叫常量，定义时就要赋值，并且值不能改变

String属于基本数据类型吗
String是引用数据类型，基本数据类型有8种，分别是：byte、short、int、long、float、double、boolean、char

java中操作字符串的类有哪些？他们之间有什么区别？
有String、StringBuffer、StringBuilder
String是不可变的对象，不能添加元素
StringBuffer和StringBulider是可变对象，可以使用append方法添加新元素
StringBuffer和StringBulider最大的区别是，StringBuffer是线程安全的，如果使用多线程操作，可以使用StringBuffer，如果是单线程操作可以使用StringBulider，因为StringBulider性能更高

String str="I"与Stirng str = new String(“i”)一样吗
不一样，前者的数据会存到常量池中，后者的数据会存到堆内存中

如何将字符串反转
使用StringBuffer或StringBuilder的reverse()方法

抽象类必须有抽象方法吗
不需要，抽象类不一定非要有抽象方法
abstract class Cat {
public static void sayHi() {
System.out.println(“hi~”);
}
}

普通类和抽象类有哪些区别
普通类不能创建抽象方法，抽象类可以创建抽象方法
普通类可以直接实例化，抽象类不可以

接口和抽象有什么区别
接口必须使用implements来实现，抽象类的子类使用extends来继承
一个类可以实现很多接口，但只能继承一个抽象类
接口不能有构造函数，抽象类可以有

java中io流分为几种
字节流：FileInputStream(字节输入流)、FileOutputStream(字节输出流)
字节缓冲流：BufferInputStream(字节输入缓冲流)、BufferOutputStream(字节输出缓冲流)
字符流：InputStreamReader(字符输入流)、OutputStreamWriter(字符输出流)
字符缓冲流：BufferReader(字符缓冲输入流)、BufferWriter(字符缓冲输出流)
对象流：ObjectInputStream(对象输入流)、ObjectOutputStream(对象输出流)

java容器中List、Map、Set之间有什么区别
List：常见实现类有ArrayList(底层是数组，查询快，增删慢)，LinkedList(底层是链表，增删快，查询慢)；元素可重复，有序
Map：常见实现类有：HashMap(元素不可重复，无序存放)、TreeMap(元素不可重复，有序存放)
Set：常见实现类有HashSet，treeSet；元素不可重复，无序

ArrayList和Vector区别
ArrayList是线程不安全的，Vector是线程安全的

HashMap和HashTable有什么区别
底层都是数组加链表
HashMap是线程不安全的，HashTable是线程安全的
HashMap是非同步的，HashTable是同步的，效率上HashTable要高
HashMap去掉了HashTable的contains方法，但是加上了containsKey()和containsValue方法
HashMap允许空键值，而HashTable不允许

什么是反射
指程序可以访问、检测和修改它本身状态的一种能力

什么是java序列化
为了保存，在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的，对象状态再读出来，java提供了一种保存对象的机制，就是序列化

Synchronized 与 Lock 的区别
1、Synchronized 能实现的功能 Lock 都可以实现，而且 Lock 比 Synchronized 更好用，更灵活。
2、Synchronized 可以自动上锁和解锁；Lock 需要手动上锁和解锁

Runnable 和 Callable 的区别
1、Runnable 接口中的方法没有返回值；Callable 接口中的方法有返回值
2、Runnable 接口中的方法没有抛出异常；Callable 接口中的方法抛出了异常
3、Runnable 接口中的落地方法是 run 方法；Callable 接口中的落地方法是 call 方法

springboot和redis面试题
一、springboot是什么？
通过http协议能够访问到的spring内容的服务

二、springboot的分层架构
控制层：和用户直接交互
业务层：具体的业务逻辑
数据库持久层：和数据库进行交互

三、redis是什么
基于内存的、支持持久化的、以key-value格式存储的nosql数据库

四、Redis有哪些数据结构？
字符串String、列表List、字典Hash、集合Set、有序集合SortedSet。

五、redis数据库的基本指令
设置过期时间：expire(key,秒数)
列表List：
从左压入元素：lpush key value
从左弹出元素：lpop key
字典Hash：
存入单个字段：hset key field(内容里面的key) value
存入多个字段：hmset key field value field value…
返回单个字段值：hget key field
返回所有的键值对：hgetall key
集合Set：
增加一个或多个元素：sadd key member member…
返回集合中包含的所有元素：smembers key

六、缓存穿透
缓存穿透是指查询一个一定不存在的数据。
解决方案：
1、将空对象也缓存起来，并给它设置一个很短的过期时间
2、采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的 bitmap 中，一个一定
不存在的数据会被这个 bitmap 拦截掉

七、缓存雪崩
大量缓存集中在同一个时间点内失效，这个时间点会发生大量的缓存穿透，所有的查询都落在数据库上，就会造成缓存雪崩。
解决方案：让不同缓存失效的时间点尽可能的分散开

八、缓存击穿
指一个 key 非常热点，当这个 key 在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库。
解决方案：可以设置对应 key 永不过期

九、redis持久化的几种方式
RDB：在默认情况下，redis将数据库快照保存在名字为dump.rdb的二进制文件中，自动触发需要配置策略，手动触发需要输入save或bgsave命令
AOF：采用追加的方式保存到appendonly.aof的文件中，可以在配置文件中打开AOF模式

hadoop面试题
一、什么是hadoop？有哪些组件？
hadoop是一个能够对海量数据进行分布式存储和分布式计算的平台
hdfs：是一个分布式存储框架，适合海量数据存储
mapreduce：是一个分布式计算框架，适合海量数据计算
yarn：是一个资源调度平台，负责给计算框架分配计算资源

二、请列出正常工作的hadoop集群中hadoop都需要启动哪些进程，他们的作用分别是什么?
(或HDFS的组成与架构)？
NameNode：主节点，管理元数据，管理文件系统的目录结构
Secondary NameNode：备份NameNode的元数据，会定期对namenode的编辑日志进行合并
DataNode：把HDFS数据块读写到本地的文件系统

三、如果HDFS写的过程中DataNode宕机了会怎么办？
当DataNode突然挂掉了，如果客户端接收不到这个DataNode发送的ack确认，客户端会通知NameNode，当datanode的节点数大于3个，NameNode会通知其他DataNode去复制副本，并将挂掉的DataNode作下线处理。当datanode的节点数小于等于3个，无法复制三个副本，数据就会丢失

三、hadoop常用的端口号
1、访问hdfs： hadoop2.x 50070 hadoop3.x 9870
2、访问yarn： hadoop2.x 8088 hadoop3.x 8088
3、访问历史服务器： hadoop2.x 19888 hadoop3.x 19888
4、访问集群： hadoop2.x 9000 hadoop3.x 8020

四、简单的hadoop集群搭建过程
1、安装jdk
2、配置ssh免密登录
3、配置hadoop核心文件
4、格式化namenode

五、hadoop解决数据倾斜的方法
1、提前在map阶段进行combine，对相同key进行了预聚合，减少传输的数据量
2、增加reducer(在hive中设置更大的reduce参数，在spark代码中使用repartition调整reduce个数)，提高并行度
3、实现自定义分区：根据数据分布情况，自定义散列函数，将key均匀分配到不同reducer

六、hadoop的优化
1、提前在map阶段进行combine，对相同key进行了预聚合，减少传输的数据量
2、增加reducer，提高并行度
3、实现自定义分区：根据数据分布情况，自定义散列函数，将key均匀分配到不同reducer
4、在cpu和内存不足的情况下，可以将切片调大；在cpu和内存充足的情况下，可以将切片调小

七、hdfs小文件处理方法
1、在数据采集的时候，就将小文件合并成大文件再上传hdfs，或将hdfs的小文件合并
2、在MapReduce处理时，采用CombineTextInputFormat合并小文件
3、开启JVM重用，对于大量小文件job，会减少运行时间

八、hdfs读写流程？
读流程：
1、首先调用FileSystem对象的open方法，通过rpc连接(类似tcp，底层也是socket)namenode，获取第一个block块的位置，按照就近原则获取离客户端最近的该bolck块的副本的位置
2、通过返回的IO流对象找出离客户端最近的datanode并连接，客户端调用read方法读取数据，当第一个block中的数据被读完，会读取下一个block块
3、当第一批block读完之后，IO流会去namenode拿下一批block块的位置，然后继续读，如果所有的块都读完了，就会关闭所有的流
写流程：
1、首先调用FileSystem对象的create方法，通过rpc调用namenode去创建一个没有block块的新文件，创建前会进行校验，如果校验通过，namenode就记录下新文件
2、通过返回的IO流对象把写入的数据切成一个个小packet，然后询问namenode找到最合适存储的几个datanode，然后把packet写入到第一个datanode中，接着写入到第二个，以此类推。
3、当数据写入后，对应的packet会被移除，客户端完成写入数据后，就会关闭所有的流

九、mapreduce原理(含shuffle原理)
map阶段：大文件被拆分为一个一个block块存储在hdfs中，默认每个block块对应一个切片，每个切片对应一个map task
map shuffle阶段：每个map task一边处理切片中的数据，一边将数据写入内存的环形缓冲区中，缓存区默认是100m，每当内存缓冲区中写入的数据达到阈值0.8之后，会将内存中的数据溢写到磁盘，在溢写的过程中会对数据进行hash分区和快速排序，多个磁盘小文件会进行归并排序合并成一个大文件
reduce shuffle阶段：当所有map task执行完成后，在reduce task执行之前会先去map task所在的节点拉取数据，然后对多个文件进行合并
reduce阶段：然后执行reduce task，相同的key放入同一个reduce task，最后每个reduce生成一个文件

十、yarn的核心组件及功能
ResourceManager：yarn集群的主节点，负责管理和分配整个集群的资源
NodeManager：yarn集群中的从节点，是集群中实际拥有资源的工作节点
ApplicationMaster：用户提交应用程序时申请的编程接口，同时负责监控应用，跟踪应用执行状态

十一、yarn提交任务的流程
1、客户端提交应用到ResourceManager
2、ResourceManager在NodeManager中启动ApplicationMaster
3、ApplicationMaster向ResourceManager申请启动应用程序
4、ResourceManager在NodeManager中启动应用程序
5、应用程序会向ApplicationMaster报告状态和进度
6、当应用执行完后，ApplicationMaster向ResourceManager申请注销自己

十二、Yarn调度器的分类及区别
Hadoop2.7.2 默认的资源调度器是：容量调度器
FIFO 调度器：单队列；先进先出，同一时间同一队列中只有一个任务在执行
容量调度器：多队列；每个队列内部先进先出，同一时间同一队列中只有一个任务在执行
公平调度器：多队列；每个队列内部按照缺额大小分配资源，同一时间同一队列中有多个任务执行

十三、ZooKeeper是什么？
ZooKeeper是一个高效的分布式协调服务，可以提供：配置信息管理、集群管理、分布式同步、主备切换等服务。它数据存储在内存，所以不适合用来存储大量信息，可以用来存储一些配置、发布与订阅等少量信息
Zookeeper 的核心是原子广播，这个机制保证了各个Server之间的同步
ZooKeeper集群节点的个数一般为奇数个，若集群中master挂掉，剩余节点在半数以上时，就可以推举新的主节点，继续对外提供服务

Hive面试题
一、什么是hive，为什么要使用Hive，hive的特点是什么？
1.Hive是基于Hadoop的用来建立数据仓库的工具，可以将结构化的数据文件映射为一张数据库表，并提供类SQL查询功能。
2.避免了去写MapReduce，减少开发人员的学习成本
3.特点
可扩展：Hive可以自由的扩展集群的规模，一般情况下不需要重启服务
延展性好：Hive支持用户自定义函数
容错性好：节点出现问题SQL仍可完成执行

二、hive的底层架构
hive的数据存储在hdfs中，通过mapreduce对数据进行分布式计算，通过yarn实现资源调度。hive的元数据一般保存在mysql中，因为元数据的数据量不大，且mysql对于这种少量数据可以实现实时查询。

三、hive 中的压缩格式TextFile、 RCFile、 SequenceFile 各有什么区别？
TextFile：默认格式，数据不做压缩，磁盘开销大，数据解析开销大，但数据可以直接下载，用记事本打开
RCFile：一种行列存储相结合的存储方式，有利于数据的压缩和快速存取，但下载的数据以乱码的格式显示。
SequenceFile：一种二进制文件支持，可以存入所有二进制文件(音频、视频等)
Parquet（列式存储）

四、Hive 有哪些方式保存元数据，各有哪些优缺点？
存储于derby数据库，此方法只能开启一个hive客户端，不推荐使用
存储于mysql数据库中，可以多客户端连接，推荐使用

五、hive 是如何实现分区的？分区的作用？
建表语句：
create table tablename (id) partitioned by (dt string)
增加分区：
alter table tablenname add partition (dt = ‘2016-03-06’)
删除分区：
alter table tablename drop partition (dt = ‘2016-03-06’)
作用：进行分区裁剪，避免全表扫描，减少MapReduce处理的数据量，提高效率

六、hive 内部表和外部表的区别？
建表时外部表被external修饰，内部表未被external修饰
外部表数据由HDFS管理，内部表数据由Hive自身管理
外部表的路径可以自定义，内部表的路径需要在hive/warehouse/目录下
删除外部表仅仅会删除元数据，HDFS上的存储数据不会被删除，删除内部表会直接删除元数据及存储数据；；

七、hive中order by、distribute by、sort by和cluster by的区别和联系？
order by：用于全局排序，对所有的reduce输出结果进行排序，效率低
sort by：局部排序，对每个reduce中输出的结果进行排序，只能保证在相同的reduce任务中有序
distribute by：将相同key的记录划分到一个reduce中
cluster by：cluster by相当于distribute by 和 sort by 合用，但是cluster by只能默认升序排列。

八、hive开窗函数有哪些？
开窗函数使用的比较多的是：聚合开窗函数和排序开窗函数。
聚合开窗函数
sum()、 min()、max()、avg()、count()等
排序开窗函数
row_number()：顺序增加排名
rank()：相同排序并列，且留下顺序空位
dense_rank()：相同排名并列，且顺序增加
分析函数(如：sum(), max(), row_number()…) + 窗口子句(over函数)
select studentId,math,departmentId,classId,
– 符合所有条件的行作为窗口，这里符合department1的有9个
count(math) over() as count1,
– 按照classId分组的所有行作为窗口
count(math) over(partition by classId) as count2,
– 按照classId分组、按照math排序的所有行作为窗口
count(math) over(partition by classId order by math) as count3,
– 按照classId分组、按照math排序，当前行向前1行向后2行的行作为窗口
count(math) over(partition by classId order by math rows between 1 preceding and 2 following) as count4,
– 按照classId分组、按照math排序，当前行向后所有行作为窗口
count(math) over(partition by classId order by math rows between current row and unbounded following) as count5
from student_scores where departmentId=‘department1’;
九、自定义UDF、UDTF
自定义 UDF：继承 UDF类，重写 evaluate 方法
自定义 UDTF：继承自 GenericUDTF，重写 3 个方法：initialize(自定义输出的列名和类
型)，process（将结果返回 forward(result)），close

十、Hive和MySQL语法区别？
1、hive默认不支持更新操作，比如update、delete，可以在配置文件中开启
2、hive没有索引，延迟性高，而mysql延迟性低
3、hive能存储海量数据，而mysql只是存储一些少量的业务数据
4、hive和mysql中的sql函数使用不同，例如分割字符串函数，mysql使用substring_index，hive使用split

十一、hive的行转列，列转行的方法
行转列：
/*原始数据
province city
河南 郑州市,开封市，洛阳市
河北 石家庄市，保定市
湖南 长沙市，岳阳市，常德市
/
– addr为表名
SELECT province,
city_n
FROM addr
LATERAL VIEW explode (split(city,‘,’)) addr_tmp AS city_n;
/
– 查询结果
河南 郑州市
河南 开封市
河南 洛阳市
河北 石家庄市
河北 保定市
湖南 长沙市
湖南 岳阳市
湖南 常德市
*/
LATERAL VIEW explode(split(name_list,‘,’))

列转行：
将
1
2
3
4
转为
1,2,3,4
concat不能指定分隔符
concat_ws可以指定逗号作为分隔符
collect_list不去重转换
collect_set为去重转换
concat_ws(’,’,collect_set(name))

十二、hive视图
创建视图：create view viewname(字段)
删除视图：drop view viewname
查询视图：select * from view
修改视图：alter view viewname…;

十三、hive 如何优化？
建表优化：
1、使用外部表，避免数据误删
2、命名要规范，数据分层，表分离
3、创建分区表，进行分区裁剪，避免全表扫描，减少MapReduce处理的数据量，提高效率
查询优化：
1、先过滤，后join
2、尽量将小表放在 join 的左边，如果一个表很小可以采用 mapjoin，map端进行join，广播小表
数据倾斜(数据重复)优化：
1、实现自定义分区：根据数据分布情况，自定义散列函数（例如对所有的key通过hash散列），将key均匀分配到不同reducer
2、合理设置map和reduce的个数
2、找到key重复的具体值，进行拆分再join
参数优化：
1、调整mapper和reducer的数量
2、调节数据倾斜参数

十四、Union与Union all区别
1、union会将联合的结果集去重，效率较union all差;会对获取的结果进行排序操作
2、union all不会对结果集去重，效率更高;不会对获取的结果进行排序操作

十五、数据仓库建模架构(数仓分为几层？每一层作用?)
1、数据源：数据库，例如mysql、redis等，文本文件、excel表格、服务器日志等
2、采集数据：通过数据采集工具采集，例如sqoop，进行ETL(萃取、转换、加载)到hive
3、分层设计：
ODS(数据运营层)：存储原始采集的数据
DWD(数据明细层)：对ods层的数据进行简单的去噪、去重、清洗转化过滤；
DWM(数据中间层)：对dwd层数据进行轻度的聚合
DWS(数据服务层或宽表层)：将dwm层数据与dim层数据关联，合并成宽表
ADS(数据应用层)：将dws层数据按照要求转化为，数据产品或数据分析的数据
DIM(维表层)：存储长时间不会发生变化的信息表(建模架构：星型模型、雪花模型)

十六、数仓分层的意义？
1、清晰数据结构：每层数据都有它的作用域和职责，在使用表的时候能更方便地定位和理解；
2、减少重复开发：规范数据分层，开发一些通用的中间层数据，能够减少重复计算；
3、统一数据口径：通过数据分层，将ads层数据作为统一对外输出的数据出口；
4、复杂问题简单化：将一个复杂的任务分解成多个步骤来完成，每一层解决特定的问题。

Hbase面试题
一、Hbase是什么？hbase的特点是什么？
1.Hbase一个分布式的、列式存储的、实时查询的数据库，基于Hadoop的 hdfs 存储，利用zookeeper进行管理。
2.Hbase适合存储半结构化或非结构化数据
3.hbase 是主从架构。hmaster 作为主节点，hregionserver 作为从节点。
4.存储结构三维有序：rowkey：字典升序；列簇：字典升序；时间戳：自然降序

二、Hbase为什么读取速度快
1.它使用了LSM树型结构，磁盘的顺序读取速度很快
2.hbase将rowkey作为索引，且rowkey是按照字典顺序排序
3.数据是按列存储，并且会先将数据保存在内存中

二、Hbase为什么查询速度快
hbase将rowkey作为索引，且rowkey是按照字典顺序排序，通过快速定位rowkey实现快速查询

二、 hbase 的底层系统架构(存储结构)？
master 作为主节点：
1.为region server分配region
2.负责region server的负载均衡
3.发现失效的region server并重新分配其上的region
4.管理用户对表的增删改操作
5.回收垃圾，回收过期的region
region server作为从节点：
1.维护region，处理这些region的IO读写请求
2.负责切分在运行过程中变得过大的region
region、store、memstore、storefile、hfile联系：
一个region由多个store组成，一个store对应一个列簇，store包括位于内存中的memstore和位于磁盘的storefile，数据先写入memstore，当memstore中文件达到默认大小或时间达到默认时间或手动flush时，momstore中的数据会被写入storefile。当storefile的数量增长到阈值后，系统会进行合并，合并过程中进行版本合并和删除工作，形成更大的storefile，storefile最终以hfile文件存入hdfs。当一个region的storefile大小和数量超过阈值，region会进行分裂。
zk分布式协调框架：
1.存储hbase元数据(meta表的信息，region server的信息，hmaster的信息等)
2.负责master的高可用

三、hbase读写流程？
检索流程：
1.通过java api、python api等方式连接zk，获取meta表(存所有region位置)所在region所在的位置
2.连接meta表所在region所在的region server，查询索引数据
3.判断rowkey在哪个region中，获取对应region所在的region server
读流程：
1.先在内存中查询memstore数据
2.如果内存中memstore没有，就从hfile中获取数据
3.如果在建表时设置in_memory为true，数据查询完之后会将数据放到内存中
写流程：
1.数据先写入Hlog日志文件
2.日志写成功之后再写入memstore
3.当memstore达到指定大小(默认128m)或指定时间之后会溢写到storefile，storefile最终生成一个hfile文件

四、HBase优化方法
1.预分区：
根据hbase数据表中key的分布情况，在建表的时对hbase进行region的预分区，这样可以防止大数据量插入的热点问题，提高数据插入的效率。
2.rowkey设计
简短性：rowkey最大长度为64kb，但设计时建议越短越好。因为数据的持久化文件hfile是按照KeyValue存储的，如果rowkey过长，会极大影响hfile的存储效率；并且memstore将缓存部分数据到内存，如果rowkey过长，内存的有效利用率就会降低，系统不能缓存更多的数据，这样会降低检索效率。
散列性：通过反转、加盐、哈希方式设计rowkey，使数据均匀的分散到不同的region中，可以防止出现热点问题，并且有利于查询
唯一性：rowkey必须具备明显的区别，因为rowkey是按照字典顺序排序的，相同rowkey的数据会被覆盖掉（如果表的version设置为1的话，默认保留时间戳为最新的数据）。

五、什么是热点问题、如何解决热点问题？
1.所有的数据集中在一个region中，所有的读写请求集中到一台服务器的region server上，这样这台服务器所承受的压力会超出自身承受能力，引起性能下降甚至region不可用
2.解决方法：
反转：反转固定长度或者数字格式的rowkey
加盐：在rowkey的前面增加随机前缀
哈希：例如通过加密算法对rowkey加密

六、hbase的二级索引
二级索引：建立行键与列值的映射关系
1、建立索引表：建立一个hbase表保存索引，插入数据、查询数据都需要查询索引表
2、将列值保存到rowkey中
3、使用phoenix，分为本地索引(没有建立索引表)和全局索引(建立索引表)

七、hive和hbase区别
hive适用于离线批处理场景，比如离线数仓，T+1报表业务；hive可以做复杂的计算和查询
hbase适用于实时读写场景，比如实时数仓，实时、流式的数据落地；hbase不支持做复杂的计算和查询

八、hbase如何导入数据？
使用HBase API写入数据；
使用datax等数据采集工具导入数据；
使用MapReduce导入数据；
使用Bulk Loading方法批量导入数据

九、scan和get的功能以及实现的异同
同：都能通过java api或hbase shell进行操作
异：
get：按照RowKey获取唯一一条记录
scan：按照指定的条件获取一批记录

clickhouse面试题
一、介绍
列式存储、可以通过SQL实时查询的数据库
二、特点
1.兼容SQL语法和列式存储的功能
2.高吞吐写入能力
3.划分多个分区及索引粒度，可以实现并行处理

数据集成工具面试题
一、有哪些数据采集工具？分别采集哪种数据？
sqoop：用于hadoop与mysql等传统数据库间进行数据传递，离线采集工具
datax：实现mysql、hdfs等各种异构数据源之间的同步，底层是多线程，离线采集工具
kettle：纯java编写，可以在windows、linux、unix上运行，支持数据库、文件等多种形式的数据转换，底层是mapreduce，离线采集工具
flume：日志采集工具，在自定义的配置文件中设置采集的日志路径，数据写入的kafka路径，执行配置文件，实时采集
canal：基于MySQL增量日志采集工具，在canal的配置文件中设置mysql的连接地址，数据写入的kafka路径，启动canal，实时采集

二、flume架构
flume运行的核心是agent，以agent为最小的独立运行单位。一个agent就是一个jvm。它是一个完整的数据收集工具，含有三个核心组件，分别是source、channel、sink，source用来采集日志数据、channel对source采集的数据进行缓存、sink导出channel中的数据。通过这些组件，event(数据单元)可以从一个地方流向另一个地方

三、增量同步和全量同步
第一次导入数据的时候使用全量同步；当更新的数据量不大的时候用全量同步
当不是第一次导入数据，且更新的数据量很大时采用增量同步

四、kettle的工具和两种设计
sqoon(勺子)：图形化界面
pan(平底锅)：在命令行运行转换的工具
kitchen(厨房)：在命令行运行作业的工具
carte(菜单)：启动kettle集群
transformation(转换)：完成针对数据的基础转换，是数据流
数据输入——>处理逻辑——>输出
job(作业)：完成整个工作流的控制，是步骤流
start——>转换——>作业项目——>成功

spark面试题
一、RDD(弹性分布式数据集)的五大特性
1、RDD是由一组分区(partition)组成，默认一个切片对应一个分区
2、函数作用在每一个分区上，每一个分区由一个task处理
3、RDD之间有一系列的依赖关系，后一个RDD依赖于前一个RDD。依赖关系分为两种，一种是宽依赖(有shuffle)，一种是窄依赖(没有shuflle)，在宽依赖的位置切分不同的stage，宽依赖之前是一个stage，宽依赖之后是一个stage。(stage相当于mapreduce的map端或reduce端，可以并行计算)
4、分区内的算子只能作用在kv格式的RDD上
5、spark为task的计算提供了最佳的计算位置，移动计算而不是移动数据，会尽量将task发送到数据所在的节点执行

二、spark比mapreduce快的原因
1、spark中具有DAG有向无环图，在此过程中减少了shuffle的次数，并且多个shuffle中间结果不需要落到磁盘
2、spark可以尽量将数据放在内存中计算，MapReduce是基于磁盘进行数据处理的
3、spark是粗粒度资源申请，在任务执行之前会将所需要的资源全部申请下来

三、spark有几种部署方式
Local：运行在一台机器上，通常是测试环境
Standalone：spark自己搭建一个资源管理集群，不依赖于hadoop
yarn：将spark任务提交到yarn上运行，需要实现ApplicationMaster申请资源

四、如何理解spark中的血统(lineage)概念
RDD在血统依赖方面分为宽依赖与窄依赖，这两种依赖在解决数据容错时具有高效性，以及在划分任务时起到重要作用

五、简述spark中的宽窄依赖
宽依赖：指的是同一个父RDD的partition被子RDD的多个partition使用
窄依赖：指的是同一个父RDD的partition最多被子RDD的一个partition使用

六、spark如何划分job？spark如何划分stage？每个stage又根据什么决定task个数？
job：在spark应用中，每碰到一个action算子，就会起一个job
stage：遇到一个宽依赖则划分一个stage
task：stage是一个taskSet，将stage根据分区数划分成一个个的task

七、spark资源调度和任务提交的流程
1、driver端向ResourceManager申请启动ApplicationMaster
2、ResourceManager会随机选择一个nodeManager启动ApplicationMaster
3、ApplicationMaster向ResourceManager申请启动executor
4、ResourceManager在nodeManager中启动一批executor
5、executor反向注册给driver端
6、当遇到一个action算子的时候开始任务调度
7、构建DAG有向无环图
8、DAG Schduler根据宽窄依赖将job切分成多个stage
9、将stage按照顺序以taskSet的形式发送给task Scheduler
10、task Scheduler将task一个一个发送到executor中执行，会尽量将task发送到数据所在的节点执行

八、spark中transformer算子与action算子的区别
action算子的作用就像一个触发器，用来触发之前的transformation算子。
transformation算子具有懒加载的特性，操作定义后并不会立即加载，只有当某个action的算子执行之后，前面所有的transformation算子才会全部执行。

八、列举spark的transformation算子，并简述功能
map：用于遍历RDD，对输入的参数进行转换操作
mapPartitions：用于遍历操作RDD中的每一个分区
flatMap:将RDD中的一行数据拆分成多行数据
filter:过滤RDD中的数据
groupByKey：在RDD中通过key进行分组
reduceByKey:在RDD中通过key进行聚合
join：表关联，通过key进行关联

九、列举spark中的action算子，并简述功能
count：统计RDD的行数
collect：将RDD转换成集合
foreach：遍历RDD中的数据
save：保存RDD中的数据

十、高级算子
reduceByKey：按照key进行聚合，在shuffle之前有预聚合操作
combineByKey : 和reduceByKey效果相同
aggregateByKey：按照key进行分组，先进行局部操作，再进行整理操作
repartition：对数据重新分区，用于增大分区，会进行shuffle,
coalesce：对数据重新分区，用于缩小分区，不会进行shuffle

十一、聚合算子
reduceByKey：按照key进行聚合，在shuffle之前有预聚合操作
combineByKey : 和reduceByKey效果相同
aggregateByKey：按照key进行分组，先进行局部操作，再进行整理操作

十二、spark中常用算子reduceByKey与groupByKey的区别
reduceByKey：按照key进行聚合，在shuffle之前有预聚合操作
groupByKey：按照key进行分组，直接进行shuffle

十三、简述spark中广播变量和累加器的基本原理与用途
广播变量：广播变量只能在算子外面定义，只能在算子里面使用，算子在执行的过程中如果使用到广播变量，会向executor获取，如果executor有，直接使用，如果没有再去driver端拉取广播变量的数据。使用广播变量之后变量副本数量会减少，提高性能
累加器：在driver端定义，在算子内累加，然后在driver端进行汇总。用于累加计算

十四、spark任务运行的几种方式
Local 本地方式：直接在 IDEA 中运行程序，无需打包发布到集群中，方便测试。
Standalone 方式：Spark 原生的 Master/Worker 集群，
Yarn 方式：Hadoop 的 Yarn 集群，通过 Yarn 来进行资源的管理和调度。

十五、spark优化
代码优化：
2、对多次使用的rdd进行缓存，缓存级别一般使用 MEMORY_AND_DISK_SER
3、使用高性能的算子。例如使用reduceBykey代替groupBykey；使用mapPartitions代替map；使用coalesced代替repartition合并小文件
4、使用广播变量，一般用于map join时对小表广播
5、使用Kryo优化序列化性能，例如cache(拥有血统依赖，将rdd中的数据缓存在内存)、checkpoint(没有血统依赖，将rdd数据保存到hdfs中)、shuffle、的时候
参数优化：
1、–num-executors：执行器数量，直接决定任务可以执行多快，一般指定50-100个比较合适。
num-executors的数量乘以executor-cores核数不能超过yarn总的cpu数。
num-executors的数量乘以executor-memory不能超过yarn总的内存，一般最多使用一半左右
2、–executor-memory：单个执行器内存，一般指定4G到8G
3、–executor-cores：单个执行器核数，一般2-4个，保证每一个cpu分到的内存不低于2G
4、–driver-memory：Driver内存，用于存储广播变量，但广播变量的大小不能超过内存
5、–conf spark.default.parallelism=100：rdd shuffle之后的reduce的数量
6、–conf spark.sql.shuffle.partitions=100：spark sql shuflle之后reduce的数量，默认是200个
7、–conf spark.storage.memoryFraction=0.4：持久化可以使用的内存
8、–conf spark.shuffle.memoryFraction=0.4：shuffle阶段可以使用的内存
9、–conf spark.locality.wait=10：task在executor中执行的等待时间
10、–conf spark.network.timeout=600s：spark网络连接的超时时间
数据倾斜优化：
数据倾斜的定位：在执行到某个 job 时任务卡在 99%，甚至导致响应超时
产生的原因：key值分布不均；产生shuffle
优化
2、过滤掉导致数据倾斜并且对业务影响不大的key
3、提高shuffle的并行度，使用shuffle算子的时候，设置更大的并行度参数
4、对于业务不复杂的情况，可以采用双重聚合，首先加前缀进行第一次聚合，然后去掉前缀进行第二次聚合
5、大表和小表关联，采用map join(小表广播，大表使用map算子)
6、大表和大表关联，采样倾斜的key并拆分join

十七、Spark Shuffle分类和底层原理
HashShuffle：和mapReduce原理差不多，会导致小文件过多，spark2以后被移除
SortShuffle：对小文件进行合并，有两种运行机制，一种是普通的运行机制，一种是bypass运行机制。
普通机制：
map task 的计算结果会写入到一个内存数据结构里面，内存数据结构默认是5M
在shuffle的时候会有一个定时器，不定期的去估算这个内存结构的大小，当内存结构中的数据超过5M时，比如现在内存结构中的数据为5.01M，那么他会申请5.01*2-5=5.02M内存给内存数据结构。
如果申请成功，不会进行溢写，如果申请失败，会溢写到磁盘。
在溢写之前内存结构中的数据会进行排序分区
然后开始溢写到磁盘，以batch的形式去写，一个batch是1万条数据，
map task执行完后，会将这些磁盘小文件合并成一个磁盘大文件，同时生成一个索引文件。
reduce task去map端拉取数据的时候，首先解析索引文件，根据索引文件再去拉取对应的数据。
bypass机制：
当shuffle read task的数量小于等于bypass参数的值（默认为200）时，就会启用bypass机制。
不对数据进行排序操作，节省掉这部分的性能开销

十八、Spark Streaming窗口函数的原理
窗口函数就是在原来定义的SparkStreaming计算批次大小的基础上再次进行封装，每次计算多个批次的数据，同时还需要传递一个滑动步长的参数，用来设置当次计算任务完成之后下一次从什么地方开始计算。

十九、Spark Streaming 有哪几种方式消费 Kafka 中的数据
1、Receiver方式是使用高级API，需要kafka的消费者连接zookeeper来读取数据。是由zookeeper来维护偏移量，减少了代码量。但是有丢失数据、浪费资源等缺点
2、Driect方式则采用的是最底层的API，直接连接在kafka服务器上读取数据。需要我们自己维护偏移量，代码量稍大些。不过这种方式具有高性能、保证数据只消费一次等优点

二十、Spark Streaming默认分区数
默认分区数与对接的kafka的topic分区数一致

旅游集市项目
构建数据仓库
ods(数据运营层)：存入用户通话、短信、坐标等各种信息，用多张表进行存储。有ods_ddr表，ods_oidd表；ods_wcdr表；ods_dpi表；用户画像表：ods_usertag_m；行政区配置表：ods_admincode；景区边界表：ods_scenic_boundary
dim(维表层)：用户画像表：dim_usertag_m；行政区配置表：dim_admincode；景区边界表：dim_scenic_boundary；网格配置表；景区网格表
dwd(数据明细层)：位置融合表：dwi_res_regn_mergelocation_msk_d：1、从原始数据中抽取用户位置数据，2、过滤脏数据，3、对数据进行校准，4、对数据进行脱敏；停留表：dwi_staypoint_msk_d：按照时间顺序将同一个人在同一个网格中的多条数据合并成一条数据
旅游集市
省游客表：出游距离大于10km，停留时间大于3小时
省游客宽表：将所需的所有字段关联组成一张大表
市游客表
市游客宽表
景区游客表
景区游客宽表
应用
BI大屏：以可视化图形展示
数据报表：做成excel表格
数据服务：景区短信营销

深圳地铁项目
构建数据仓库
ods(数据运营层)：
1、由ETL工程师将数据采集后放到ods层中
2、我在hive数据仓库的dwd(数据明细层)中创建入站表、出战表、出入站表等其他表，按天分区，然后在服务器中执行shell脚本或上传jar包，将ods层的数据导入
3、在dim(维表层)中创建卡号信息表，线路站点表等其他维表
4、然后在dws(宽表层)中创建出站、入站、出入站宽表等其他宽表，执行shell脚本或上传jar包，将dwd层表和dim层表关联取出的数据导入
5、然后根据指标要求在ads(数据应用层)中创建各种应用表，例如“每站进站人次排行榜”等指标，执行shell脚本或上传jar包，将相应宽表中的数据导入，最后在mysql中建表，将ads层中表的数据通过datax执行配置好的json文件，导入到mysql相应表中
公司其他人员将表做成报表，或bi工程师将数据可视化展示，以及将数据以接口的方式暴露给前端

kafka面试题
一、kafka副本数设定？
一般我们设置成2个或3个，很多企业设置为2个
副本优势：提高可靠性
副本劣势：增加了网络IO传输
二、Kafka日志保存时间？
默认保存7天；生产环境建议3天
三、Kakfa分区数？
分区数一般设置为：3-10个
kafka只能保证每个分区内的数据有序；要想实现全局有序，那么只有一个分区和一个消息的生产者
四、多少个topic？
通常情况：有多少个日志类型就有多少个topic
五、kafka挂掉？
1、flume有记录
2、日志有记录
3、短期没事
六、kafka性能好的原因
1、顺序读写
2、零拷贝
七、kafka丢不丢数据？
设置不同的acks，产生不同的数据保存方式
acks=0，生产者发送出去就代表成功
acks=1，当分区的leader接收到数据并保存到磁盘上代表成功
acks=all，当分区的所有副本都保存成功才代表成功
八、 解决Kafka数据重复？
1、设置acks
acks=0，生产者发送出去就代表成功
acks=1，当分区的leader接收到数据并保存到磁盘上代表成功
acks=all，当分区的所有副本都保存成功才代表成功
2、开启事务
多次发送数据要么都成功要么都失败
3、幂等性
如果在发送数据的时候超时，重新发送不会出现重复数据
九、为什么要使用kafka
缓冲：上游时常有大量数据发出，下游可能扛不住，kafka在中间起到一个缓冲的作用，能把消息暂存在kafka中
解耦：项目开始的时候并不能确定具体的需求，kafka作为一个接口，能解耦重要的业务流程
异步通信：kafka提供了异步处理机制，允许用户把消息放在队列中，但不立即处理
十、kafka优化
1、partition数量配置：partition数量由topic的并发决定，并发少则1个分区就可以，并发越高，分区数越多，可以提高吞吐量。
2、日志保留策略设置：kafka日志默认是保留7天，建议根据磁盘情况配置保留策略，避免磁盘撑爆。
3、文件刷盘策略：为了大幅度提高producer写入吞吐量，需要定期批量写文件。建议配置：每当producer写入10000条消息时，刷数据到磁盘；每间隔1秒钟时间，刷数据到磁盘

flink面试题
简单介绍一下flink？
Flink 是一个分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。
实时计算
flink相比传统的spark streaming的相同点和区别？
Flink 是标准的实时处理引擎，基于事件驱动。而 Spark Streaming 是微批（Micro-Batch）的模型。
资源申请：粗粒度资源申请，和spark一样
任务调度：
1、spark streaming 每一个batch进行一次任务调度
2、flink只做一次任务调度，在开启的时候，task也只部署一次，这是flink比spark streaming快的重要原因
flink的基础编程模型了解吗？
source(读取数据)
1、读取本地集合
2、读取文件
3、读取socket
4、自定义source
实现SourceFunction接口
读取kafka中的数据，使用FlinkKafkaConsumer
自定义读取mysql
自定义读取hbase
transformation(转换数据)
说说flink的常用算子？
map：对输入的参数进行转换操作
fliter：过滤掉指定条件的数据
flatMap
keyBy：按照指定的key进行分组
Reduce：用来进行结果汇总合并
sum
window：窗口函数，根据某些特性将每个key的数据进行分组（例如：在5s内到达的数据）
join(难点)
union
sink(输出数据)
1、打印
2、写入文件
3、写入socket
4、自定义sink
实现sinkFunction 或者 rickSinkFunction
sink到kafka
集群搭建
flink的运行必须依赖hadoop组件吗？
Standalone：可以独立搭建一个flink资源管理集群，不依赖于hadoop
flink on yarn
yarn -session模式，在yarn上启动一个job manager，所有job共享一个job manager
yarn-cluster模式：直接提交任务到yarn集群，每一个job独享一个job manager
提交方式：1、通过网页提交，2、通过linux命令行提交(flink run)
时间
flink中的时间有哪几类？
1、事件时间(采集的数据字段中带有时间字段，最真实，应用范围最广)
数据必须自带时间才可以使用
通过将水位线前移解决乱序问题
2、接收时间(数据到达flink的source端的时间，一般用不上)
3、处理时间(默认。以当前系统时间作为计算时间)
窗口
说说flink中的窗口？
时间窗口(例如5秒生成一个统计结果的窗口)
事件时间的滚动窗口
事件时间的滑动窗口
处理时间的滚动窗口
处理时间的滑动窗口
会话窗口(如果一段时间没有数据，生成一个窗口)
每隔一段时间没有数据，进行计算
事件时间和处理时间
统计窗口(例如以固定的数据量过来，生成一个统计结果的窗口)
滚动和滑动
状态
说说flink中的状态？
flink可以将程序中间计算结果以状态的形式保存起来(单词的数量，消费偏移量)，状态会随着checkpoint保存到hdfs中，保证数据不丢失
分类：
valueState(针对每一个key保存一个单值,例如Reduce算子的底层)
listState(针对每一个key保存一个list集合)
ReduceState(针对每一个key保存一个值)
MapState(针对每一个key保存一个map集合)
针对每一个key都会保存一个状态
checkpoint
说说flink中的checkpoint的流程？
分布式快照，将状态持久化到hdfs中
流程
1、job manager定时发起checkpoint，向source task发送触发器
2、source task会在数据中安插标记，同时自己进行checkpoint，将数据保存到hdfs中
3、下游算子收到标记后异步进行快照
4、当所有的算子处理完同一个标记后代表一次checkpoint成功
状态后端
说说flink中的状态存储？
MemoryStateBackend：将状态保存到job manager的内存中
FsStateBackend：先将状态保存到task manager的内存中，当进行checkpoint的时候将状态保 存到hdfs中
RocksDBStateBackend：先将状态保存到task manager本地的RocksDS中，当进行checkpoint的时候将状态保存到hdfs中，可以支持增量快照
如何保证kafka采集到flink的数据不丢失？
Exactly once(数据只处理一次)
1、消息生产者kafka
1、acks
acks=0，生产者发送出去就代表成功
acks=1，当分区的leader接收到数据并保存到磁盘上代表成功
acks=all，当分区的所有副本都保存成功才代表成功
2、事务
多次发送数据要么都成功要么都失败
3、幂等性
如果在发送数据的时候超时，重新发送不会出现重复数据
2、flink消费端
通过flink的状态和checkpoint保存消费的偏移量以及计算的中间结果，保证数据不重复
3、flink生产端
1、依赖flink两步提交的sink
2、依赖kafka的事务支持，在checkpoint之前开启事务，在checkpoint成功之后提交事务，但会导致数据输出的延迟

电商大数据项目
数据源：电商后台数据库，使用canal实时采集mysql数据库中的数据
使用flink创建表，将表结构存放在hive中；通过flink进行实时计算
ods(数据运营层)：
canal将采集到的数据保存到kafka中；启动hadoop、启动hive元数据服务、启动yarn-session、进入sql-client创建ods的表
dim(维度表)：
可以放在mysql、hbase中，因为是实时计算
1、进入sql-client创建dim的表，通过kafka接收mysq表的数据
2、然后对多个dim表进行关联，生成新的宽维表(地区维表、商品维表、用户维度表等)，指定数据存储路径为mysql中创建相应的宽维表的路径；在mysql中创建相应的宽维表，使用flink-sink配置路径，将数据导入
3、再到sql-client中创建mysql cdc表，这时mysql原表中数据更新，宽维表的数据相应更新
dwd(数据明细层)：
数据放在kafka中
进入sql-client创建dwd的表，对ods的表进行关联(支付明细表)
ads(数据应用层)：
放在mysql、hbase中
进入sql-client创建ads的表，指定数据存储路径为mysql中指标表的路径，对dwd的表和dim的宽维表关联，获取需求指标，例如(每天每个省份的订单数)；在mysql中创建相应ads的指标表，将数据导入

以前公司大数据团队有多少人？集群规模有多大？项目周期多久？
1.公司大数据团队有5个人，组长、一个做数据采集、两个做离线数仓工程、一个做实时数仓，组长最后拿到ads层的指标数据再进行处理。
2.不太清楚公司的集群，这个是由运维人员去搭建好的
3.一个项目大概三四个月的时间完成，有的更长，半年左右

第一次模拟面试
1、scala隐式转换作用
一个类的对象能够调用另外一个类方法，这样可以使用本来没有的方法，更加方便

2、hadoop中怎么减少shuffle？(shuffle优化)
Map阶段
1、增大环形缓冲区大小。比如由100m扩大到200m
2、增大环形缓冲区溢写的比例。比如由0.8扩大到0.9
3、提前在map阶段进行combine，对相同的key进行预聚合，减少传输的数据量
Reduce阶段
1、合理设置Map和Reduce数量
2、设置Map、Reduce共存：调节参数，使map运行到一定程度后，reduce也开始运行，减少Reduce的等待时间
整体
1、增大MapTask和ReduceTask的cpu和内存

3、hive组成架构
1、用户接口：Client CLI(hive shell 命令行)，JDBC/ODBC(java访问hive)，WEBUI(浏览器访问hive)
2、元数据：Metastore。包含表的所有信息
3、数据：hive使用hdfs存储数据，使用mapreduce进行计算
4、驱动器：Driver。包含解析器：将sql转换成抽象语法树；编译器：将抽象语法树编译成逻辑执行计划；优化器：对逻辑执行计划进行优化；执行器：就是MapReduce，用来执行逻辑执行计划

4、RDD为什么是弹性的
1、自动进行内存和磁盘切换
3、task如果失败会自动重试(重试次数可以设定)
4、stage如果失败会自动重试
5、DAG、Task调度和资源管理无关

5、spark架构
1、spark core：包含spark的基本功能，包含定义RDD的API
2、spark sql：通过DataFrame将spark-sql转化为spark操作
3、spark streaming：对实时数据流进行处理和控制
4、spark mllib：一个机器学习的算法库

6、kafka架构
1、topic：kafka的数据存储在topic中
2、partition：一个topic可以分成多个partition
3、broker(经纪人)：负责维护发布数据的简单系统
4、producer：生产者，发送一个或多个topic消息
5、consumer：消费者，从broker处读取数据
6、zk：Zookeeper中保存broker和消费者等信息

7、flink的执行流程
1、flink客户端向ResourceManager提交任务
2、ResourceManager选择一个nodeManager启动ApplicationMaster
3、ApplicationMaster向ResourceManage申请启动TaskManager
4、ResourceManager选择一个nodeManager启动TaskManager
5、TaskManager启动后向JobManager发送心跳包，并等待JobManager向其分配任务

9、事实表有哪几种
1.1 事务事实表
描述业务过程，保存的是最原子的数据；例如日志数据，每一次相关的改变都记录下来，生成一行新的数据
1.2 周期快照事实表
以一个周期为时间间隔，来记录事实，一般周期可以是每天、每月等；
比如：订单收货，以订单收货时间来切分数据，周期可以为每天、每月等。
1.3 累积快照事实表
用来描述过程开始和结束之间的关键步骤，覆盖整个过程的生命周期，通常具有多个日期字段来记录关键时间点；当过程随着生命周期不断变化时，记录也会随着过程的变化而被修改；
比如：创建订单 → 买家付款 → 卖家发货 → 买家确认收货，这个过程的订单状态变化

10、请列举说明结构化数据、半结构化数据、非机构化数据的区别？
1.结构化数据定义：以关系型数据库表形式管理的数据
2.半结构化数据定义：非关系模型的、有基本固定模式的数据，例如日志文件、JSON文件等
3.非结构化数据定义：没有固定模式的数据，如PPT、图片、视频等

10、各个框架的版本
jdk：8
linux：centos-7
hadoop：2.7.6
zookeeper：3.4.6
hive：1.2.1
hbase：1.4.6
spark：2.4.5
flink：1.11.2
mysql：5.5.59
redis：3.0.0
kafka：2.11
canal：1.1.4
CDH:5.4.0

11、工作中遇到的难点，以及如何解决
1、在hive中创建分区表时，将历史数据按照时间字段动态分区，导致分区太多，小文件很多，后面处理起来耗费资源，跑起来很慢，后面将历史数据放到同一个分区中，每天新增的数据放到新的分区中
2、使用datax迁移数据时由于业务数据的表太多，这样配置datax的json文件时重复作业太多，后面采用jdbc连接mysql数据库读取表结构，将获取的表名、字段名、字段类型登信息填充到json文件中，自动生成需要迁移表的json配置
3、将hive数据同步到clickhouse时，报错示分区数太大，超过了100个分区，这是因为clichouse建表时选择作为分区的字段的不同值太多，例如日期字段会产生很多分区，可以在clickhouse的配置文件中设置更大的最大分区数参数，或者在建表时选择字段值更少的字段作为分区字段，例如性别字段