Spark知识点总结

scala

1.Scala六大特性与java区别
1).与java无缝整合
2).类型自动推断
3).支持并行和分布式 actor
4).Trait特质特性
5).模式匹配 match
6).高阶函数
2.Scala类和对象
val,var ,伴生对象，伴生类，类可以传参
3.Scala 流程控制
if…else for… do…while …
4.Scala 方法和函数
1).方法定义
def xxx(xx；xxx):xxx ={xxxx}
2).递归方法
3).方法参数有默认值的方法
def fun(a:Int = 10)={…}
4).可变长方法
def fun(s:String*) ={…}
5).匿名函数
val xxx = (xx:xxx,xx:xxx)=>{…}
6).嵌套的方法
7).偏应用表达式
def xxx(x1:x,x2:x,x3:x) ={xxx}
val xxx = xxx(xx,xx,_:String)
8).高阶函数 *****************
a).函数的参数是函数
b).函数的返回是函数
c).函数的参数和返回都是函数
9).柯里化函数
def xxx(…)(…) ={xxx}
5.Scala中的集合
Array:
定义、遍历、可变长、方法
List:
定义、遍历、可变长、方法
Set：
定义、遍历、可变长、方法
Map:
定义、遍历、可变长、方法
Tuple： *****************
定义、遍历[tuple.productIterator]、支持长度、取值。
6.Trait 特质特性 *******************
1).Trait不可以传参
2).一个类继承多个Trait时，第一个关键字使用extends,之后使用with
3).Trait可以定义常量，变量，定义方法的实现和不实现
7.样例类：
使用关键字case 修饰的类就是样例类。可以new 也可以不用new创建，实现了 toString,hash,equels…方法
case class中的参数默认就是当前类中的属性
8.模式匹配
match 关键字：
1).case _ =>{} 代表默认匹配,要放在最后
2).从上往下自动匹配，匹配上之后就自动终止
3).既可以匹配值还可以匹配类型
4).o match {…}是一整行，可以省略方法的{。。。。}
9.偏函数
partialFunction[匹配类型，匹配上之后返回的类型]
10.Scala隐式转换
隐式值
隐式转换函数 – demo
隐式类
11.Actor通信模型 *********************
Spark1.6底层通信使用的Akka,Akka的底层使用的是Actor实现
Spark2.0 之后，通信使用的netty
Actor通信模型代码

case class Message(actor:Actor,msg:Any)
class Actor1 extends Actor{
  def act(){
    while(true){
      receive{
        case  msg :Message => {
          println("i sava msg! = "+ msg.msg)
          
          msg.actor!"i love you too !"
          }
        case msg :String => println(msg)
        case  _ => println("default msg!")
      }
    }
  }
}

class Actor2(actor :Actor) extends Actor{
  actor ! Message(this,"i love you !")
	def act(){
		while(true){
			receive{
  			case msg :String => {
  			  if(msg.equals("i love you too !")){
  			    println(msg)
  			   actor! "could we have a date !"
  			  }
  			}
  			case  _ => println("default msg!")
			}
		}
	}
}

object Lesson_Actor2 {
  def main(args: Array[String]): Unit = {
    val actor1 = new Actor1()
    actor1.start()
    val actor2 = new Actor2(actor1)
    actor2.start()
  }
}

Spark

1.Spark Scala WordCount & java WordCount
必须手写wordcount *****************

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.rdd.RDD.rddToPairRDDFunctions

object WordCount {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local").setAppName("WC")
    val sc = new SparkContext(conf)
    val lines :RDD[String] = sc.textFile("./words.txt")
    val word :RDD[String]  = lines.flatMap{lines => {
      lines.split(" ")
    }}
    val pairs : RDD[(String,Int)] = word.map{ x => (x,1) }
    val result = pairs.reduceByKey{(a,b)=> {a+b}}
    result.sortBy(_._2,false).foreach(println)
    //简化写法
    lines.flatMap { _.split(" ")}.map { (_,1)}.reduceByKey(_+_).foreach(println)
  }
}

2.MapReduce & Spark 区别 *****************
1).针对迭代的业务场景，Spark可以基于内存计算，MR是基于磁盘
2).Spark中有DAG有向无环图优化
3).MapReduce中只有map reduce两端，逻辑实现需要自己实现
Spark中有各种场景算子适用不同的场景。
4).Spark是粗粒度资源申请，MR是细粒度资源申请。
5).Spark Shuffle相对于MR shuffle有特殊实现，还有bypass机制。
6).Spark中处理数据默认可以指定副本，MR默认有三份
3.Spark技术栈
SparkCore
SparkSQL
SparStreaming
StructString
HDFS
MR
Hive
Yarn
4.Spark核心RDD *****************
RDD:弹性分布式数据集。
五大特性：
1).RDD是由一系列partition组成
2).算子（函数）是作用在Partition上的
3).RDD之间有依赖关系
4).分区器是作用在K,V格式的RDD上
5).partition对外提供最佳的计算位置，利于数据处理的本地化。
注意：
1).textFile读取数据采用了MR读取HDFS文件的方法，首先先split，每个split默认与一个block相同，这里的一个split也对应一个RDD中的分区
2).什么是K,V格式的RDD?RDD中数据是一个个的二元组
3).哪里体现了RDD的弹性？
a.RDD之间有依赖关系
b.RDD的分区可多可少
4).哪里体现了RDD的分布式？
partition是分布在多个节点上的。
5.Spark算子 *****************
a.Transformation 转换算子
特点：懒执行，需要action算子触发执行
map,flatMap,filter,reduceByKey，sortBy,sortByKey,sample,mapPartitions,join,leftOuterJoin,rightOuterJoin,fullOuterJoin,subtract,distinct,intersection,mapPartitionWithIndex,mapValues,cogroup,groupByKey,repartition,coalesce,zip,zipWithIndex,mapToPair,flatMapToPair,mapPartitoinsToPair,aggregateByKey,combineByKey
b.action 行动算子
特点：触发transformation执行，当一个application中有一个action算子时，就有一个job。
count,collect,foreach,foreachPartition,take,first,takeSample,collectAsMap,countByKey,countByValue,reduce,saveAsTextFile
**c.持久化算子 *******************
cache:
cache()= persist() = persist(StorageLevel.MEMORY_ONLY)
特点：就是将数据直接持久化到内存。
persist:
可以执行级别将数据持久化到内存或者磁盘和是否序列化
MEMORY_ONLY,MEMORY_ONLY_SER,MEMORY_AND_DISK_SER,MEMORY_AND_DISK。
对persist尽量避免使用“_2”和DISK_ONLY级别。
checkpoint:
当lineage非常长，计算逻辑复杂时，可以对RDD进行checkpoint,checkpoint用于状态保存。
注意：
a.cache和persist需要注意：
i).cache和persist都是懒执行算子，持久化的单位都是partition
ii).对一个RDD进行cache或者persist之后，可以赋值给一个变量，下次再其他job中使用这个变量就是使用的持久化的数据
iii).如果采用第二种方式，算子后面不能紧跟action算子。
b.checkpoint也是懒执行与persist(StorageLevel.DISK_ONLY)区别？
区别：persist是由Spark框架管理，当Spark Applicationi执行完成之后，数据目录会被清空（cache也是一样）。
checkpoint是由外部存储系统决定数据的，当Application执行完成之后，数据不会被清空。正是由于这种特点，
checkpoint更适合保存状态。
c.checkPoint执行流程
i).当job执行完成之后，Spark框架从后往前回溯
ii).找到checkpointRDD进行标记，回溯完成之后，重新启动一个job计算checkpointRDD的结果
iii).将结果持久化到指定的目录中。如果发现内存中有当前checkpointRDD的数据，直接从内存转入磁盘。
优化：对哪个RDD进行checkpoint之前先cache下。
6.Spark 代码执行流程
1).val conf = new SparkConf().setMaster…setAppName…
2).val sc = new SparkContext(conf) === val sessinon = SparkSeesion.builder().conf…master.appName…getOrCreate…
3).val rdd = session.SparkContext.textFile(…)
4).对RDD使用Transformation类算子转换
5).对RDD使用action算子触发执行
6).sc.stop()