Spark基础知识点儿汇总



*spark的理解
spark是一个快速的、统一的大规模数据处理引擎
它是基于内存计算的
它的特点是:快速、易用、适用于各种数据处理场景(批处理、流处理、交互式处理)、它可以运行在多种分布式计算框架中,如yarn和mesos等

*spark的架构
Master
  spark计算集群的主节点,负责接收客户端提交来的spark job,并且负责work节点的资源申请和资源调配,在程序运行时,对各个子节点的状态监控和运行程序的执行情况的查看。
Worker
  根据master的资源申请,运行起executor和driver程序,在executor和driver上运行具体的执行程序

spark程序的集群运行方式:
1.把master的url设置成集群的主节点服务的url
  val conf = new SparkConf().setAppName("wordcount").setMaster("spark://centos1:7077")
  把本地的intellj里的代码打成jar包
  然后再sc上添加:
  sc.addJar("E:\\bigdata\\sparkfirst20\\out\\artifacts\\sparkfirst20_jar\\sparkfirst20.jar")
 
  然后再intellj上右键运行就能把程序发送到spark集群上来运行
2.把项目打包,然后发送到linux,使用spark的submit指令把程序发布到spark集群上运行
  spark-submit
  --class com.zhiyou.bd20.WordCount
  --master spark://centos1:7077
  --executor-memory 1G
  sparkfirst20.jar

standalone
client   cluster

*spark的编程模型
1.创建sparkconfig对象,用于配置spark运行环境
2.使用config来构建sparkcontext对象,sparkcontext对象主要用于和spark集群服务连接并发布应用程序,同时用于加载数据源和创建rdd、累加器、广播变量
3.使用sparkcontext加载数据源,获取rdd
4.调用rdd的各种transformation方法
5.调用rdd的action方法触发计算job的执行。在action方法中对计算结果进行读值/取值。
6.sparkcontext.stop()


我们开发的spark代码可以分成两块:
1:Driver,application的入口执行程序,一个application的数据处理过程全部都是在driver中来进行定义和配置的。
2:Executor,一个application对数据的处理过程是分布式进行的,分布式处理中的每一个任务执行节点里面会运行起一个executor,executor来接收driver发送过来的任务(task)

driver在运行时,会负责监控每一个executor的执行进度,每一个executor在被分配给driver之后直接向driver负责,接收driver发布进来的指令和任务,在这个过程中,具体task的执行进度状况不再向master汇报。

application,app:一个完整的数据处理过程被称为一个app
                一个application程序中包含一个driver和多个executor

Cluster Manager:分布式计算框架的主节点。spark集群来说是:master,对yarn来说是:resource manager
Worker Node:分布式计算框架的子节点。对spark集群来说就是:worker,对yarn来说是:node manager

job:一个application中会有多个job,job是由action方法来触发的,一个action方法就会有一个job。每一个job都会有一个dag图和一个调度,job的执行是由调度按照dag来调配work node子节点上运行其executor来接收并执行task的
Stage:一个job在被解析编译时会划分成多个stage,stage是以shuffle来作为边界划分的。每个stage里有多个task任务。
task:每个job中都会有多个task,task是由driver分配指派给executor来进行执行的


*spark核心api
SparkContext类型

实例化sparkcontext对象:SparkContext.getOrCreate(conf)
创建rdd:
  makeRDD:使用driver节点内存中的集合对象创建rdd
  parallelize:使用driver节点内存中的集合对象创建rdd
  range:获取一个序列rdd
 
  textFile:加载文本格式数据文件获取rdd
  sequenceFile:加载sequence个是的数据文件获取rdd
  newAPIHadoopFile:用来加载任意格式的mr可以加载的数据文件
  newAPIHadoopRDD:用来加载hbase中的数据
 

创建累加器:
  collectionAccumulator
  doubleAccumulator
  longAccumulator
  register
创建广播变量:
  broadcast

setCheckpointDir 设置检查点的目录

累加器和广播变量可以优化spark程序

*RDD的api
rdd:弹性分布式数据集。
不可变的、元素被分区的,可被并行操作的数据集
1.rdd是一组分区
2.对rdd调用api方法进行计算时,计算函数是作用于每一个分区的(分布式计算)
3.rdd之间是有依赖关系的,每个rdd都有一个依赖列表,或称为血统关系
4.对于kv的rdd可以指定partitioner对其进行分区
5.rdd在进行加载和计算时会尽可能考虑本地加载和本地计算

窄依赖:父rdd的一个分区的数据进行计算只流向子rdd的一个分区,这种依赖是窄依赖
宽依赖:父rdd的一个分区的数据计算时会流向子rdd的多个分区,这种依赖就叫做宽依赖

有些api方法是窄依赖如:map,flatmap,filter等
有些api方法是宽依赖,如:groupby,reducebykey等

总的来说rdd的方法分为action(返回值类型不是rdd的方法)和transformation(返回值类型是rdd的方法)

rdd本身的api包括:普通rdd(每个元素都是一个对象)和kvrdd(每个元素是一个kv)
  kv的rdd除了具有普通rdd的全部功能之外还有额外的功能

数据映射:对数据的转换,解析,一对一计算等功能
map :一个输入元素对应一个输出元素。每一个元素都会经过map的算子被计算
mapPartitions:每一个partition作为一个整体经过mappartition算子被计算(效率更高)
flatMap:一个输入对应多个输出元素
filter:过滤rdd的元素,留下符合条件的数据。每个元素,经过算子输出是true就会被留下,如果是false的话就会被排掉
distinct:排重去重
keyBy:把一个普通的rdd转换成kv rdd的一种方式,它的算子就是确定key值

action:
foreach
foreachPartition

数据聚合的
action:
reduce:不需要初值,算子的输入和输出类型要保持一致
fold:需要初值,算子的输入和输出类型要保持一致
aggregate:需要初值,算子的输入和输出类型可以不一致
max:
min:
count:
countByValue


transformation:
groupBy:对rdd中的数据按照key值进行分组,同一个key在输出rdd里面只存在一次,同一个key下的原rdd的多个value会被合并成一个集合对象Iterable,与key形成一个keyvalue从而形成一个kvrdd。groupby只对数据做一个分组操作,没有进行实际的聚合计算,所以如果需求是做分组并聚合的话尽量避免使用groupby,使用kv rdd的其他更高效的方法来完成分组聚合计算。


排序
action:
first 取出rdd的第一条记录
take 取出rdd中的前N条数据,它是按照rdd的原顺序来取值

takeOrdered 取出rdd按照从小到大的顺序排序后的前N条数据
top  取出rdd按照从大到校的顺序排序后的前N条数据

transformation:
sortBy 是每个分区各自排序

缓存
spark程序的优化手段
当一个rdd会被后续的很多计算进行使用的时候,把这个rdd放在缓存中会提高程序的运行效率
cache:把数据缓存在内存中
persist:接受StorageLevel级别来决定把数据缓存在内存中或者缓存在磁盘上。如果不传参数就是缓存在内存中

unpersist:把rdd从缓存中踢出去

持久化
saveAsTextFile  保存成文本文件
saveAsObjectFile 保存成对象文件

重分区
数据在经过聚合或者过滤等计算之后,原rdd的各个分区中的数据有可能产生倾斜的情况,为了解决数据倾斜的情况,可以对计算后的rdd进行重分区。
coalesce:当原rdd的分区数小于分区后的rdd的分数的时候,可以使用coalesce从而避免分区过程中产生shuffle
repartition:不管重分区的数量怎么发生变化,该方法都是会经过shuffle


集合计算
transformation:
union  并集
++
intersection 交集
subtract     减集
cartesian    笛卡尔乘积

zip   拉链操作
拉链操作要保持对应分区的元素数量要保持一致,不然会报错。

检查点:
checkpoint:
localCheckpoint:
getCheckpointFile
isCheckpointed


collect()

*PairRdd  kvrdd
pairrdd具有普通rdd的全部方法和功能。

kvrdd可以由普通的rdd映射而来,映射生成的rdd中的每一个元素是一个元组,这个元组只有两个元素,这样一个rdd就是一个pairrdd
val rdd = sc.parallize(List(1,2,3,4,5,6))
val kvrdd = rdd.map(x=>(x%2,x))

kv的rdd可以由sc加载数据文件而来


映射方法:
mapValues    只对kv中的value进行映射,key保持不变。算子的输入是value,输出是结果的value
flatMapValues

分组聚合函数:
transformation:
下面三个聚合函数的聚合都有两个过程,1:partition内部聚合,2:partition之间的聚合
reduceByKey:根据key值对pairrdd的value进行分组聚合,不需要聚合的初始值,但是要求聚合的结果值必须要和kvrdd的value的类型保持一致。
reducebykey只接受一个算子,这个算子要同时被用于partition内部聚合和partition之间的聚合,所以,这个要求这个算子必须满足两个输入参数的地位要是对等关系。reducebykey值适合进行累加之类的计算

foldByKey:foldbykey除了比reducebykey多了一个初值之外,reducebykey的限制,它一样具有

aggregateByKey:对分组聚合没有太多的限制几乎可以满足所有的聚合
该方法接受三个参数,一个初始值和两个算子,
第一个算子是用于分区内的聚合过程(会用到初始值)
第二个算子是用于分区间的聚合(不会用到初始值)

combineByKey:对分组聚合没有太多的限制几乎可以满足所有的聚合
该方法接受三个参数,三个参数都是算子
第一个算子用于初始值的计算过程.这个算子是会作用于每一个分区的第一个元素。
第二个算子用于分区内的聚合过程(要使用到第一个算子执行结果)
第三个算子是用于分区间的聚合

groupByKey:对数据按照key值进行合并,把一个rdd下某个key值相同的所有的value合并成一个集合对象,并和原key形成一个新的kv


countByKey:统计出相同的key的个数,和原key形成一个新的kv

cogroup:多个kvrdd之间的操作如
kvrddA.cogroup(kvrddB)
先对kvrddA和kvrddB进行groupbykey
keyA:Iterator
keyB:Iterator
join
key,(Iteratora,Iteratorb)
然后对两个groupbykey后的结果进行join(fullOutterJoin)操作,这里的连接是使用的全外连接。

cogroup=groupbykey + fulloutterjoin
groupWith:和cogroup功能用法完全一模一样

数据集操作方法:
subtractByKey  减集

join              内连接   :两个rdd根据key值相互过滤,只有能关联上的数据才会在结果集中
leftOuterJoin     左外连接 :左边的rdd是主rdd右边的是辅rdd,用左边rdd的key去过滤右边rdd的数据,关联上的在结果结果集里面就是Some(辅表的数据),关联不上的就是None

fullOuterJoin     全外链接
rightOuterJoin    右外连接

lookup:查找某个key下的所有value

持久化操作方法:
saveAsNewAPIHadoopDataset:保存数据到hbase的
saveAsNewAPIHadoopFile:以hadoopfile的输出格式保存文件

spark完全支持hadoop的读写
val rdd1 = sc.parallelize(List((1,"张三"),(2,"李四"),(3,"王二")))
    rdd1.map(x=>(new IntWritable(x._1),new Text(x._2)))
      .saveAsNewAPIHadoopFile("file:///e:/usersparkoutput",classOf[IntWritable],classOf[Text]
        ,classOf[SequenceFileOutputFormat[IntWritable,Text]])

    val rdd2 = sc.newAPIHadoopFile("file:///e:/usersparkoutput",classOf[SequenceFileInputFormat[IntWritable,Text]]
      ,classOf[IntWritable],classOf[Text])
    rdd2.foreach(println)


统计每个用户,login次数,logout次数,view_user次数,new_tweet次数,每个ip上平均行为次数
   jim           44        33           22             33                   22

每个ip上平均行为次数 = 用户行为次数/该用户使用过的ip数量

维度
指标(KPI)

*共享变量
广播变量:广播变量是在driver上声明,在executor上使用的一些变量数据
          广播变量对executor来说是只读的
  使用步骤:1.在driver上声明广播变量
            2.在executor执行的算子中使用这个广播变量
  工作过程中,经常在两张表关联的时候使用广播变量。
  spark上在对两个rdd进行关联的时候,如果一个rdd的数据量很小,一个rdd的数据量很大,可以使用广播变量来把关联过程变成map端关联。把小表的数据变成广播变量,广播给每一个加载大表rdd的executor。
累加器:在driver上声明,在executor进行累加奇数,
        累加器对executor来说是只写
  使用步骤:1.driver上声明累加器
            2.在executor上对累加器进行累加数据处理
            3.在driver上读取并得到累加结果

  当在工作过程中需要一些全局计数类型的聚合的时候,可以考虑使用累加器来替代rddapi方法完成聚合。这种方式可以减少job的数量提高spark的执行效率。

*spark的部署模式
local模式:本地运行模式,一般开发调试时使用该模式。
  driver和executor都在本地运行,它是通过多线程来模拟实现分布式的

standalon模式:把spark程序发布到spark的集群上去运行。
client模式:driver运行在客户端,executor运行在集群work节点上
cluster模式:driver和executor都运行在集群的work节点上
cluster模式需要把spark程序的jar包放到hdfs上
spark-submit \
--class com.zhiyou.bd20.WordCount \
--master spark://centos1:7077 \
--deploy-mode cluster \
hdfs://master:9000/path/to/sparkjar


yarn模式:把spark程序发布到yarn集群上去执行。
clinet模式:driver运行在提交运行程序的客户端,executor运行在集群的nodemanager上
spark-submit \
--class com.zhiyou.bd20.WordCount \
--master yarn \
--deploy-mode cluster \
/path/to/jar

cluster模式:driver和executor都运行在集群的nodemanager节点上


*spark程序读写数据库(sql和nosql)
mysql:
读:new JdbcRDD
写:foreachPartition mapPartition
hbase:
读:sc.newAPIHadoopRDD(configuration,classOf[TableInputFormat],classOf[ImmutableBytesWritable],classOf[Result])
写:两种方式:
    1.oHBaseRdd.saveAsNewAPIHadoopDataset(job.getConfiguration)。这里要保证rdd的value必须是Put类型或者是Delete类型
    2.和mysql一样是用foreachPartition的方式,在算子里面用hbase的api把数据通过hbase服务保存到hbase中

*java开发spark
1.创建项目引入依赖
2.构建sparkcontext对象
3.使用sparkcontext对象加载RDD
4.调用rdd的api方法,传入算子,完成对数据的处理逻辑过程
5.调用rdd的action方法触发计算并读取计算结果


hive
driver

hiveserver2 driver
beeline  squrrile


impala cloudera
presto teradata

hive--->hive run on spark
hive可以通过设置让底层执行引擎直接由mapreduce换成spark
shark(sparksql 1.0)
更改了hive的执行引擎为spark,hive核心中的sql优化在自己项目里面以spark为执行引擎的基础上重构

sparksql2.x


*sparksql的开发步骤
1.构建SparkSession
引入sparksession的隐式转换:
import spark.sql
import spark.implicits._
2.用sparksession加载数据源Dataset DataFrame
把dataset或dataframe创建成视图
3.对dataset使用sql来完成数据处理过程
4.对处理后的数据进行读值触发计算过程
5.关闭SparkSession

spark的配置参数:spark.sql.warehouse.dir用来指定给一个目录来作为spark的warehouse目录

*Dataset和DataFrame
DataFrame是Dataset的一个特例
DataFrame = Dataset[Row]

dataframe的row类型可以让我们自定义每一个字段的名称
dataset的字段的名称是自动转换而来

如果每条记录的类型是一个case class的话,那转换成dataset之后,模式字段的名称和类型会和case class的属性的名称和类型保持一致。

数据集每个元素是元组的--------》转成dataframe
数据集每个元素是case class----------》转成dataset

*sparksql数据加载和保存
使用sparksession加载数据
使用dataset的方法保存数据
读:SparkSession.read 使用DataFrameReader的方法加载各种数据源处的数据,可以很方便的加载各种格式的数据文件,和数据库。
写:Dataset.write 使用DataFrameWriter的方法可以方便把数据保存成各种格式和数据存储位置。

select
where
找出personDataSet年龄大于5的数据
personDataSet.createOrReplaceTempView("person")
sql("select * from person where age>5")
-----------------------------
linq写法
personDataSet.select("name","age").where("age>5")

*spark使用hive的metastore和hive进行数据互通
1.hive-site.xml引入项目
2.添加依赖spark-hive
3.在sparksession创建过程中调用builder的enableHiveSupport
如果报元数据版本不一致,把hive-site.xml的参数
hive.metastore.schema.verification=false


*流处理
流处理和批处理的区别
1.流处理对应实时数据处理业务场景,批处理对应历史报表业务场景
2.处理速度上,流处理速度快,批处理速度慢;处理数据量上,流处理处理的数据量小,批处理处理的数据量大
  其实对流处理的框架来说处理的数据量的大小,而是使用吞吐量来衡量流处理框架的处理能力
3.批处理程序是使用定时调度来进行运行和终止的。
  流处理7X24运行,一旦运行起来,除非更新程序或意外情况,流处理不会被终止。
4.批处理启动后只执行一次计算
  流处理启动后可能会执行无数次计算

在数据处理上
流处理有时间的概念
批处理只有时间点的概念

*spark streaming的开发流程
1.构建StreamingContext,这个类型封装了SparkContext
2.从数据源处加载流数据,获取DStream,它封装了rdd
3.调用DStream的各种api方法完成流处理过程
4.启动流计算

*spark streaming开发重要内容
1.获取数据源(kafka flume socket mq)
2.DStream的api方法


*时间间隔长度
 Duration、Minutes、Seconds



需求:
实时展现商品销量的top5

1.流数据源(nc -lk)
  订单id 产品id 订单产品数量 订单金额
1       2     3             344
1       1     1             111
1       1     1             111
1       2     3             123
2.统计出每个产品的总销量和每个产品的总订单金额
  transformation:
  map算子
  reducebykey算子
  action:
  foreachpartition算子
3.取出销量的top5

mysql数据库设计
create table order_stastic(
  product_id integer,
  account_num integer,    -- 累计销量
  amount_num integer,     -- 累计总金额
  primary key(product_id)
)

数据每个微批次都更新到mysql的这张表
使用:

实时查看销量top5:
select * from order_stastic order by account_num desc limit 5
实时查看销售金额top5:
select * from order_stastic order by amount_num desc limit 5


作业
计算累计的wordcount
计算结果保存在hbase中
 

*dstream的api
映射:
transformation:
flatMap
map
mapPartitions
filter

action:
foreachRDD

print 打印前10条数据

聚合函数:
reduce
count
countByValue



-------------------------------------------------
缓存:
cache
persist
重分区:
repartition
持久化:
saveAsTextFiles


*kvdstream(pairdstream)的api
一个dstream只要符合如下条件就自动具有paridstream的所有方法:
dstream中每个元素是一个元组,每个元组中有两个元素

pairdstream具有dstream的所有方法和功能
映射
mapValues
flatMapValues

聚合:
分组聚合
reduceByKey
combineByKey
groupByKey
cogroup,先groupby 再join

持久化:
saveAsNewAPIHadoopFiles

数据集合数据集的关联操作:
join
leftOuterJoin
rightOuterJoin
fullOuterJoin


*dstream附加算子

统计近10分钟之内接受到的数据的wordcount累计值

窗口计算算子
1.窗口的宽度和微批次时间长度一样是个时间长度的概念,一个窗口包括若干个微批次时间长度
2.窗口宽度必须是微批次时间长度的整数倍
3.当计算的时间间隔需要超过微批次的时间间隔的时候,可以使用窗口滑动参数来进行设置计算的时间间隔。窗口滑动的宽度也必须是微批次时间长度的整数倍。(当窗口计算没有滑动参数的时候,计算的时间间隔是微批次的时间,当窗口计算有滑动参数的时候,计算的时间间隔就是滑动参数的时间长度)
groupByKeyAndWindow
reduceByKeyAndWindow


countByValueAndWindow
countByWindow
reduceByWindow

统计近1分钟个之内的累计wordcount

window:开窗算子

累计计算算子:
这种累计计算的算子只有在pairdstream里面才有,普通的dstream不具有累积计算的功能。
mapWithState

updateStateByKey





















©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页