第四阶段笔记

scala
第一天笔记
一、流行的三大语言发展史
Java：1990年开始研发，1995年投入使用
Python：1991年诞生
Scala：2003年诞生=》2013年=》10年期间无人问津=》太难了=》2013年spark框架开源了=》spark底层源码是Scala语言编写的=》write less do more
二、什么是Scala
是一门多范式的编程语言，有着面向对象和面向函数式编程的特性
三、为什么要学习Scala
1、优雅
2、速度快
3、能融合到hadoop生态圈
4、Spark底层源码是scala编写
四、scala编译器安装
1、windows上安装
2、Linux上安装
3、开发工具上安装

第二天笔记
一、定长数组和变长数组
定长数组：数组长度不可变
变长数组：数组长度可变
二、定长和变长数组之间的转换
定长转变长：调用toBuffer方法
变长转定长：调用toArray方法
三、函数
Map：映射，针对列表当中的每一个元素进行操作，操作完成后，返回一个新的列表
特点：操作之前列表当中有多少个元素，操作之后，还是多少个
filter：过滤出来我们想要的结果，摒弃掉不要的结果
四、tuple元组
最多只能存放22个元素
五、集合
List：有序、有索引，里面元素可以重复
Set：无序、无索引，里面元素唯一
Map：key/value形式
在scala中，集合分为可变集合和不可变集合，
可变集合由：scala.collection.mutable._这个包掌管
不可变集合由：scala.collection.immutable._这个包掌管
Scala当中默认创建的集合都是不可变集合
1、List
Nil：空列表，指的是List（Nothing）
：： ：cons，右连接的作用
六、Option对象
Option对象里有两个子类
一个是Some：默认不为空
一个是None：默认为空
七、队列Queue
特点：先进先出

第三天笔记
一、常用函数
Map：映射，针对列表当中的每一个元素进行操作，操作完成后返回一个新的列表，操作之前多少个元素，操作之后个数不变
flatMap：=map+flatten，先映射，再扁平化管理，操作之后元素的个数大于等于操作之前元素的个数。
二、构造器
辅助构造器首行必须调用主构造器或其他辅助构造器
三、App
App是特质，trait相当于java当中的接口
四、继承
子类继承父类，子类拥有父类当中的属性和方法，也有自己独特的属性和方法
五、关键字
Override：重写父类当中非抽象的属性或方法，必须加override关键字；重写父类当中抽象的属性和方法，选加override关键字
Super：子类调用父类当中的方法，使用super关键字
六、抽象类
抽象字段或抽象方法必须存在于抽象类当中或者特质中
七、样例类
样例类分为两种，一种是多例样例类：case class ; 一种是单例样例类：case object
Case class:后面要跟构造参数
Case object：后面不能跟构造参数
八、偏函数
偏函数：一组没有match的case语句
作用：验证传入的参数是否正确

第四天笔记
一.操作方法需将方法转换成函数
1.val f1=m_ :将方法m转换成函数
2.val f1:(Int)=>Int=m :方法自动转换成函数
二.匿名函数
箭头左边是参数列表，右边是函数体
三.递归函数
自己调用自己
四.高阶函数
操作其他函数的函数
五.函数嵌套
函数内部的函数称之为局部函数
六.函数柯里化
将原来接受两个参数的函数变成新的接受一个参数的函数过程，新的函数返回一个以原有第二个参数为参的函数
例： def add(x:Int,y:Int)=x+y
七、闭包
方法体当中，匿名函数计算调用了方法的参数就叫做闭包
八、隐式值
作用域内，相同类型的值只能存在一个
如果隐式值或隐式视图在别的作用域内，可以通过import关键字调用
九、隐式视图
等号左侧是指要赋予谁功能
等号右侧是指要赋予什么功能

spark
第五天笔记
一、spark为什么比mapreduce
1、mapreduce中间结果保存在磁盘，而spark中间结果保存在内存当中
2、Mapreduce执行任务开启的是进程，而spark开启的是线程
二、spark要取代hadoop
Spark不是要取代hadoop，spark是一个类似于hadoop当中mapreduce的计算框架，目的是要取代mapreduce，而分布式存储要依赖hadfs，资源调度依然要依赖yarn。
三、运行模式
1．Standalone模式
2．Standalone-HA高可用模式
3．Yarn模式（yarn on client模式，yarn on cluster模式）
4．Local模式：local、local[N]、local[*]
四、常用术语总结
DAG有向无环图：有方向无闭环，描述的是RDD的执行流程
一个DAG有向无环图=一个Job
一个Job=多个stage
一个stage=一个taskSet
一个taskSet=多个task
RDD：弹性分布式数据集
算子分为两类：一个是transformations（转换算子），一个是action（执行算子）
转换算子：懒执行策略，只做连接，不运算
执行算子：带动转换算子进行运算，得出结果
五、如何区分转换算子还是执行算子
返回值类型是RDD的就是转换算子
返回值类型不是RDD的就是执行算子
六、spark的bin目录
Spark-shell：进入到编辑接面，可以直接书写代码，用于学习测试使用
Spark-submit：提交jar包，用于开发生产使用
七、reduceByKey
针对的是（k,v）类型的数据，操作完以后依然是（k,v）类型
八、为什么要有高可用模式
为了防止主节点单点故障问题

第六天笔记
一、什么是RDD？RDD有什么特点？RDD是否可以携带数据？
RDD：弹性分布式数据集
特点：不可变，可分区，可并行计算的集合
不可以携带数据，类似于java当中的接口
二、RDD算子
RDD算子分为两类：一类是转换算子（Transformation），一类是执行算子（Action）
转换算子：懒执行策略，只做连接，不运算，直到遇到执行算子，才会带动运行。
执行算子：带动转换算子运算
三、两类算子的区分
返回值是RDD的就是转换算子
返回值不是RDD的就是执行算子
四、分区方式
非key，value数据分区方式为None
Key，value的数据可以有分区方式，没有指定之前是None，但是可以指定，有这个功能
五、依赖
依赖分为两种：一种是窄依赖，一种是宽依赖
窄依赖：父RDD的一个分区只能被子RDD的一个分区所依赖=》独生子女
宽依赖：父RDD的一个分区会被子RDD的多个分区所依赖=》超生子女
六、DAG有向无环图
描述的就是RDD的执行流程
七、Stage如何划分
根据RDD的执行流程构建DAG有向无环图，划分好图后，采用回溯方法，从后往前推，遇到窄依赖包含到当前stage中，遇到宽依赖断开，形成stage。

宽依赖是划分stage的重要依据
八、reduceByKey和groupByKey哪个效率高？为什么？
reduceByKey效率高：因为前期进行了预聚合
九、map和mapPartitions哪个效率高
MapPartitions效率高

第七天笔记
一、reduceByKey和reduce哪个是转换算子，哪个是执行算子？
reduceByKey是转换算子，reduce是执行算子
二、缓存的方式
缓存的方式有两种，一种cache（），一种是persist
def cache(): this.type = persist()
Cache底层调用的persist的无参构造，默认情况下，仅将数据缓存在内存中。
Persist：可以将数据缓存在内存或磁盘等地方，相对来说，比较安全
val result: RDD[Int] = result.persist(StorageLevel.MEMORY_AND_DISK)
工作当中，使用的缓存方式就是这个MEMORY_AND_DISK
三、join既有可能是窄依赖，也有可能是宽依赖
四、Lineage（血统）
五、分区
非key，value数据分区方式为None
Key，value数据默认分区方式为None，可以指定分区方式
在这里插入图片描述

action算子才会有RDD 一个DAG（有向无环图）=job
转换算子：

1. 1.map(func) 返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
   2.filter(func) 返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成
   3.flatMap(func) 类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）
   4.mapPartitions(func) 类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] =>
   Iterator[U]
   5.mapPartitionsWithIndex(func) 类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是
   (Int, Interator[T]) => Iterator[U]
   6.union(otherDataset) 对源RDD和参数RDD求并集后返回一个新的RDD
   7.intersection(otherDataset) 对源RDD和参数RDD求交集后返回一个新的RDD（交集）
   8.distinct([numTasks])) 对源RDD进行去重后返回一个新的RDD
   9.groupByKey([numTasks]) 在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
   10.reduceByKey(func, [numTasks]) 在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
   11.aggregateByKey(zeroValue)(seqOp, combOp, [numTasks]) 先按分区聚合 再总的聚合 每次要跟初始值交流 例如：aggregateByKey(0)(+,+) 对k/v的RDD进行操作
   12.sortByKey([ascending], [numTasks]) 在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
   13.sortBy(func,[ascending], [numTasks]) 与sortByKey类似，但是更灵活 第一个参数是根据什么排序 第二个是怎么排序 false倒序 第三个排序后分区数 默认与原RDD一样
   14.join(otherDataset, [numTasks]) 在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
   相当于内连接（求交集）
   15.cogroup(otherDataset, [numTasks]) 在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
   16.cartesian(otherDataset) 两个RDD的笛卡尔积 的成很多个K/V
   17.coalesce(numPartitions) 重新分区 第一个参数是要分多少区，第二个参数是否shuffle 默认false 少分区变多分区 true 多分区变少分区 false
   18.repartition(numPartitions) 重新分区 必须shuffle 参数是要分多少区 少变多
   19.foldByKey(zeroValue)(seqOp) 该函数用于K/V做折叠，合并处理 ，与aggregate类似 第一个括号的参数应用于每个V值 第二括号函数是聚合例如：+

执行算子：

1. 1.reduce(func) 通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的
   2.collect() 在驱动程序中，以数组的形式返回数据集的所有元素
   3.count() 返回RDD的元素个数
   4.first() 返回RDD的第一个元素（类似于take(1)）
   5.take(n) 返回一个由数据集的前n个元素组成的数组
   6.takeSample(withReplacement,num, [seed]) 返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
   7.takeOrdered(n, [ordering]) 使用自然顺序或自定义比较器返回RDD的前n个元素。
   8.saveAsTextFile(path) 将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它转换为文件中的文本
   9.saveAsSequenceFile(path) 将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统
   10.saveAsObjectFile(path) 使用Java序列化以简单格式编写数据集的元素，然后可以使用Java序列化加载SparkContext.objectFile()。
   11.countByKey() 针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
   12.foreach(func) 在数据集的每一个元素上，运行函数func进行更新。
2. 第八天笔记 一、底层抽象和程序入口 sparkCore程序入口：SparkContext；底层抽象：RDD sparkSql程序入口：SparkSession；底层抽象：DataFrame和DataSet
   二、RDD、DataFrame、DataSet三者之间的关系 DataFrame=RDD-泛型+schema+sql+sql优化
   DataSet=RDD+schema+sql+优化 DataFrame=DataSet[Row]
   DataSet=DataFrame.as[Row] 三、sparkSql查询风格 分为两种，一种是DSL风格，一种是SQL风格
   DSL风格：要求编程能力 SQL风格：纯sql风，抒写sql语句 四、DSL风格和SQL风格起手式
   DSL风格：DataFrame/DataSet.select SQL风格：spark.sql(sql语句) 五、类型转换
   //RDD->DataFrame val df: DataFrame = personRDD.toDF() //RDD->DataSet
   val ds: Dataset[Peoples] = personRDD.toDS() //DataFrame->RDD val
   rdd: RDD[Row] = df.rdd //DataSet->RDD val rdd1: RDD[Peoples] =
   ds.rdd //DataFrame->DataSet val ds1: Dataset[Peoples] =
   df.as[Peoples] //DataSet->DataFrame val df1: DataFrame = ds.toDF()
   六、加载/保存 保存：DataFrame/DataSet.write 加载：spark.read

第九天笔记
一、SparkStreaming和Storm对比
SparkStreaming：时间驱动
Storm：数据驱动
缺点：storm吞吐量太低了
二、SparkStreaming简介
底层抽象：DStream：封装了一个时间批次的RDD
三、kafka如何保证数据不丢失？
这不是一个问题，这是三个问题
1、producer端如何保证数据不丢失？
2、Broker端如何保证数据不丢失？
3、Consumer端如何保证数据不丢失？
四、kafka为什么那么快？
1、采用pageCache页缓存技术
2、顺序读写
五、kafka保存数据
保存在segment文件段当中
Segment文件段由.log文件和.index文件组成
.log文件保存的是数据
.index文件保存的是.log文件中数据的索引，而且是稀疏索引
当segment文件段数据量达到1G的时候进行分裂
Kafka默认保存数据时长是168小时，也就是7天
Segment文件段命名规则：
以上一个segment文件段当中最后一条数据的偏移量命名
第一个segment段命名：
-rw-r–r-- 1 root root 0 Oct 21 20:35 00000000000000000000.index
-rw-r–r-- 1 root root 0 Apr 8 2020 00000000000000000000.log
第二个segment段命名：
-rw-r–r-- 1 root root 0 Oct 21 20:35 00000000000000014325.index
-rw-r–r-- 1 root root 0 Apr 8 2020 00000000000000014325.log
第三个segment段命名：
-rw-r–r-- 1 root root 0 Oct 21 20:35 00000000000002964265.index
-rw-r–r-- 1 root root 0 Apr 8 2020 00000000000002964265.log
六、DStream转换操作
分为无状态和有状态转换操作
无状态：当前批次计算的结果不依赖于之前的批次结果
有状态：当前批次计算的结果依赖于之前的批次结果