spark笔记

spark 分布式计算框架

spark 不是部署分布式的 只是client而已 =》 hive
spark 支持分布式部署 =》 standalone
1.spark产生背景?
1.mr、hive批处理、离线处理 存在一些局限性:
1.mr api 开发复杂
2.只能做离线计算 不能做实时计算
3.性能不高
2.什么是spark?
1.spark.apache.org
1.计算引擎 【不关注数据存储】
2.特点
1.Batch/streaming data =》 批流一体
2.SQL analytics
3.Data science at scale
4.Machine learning
3.速度快:
1.spark基于内存计算
2.DAG 有向无环图
mr1=>mr2=>mr3
算子 链式编程
3.pipline 【通道的】
4.编程模型 线程级别的
4.易用性:
1.开发语言: java、scala、python、sql
2.封装好了多种外部数据源
3.80多个高级算子
5.通用性:
子模块
sparkcore =》 离线计算
sparksql =》 离线计算
sparkstreaming、structstreaming =》 实时计算
mllib =》 机器学习
图计算 =》 图处理
spark的子模块 之间可以进行交互式使用
6.运行作业的地方
1.yarn ***
2.mesos
3.k8s ***
4.standalone[spark本身集群 ]
3.hadoop生态圈 vs spark 生态圈
1.Batch:mr、hive vs sparkcore、sparksql
2.SQL:hive、impala vs sparksql
3.stream:storm vs sparkstreaming、sss
4.MLLib: Mahout vs MLlib
5.real 存储: HBase、cassandra vs DataSouce Api

sparkcore

rdd 开发 降低开发人员的开发成本
什么是rdd ?
1.“弹性 分布式 数据集”
2.数据集:
partitions: 元素 =》 一条一条的数据
3. 可以以并行的方式进行计算
1.弹性?容错 =》 计算的时候 可以重试
2.分布式?
1.存储
rdd: 1 2 3 4 5 6
partition1:1 2 3
partition2:4 5
partition3:6
2.计算
对rdd进行操作实际上是操作 rdd分区里面的数据
3.数据集: 就是构建rdd本身的数据
4.immutable 不可变的
不可变=》 rdda 通过计算/操作得到一个新的rdd
5.partitioned collection of elements 【rdd 可以被分区存储/计算的】
一个rdd是由多个partition所构成
rdd数据存储是分布式的 ,是跨节点进行存储的
6.elements that can be operated on in parallel =》 计算
对rdd进行操作 就是对rdd底层partition里面的元素进行操作
abstract class RDD[T: ClassTag](
@transient private var sc: SparkContext,
@transient private var deps: Seq[Dependency[
]]
) extends Serializable with Logging {
1.abstract
2.T 泛型 =》 限定rdd里面数据 是什么类型的
RDD[String]、RDD[Int] 、RDD[Student]
3.Serializable 序列化 =》数据经过网络传输
4.@transient 注解 这个属性就不需要序列化 【了解】

RDD五大特性[面试】

1.rdd底层存储一系列partition
2.针对rdd做计算/操作其实就是对rdd底层的partition进行计算/操作
3.rdd之间的依赖关系 (血缘关系)
rdd 不可变 rdda => rddb => rddc
4.Partitioner => kv类型的rdd
默认分区:hash
5.数据本地性 =》 减少数据传输的网络io
优先把作业调度在数据所在节点 =》 【理想状况】
【常见计算】
作业调度在别的节点上 ,数据在另外一台节点上
只能把数据通过网络把数据传输到 作业所在节点上去进行计算

构建sparkcore 作业

1.添加依赖:


org.apache.spark
spark-core_2.12
3.2.1

2.Initializing Spark:
1. SparkContext =》 sparkcore 程序入口
tells Spark how to access a cluster.
2.SparkConf =》 指定 spark app 详细信息
1.AppName => 作业名字
2.Master =》 作业运行在什么地方 spark作业的运行模式
local、yarn、standalone、k8s、mesos
1.local[k]模式 k 指的是线程数
2.standalone spark://HOST:PORT
3.yarn
yarn 两种模式: client模式
cluster模式
4.k8s k8s://HOST:PORT
3.创建rdd
1. parallelize existing collection =》 已经存在的集合
2. makeRDD 已经存在的集合
2.referencing a dataset in an external storage system =》外部数据源 =》 textFile
1.外部数据源存储
hdfs、local、hbase、s3、cos、
2.数据文件类型:
text files, SequenceFiles, and any other Hadoop InputFormat
3.从已经存在rdd转换生成一个新的rdd

val conf: SparkConf = new SparkConf().setAppName("Spark01App").setMaster("local[2]")
val sc: SparkContext = new SparkContext(conf)
// 存在的集合方式创建rdd
val arr: Array[Int] = Array(1, 2, 3, 4, 5)// scala
val rdd: RDD[Int] = sc.parallelize(arr) // spark弹性分布式数据集
println(rdd.partitions.size)
val rddArr: Array[Int] = rdd.collect()// 将rdd变成数组输出
rddArr.foreach(println(_))
println("====================")
val rdd1: RDD[Int] = sc.parallelize(arr, 10) // 修改分区=>task
println(rdd1.partitions.size)
val rdd2array: Array[Int] = rdd1.collect()
rdd2array.foreach(println(_))
println("====================")
sc.stop()
	val conf: SparkConf = new SparkConf().setAppName("Spark01App").setMaster("local[2]")
	val sc: SparkContext = new SparkContext(conf)
// 外部存储系统的方式创建rdd
    val distFile: RDD[String] = sc.textFile("data/wc.data")
    println(distFile.partitions.size)
    distFile.collect().foreach(println(_))
    distFile.saveAsTextFile("file:home/hadoop/tmp/spark/spark01")
    distFile.saveAsTextFile("hdfs://bigdata12:9000/spark/spark01")
    println("======================")
    val distRdd2: RDD[String] = sc.textFile("data/wc.data", 10)
    println(distRdd2.partitions.size)
    distRdd2.collect().foreach(println(_))
    distRdd2.saveAsTextFile("file:home/hadoop/tmp/spark/spark02")
    distRdd2.saveAsTextFile("hdfs://bigdata12:9000/spark/spark02")
    sc.stop()

spark-shell

spark-shell :
–master spark作业运行环境
–deploy-mode yarn模式 运行选择
–class spark作业包 运行主类main class 包名
–name 指定spark作业的名字
–jars 指定第三方的依赖包
–conf 指定spark作业配置参数
yarn 参数补充:
–num-executors 指定 申请资源的参数
–executor-memory 指定 申请资源的参数
–executor-cores 指定 申请资源的参数
–queue 指定作业 运行在yarn的哪个队列上

spark-shell 交互式命令 底层调用 =》 spark-submit
开发者 主要使用的脚本 用于提交用户自己开发的spark作业
为什么spark-shell webui名字 是Spark shell?如何修改 --name
spark-core 如何触发作业的执行呢?
1、sparkcore里面 触发作业的执行 必须使用action算子
2.创建rdd 是不会触发作业的执行
task数为什么是2?
有多少个partition就有多少个task去处理我们的数据
跟我们运行模式有关系
spark =》 hdfs 生成的文件数量 跟什么有关系?
spark => hdfs => tasks数 =》 parition数
rdd 里面parition有多少个 =》 文件落地有多少个文件

封装

1.隐式转换添加功能

package com.dl2262.sparkcore.function
import org.apache.spark.rdd.RDD
object ImplictAsRdd {
  implicit def rdd2RichRdd[T](rdd:RDD[T]):RichRdd[T]={
    new RichRdd[T](rdd)
  }
}
class RichRdd[T](rdd:RDD[T]){
  def print(num:Int)={
    num match {
      case 0 => rdd.foreach(println(_));println("===========")
      case _ =>
    }
  }
}

2.封装重复代码

package com.dl2262.sparkcore.util
import org.apache.spark.{SparkConf, SparkContext}
object ContextUtils {
  def getSparkContext(appName:String,master:String="local[2]")={
    val conf: SparkConf = new SparkConf().setAppName(appName).setMaster(master)
    new SparkContext(conf)
  }
}

RDD 相关的操作

1.transformations 【转换操作】:create a new dataset from an existing one
1.All transformations in Spark are lazy =》 懒加载
rdda => rddb =>rddc => 不会立即执行 不会触发job的执行 当有action才会执行
rdd.map().fitler =》 rdd 血缘关系
map相关的算子:
1.map : 一一映射 处理rdd里面每一个元素

val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
// map
val rdd: RDD[Int] = sc.parallelize(List(3, 4, 5, 6))
val mapData: RDD[Int] = rdd.map(x => x * 2)
mapData.foreach(x => println(x))
println("====================")
val array: Array[Int] = mapData.collect()
array.foreach(x => println(x))
println("==============")
sc.stop()

2.filter

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
 	// filter
    val rdd1: RDD[Int] = sc.parallelize(1 to 10)
    val filterRdd: RDD[Int] = rdd1.filter(_ % 2 == 0).filter(_ > 8)
    filterRdd.foreach(println(_))
    println("================")
    val filterRdd2: RDD[Int] = rdd1.filter(x => x % 2 == 0 && x > 8)
    filterRdd2.foreach(println(_))
    println("==============")
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    filterRdd2.print(0)
    filterRdd2.print(1)
    filterRdd2.print(0)
    sc.stop()

3.mapPartitions 按分区处理数据 调优比map

val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val rdd: RDD[Int] = sc.parallelize(List(1, 2, 4))
    val rdd2: RDD[Int] = sc.makeRDD(List(1, 2, 3))
    rdd.map(x=>{
      println("调用")
      x*2
    }).print(0)
    println(rdd.partitions.size)
    println("=========")
    rdd.mapPartitions(partition=>{
      println("调用")
      partition.map(x=>x*2)
    }).print(0)
    sc.stop()

需求: spark-core: map filter =》 不让用 如何实现其功能?实现底层MapPartitionsRDD

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    val rdd: RDD[Int] = sc.parallelize(1 to 10)
    new MapPartitionsRDD[Int,Int](rdd,(_,_,iter)=>iter.map(_*2)).foreach(println(_))
    sc.stop()

4.makeRDD = parallelize
5.mapPartitionsWithIndex 可以查看 rdd里面每个分区对应的数据

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val rdd: RDD[Int] = sc.parallelize(List(1, 2, 3, 4))
    rdd.mapPartitionsWithIndex((index,partition) => {
      partition.map(x => s"分区的下标${index},分区的元素${x}")
    }).foreach(println(_))
    println("=================")
    sc.stop()

6.mapvalues 针对kv类型对v做处理

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val rdd: RDD[Int] = sc.parallelize(List(1, 2, 3, 4))
    rdd.map(x => (x,1)).mapValues(v => v+1).print(0)
    sc.stop()

7.flatMap 一一映射 底层也是MapPartitionsRDD
flatmap = flatten + map flatten => 压扁的
flatMap =》 更改原始数据结构的 map 不会改变数据结构

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
	val rdd1: RDD[List[Int]] = sc.parallelize(List(List(1, 2), List(3, 4)))
    val value: RDD[List[Int]] = rdd1.map(x => x.map(_ * 2))
    val value1: RDD[Int] = rdd1.flatMap(x => x.map(_ * 2)) 
    sc.stop()

other算子:
1.glom : 把每一个分区的元素作为一个数组返回 比mapPartitionsWithIndex

val value2: RDD[Array[Int]] = sc.parallelize(1 to 9).glom()
scala> value2.collect
res0: Array[Array[Int]] = Array(Array(1, 2, 3, 4), Array(5, 6, 7, 8, 9)) 

2.sample 抽样

sc.parallelize(1 to 20).sample(true,0.4,10).print(0)

3.union : 简单数据合并 不去重 不要与sql : union union all弄混

val rdd2: RDD[Int] = sc.parallelize(1 to 3)
val rdd3: RDD[Int] = sc.parallelize(2 to 5)
rdd2.union(rdd3).print(0)

4.intersection 交集

val rdd2: RDD[Int] = sc.parallelize(1 to 3)
val rdd3: RDD[Int] = sc.parallelize(2 to 5)
rdd2.intersection(rdd3).print(0)

5.subtract 差集:显示a里面不含有b的元素

	val rdd2: RDD[Int] = sc.parallelize(1 to 3)
	val rdd3: RDD[Int] = sc.parallelize(2 to 5)
	rdd2.subtract(rdd3).print(0)
    rdd3.subtract(rdd2).print(0)

6.distinct 去重 *** 默认采用分区器: hash
hash分区:某个元素%分区总数

	sc.parallelize(List(4,4,4,5,5,5,6,6,6)).distinct().print(1)
    val rdd4: RDD[Int] = sc.parallelize(List(4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 8, 9, 10, 10))
    rdd4.distinct(4).mapPartitionsWithIndex((index,partition)=>{
      partition.map(x => s"分区号:${index},元素:${x}")
    }).print(0)
    case _ => map(x => (x, null)).reduceByKey((x, _) => x, numPartitions).map(_._1)// 底层调用map+reduceByKey+map完成对数据的key去重

需求: disctint =》 不使用distinct 完成数据去重?

	val rdd5: RDD[Int] = sc.parallelize(List(1, 1, 1, 2, 2, 2, 3, 3, 3))
    rdd5.map(x => (x,null)).reduceByKey((x,y) =>{
      x
    }).map(x => x._1).print(0)

kv类型的算子
1.groupByKey 按key进行分组 不要使用 效率低 不灵活 , mapSideCombine = false 没有开启的 发送数据 网络io 没有变化的
预聚合mapSideCombine: 减少map端输出的数据量 =》 减少网络io
map :
(a,1)
(a,1)
(a,1)
(b,1)
(b,1)
combine: 预聚合 按照map端输出的key进行聚合数据
(a,3)
(b,2)
reduce:
(a,3)
(b,2)
a,<3>
b,<2>
预聚合:前提: + - 操作 =》 预聚合开启
求平均值操作 =》 预聚合 结果数据 不对

	val wc: RDD[(String, Int)] = sc.parallelize(List(("a", 1), ("b", 2), ("c", 2), ("a", 10)))
    val groupbyData: RDD[(String, Iterable[Int])] = wc.groupByKey()
    groupbyData.print(0)
    (a,CompactBuffer(1, 10))
	(b,CompactBuffer(2))
	(c,CompactBuffer(2))
	groupbyData.mapValues(x => x.sum).print(0)
	(b,2)
	(a,11)
	(c,2)
	 wc.map(x =>(x._2,x._1)).groupByKey().print(0)
	 (1,CompactBuffer(a))
	(10,CompactBuffer(a))
	(2,CompactBuffer(b, c))

2.reduceByKey mapSideCombine = true + func,按照key进行分组对value进行操作

 	val wc: RDD[(String, Int)] = sc.parallelize(List(("a", 1), ("b", 2), ("c", 2), ("a", 10)))
 	wc.reduceByKey((x,y) => { //相同key后面的value
      x+y
    }).print(0)
    (b,2)
	(a,11)
	(c,2)

3.groupby 自定义分组

	val rdd6: RDD[String] = sc.parallelize(List("a", "a", "a", "a", "b", "b", "b"))
    rdd6.groupBy(x => x).print(0)
    val wc: RDD[(String, Int)] = sc.parallelize(List(("a", 1), ("b", 2), ("c", 2), ("a", 10)))
    wc.groupBy(x => x._1).print(0)
    (b,CompactBuffer(b, b, b))
	(a,CompactBuffer(a, a, a, a))
	===========
	(b,CompactBuffer((b,2)))
	(a,CompactBuffer((a,1), (a,10)))
	(c,CompactBuffer((c,2)))

4.sortByKey =》按照key进行排序 分区排序 默认升序
想要全局排序的前提是rdd的分区只有一个

	val rdd7: RDD[(String, Int)] = sc.parallelize(List(("zuan", 18), ("kaige", 20), ("doublehappy", 21)),1)
    rdd7.sortByKey().print(0)
    rdd7.sortByKey(false).print(0)
    rdd7.map(x => (x._2,x._1)).sortByKey(false).map(x => (x._2,x._1)).print(0)
    (doublehappy,21)
	(kaige,20)
	(zuan,18)
	===========
	(zuan,18)
	(kaige,20)
	(doublehappy,21)
	===========
	(doublehappy,21)
	(kaige,20)
	(zuan,18)

5.sortby 自定义排序 灵活

	val rdd7: RDD[(String, Int)] = sc.parallelize(List(("zuan", 18), ("kaige", 20), ("doublehappy", 21)),1)
	rdd7.sortBy(x => x._2,false).print(0)
    rdd7.sortBy(x => -x._2).print(0)
    (doublehappy,21)
	(kaige,20)
	(zuan,18)
	===========
	(doublehappy,21)
	(kaige,20)
	(zuan,18)

6.join

	val rdd7: RDD[(String, Int)] = sc.parallelize(List(("zuan", 18), ("kaige", 20), ("doublehappy", 21)))
    val rdd8: RDD[(String, String)] = sc.parallelize(List(("zuan", "广西"), ("kaige", "中国"), ("doublehappy", "大连")))
    rdd7.join(rdd8).print(0)
    (doublehappy,(21,大连))
	(zuan,(18,广西))
	(kaige,(20,中国))

7.cogroup

 	val rdd7: RDD[(String, Int)] = sc.parallelize(List(("zuan", 18), ("kaige", 20), ("doublehappy", 21)))
    val rdd8: RDD[(String, String)] = sc.parallelize(List(("zuan", "广西"), ("kaige", "中国"), ("doublehappy", "大连")))
    rdd7.cogroup(rdd8).print(0)
    (zuan,(CompactBuffer(18),CompactBuffer(广西)))
	(doublehappy,(CompactBuffer(21),CompactBuffer(大连)))
	(kaige,(CompactBuffer(20),CompactBuffer(中国)))

join vs cogroup
1.操作对象都是kv类型的
2.都是根据key进行关联
3.join返回值类型是RDD[(k,(option[v],option[w]))],cogroup的返回值类型是RDD[(k,(Iterable[v],Iterable[w]))],一个直接返回值,一个返回集合
4.join底层调用cogroup算子
scala:option 有就返回some 没有就返回none

 	val rdd7: RDD[(String, Int)] = sc.parallelize(List(("zuan", 18), ("kaige", 20), ("doublehappy1", 21)))
    val rdd8: RDD[(String, String)] = sc.parallelize(List(("zuan", "广西"), ("kaige", "中国"), ("doublehappy", "大连")))
    rdd7.join(rdd8).print(0)
    rdd7.cogroup(rdd8).print(0)
    (zuan,(18,广西))
	(kaige,(20,中国))
	===========
	(doublehappy,(CompactBuffer(),CompactBuffer(大连)))
	(kaige,(CompactBuffer(20),CompactBuffer(中国)))
	(zuan,(CompactBuffer(18),CompactBuffer(广西)))
	(doublehappy1,(CompactBuffer(21),CompactBuffer()))

转换算子常用的:map、flatmap、filter、mappartitions、distinct
kv:groupby、sortby、reducebykey、mapvalues
补充:zipWithIndex,生成kv,v是从0-n

val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
rdd9.zipWithIndex().print(0)
(3,2)
(1,0)
(4,3)
(2,1)
(5,4)

2.actions 【触发job执行的操作】把服务器上的rdd拉到driver上 action算子不能再接一个action算子
which return a value to the driver program 【spark client、控制台】after running a computation on the dataset【rdd】
1.collect() 把rdd数据集拉到控制台上以数组形式显示
2.foreach() => 输出 driver 循环输出每一个元素
1.控制台
2.hdfs 不这样用
3.db
3.foreachPartition 按照分区循环输出 调优比foreach 获取链接次数少

 	val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
    rdd9.foreach(x =>{
      println("调用")
      println(x)
    })
    println("==================")
    rdd9.foreachPartition(partition => {
      println("调用")
      partition.foreach(x => println(x))
    })

4.reduce

	val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
	val res: Int = rdd9.reduce((x, y) => {
      x + y
    })
    println(res)
    15
    rdd9.reduce(_+_)

5.first 和take(n)取数据集里面第一个到第n个的元素
first底层调用的是take算子

	val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
 	val first: Int = rdd9.first()
    println(first)
	val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
	val arr: Array[Int] = rdd9.take(3)
    arr.foreach(print(_))

6.saveAsTextFile
7.top 和 takeOrdered 数据量不要太大 控制台拉回过程中也需要进行数据存储的,存储到内存
top是降序取前n个数据集, takeOrdered 是升序取前n个数据集
top底层是takeOrdered实现的

	val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
	val top: Array[Int] = rdd9.top(3)
    top.foreach(println(_))
    5
    4
    3
	val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
	val array: Array[Int] = rdd9.takeOrdered(2)
    array.foreach(println(_))
    1
    2

8.countByKey 针对kv类型的rdd,按照key进行分组,统计key的数量

	val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
	val countbykey: collection.Map[Int, Long] = rdd9.zipWithIndex().countByKey()
    countbykey.foreach(println(_))
    (5,1)
	(1,1)
	(2,1)
	(3,1)
	(4,1)

9.collectAsMap把rdd转换为map输出,对比collect将rdd转换为数组输出

	val rdd9: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5))
	val collectasmap: collection.Map[Int, Long] = rdd9.zipWithIndex().collectAsMap()
    collectasmap.foreach(println(_))
    (2,1)
	(5,4)
	(4,3)
	(1,0)
	(3,2)

10.count 返回rdd里面元素的个数

	val rdd10: RDD[Int] = sc.parallelize(List(2, 5, 7, 9))
    val cnt: Long = rdd10.count()
    println(cnt)
    4

action常用的算子:foreach()、foreachpartition()
思考: spark-core xxxBykey算子都是 转换算子 对么?
大部分 xxxBykey算子 =》 transformation算子 ,除了countByKey() =》 aciton算子
源码里面 :sparkcount.runjob => 触发作业的执行 =》 action算子

spark-core =》 业务分析

商品名字 商品价格 库存数量
dior 300 1000
香奈儿 4000 2
螺蛳粉 200 98
3090显卡 200 10
按照商品的价格进行【desc】排序 如果价格相同 按照库存排序【asc】
rdd:
1.常用数据类型:
1.tuple 推荐
2.class 不推荐
1.object not serializable ?
如果作业和数据不在一个节点时,要把数据拉取到作业所在节点,数据拉取的过程中需要进行网络传输,经过网络传输首先你的数据一定要实现序列化,如果不实现序列化是无法进行网络传输的
解决: extends Serializable
2.输出格式 不标准
override def toString
3.case class 推荐!!!
1.默认实现了 序列化
2.重写了 tostring方法
3.不用new可以直接用

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("dior	300	1000",
      "香奈儿	4000	2",
      "螺蛳粉	200	98",
      "3090显卡	200	10"),1)
    val etlData: RDD[(String, Int, String)] = input.map(line => {
      val array: Array[String] = line.split("\t")
      val name: String = array(0)
      val price: Int = array(1).toInt
      val cnt: String = array(2)
      (name, price, cnt)
    })
    etlData.sortBy(x => (-x._2,x._3)).print(0)
    etlData.sortBy(x => (-x._2,x._3)).saveAsTextFile("hdfs://bigdata12:9000/spark/spar01")
    sc.stop()
    (香奈儿,4000,2)
	(dior,300,1000)
	(3090显卡,200,10)
	(螺蛳粉,200,98)
	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("dior	300	1000",
      "香奈儿	4000	2",
      "螺蛳粉	200	98",
      "3090显卡	200	10"), 1)
    val etlData: RDD[Sku] = input.map(line => {
      val array: Array[String] = line.split("\t")
      val name: String = array(0)
      val price: Double = array(1).toDouble
      val cnt: Int = array(2).toInt
      new Sku(name, price, cnt)
    })
    etlData.sortBy(x => (-x.price,x.cnt)).print(0)
    etlData.sortBy(x => (-x.price,x.cnt)).saveAsTextFile("hdfs://bigdata12:9000/spark/spark01")
    sc.stop()
  }
  class Sku(val name:String,val price:Double,val cnt:Int) extends Serializable{
    override def toString: String = name + "\t" + price + "\t" + cnt
  }
 	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("dior	300	1000",
      "香奈儿	4000	2",
      "螺蛳粉	200	98",
      "3090显卡	200	10"), 1)
    val etlData: RDD[SKU] = input.map(line => {
      val array: Array[String] = line.split("\t")
      val name: String = array(0)
      val price: Double = array(1).toDouble
      val cnt: Int = array(2).toInt
      SKU(name, price, cnt)
    })
    etlData.sortBy(x => (-x.price,x.cnt)).print(0)
    //etlData.sortBy(x => (-x.price,x.cnt)).saveAsTextFile("hdfs://bigdata12:9000/spark/spark02")
    sc.stop()
  }
  case class SKU(val name:String,val price:Double,val cnt:Int)

按照 对象本身进行排序:
1.实现 排序的接口
Ordering =》 compareable
Ordered =》 comparetor
2.隐士转换 普通类 =》 nb类

    val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("dior	300	1000",
      "香奈儿	4000	2",
      "螺蛳粉	200	98",
      "3090显卡	200	10"), 1)
    val etlData: RDD[SKu] = input.map(line => {
      val array: Array[String] = line.split("\t")
      val name: String = array(0)
      val price: Double = array(1).toDouble
      val cnt: Int = array(2).toInt
      new SKu(name, price, cnt)
    })
    etlData.sortBy(x => x).print(0)
    sc.stop()
  }
  class SKu(val name:String,val price:Double,val cnt:Int) extends Serializable with Ordered[SKu]{
    override def toString: String = name+"\t"+price+"\t"+cnt
    override def compare(that: SKu): Int = {
      if (-(this.price - that.price).toInt == 0){
        this.cnt - that.cnt
      } else {-(this.price - that.price).toInt}
    }
  }
	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("dior	300	1000",
      "香奈儿	4000	2",
      "螺蛳粉	200	98",
      "3090显卡	200	10"), 1)
    val etlData: RDD[sku] = input.map(line => {
      val array: Array[String] = line.split("\t")
      val name: String = array(0)
      val price: Double = array(1).toDouble
      val cnt: Int = array(2).toInt
      new sku(name, price, cnt)
    })
    implicit def sku2Ordered(sku:sku):Ordered[sku]={
      new Ordered[sku] {
        override def compare(that: sku): Int = {
          if (-(sku.price-that.price).toInt==0){
            sku.cnt-that.cnt
          } else {
            -(sku.price-that.price).toInt
          }
        }
      }
    }
    etlData.sortBy(x => x).print(0)
    sc.stop()
  }
  class sku(val name:String,val price:Double,val cnt:Int) extends Serializable {
    override def toString: String = name+"\t"+price+"\t"+cnt
  }

案例

eg:
word,show,click
a,1,2
a,2,3
b,3,4
输出: a,3,5
b,3,4

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("a,1,2",
      "a,2,3",
      "b,3,4"))
    val etl: RDD[(String, (Int, Int))] = input.map(line => {
      val array: Array[String] = line.split(",")
      val word: String = array(0)
      val show: Int = array(1).toInt
      val click: Int = array(2).toInt
      (word, (show, click))
    })

    /**
     * a,(1,2)
     * a,(2,3)
     * a,<(1,2),(2,3)>
     */
    etl.reduceByKey((x,y) => {
      (x._1+y._1,x._2+y._2)
    }).map(x => (x._1+"\t"+x._2._1+"\t"+x._2._2)).print(0)
    sc.stop()
  }

核心概念

1.Application:spark作业
1.a driver program =》 driver
2.executors on the cluster =》 executors
spark作业:
1.sparkcontext
2. web ui
2.Application jar: 通过代码生成的spark jar包
spark作业生成的jar包 =》 包含spark作业里面含有main方法 =》 开发完spark作业后部署服务器上
3.Driver program:
1.运行jar包里面的main 方法
2.创建sparkcontext
4.Cluster manager: 通过集群获取资源 An external service for acquiring resources
5.Deploy mode: 作业部署模式 spark jar 提交服务器去运行 =》 yarn yarn调度有两种模式
cluster: driver inside of the cluster driver跑在yarn所在的机器里面
client driver 运行在集群cluster之外,在哪提交作业的地方
6.Worker node: 工作节点 can run application code 一个Worker node包含多个Executor
补充: spark作业 yarn
Worker node相当于yarn里面的nodemanager
7.Executor: 相当于yarn里面的container: 容器 包含mem、cpu
1.runs tasks
2.keeps data in memory or disk storage
Each application has its own executors spark作业,每个作业运行过程中,都有自己的container,申请自己的资源
application1: 1driver + 2executor
application2: 1driver + 2executor 这两个executor是不一样的
8.Task: 任务等于rdd: partitions个数
9.Job:
action => job执行
spark作业 =》 Application
job =》 Application里面的jobs
10.Stage:
1.Each job gets divided into smaller sets of tasks => stage
2. depend on each other 依赖关系
总结:
一个application :包含 1 到n 个job
一个job: 包含 1到n个stage
rdda => rddb => rddc action => 一个job
01stage 02stage
一个stage:包含 1个到n个task
task 和 partition 一一对应
spark笔记_第1张图片

spark执行流程【面试】

1.spark作业运行在集群上 有一系列进程
2.SparkContext 去协调这些进程
进程 :
driver 1
executors
3.运行spark作业:
1.sc 去连接 集群cluster manager
2.只要连接到集群,cluster manager 给spark作业分配资源
3.spark一旦连接上cluster
1.启动executor
2.executor =》 计算和存储数据
4.
sparkcontext 发送代码 给executor
sparkcontext 发送task 去executor 运行
补充: mem、CPU
1.worknode =》 nodemanager 所在的节点
executor=》 container:
task、store data
4.spark执行架构补充:
1.每个spark作业有自己的executor进程
app1: executors 1
app2: executors 1
好处:
1.资源隔离,这个作业申请的executor,别的作业不能用
2.调度的隔离,每个driver调度自己的任务
不同作业之间数据是不能进行共享的,除非把数据存储在外部存储系统上

案例

数据:
用户:
uid log_type show click
u01,英雄联盟|绝活&职业|云顶之一|女神,1,1
u01,英雄联盟|绝活&职业|云顶之一|金铲铲,1,0
u01,英雄联盟|绝活&职业|云顶之一|带粉上车,1,0
u02,星秀|好声音|女团|小6,1,0
u02,星秀|好声音|女团|三年一班,1,1
u02,星秀|好声音|女团|姜恩惠Yommy,1,1
需求: 每个用户每个日志类型的 展现量 和点击量 =》 spark-core

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("u01,英雄联盟|绝活&职业|云顶之一|女神,1,1",
      "u01,英雄联盟|绝活&职业|云顶之一|金铲铲,1,0",
      "u01,英雄联盟|绝活&职业|云顶之一|带粉上车,1,0",
      "u02,星秀|好声音|女团|小6,1,0",
      "u02,星秀|好声音|女团|三年一班,1,1",
      "u02,星秀|好声音|女团|姜恩惠Yommy,1,1"))
    val etlData: RDD[((String, String), (Int, Int))] = input.flatMap(line => {
      val array: Array[String] = line.split(",")
      val uid: String = array(0)
      val show: Int = array(2).toInt
      val click: Int = array(3).toInt
      val logtypes: String = array(1)
      val logs: Array[String] = logtypes.split("\\|")
      logs.map(log => ((uid, log), (show, click)))
    })
    etlData.reduceByKey((x,y) => {
      (x._1+y._1,x._2+y._2)
    }).map(line => {
      line._1._1+"\t"+line._1._2+"\t"+line._2._1+"\t"+line._2._2
    }).print(0)
    sc.stop()
  }

RDD持久化

rddb 持久化操作 =》 调优的
操作:
1.persist() or cache() methods
2.触发action之后 会对rdd数据进行持久化的
总结:
1.cache() 是lazy 是懒加载的 不是action算子
rdda => action job
rdda => cache => action job => rdd持久化 生效
rdda => action job rdda的数据从 rdd持久化的地方加载数据
rddb.cache 之后 rddb之后数据就不用从头开机计算 提升计算效率
补充: 对rdd做持久化 就是对rdd里面的分区做持久化
好处: 1.much faster 【计算效率】
2. reuse 复用
cache vs persist(更好) 区别:【面试】
1.cache底层就是调用 persist算子
2.spark-core 持久化 默认存储级别:StorageLevel.MEMORY_ONLY

存储级别

StorageLevel:
private var _useDisk: Boolean,
private var _useMemory: Boolean,
private var _useOffHeap: Boolean,
private var _deserialized: Boolean,
private var _replication: Int = 1
val NONE = new StorageLevel(false, false, false, false)
val DISK_ONLY = new StorageLevel(true, false, false, false)
val DISK_ONLY_2 = new StorageLevel(true, false, false, false, 2)
val DISK_ONLY_3 = new StorageLevel(true, false, false, false, 3)
val MEMORY_ONLY = new StorageLevel(false, true, false, true)
val MEMORY_ONLY_2 = new StorageLevel(false, true, false, true, 2)
val MEMORY_ONLY_SER = new StorageLevel(false, true, false, false)
val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, false, 2)
val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)
val MEMORY_AND_DISK_2 = new StorageLevel(true, true, false, true, 2)
val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false, false)
val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, false, 2)
val OFF_HEAP = new StorageLevel(true, true, true, false, 1)
存储级别选择:
1.MEMORY_ONLY 首选
2.MEMORY_ONLY_SER 次选 (cpu充足时)
1.Java serialization: By default,
2.Kryo: 注册 class 比java快
3.不建议选择磁盘
4.不要选择副本 太占内存

object Spark14App {
  case class Info(name:String,age:Int,gender:String,address:String)
  def main(args: Array[String]): Unit = {
    val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val names: Array[String] = Array("金社子", "刘裕众", "小歪歪的狗子")
    val genders: Array[String] = Array("男", "女")
    val addresses: Array[String] = Array("大连", "广西", "北京")
    val infoes: ArrayBuffer[Info] = new ArrayBuffer[Info]()
    (1 to 30000).map(x => {
      val name: String = names(Random.nextInt(3))
      val gender: String = genders(Random.nextInt(2))
      val address: String = addresses(Random.nextInt(3))
      val age: Int = Random.nextInt(40)
      infoes += (Info(name,age,gender,address))
    })
    val data: RDD[Info] = sc.parallelize(infoes)
    data.persist()// 10.3M
    data.persist(StorageLevel.MEMORY_ONLY_SER)// 7.6M 默认是java 类需要序列化 样例类默认是实现序列化
    // Kryo 8.6M 性能比java高
    data.count()
    sc.stop()
  }
}
object ContextUtils {
  def getSparkContext(appName:String,master:String="local[2]")={
    //val conf: SparkConf = new SparkConf().set("spark.serializer","org.apache.spark.serializer.KryoSerializer").setAppName(appName).setMaster(master)
    val conf: SparkConf = new SparkConf().setAppName(appName).setMaster(master)
    conf.set("spark.serializer","org.apache.spark.serializer.KryoSerializer")
    conf.registerKryoClasses(Array(classOf[Info]))
    new SparkContext(conf)
  }
}

移除rdd持久化 :
1.lru 会自动移除不常用的持久化数据
2.手动 :【生产】
RDD.unpersist(true) 立即执行的 eager

血缘关系

lineage: rdda => rddb => rddc
一个rdd是如何从父rdd计算得来的
好处: 容错(性能 + 容错)
rddb某个分区挂了时,直接从rdda对应的分区进行重新计算即可
spark笔记_第2张图片
而且 本身持久化的数据集 也支持 容错 重新进行计算

依赖关系

rdda => rddb
不同的依赖 会导致 生成rdd分区数发生变化的
分类:【面试】
1.宽依赖:
1.一个父rdd的parition会被子rdd的parition使用多次
2.会产生shuffle(数据重新洗牌) 会有新的stage产生
2.窄依赖:
1.一个父rdd的parition至多被子rdd的partition使用一次
2.不会产生shuffle,都是在一个stage里面完成的
宽依赖:
xxxbykey shuffle
其他: 普通/reducejoin
窄依赖:
mapjoin、map filter flatmap union
spark: stage是如何划分? ****
spark-core 产生 宽依赖 就会划分stage
算子:引起shuffle 就会划分stage
一个shuffle算子 会划分2个stage,两个shuffle算子 会产生3个stage

shuffle 算子

“生产上能使用窄依赖算子 就不使用宽依赖算子”:
1.不准确
1.生产上大部分 需求 必须使用宽依赖的
2.容错的角度 :
1.如果经过宽依赖之后的rdd的某一个分区数据挂掉
需要去父RDD分区重新计算 会把父rdd里面的所有分区都会算一下才行
引起shuffle的算子:
1.xxxbykey =》
2. repartition and coalesce【不准确】
3. join:
map join 不会引发shuffle
reduce join /common join =》 引起shuffle
生产上调整 计算的并行度:【重要】
coalesce: 一般用于 减少rdd的分区数 =》 窄依赖 =》 不会引起shuffle 减少并行度task少了
data.coalesce(1)
repartition:增加rdd的分区数 会引起shuffle data.repartition(3)
coalesce(num,shuffle=true)
思考:
可不可以使用coalesce 增加rdd分区数 ? 可以的 data.coalesce(4,true)
repartition 减少rdd的分区数? 不能
思考: coalesce 增加rdd分区数 ? 走不走shuffle? 必然走shuffle
思考:
rdd =》 hdfs 200个小文件 变成10个文件
rdd.coalesce(10)

区分代码里的driver和executor

主要看操作对象
操作对象是rdd的就是executor
操作对象不是rdd的就是driver

案例

网站访问量排名:
domain uid flow
www.baidu.com,uid01,1
www.baidu.com,uid01,10
www.baidu.com,uid02,3
www.baidu.com,uid02,5
www.github.com,uid01,11
www.github.com,uid01,10
www.github.com,uid02,30
www.github.com,uid02,50
www.bibili.com,uid01,110
www.bibili.com,uid01,10
www.bibili.com,uid02,2
www.bibili.com,uid02,3
需求: 每个域名每个用户的访问量的top2

 	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("www.baidu.com,uid01,1",
      "www.baidu.com,uid01,10",
      "www.baidu.com,uid02,3",
      "www.baidu.com,uid02,5",
      "www.github.com,uid01,11",
      "www.github.com,uid01,10",
      "www.github.com,uid02,30",
      "www.github.com,uid02,50",
      "www.bibili.com,uid01,110",
      "www.bibili.com,uid01,10",
      "www.bibili.com,uid02,2",
      "www.bibili.com,uid02,3"))
    val etlData: RDD[((String, String), Int)] = input.map(line => {
      val array: Array[String] = line.split(",")
      val domain: String = array(0)
      val uid: String = array(1)
      val flow: Int = array(2).toInt
      ((domain, uid), flow)
    })
    val res1: RDD[((String, String), Int)] = etlData.reduceByKey((x, y) => {
      x + y
    })
    res1.groupBy(x => x._1._2).mapValues(x => x.toList.sortBy(x => -x._2).map(x => (x._1._1,x._2)).take(2)).print(0)
    sc.stop()

存在安全隐患: x.toList 数据太大时会直接导致List存不下
sparkcore 进行数据分析: rdd进行操作 不要使用scala里面的集合进行存储
思想: 分而治之 类似 mr 分组

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val input: RDD[String] = sc.parallelize(List("www.baidu.com,uid01,1",
      "www.baidu.com,uid01,10",
      "www.baidu.com,uid02,3",
      "www.baidu.com,uid02,5",
      "www.github.com,uid01,11",
      "www.github.com,uid01,10",
      "www.github.com,uid02,30",
      "www.github.com,uid02,50",
      "www.bibili.com,uid01,110",
      "www.bibili.com,uid01,10",
      "www.bibili.com,uid02,2",
      "www.bibili.com,uid02,3"))
    val etlData: RDD[((String, String), Int)] = input.map(line => {
      val array: Array[String] = line.split(",")
      val domain: String = array(0)
      val uid: String = array(1)
      val flow: Int = array(2).toInt
      ((domain, uid), flow)
    })
    //val uids: Array[String] = Array("uid01", "uid02")
    // collect只有在这种情况下才使用,适用于数据量小
    val uids: Array[String] = etlData.map(_._1._2).distinct().collect()
    for (elem <- uids) {
      etlData.filter(x => x._1._2 == elem).reduceByKey(_+_).sortBy(x => -x._2).take(2).foreach(println(_))
    }
    sc.stop()

案例二

需求:
spark-core =》 wc
input:hdfs
todo:wc
output:hdfs
在resources里面添加core-site.xml和hdfs-site.xml

	val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val in: String = "hdfs://bigdata12:9000/input/"
    val out: String = "hdfs://bigdata12:9000/output/"
    val input: RDD[String] = sc.textFile(in)
    FileUtils.deletePath(sc.hadoopConfiguration,out)
    input.flatMap(line => {
      line.split(",")
    }).map(x => (x,1)).reduceByKey(_+_).saveAsTextFile(out)
    sc.stop()
def deletePath(conf:Configuration,outpath:String)={
    val fs: FileSystem = FileSystem.get(conf)
    val out: Path = new Path(outpath)
    if (fs.exists(out)){
      fs.delete(out,true)
    }
  }

部署spark作业:
1.jar
2.spark-submit 提交作业
local法一:

def main(args: Array[String]): Unit = {
    if (args.size != 2){
      logError("请正确输入两个参数: ")
      System.exit(0)
    }
    val in: String = args(0)
    val out: String = args(1)
    val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
//    val in: String = "hdfs://bigdata12:9000/input/"
//    val out: String = "hdfs://bigdata12:9000/output/"

    val input: RDD[String] = sc.textFile(in)
    FileUtils.deletePath(sc.hadoopConfiguration,out)
    input.flatMap(line => {
      line.split(",")
    }).map(x => (x,1)).reduceByKey(_+_).saveAsTextFile(out)
    sc.stop()
  }
spark-submit \
--class com.dl2262.sparkcore.day01.WCAPP \
--master local[2] \
--name wordcount \
/home/hadoop/project/spark/spark-2262-1.0.jar \
hdfs://bigdata12:9000/input/ hdfs://bigdata12:9000/output/

local法二:

def main(args: Array[String]): Unit = {
    val sc: SparkContext = ContextUtils.getSparkContext(this.getClass.getSimpleName)
    import com.dl2262.sparkcore.function.ImplictAsRdd._
    val in: String = sc.getConf.get("spark.input.path", "hdfs://bigdata12:9000/input/")
    val out: String = sc.getConf.get("spark.output.path", "hdfs://bigdata12:9000/output/")
    val input: RDD[String] = sc.textFile(in)
    FileUtils.deletePath(sc.hadoopConfiguration,out)
    input.flatMap(line => {
      line.split(",")
    }).map(x => (x,1)).reduceByKey(_+_).saveAsTextFile(out)
    sc.stop()
  }
spark-submit \
--class com.dl2262.sparkcore.day01.WCAPP \
--master local[2] \
--name wordcount \
--conf spark.input.path=hdfs://bigdata12:9000/input/1 \
--conf spark.output.path=hdfs://bigdata12:9000/output1/ \
/home/hadoop/project/spark/spark-2262-1.0.jar.0

sparksql

1.什么是sparksql?
sparksql 主要处理结构化数据
什么是结构化数据?
“带有schema信息的数据” 【schema :table 字段的名称、字段的类型】eg:mysql
半结构化数据: csv(可以用excel打开)、json、orc、parquet
非结构化数据: nosql – redis、hbase
2.在spark里面 Spark SQL 模块 :不仅仅是sql 、还有dataframe
3.sparksql 有哪些特性?
0.sparksql dataframe api vs 同时sparkcore里面使用的算子在sparksql里面也可以使用的
1.Sparksql= sql + dataframe api 处理 结构化数据
2.Uniform data access 【外部数据源】
SparkSQL 是能够处理多种不同的数据源的数据:
Hive, Avro, Parquet, ORC, JSON, and JDBC text 数据
HDFS/s3(亚马逊)/oss(阿里)/cos(腾讯) 数据存储系统
3.Hive integration [整合hive(数据仓库)]
SparkSQL访问hive的元数据库即 可利用sparksql查询hive里面的数据
注意:
1.Sparksql 不仅仅是sql
2. hive on spark vs spark on hive
hive on spark : hive查询引擎是 mr=》 spark 【几乎不用,bug很多】
spark on hive :可以使用sparksql 去hive上查询数据 【可能hive 引擎是mr】【99.953%】

概述

概述:
1.sparksql 处理数据的性能比 spark rdd 方式的处理性能高
1.more information about the structure of both the data 【schema】
2.sparksql架构有关
sparksql底层跑的还是 Sparkcore rdd ,只是spark框架底层给我们做了优化
sparkcore:编程模型 rdd
sparksql: rdd[数据集] +schema[字段 字段的类型] =》 table
2.Spark SQL including SQL and the Dataset API
3.Datasets and DataFrames:
Dataset
1.Dataset 也是一个分布式数据集
2.比rdd多出的优势:
1.强类型
2.Dataset 也可以使用算子
3.optimized execution engine. 执行性能 高 【sparksql架构 catelyst 做了很多优化】
4.Dataset 是Spark 1.6 之后诞生的
3.Dataset API :scala java进行开发
DataFrame:
1.DataFrame 也是一个dataset
A DataFrame is a Dataset organized into named columns
2.DataFrame四种创建方式:
structured data files, tables in Hive, external databases, or existing RDDs
3. DataFrame is represented by a Dataset of Rows:
DataFrame = Dataset[Row]
Row => 一行数据 仅仅包含 named columns
DataFrame =》 table
sparkcore=> rdd 数据集
sparksql=》 DataFrame /df 数据集 【数据集 + 额外的信息【schema】】
rdd + schema => table
Sparksql:
1.0: schemaRDD : rdd(存数据)+ schema(数据的(额外信息:元数据):字段、字段类型) =》 table
=》1.2/3
=> DataFrame =>schemaRDD 变过来的
=》1.6
=》 DataSet =》 DataFrame 变过来的
DataFrame /df vs rdd:
区别:
1.rdd : 不同的语言开发的 rdd ,执行性能是不一样
java和scala(会被语言转换为jvm去运行)、python(pathon会转化成自己的运行时数据区去运行,pathon开发rdd性能没有java和scala高)
2.DataFrame/df:使用不同的开发语言 执行性能是一样的 (spark底层逻辑优化=》物理执行计划=》rdd执行,此时执行性能和语言就没有关系了),df比rdd开发简单
java、scala、python、r
spark笔记_第3张图片

开发 DF

1.idea里面开发sparksql
引入 sparksql依赖:


org.apache.spark
spark-sql_2.12
3.2.1

2.SparkSQL程序开发入口 :
1.rdd =》 SparkContext
2.SQL =》 SparkSession
获取df后会立即触发job,不是懒加载
3.SparkSQL进行数据分析:
1.sql方式 【好维护】
2.api方式【不好维护】
开发df:
1.sql 【idea api+sql 或者 hive sql文件 】
2.api 【一般用于 开发平台、工具】
1.api方式 =》
api =》 sql 一一对应
1.加载df中某个字段
select(“字段名字”) =》 string
select(col: String, cols: String*):
1. select(“字段名字”) =》 推荐
2. select($“字段名字”) + 隐士转换 import spark.implicits._
可以调用sql里面的函数
补充: df.select('age)
select(cols: Column*):
import org.apache.spark.sql.functions._
df.select(col(“age”))

 	 val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    // val spark: SparkSession = SparkSession.builder().appName("SparkSQL01").master("local[2]").getOrCreate()
    val df: DataFrame = spark.read.text("file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\wc.data")
    df.select("age").show()
    df.select("age","name").show()
    import spark.implicits._
    df.select($"age").show()
    df.select($"age",$"name"+1).show()
    df.select('age).show()
    import org.apache.spark.sql.functions._
    df.select(col("age")).show()
    spark.stop()

2.sql方式进行操作
spark.sql(“select count(1) as cnt from test”).show()
开发数仓:
1.sql文件 维护数仓 =》 推荐 好维护
2.idea : 不好维护 udf函数比较方便
1.sql方式维护数仓 =》 有公司这么干的 【滴滴】
2.api方式维护数仓 =》 有公司这么干的
1.通用性的 代码来维护 code开发能力有要求 难度大

案例

df.show(2) 显示2条数据 默认显示20条数据
df.show(2,false) 显示2条数据,显示所有字符串长度,默认截至字符串20字节
df.printSchema() 显示数据集的字段名字和字段类型
需求分析
1、table中数据条数
2.table中所有人薪资总和

	val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    val df: DataFrame = spark.read.json("file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\emp.json")
    df.show(2)
    df.printSchema()
    import spark.implicits._
    df.groupBy().count().select($"count".as("cnt")).show()

    df.groupBy().sum("salary").select($"sum(salary)".as("sum_sal")).show()

    df.createOrReplaceTempView("tmp")
    spark.sql(
      """
        |select count(1) as cnt from tmp
        |""".stripMargin).show()
    spark.sql(
      """
        |select sum(salary) as sum_sal from tmp
        |""".stripMargin).show()
    spark.stop()

构建dataframe

三种方式:
existing RDD, from a Hive table, or from Spark data sources.
1.existing RDD
RDD =》dataframe 有两种方式:
1.反射的方式
2.编程的方式
1.RDD[Row]
2.schema
3.createDataFrame =>df
rdd + schema => table
schema: table 元数据【字段名字、字段的类型】 =》 StructType
fileds: 一个字段的元数据 =》 StructField
反射的方式创建:

object SparkSQL03 {
  case class Info(uid:String,name:String,age:Int)
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    val sc: SparkContext = spark.sparkContext
    val input: RDD[String] = sc.textFile("file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\info.txt")
    // rdd里面的数据结构case class 和tuple
    val inputDF: DataFrame = input.map(line => {
      val array: Array[String] = line.split(",")
      val uid: String = array(0)
      val name: String = array(1)
      val age: Int = array(2).toInt
      Info(uid, name, age)
    }).toDF()
    inputDF.show(5,false)
    inputDF.printSchema()
    val inputDF2: DataFrame = input.map(line => {
      val array: Array[String] = line.split(",")
      val uid: String = array(0)
      val name: String = array(1)
      val age: Int = array(2).toInt
      (uid, name, age)
    }).toDF("uid","name","age")
    inputDF2.show(5,false)
    inputDF2.printSchema()
    spark.stop()
  }
}

编程方式创建:

val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    val sc: SparkContext = spark.sparkContext
    val input: RDD[String] = sc.textFile("file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\info.txt")
    val rowRDD: RDD[Row] = input.map(line => {
      val array: Array[String] = line.split(",")
      val uid: String = array(0)
      val name: String = array(1)
      val age: Int = array(2).toInt
      Row(uid, name, age)
    })
    val schema: StructType = StructType(Array(StructField("uid", StringType), StructField("name", StringType), StructField("age", IntegerType)))
    val inputDF: DataFrame = spark.createDataFrame(rowRDD, schema)
    inputDF.show(10,false)
    inputDF.printSchema()
    spark.stop()

相互转换【面试】

如何把rdd转变成df、ds?
rdd =》 toDF / => toDS
如何把 df/ds => rdd ?
df/ds.rdd
df 如何转变成ds ?
df.as[数据类型] =》 ds

 	  val inputDS: Dataset[(String, String, Int)] = input.map(line => {
      val array: Array[String] = line.split(",")
      val uid: String = array(0)
      val name: String = array(1)
      val age: Int = array(2).toInt
      (uid, name, age)
    }).toDS()

    val rdd: RDD[Row] = inputDF2.rdd

    val dataset: Dataset[Info] = inputDF.as[Info]

构建 DataFrame

1.rdd
2.hive ***
3.外部数据源 *** json、csv、jdbc/odbc
1.读数据 api
spark.read.format(“text”).load(paths : _) =》 df
spark.read.format(“json”).load(paths : _
)
spark.read.textFile(path) =》ds
2.写数据 api
df.write.mode(SaveMode.Overwrite).format(“text”).save(path)
df.write.mode(SaveMode.Append).format(“json”).save(path)

text文件

本身是不带有schema信息 【字段 value string 】
text 比 json csv 带有的schema信息偏少,只有一个value字段
1.text文件加载进来之后 需要解析数据 需要引入隐式转换
2.文本类型不支持Int类型
3.写数据时
Text data source supports only a single column, and you have 3 columns.
Text仅仅支持一列(一个字段)输出 不支持多列输出
使用sparksql 支持text多列输出?
1.自定义外部数据源 =》 难度
2.df 转变成rdd方式进行输出 =》 常用的手段
spark.read.text:

package com.dl2262.sparkcore.day02

import com.dl2262.sparkcore.util.{ContextUtils, FileUtils}
import org.apache.spark.sql.{DataFrame, Dataset, SaveMode, SparkSession}

object DataSource01 {
  def text(spark: SparkSession, path: String) = {
    import spark.implicits._
    val df: DataFrame = spark.read.format("text").load(path)
    df.show(false)
    df.printSchema()
    val data: DataFrame = df.map(row => {  // df.map之后是dataset
      val line: String = row.getString(0) // 读取第一个字段,text里面只有value一个字段
      val array: Array[String] = line.split(",")
      val uid: String = array(0)
      val name: String = array(1)
      val age:String = array(2)
      (uid, name, age)
    }).toDF("uid", "name", "age")
    data.show(false)
    data.printSchema()
    val outpath: String = "hdfs://bigdata12:9000/spark/spark02"
    FileUtils.deletePath(spark.sparkContext.hadoopConfiguration,outpath)
    data.rdd.map(row => row.getString(0)+","+row.getString(1)+","+row.getString(2)).saveAsTextFile(outpath)
    //data.write.mode(SaveMode.Overwrite).format("text").save("file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\out-text")
  }

  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    // text df
    text(spark,"file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\info.txt")
    spark.stop()
  }
}

spark.read.textFile:

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.{ContextUtils, FileUtils}
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}

object DataSourceText02 {

  def text(spark: SparkSession, path: String) = {
    import spark.implicits._
    val ds: Dataset[String] = spark.read.textFile(path)
    ds.show()
    ds.printSchema()
    val data: DataFrame = ds.map(line => {
      val array: Array[String] = line.split(",")
      val uid: String = array(0)
      val name: String = array(1)
      val age: String = array(2)
      (uid, name, age)
    }).toDF("uid", "name", "age")
    data.printSchema()
    data.show()
    val outpath: String = "hdfs://bigdata12:9000/spark/spark02"
    FileUtils.deletePath(spark.sparkContext.hadoopConfiguration,outpath)
    data.rdd.map(row => row.getString(0)+","+row.getString(1)+","+row.getString(2)).saveAsTextFile(outpath)
  }

  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    // text ds
    text(spark,"file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\info.txt")
    spark.stop()
  }
}

json

1.普通json
2.嵌套json:
1.api:
struct:打点
array:expolde + struct:打点
2.sql:
hive
struct:打点
array:expolde + struct:打点
3.不规范json =》udf函数来解决
数据输出:
数据写出方式:
1.覆盖 overwrite
2.追加 append
普通json:

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}

object DataSourceJson01 {

  def json(spark: SparkSession, path: String) = {
    import spark.implicits._
    val input: DataFrame = spark.read.format("json").load(path)
    input.show()
    input.printSchema()
    input.createOrReplaceTempView("city_info")
    spark.sql(
      """
        |select count(1) as cnt from city_info
        |""".stripMargin).write.mode(SaveMode.Overwrite).format("json").save("hdfs://bigdata12:9000/spark/spark03")
  }

  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    // 普通json
    json(spark,"file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\city_info.json")
    spark.stop()
  }
}

嵌套json API:

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}

object DataSourceJson02 {


  def json(spark: SparkSession, path: String) = {
    import spark.implicits._
    var jsonData: DataFrame = spark.read.format("json").load(path)
    jsonData.show(false)
    jsonData.printSchema()
    import org.apache.spark.sql.functions._
    jsonData=jsonData.withColumn("color",col("store.bicycle.color")) // 增加一个列或替代以及存在的一列
    jsonData=jsonData.withColumn("price",col("store.bicycle.price"))
    jsonData=jsonData.withColumn("fruit",explode(col("store.fruit")))
    jsonData=jsonData.withColumn("type",col("fruit.type"))
    jsonData=jsonData.withColumn("weight",col("fruit.weight"))
    jsonData=jsonData.drop("store","fruit")
    jsonData.show(false)
    jsonData.printSchema()
  }

  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    // 嵌套json API
    json(spark,"file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\store.json")
    spark.stop()
  }
}

嵌套json sql:

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.{DataFrame, SparkSession}

object DataSourceJsonSQL {

  def json(spark: SparkSession, path: String) = {
    val data: DataFrame = spark.read.format("json").load(path)
    data.show(false)
    data.printSchema()
    data.createOrReplaceTempView("store_json")
    val etl: DataFrame = spark.sql(
      """
        |select
        |email,
        |owner,
        |store.bicycle.color as color,
        |store.bicycle.price as price,
        |fruit.type as type,
        |fruit.weight as weight
        |from store_json
        |lateral view explode(store.fruit) as fruit
        |""".stripMargin)
    etl.show(false)
    etl.printSchema()
  }

  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    // 嵌套json sql
    json(spark,"file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\store.json")
    spark.stop()
  }
}

csv

csv文件 excel=> spark-excel
1.可以使用excel打开
2.默认字段之间的分割符 , [可以进行更改]
常用参数:
read:
1.sep 分割符 ,
2.header 第一行作为table中的字段
3.inferSchema 类型推断功能
4.encoding 指定读取的csv文件的字符集 默认utf-8
write:
compression
sep
encoding

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}

object DataSourceCSV01 {

  def csv(spark: SparkSession, path: String) = {
    val data: DataFrame = spark.read.option("sep",";")
      .option("header","true")
      .option("inferSchema","true")
      .format("csv").load(path)
    import spark.implicits._
    data.show(false)
    data.printSchema()
    data.createOrReplaceTempView("csv")
    spark.sql(
      """
        |select
        |city_id,city_name,area
        |from csv
        |where lower(city_name)='beijing'
        |""".stripMargin)
    data.write.option("compression","gzip").mode(SaveMode.Overwrite).format("csv").save("hdfs://bigdata12:9000/spark/spark04")
  }

  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    // csv
    csv(spark,"file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\city_info.csv")
    spark.stop()
  }
}

jdbc

1.目前这种写法 :
加载数据 性能不高:
1.直接表table 数据全部加载过来 , 再进行筛选 性能不高
加载数据: 谓词下压: 首选!!!先进性where 加载数据 性能高
2.写数据:
1.在mysql上先创建一个table
CREATE TABLE rpt_zihang_sum (
uid varchar(20) DEFAULT NULL,
name varchar(20) DEFAULT NULL,
sku varchar(20) DEFAULT NULL,
os varchar(20) DEFAULT NULL,
cnt int(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8
2.write

mysql
mysql-connector-java
5.1.49

package com.dl2262.sparksql.day02

import java.util.Properties

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}

object DataSourceJDBC01 {

  def jdbc(spark: SparkSession) = {
    val inputsql =
      """
        |select *
        |from dept
        |where deptno=10
        |""".stripMargin
    val data: DataFrame = spark.read.format("jdbc")
      .option("url", "jdbc:mysql://bigdata12:3306/bigdata")
      .option("dbtable", s"($inputsql) as tmp")
      .option("user", "root")
      .option("password", "123456")
      .load()
    data.show(false)
    data.printSchema()
    val url = "jdbc:mysql://bigdata12:3306/bigdata"
    val table = "dept01"
    val properties: Properties = new Properties()
    properties.setProperty("user","root")
    properties.setProperty("password","123456")
    data.write.mode(SaveMode.Append).jdbc(url,table,properties)
  }

  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    jdbc(spark)
    spark.stop()
  }
}

sparksql整合hive

1.linux环境 spark 整合hive 【生产集群环境 配置】
2.代码开发 idea
1.生产环境
placing your hive-site.xml,
core-site.xml (for security configuration), and
hdfs-site.xml (for HDFS configuration) file in conf/.
把hive-site.xml, core-site.xml ,hdfs-site.xml 放置spark安装目录 conf文件下即可
之前spark 跑yarn上 : 已经配置了hadoop配置文件路径的参数 ,core-site.xml ,hdfs-site.xml是不需要再次配置在conf目录下
1.可以的 [不推荐]:cp hive_home/conf/hive-site.xml spark_home/conf/
2.最好使用软连接:[hadoop@bigdata12 conf]$ ln -s /home/hadoop/app/hive/conf/hive-site.xml ./hive-site.xml
spark-shell =》 hive : 报错:没有mysql驱动
spark整合hive,只需要spark作业能够访问hive metastore即可,hive的metastore在mysql里
spark作业添加mysql驱动:
1.linux环境变量里面 添加 mysql驱动包 【不常用】
2.当前spark作业 添加mysql驱动即可
spark:
driver
executor 每个executor都要有 mysql驱动jar包
启动spark-sql 脚本:
spark-sql --master local[2]
–jars /home/hadoop/software/mysql-connector-java-5.1.28.jar
–driver-class-path /home/hadoop/software/mysql-connector-java-5.1.28.jar
测试:
spark.sql(“show databases”).show()
spark.sql(“show tables in bigdata”).show()
spark.sql(“select * from bigdata.city_info”).show()
select count(1),city_name from city_info group by city_name
spark.sql(“select count(1),city_name from bigdata.city_info group by city_name”).show()
spark-shell => test
spark-submit => 用于提交用户 自己开发spark作业 jar
spark-sql => 类比于 hive
启动spark-sql 脚本:
spark-sql --master local[2]
–jars /home/hadoop/software/mysql-connector-java-5.1.28.jar
–driver-class-path /home/hadoop/software/mysql-connector-java-5.1.28.jar
补充: database namespace 都是指数据库
数据分析:数仓里面的数据
ad-hoc: 临时查询、测试
hive 脚本 :
分析少用
建表
spark-sql脚本:分析用
建议不要建表【sparksql hive 建表 有小问题 可以用】
hive function =》 spark绝对有
spark里面有的东西 =》 hive 未必有
维护数仓: 数据导入到xxl、airflow
hive -e/-f xxx.sql => mr
spark-sql -e/-f xxx.sql => sparksql => 推荐的方式 离线数仓 好维护 简单
=》 idea api 方式 不太推荐 离线数仓 不好维护

idea

1.在resources里面导入hive-site.xml并导入hive依赖包

org.apache.spark
spark-hive_2.12
3.2.1

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.SparkSession

object DataSourceHive01 {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    import org.apache.spark.sql.functions._
    val data = spark.sql(
      """
        |select * from bigdata.city_info
        |""".stripMargin)
    data.printSchema()
    data.show(false)
    spark.stop()
  }
}

案例

id visit_dt visit_cnt
u01 2017/1/21 5
u02 2017/1/23 6
u03 2017/1/22 8
u04 2017/1/20 3
u01 2017/1/23 6
u01 2017/2/21 8
u02 2017/1/23 6
u01 2017/2/22 4

create table user_log (
uid string,
visit_dt string,
visit_cnt int
)
row format delimited fields terminated by ','
load data local inpath '/home/hadoop/tmp/user.log' overwrite into table user_log;

需求:
要求使用sql 统计出 每个用户的累计访问次数
uid 月份(month) cnt 累计cnt
u01 2017-01 11 11
u01 2017-02 12 23
1.每个用户每个月的 访问次数
2.累计访问次数

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.SparkSession

object DataSourceHive02 {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    import org.apache.spark.sql.functions._
    val data = spark.sql(
      """
        |select
        |uid,
        |month,
        |cnt,
        |sum(cnt) over(partition by uid order by month) as total_cnt
        |from(
        |select
        |uid,
        |date_format(replace('visit_dt','/','-'),'yyyy-MM') as month,
        |sum(visit_cnt) as cnt
        |from bigdata.user_log
        |group by uid,month
        |) as a
        |""".stripMargin)
    data.show(false)
    data.printSchema()
    spark.stop()
  }
}

案例

需求:
mysql数据:
city_info、 城市表
product_info 商品表
{“product_status”:1}
1表示自营
0表示第三方
日志数据:user_click.txt
1.按照区域求最受欢迎【点击次数】的商品的 top3
2.统计每个城市每个商品状态[自营/非自营]的最受欢迎的商品
1.使用sparksql 代码的方式做需求,并把结果数据写入mysql
2.需求需要 部署在xxl上进行调度,调度周期 t+1
3.将结果数据进行可视化展示,使用superset:
1.可视化要求:必须要使用下拉框,其他图表任意使用
4.整理整个需求的思路架构图
临时需求:
1.数据源在不同位置:
1.把多种数据源数据 全部放到 hive 统一进行处理 【推荐】
2.sparksql 集成code 把各种各样的数据源都加载sparksql里 形成dataframe 不同dataframe可以进行数据交互 一般用于临时开发
input:
mysql:2table =》 sparksql =》 2df
日志数据:hdfs => sparksql => df
todo:
1.按照区域求最受欢迎【点击次数】的商品的 top3
2.统计每个城市每个商品状态[自营/非自营]的最受欢迎的商品
output: mysql
部署: xxl: T+1 报警
spark-submit jar
数据可视化: superset
idea 打包方式:
瘦包 仅仅把编好的代码打入到 jar里面 ,版本升级时不需要进行改动
胖包:除了打入编好的代码之外还会打入需要的依赖到jar里面
缺点: 160M * 1000 =》 linux 数据量太大
不建议: 把需要的jar包直接导入到spark里面的jars里,会脏了 spark 环境,导入的jar包很容易和spark里面的jar包冲突,导致spark用不了了,或版本升级后可能会导致jar包冲突

package com.dl2262.sparksql.day03

import java.util.Properties

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.{DataFrame, Dataset, SaveMode, SparkSession}

object UserLogApp {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    import org.apache.spark.sql.functions._
    val city_info: DataFrame = spark.read.format("jdbc")
      .option("url", "jdbc:mysql://bigdata12:3306/bigdata")
      .option("dbtable", "city_info")
      .option("user", "root")
      .option("password", "123456")
      .load()
    val product_info: DataFrame = spark.read.format("jdbc")
      .option("url", "jdbc:mysql://bigdata12:3306/bigdata")
      .option("dbtable", "product_info")
      .option("user", "root")
      .option("password", "123456")
      .load()
    city_info.show(false)
    product_info.show(false)
    //spark.read.format("text").load("hdfs://bigdata12:9000//user/hive/warehouse/bigdata.db/user_click/")
    val logData: Dataset[String] = spark.read.textFile("hdfs://bigdata12:9000//user/hive/warehouse/bigdata.db/user_click/")
    val userLog: DataFrame = logData.map(line => {
      val splits: Array[String] = line.split(",")
      val uid: String = splits(0)
      val session_id: String = splits(1)
      val dt: String = splits(2)
      val city_id: String = splits(3)
      val product_id: String = splits(4)
      (uid, session_id, dt, city_id, product_id)
    }).toDF("uid", "session_id", "dt", "city_id", "product_id")
    userLog.show(3,false)
    city_info.createOrReplaceTempView("city_info")
    product_info.createOrReplaceTempView("product_info")
    userLog.createOrReplaceTempView("user_log")
    spark.sql(
      """
        |drop table if exists bigdata.dws_user_log
        |""".stripMargin)
    spark.sql(
      """
        |create table bigdata.dws_user_log as
        |select
        |a.city_id,
        |a.product_id,
        |area,
        |product_name
        |from(
        |select
        |city_id,
        |product_id
        |from user_log
        |) as a left join(
        |select
        |city_id,
        |area
        |from city_info
        |) as b
        |on a.city_id=b.city_id
        |left join(
        |select
        |product_id,
        |product_name
        |from product_info
        |)as c
        |on a.product_id=c.product_id
        |""".stripMargin)
    spark.sql(
      """
        |drop table if exists bigdata.rpt_user_log_click_rank
        |""".stripMargin)
    spark.sql(
      """
        |create table bigdata.rpt_user_log_click_rank as
        |select
        |area,
        |product_name,
        |cnt,
        |row_number() over(partition by area order by cnt desc) as rk
        |from(
        |select
        |area,
        |product_name,
        |count(*) as cnt
        |from bigdata.dws_user_log
        |group by area,product_name
        |) as a
        |""".stripMargin)
    val rpt = spark.sql(
      """
        |select
        |area,
        |product_name,
        |cnt,
        |rk
        |from bigdata.rpt_user_log_click_rank
        |where rk <= 3
        |""".stripMargin)
    rpt.show(false)
    val url = "jdbc:mysql://bigdata12:3306/bigdata"
    val table = "rpt_cnt_top3"
    val properties: Properties = new Properties()
    properties.setProperty("user","root")
    properties.setProperty("password","123456")
    rpt.write.mode(SaveMode.Append).jdbc(url,table,properties)
    spark.stop()
  }
}
def getSparkSession(appName:String,master:String="local[2]")={
    SparkSession.builder()
      //.appName(appName).master(master)
      .enableHiveSupport().getOrCreate()
  }
spark-submit \
--master local[2] \
--name userlog \
--class com.dl2262.sparksql.day03.UserLogApp \
--jars /home/hadoop/software/mysql-connector-java-5.1.28.jar \
--driver-class-path /home/hadoop/software/mysql-connector-java-5.1.28.jar \
/home/hadoop/project/spark/spark-2262-1.0.jar.1

以yarn方式进行部署【面试】

  1.  client : driver   =》 client机器(提交机器)
     cluster: driver  =》 集群内部的 
    

2.提交作业有关
cluster :
提交作业 client作业提交 client就可以关闭了 对spark作业是没有影响的
client:
提交作业 client作业提交 如果client关闭了 driver process 挂了 对spark作业有影响的
3.输出日志
client =》 可以直接查看日志
cluster =》 yarn上去看运行日志

spark-submit \
--master yarn \
--deploy-mode client \
--name userlog \
--executor-memory 1G \
--num-executors 1 \
--executor-cores 1 \
--class com.dl2262.sparksql.day03.UserLogApp \
--jars /home/hadoop/software/mysql-connector-java-5.1.28.jar \
--driver-class-path /home/hadoop/software/mysql-connector-java-5.1.28.jar \
/home/hadoop/project/spark/spark-2262-1.0.jar.1
spark-submit \
--master yarn \
--deploy-mode cluster \
--name userlog \
--executor-memory 1G \
--num-executors 1 \
--executor-cores 1 \
--class com.dl2262.sparksql.day03.UserLogApp \
--jars /home/hadoop/software/mysql-connector-java-5.1.28.jar \
--driver-class-path /home/hadoop/software/mysql-connector-java-5.1.28.jar \
--driver-library-path /home/hadoop/software/mysql-connector-java-5.1.28.jar \
/home/hadoop/project/spark/spark-2262-1.0.jar.1

数据写入hive

1.sql方式: hivesql
普通表
1.hive创建一张普通表
2.insert :
insert into
insert overwrite 【常用】

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.SparkSession

object DataSourceHive02 {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    import org.apache.spark.sql.functions._
    val data = spark.sql(
      """
        |select
        |uid,
        |month,
        |cnt,
        |sum(cnt) over(partition by uid order by month) as total_cnt
        |from(
        |select
        |uid,
        |date_format(replace('visit_dt','/','-'),'yyyy-MM') as month,
        |sum(visit_cnt) as cnt
        |from bigdata.user_log
        |group by uid,month
        |) as a
        |""".stripMargin)
    data.show(false)
    data.printSchema()

    /**
     * sql方式写入数据
     * 1.在hive里建普通表
     * 2.insert进hive表里
     */
    data.createOrReplaceTempView("result")
//    spark.sql(
//      """
//        |--不推荐 ctas
//        |create table bigdata.result01 as
//        |select * from result
//        |""".stripMargin)
//    spark.sql(
//      """
//        |insert into table bigdata.result01
//        |select * from result
//        |""".stripMargin)
    spark.sql(
      """
        |insert overwrite table bigdata.result01
        |select * from result
        |""".stripMargin)
    spark.stop()
  }
}

分区表 :
1.hive创建一张分区表
2.insert :
into
overwrite
静态分区:
动态分区:

package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.SparkSession

object WriteHive02 {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    import org.apache.spark.sql.functions._
    val data = spark.sql(
      """
        |select
        |uid,
        |month,
        |cnt,
        |sum(cnt) over(partition by uid order by month) as total_cnt
        |from(
        |select
        |uid,
        |date_format(replace('visit_dt','/','-'),'yyyy-MM') as month,
        |sum(visit_cnt) as cnt
        |from bigdata.user_log
        |group by uid,month
        |) as a
        |""".stripMargin)
    data.show(false)
    data.printSchema()

    /**
     * sql方式写入数据
     * 1.在hive里面建分区表
     * 2.insert进hive表里
     */
    data.createOrReplaceTempView("result")
//    spark.sql(
//      """
//        |--1.静态分区
//        |insert overwrite table bigdata.result02 partition(month='2017-01')
//        |select
//        |uid,
//        |cnt,
//        |total_cnt
//        |from result
//        |where month='2017-01'
//        |""".stripMargin)
    spark.conf.set("hive.exec.dynamic.partition","true")
    spark.conf.set("hive.exec.dynamic.partition.mode","nonstrict")
    spark.sql(
      """
        |--1.动态分区
        |insert overwrite table bigdata.result02 partition(month)
        |select
        |uid,
        |cnt,
        |month,
        |total_cnt
        |from result
        |""".stripMargin)
    spark.stop()
  }
}
2.api方式
	table: 
		普通表
		分区表
	写入方式: 
		append
		overwrite 
package com.dl2262.sparksql.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.{SaveMode, SparkSession}

object WriteApiHive01 {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    import org.apache.spark.sql.functions._
    val data = spark.sql(
      """
        |select
        |uid,
        |month,
        |cnt,
        |sum(cnt) over(partition by uid order by month) as total_cnt
        |from(
        |select
        |uid,
        |date_format(replace('visit_dt','/','-'),'yyyy-MM') as month,
        |sum(visit_cnt) as cnt
        |from bigdata.user_log
        |group by uid,month
        |) as a
        |""".stripMargin)
    data.show(false)
    data.printSchema()

    /**
     * Api写入数据
     */
    // 普通表
    // saveAsTable普通表会自动建表
     data.write.mode(SaveMode.Append).format("hive").saveAsTable("bigdata.result03") data.write.mode(SaveMode.Overwrite).format("hive").saveAsTable("bigdata.result03")

    data.createOrReplaceTempView("tmp")
    val mon_data=spark.sql(
      """
        |select * from tmp where month='2017-01'
        |""".stripMargin)
    // 分区表
    // saveAsTable(不能用!!!):会自动建表 api默认是动态分区
    spark.conf.set("hive.exec.dynamic.partition","true")
    spark.conf.set("hive.exec.dynamic.partition.mode","nonstrict")
    
    data.write.mode(SaveMode.Overwrite)
     .partitionBy("month")
     .format("hive")
      .saveAsTable("bigdata.result04")
      
    // SaveMode.Overwrite更新整个表,不是某个分区
    mon_data.write.mode(SaveMode.Overwrite)
        .partitionBy("month")
        .format("hive")
        .saveAsTable("bigdata.result04")
        
    // insertInto不能和partitionBy连用  不能用于写入分区表!!!
    mon_data.write.mode(SaveMode.Overwrite)
        .partitionBy("month")
        .format("hive")
        .insertInto("bigdata.result04")


    /**
     * 解决手段:
     * 把你的数据写入到hdfs对应的table path下面即可
     * 等同于通过sqoop和datax直接把mysql里面的数据同步到hdfs
     * hive里面的table能不能直接使用呢
     * 普通表写到hdfs上之后,是可以直接read的
     * 分区表写到hdfs上之后,不能直接读
     * 因为hdfs上数据是ok的,但元数据是不ok的,会导致hive元数据和数据没有关联上
     * 解决方法修复table中的元数据
     */
    spark.stop()
  }
}

	文件存储格式: 
		text(单列输出)【有问题】、orc、parquet
create table bigdata.result05(
uid string,
cnt bigint,
total_cnt bigint
)
partitioned by(month string)
row format delimited fields terminated by ","
stored as orc
 // 解决方法 分区表 不过更新的还是整张表
    data.write.mode(SaveMode.Overwrite).partitionBy("month")
      //.format("orc").save("")
        .orc("hdfs://bigdata12:9000/user/hive/warehouse/bigdata.db/result05/")
    spark.sql(
      """
        |msck repair table bigdata.result05
        |""".stripMargin)
       
     mon_data.write.mode(SaveMode.Overwrite).partitionBy("month")
      //.format("orc").save("")
      .orc("hdfs://bigdata12:9000/user/hive/warehouse/bigdata.db/result05/")
    spark.sql(
      """
        |msck repair table bigdata.result05
        |""".stripMargin)

如果想使用api的方式SaveMode.overwrite绝对用不了!!!SaveMode.overwrite操作的是table,不是具体的partition
解决方法:用SaveMode.Append,修改分区dt的过滤条件 select * from tmp where month=‘2017-01’

mon_data.write.mode(SaveMode.Append).partitionBy("month")
      //.format("orc").save("")
      .orc("hdfs://bigdata12:9000/user/hive/warehouse/bigdata.db/result05/")
    spark.sql(
      """
        |msck repair table bigdata.result05
        |""".stripMargin)

但是SaveMode.Append相同分区再次修改会出现数据重复,要解决幂等性的问题
解决方法:
1.删除对应分区hdfs上数据 =》hdfs api
2.删除对应分区 元数据 =》 alter table xxx drop partition
3.api 写入对应分区 hdfs 上数据 =》sparksql api
4.api 加上对应分区 元数据 =》alter table xxx add partition或者msck repair table xxx

spark-hive udf catalog

catalog

hive元数据 mysql里面:
spark2.0之前 spark 想要访问hive元数据 要通过jdbc 连接,取数据
spark2.0之后 调用catalog 就可以拿到 hive元数据的内容
拿到hive元数据=》 做什么事情?
1.大数据平台: 哪些表是热表哪些表是冷表,哪些表什么时间段进来数据什么时间段出去数据,数据分析平台都可以利用元数据去取数据

val ct =spark.catalog
ct.listDatabases.show(5,false)
ct.listTables("bigdata").show(5,false)
ct.listFunctions().show(100,false)
ct.listColumns("bigdata.test1").show(false)

思考: spark-shell 以yarn方式运行 client/cluster都能启动嘛【面试题】

spark-shell \
--master yarn \
--deploy-mode client \
--name dl2262 \
--executor-memory 1G \
--num-executors 1 \
--executor-cores 1 \
--jars /home/hadoop/software/mysql-connector-java-5.1.28.jar \
--driver-class-path /home/hadoop/software/mysql-connector-java-5.1.28.jar

client可以,cluster不可以
因为spark-shell是交互式脚本,它的driver就在提交机器上,client的driver也在提交机器上,而cluster的driver在集群内部

udf

1.idea 代码的方式定义 udf函数
2.hive udf 可以在sparksql里面直接使用:
使用场景 : xxx.sql
hive jar: add jar xx.jar
create function 方法名字 as copy reference

package com.dl2262.sparksql.day03

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.sql.SparkSession

import scala.util.Random

object Udf {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    import spark.implicits._
    import org.apache.spark.sql.functions._
    val data = spark.sql(
      """
        |select
        |uid,
        |month,
        |cnt,
        |sum(cnt) over(partition by uid order by month) as total_cnt
        |from(
        |select
        |uid,
        |date_format(replace('visit_dt','/','-'),'yyyy-MM') as month,
        |sum(visit_cnt) as cnt
        |from bigdata.user_log
        |group by uid,month
        |) as a
        |""".stripMargin)
    data.show(false)
    data.createOrReplaceTempView("tmp")

    /**
     * udf:f(x)
     * 添加一个随机数前缀
     * u01 => 9_u01
     */
    spark.udf.register("addRandom",(input:String) => {
      Random.nextInt(10)+"_"+input
    })
    spark.sql(
      """
        |select
        |addRandom(uid) as uid_alias,month,cnt,total_cnt
        |from tmp
        |""".stripMargin).show(false)
    spark.stop()
  }
}

sparkstreamig

spark 提供的实时计算的模块:SparkStreaming、structuredStreaming
1.流处理 /实时计算
实时:storm、flink (来一条数据处理一条数据 ) event基于事件的方式进行计算 真正的实时计算
近实时:SparkStreaming 来一批数据处理一批数据 源源不断的来 mini-batch
2.批处理/离线计算
一次性处理某一个批次的数据 数据是有始有终的
流处理:
水龙头 数据是远远不断的来 数据没有始终
技术选型:
1.生产上:
SparkStreaming、structuredStreaming 10% spark
flink 90%
storm 2% 几乎不用
开发角度 :
code代码角度:flick开发简单
flick里面还支持sql方式处理 实时计算
sparkstreaming也能用sql,但是不是所有代码都是通过sql开发的,所以诞生了structuredStreaming(基于spark-sql进行开发),structuredStreaming开发角度比sparkstreaming更简单
业务:
1.实时指标
spark和flick都差不多
2.实时数仓
1.代码 =》 spark和flick都差不多 【都不好维护】
2.sql文件:
只有flinksql 能做到维护实时数仓
sparkstreaming:
1.Easy to use
2.sparkstreaming可以调用 sparksql 进行开发
SparkStreaming
1.Spark Streaming is an extension of the core Spark API
SparkStreaming开发 与sparkcore 算子开发 差不多
2.spark Streaming 数据源:Kafka, TCP sockets ,flume,hdfs =》 input
3.处理: 算子的方式进行处理 =》 todo
4. pushed out to filesystems, databases, hdfs,and live dashboards =》 output
数据源:
kafka **** 流式引擎 + kafka 【重要数据源】数据存储在topic里进行缓冲
flume 可以使用 一般不用 没有数据缓冲的作用
hdfs 很少使用
tcp sockets =》 测试代码 +运营商数据(早期采集数据方式 )
总结: 建议不要使用flume作为spark的数据源,因为flume缓冲能力很弱 之后数据计算 直接把数据干到 spark里面 会导致 spark计算程序挂掉
spark/flick对接kafka,流式处理系统会有自己吞吐量的处理能力
数据积压:kafka数据多,spark消费能力不足,导致kafka数据大量积压
解决方法:提高spark消费能力,提高吞吐量
SparkStreaming运行:
1. receives live input data streams 接收数据
2.divides the data into batches 把接收数据 拆分成batches
sparkstreaming编程模型:DStream
a DStream is represented as a sequence of RDDs.
sparkcore:rdd
sparksql :ds、df
如何构建DStream?
1.外部数据源【kafka】
2.高阶算子方式转换
Stream data 按照时间把数据拆分一个一个的 batch(batch就是一个一个的rdd )
流式处理:
对 DStream进行转换操作
实际上就是对 DStream里面的rdd进行操作
对rdd进行操作就是对 rdd里面分区的元素进行操作
总结: 程序入口
sparkstreaming :StreamingContext
sparkcore: sparkcontext
sparksql: sparksession
实时计算处理数据的qps是多少?
qps指的是计算程序每秒钟处理的数据是多少条
虚拟机上构建StreamingContext

import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._ 
val ssc = new StreamingContext(sc, Seconds(5))
val lines = ssc.socketTextStream("localhost", 9999)
val words = lines.flatMap(_.split(" "))
val pairs = words.map(word => (word, 1))
val wordCounts = pairs.reduceByKey(_ + _)
wordCounts.print()
ssc.start()   

idea构建StreamingContext

org.apache.spark spark-streaming_2.12 3.2.1 总结: 打印的东西: 1.spark处理 当前批次的数据的结果 2.不能处理 累计批次的数据 累计批次:多个批次之间又联系的 ```scala package com.dl2262.sparkstreaming.day01

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}

object sss01 {
def main(args: Array[String]): Unit = {
val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
val lines = ssc.socketTextStream(“bigdata12”, 9999)
val words = lines.flatMap(.split(" "))
val pairs = words.map(word => (word, 1))
val wordCounts = pairs.reduceByKey(
+ _)
wordCounts.print()
ssc.start()
ssc.awaitTermination()
}
}


```scala
 /**
   * 获取StreamingContext
   */
  def getStreamingContext(appName:String,batch:Int,master:String="local[2]")={
    val conf = new SparkConf().setMaster(master).setAppName(appName)
    new StreamingContext(conf, Seconds(batch))
  }

如何构建DStream?
1.Input DStreams 【输入流 kafka】 *****
2.Receivers 【接收流 测试使用 生产上不用】: 为面试准备
并不是所有的接收数据都需要接收器
1.Receivers: 底层DStream前面带Receiver的就是接收流
1.socketTextStream:
底层调用socketStream
底层调用SocketInputDStream
Receiver:master =》 local[2] => local[1] code能否处理数据?【面试】
sparkstreaming: 1 cpu =》 1 core
1.接收流式数据 ok 需要1core去接收数据
2.流式数据 切分成 batch进行处理 no ok cpu不够 你的数据没有资源进行处理
要求:master cpu 个数 一定要大于Receiver 数量
什么是Receiver? 指的就是 接收数据形成的流 看底层返回值 底层DStream前面带Receiver的就是接收流 接收器
2.转换算子
1.transform ***
2.updateStateByKey
sparkstreaming处理数据的方式:
1.默认仅仅是计算当前批次的数据 只是计算10s一个批次的数据
需求:
统计 从现在时间点开始 b出现的累计次数?
updateStateByKey 用于解决 有状态问题
对于 累计批次的需求? 官方引出一个概念 状态
状态:State:
1.有状态 前后批次有联系的
2.无状态 前后批次是没有联系的
累计批次的需求?
1.updateStateByKey 算子解决
1.Define the state
2.Define the state update function
注意:
1.得指定 The checkpoint directory has not been set

package com.dl2262.sparkstreaming.day01

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.streaming.StreamingContext

object sss02 {
  def main(args: Array[String]): Unit = {
    val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
    ssc.checkpoint("file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\checkpoint")
    val lines = ssc.socketTextStream("bigdata12", 9999)
    val words = lines.flatMap(_.split(" "))
    val pairs = words.map(word => (word, 1))
    val wordCounts = pairs.updateStateByKey(updateFunction)
    wordCounts.print()
    ssc.start()
    ssc.awaitTermination()
  }
  /**
   * Option some none
   * @param newValues 最新批次的数据 (a,<1,1,1>)
   * @param preValues 以前批次的一个累加值 (a,3)
   * @return
   */
  def updateFunction(newValues: Seq[Int], preValues: Option[Int]): Option[Int] = {
    val curr_sum: Int = newValues.sum
    val pre_sum: Int = preValues.getOrElse(0)// 取到了就取到了,取不到就给个0
    Some(curr_sum+pre_sum)
  }
}

总结:
1.为什么要指定checkpoint?
1.维护 当前批次和以前的累计批次的数据state
2.checkpoint 目录 生产上 得指定到 hdfs上进行存储?
存在问题:
1.checkpoint 每个批次都会产生 文件 =》 hdfs 扛不住 挂掉的风险
checkpoint 的作用 针对sparkstreaming来说
【checkpoint这个东西 生产上用不了 了解它 即可 面试准备】
1.作用:
1.为了容错
2.恢复作业【实时计算作业 挂掉之后 可以恢复起来】

package com.dl2262.sparkstreaming.day01

import com.dl2262.sparkcore.util.ContextUtils
import com.dl2262.sparkstreaming.day01.sss02.updateFunction
import org.apache.spark.streaming.StreamingContext

object sss03 {
  def main(args: Array[String]): Unit = {
    val ssc = StreamingContext.getOrCreate("file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\checkpoint", functionToCreateContext)
    ssc.start()
    ssc.awaitTermination()
  }
  def functionToCreateContext(): StreamingContext = {
    val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
    val lines = ssc.socketTextStream("bigdata12", 9999)
    val words = lines.flatMap(_.split(" "))
    val pairs = words.map(word => (word, 1))
    val wordCounts = pairs.updateStateByKey(updateFunction)
    wordCounts.print()
    ssc.checkpoint("file:///F:\\bigdata\\ideaProject\\spark-2262\\data\\checkpoint")
    ssc
  }
}
2.checkpoint存储的东西:
	1.Metadata 元数据 
		Configuration  作业里面配置信息
		DStream operations  作业code里面的算子操作
		Incomplete batches  未完成的批次
	2.Data
		每个批次里面真正传过来的数据 +stateful转换
3.使用场景
	1.Usage of stateful transformations
	2.Recovering from failures of the driver running the application 
		恢复作业
4.如何正确使用checkpint? 
	如果你想要 恢复application 需要 正确编写 checkpoint设置代码 
注意: 
	checkpoint缺点:
		1.小文件多
		2.修改代码程序就用不了【修改业务逻辑代码】
checkpoint 用不了生产上 =》 累计批次指标统计问题 updateStateByKey这个算子 也用不了!!!
那么如何实现 累计批次统计需求? 
	一: 100%来处理 
		1.把每个批次数据 写到外部存储 
		2.然后利用外部存储系统再统计即可
	二:90%都没有解决 
		checkpoint 【解决 checkpoint 导致修改代码 报错问题+小文件问题解决】 

3.输出算子:
1.print
2.foreachRDD =》 db
需求: wc案例结果写mysql里面
1.mysql创建一个表
create table wc(
word varchar(10),
cnt int(10)
);
Serialization stack:
- object not serializable (class: java.lang.Object, value: java.lang.Object@4c03b7b3)
1.某个东西没有进行序列化?
1.MySQL连接驱动没有进行序列化 【做不了】
2.ClosureCleaner
Closure 闭包的 意思
闭包的: 方法内使用了方法外的变量
2.正确写法:
rdd.foreachPartition{
mysql 连接次数 会减少 rdd有多少个分区 就有多少个连接
}

package com.dl2262.sparkstreaming.day01

import java.sql.Connection

import com.dl2262.sparkcore.util.{ContextUtils, MySQLUtil}
import com.dl2262.sparkstreaming.day01.sss02.updateFunction
import org.apache.spark.streaming.StreamingContext

object sss04 {
  def main(args: Array[String]): Unit = {
    val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
    val lines = ssc.socketTextStream("bigdata12", 9999)
    val words = lines.flatMap(_.split(" "))
    val pairs = words.map(word => (word, 1))
    val wordCounts = pairs.reduceByKey(_+_)
    wordCounts.print()
    //data output => mysql
    wordCounts.foreachRDD(rdd => {
      // mysql clickhouse drios phoenix
      // 只有mysql连接不支持序列化,其他三个都支持
//      rdd.foreach(pair => {// executor
//        val conn: Connection = MySQLUtil.getConnection()
//        val sql = s"insert into wc(word,cnt) values('${pair._1}','${pair._2}')"
//        conn.createStatement().execute(sql)
//        conn.close()
//      })
      //rdd.coalesce(10).foreachPartition()
      // 如果连接有序列化可以把连接放在这
      rdd.foreachPartition(partition => {
        val conn: Connection = MySQLUtil.getConnection()
        partition.foreach(pair => {
          val sql = s"insert into wc(word,cnt) values('${pair._1}','${pair._2}')"
          conn.createStatement().execute(sql)
        })
        conn.close()
      })
    ssc.start()
    ssc.awaitTermination()
  })
}
}

3.如果 rdd.foreachPartition 写数据 存在存储性能问题: 【一般不用,可以使用!!!】
1.可以使用连接池
2.rdd.coalse =》 减少rdd分区数
4.sparksql的方式写出 =》

package com.dl2262.sparkstreaming.day01

import java.sql.Connection
import java.util.Properties

import com.dl2262.sparkcore.util.{ContextUtils, MySQLUtil}
import com.dl2262.sparkstreaming.day01.sss02.updateFunction
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
import org.apache.spark.streaming.StreamingContext

object sss04 {
  def main(args: Array[String]): Unit = {
    val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
    val lines = ssc.socketTextStream("bigdata12", 9999)
    val words = lines.flatMap(_.split(" "))
    val pairs = words.map(word => (word, 1))
    val wordCounts = pairs.reduceByKey(_+_)
    wordCounts.print()
    //data output => mysql
    wordCounts.foreachRDD(rdd => {
      // mysql clickhouse drios phoenix
      // 只有mysql连接不支持序列化,其他三个都支持
//      rdd.foreach(pair => {// executor
//        val conn: Connection = MySQLUtil.getConnection()
//        val sql = s"insert into wc(word,cnt) values('${pair._1}','${pair._2}')"
//        conn.createStatement().execute(sql)
//        conn.close()
//      })
      //rdd.coalesce(10).foreachPartition()
      // 如果连接有序列化可以把连接放在这
//      rdd.foreachPartition(partition => {   // 推荐
//        val conn: Connection = MySQLUtil.getConnection()
//        partition.foreach(pair => {
//          val sql = s"insert into wc(word,cnt) values('${pair._1}','${pair._2}')"
//          conn.createStatement().execute(sql)
//        })
//        conn.close()
      // sparksql的方式写出 推荐
      val spark = SparkSession.builder.config(rdd.sparkContext.getConf).getOrCreate()
      import spark.implicits._
      val df: DataFrame = rdd.toDF("word", "cnt")
      df.printSchema()
      df.show()
      val url = "jdbc:mysql://bigdata12:3306/bigdata"
      val table = "rpt_cnt_top3"
      val properties: Properties = new Properties()
      properties.setProperty("user","root")
      properties.setProperty("password","123456")
      df.write.mode(SaveMode.Append).jdbc(url,table,properties)
      })
    ssc.start()
    ssc.awaitTermination()
  }
}

转换算子transform

transform =》 DStream 和 rdd之间数据进行交互的算子
需求:
流处理 数据源:
一个数据来自于 mysql数据/hdfs上文本数据 【量小】 维表
一个数据 来自于 kafka sss 读取形成 DStream数据 【量大】 主业务 =》 主表
案例: 弹幕 过滤的功能 /黑名单的功能
离线:

package com.dl2262.sparkstreaming.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession

object SparkSQLBlackListApp {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession = ContextUtils.getSparkSession(this.getClass.getSimpleName)
    val sc: SparkContext = spark.sparkContext
    import spark.implicits._
    import org.apache.spark.sql.functions._
    /**
     * 主表数据:弹幕日志数据
     * 维表书局:需要过滤的弹幕 =》 黑名单
     */
    val log: RDD[String] = sc.parallelize(List(
      "好看",
      "不好看",
      "垃圾",
      "男主好帅",
      "女主好漂亮",
      "666",
      "男主演技拉跨",
      "女主演技拉跨",
      "台词拉跨"
    ))
    val black: RDD[String] = sc.parallelize(List(
      "男主演技拉跨",
      "女主演技拉跨",
      "台词拉跨"
    ))
    val log_kv: RDD[(String, Int)] = log.map(line => (line, 1))
    val black_kv: RDD[(String, Boolean)] = black.map(line => (line, true))
    log_kv.leftOuterJoin(black_kv)
        .filter(_._2._2.getOrElse(false) != true)
        .map(_._1).foreach(println(_))
    spark.stop()
  }
}

实时:

package com.dl2262.sparkstreaming.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}

object SparkStreamingBlackApp {
  def main(args: Array[String]): Unit = {
    val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
    val sc: SparkContext = ssc.sparkContext
    /**
     * socket
     * 主表数据:弹幕日志数据 DStream
     * mysql/hdfs
     * 维表数据:需要过滤的弹幕 =》 黑名单  rdd
     */
    val logs: ReceiverInputDStream[String] = ssc.socketTextStream("bigdata12", 9527)
    val black: RDD[String] = sc.parallelize(List(
      "男主演技拉跨",
      "女主演技拉跨",
      "台词拉跨"
    ))
    // 弹幕显示
    val log_kv: DStream[(String, Int)] = logs.map(word => (word, 1))
    val black_kv: RDD[(String, Boolean)] = black.map(line => (line, true))
    val result: DStream[String] = log_kv.transform(rdd => {
      rdd.leftOuterJoin(black_kv)
        .filter(_._2._2.getOrElse(false) != true)
        .map(_._1)
    })
    result.print()
    ssc.start()
    ssc.awaitTermination()
  }
}

sparkstreaming + kafka 整合

kafka 数据源=》 sparkstreaming 消费
spark 2.x :
kafka版本:
0.8
0.10.0 or higher ok
spark 3.x => kafka :
1.kafka版本:
0.10.0 or higher ok
spark 去kafka读取数据的方式:
1.kafka 0.8 reciver方式读取kafka数据 【效率低 、代码开发复杂】
2.kafka 0.10.0版本之后 direct stream的方式加载kafka数据 【效率高、代码开发简单】
kafka:
版本也有要求:
0.11.0 版本之后
交付语义: consumer producer
producer 默认就是精准一次
consumer 交付语义取决于 consumer 框架本身
交付语义: consumer
至多一次 数据丢失问题
至少一次 数据不会丢失,数据重复消费
精准一次 数据不会丢失 数据也不会重复消费
spark 整合kafka 版本 0.10.0版本之后:
1.kafka 0.11.0之后 reciver => direct stream
2.sparkstreaming 默认消费kafka数据 交付语义: 至少一次

  1. spark消费kafka, DStream 【rdd 分区数】 =》 kafka topic 分区数 是一一对应的
    1:1 correspondence between Kafka partitions and Spark partitions
    2.spark整合kafka api:
    1.simple API =》 过时不用了
    2. new Kafka consumer API 整合 kafka 主流
    3.引入依赖: org.apache.spark spark-streaming-kafka-0-10_2.12 3.2.1 不需要引入 kafka-clients 依赖

spark整合kafka操作

zkServer.sh start
zkServer.sh status
kafka-server-start.sh -daemon $KAFKA_HOME/config/server.properties
查看kafka topic命令:
kafka-topics.sh --list
–zookeeper bigdata12:2181/kafka

kafka-topics.sh --create
–zookeeper bigdata12:2181/kafka
–topic spark-kafka01
–partitions 3
–replication-factor 1

producer:
kafka-console-producer.sh
–broker-list bigdata12:9092
–topic dl2262

consumer:
kafka-console-consumer.sh
–bootstrap-server bigdata12:9092
–topic dl2262
–from-beginning

package com.dl2262.sparkstreaming.day02

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.kafka010.KafkaUtils
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe

object ss01 {
  def main(args: Array[String]): Unit = {
    val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
    /**
     * 加载kafka数据
     * ssl权限校验
     */
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "bigdata12:9092",//kafka地址
      "key.deserializer" -> classOf[StringDeserializer],//反序列化
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "dl2262",//指定一个消费者组id
      "auto.offset.reset" -> "latest",//从哪个地方开始消费数据 偏移量
      "enable.auto.commit" -> (false: java.lang.Boolean)//offset提交 选择不自动提交 手动管理
    )
    val topics = Array("dl2262")
    val stream = KafkaUtils.createDirectStream[String, String](
      ssc,
      PreferConsistent,//【面试】数据的存储策略:kafka数据均匀分布在各个executor上
      Subscribe[String, String](topics, kafkaParams)//固定写法
    )
    stream.map(record => record.value()).print()
    ssc.start()
    ssc.awaitTermination()
  }
}

需求: 消费kafka数据 wc 将 结果写到 mysql里面

package com.dl2262.sparkstreaming.day02

import java.util.Properties

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.kafka010.KafkaUtils
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe

object ss02 {
  def main(args: Array[String]): Unit = {
    val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
    /**
     * 加载kafka数据
     * ssl权限校验
     * input
     */
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "bigdata12:9092",//kafka地址
      "key.deserializer" -> classOf[StringDeserializer],//反序列化
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "dl2262",//指定一个消费者组id
      "auto.offset.reset" -> "latest",//从哪个地方开始消费数据 偏移量
      "enable.auto.commit" -> (false: java.lang.Boolean)//offset提交 选择不自动提交 手动管理
    )
    val topics = Array("dl2262")
    val stream = KafkaUtils.createDirectStream[String, String](
      ssc,
      PreferConsistent,//【面试】数据的存储策略:kafka数据均匀分布在各个executor上
      Subscribe[String, String](topics, kafkaParams)//固定写法
    )

    /**
     * to do
     */
    stream.map(record => record.value()).print()
    val wc_result: DStream[(String, Int)] = stream.map(record => record.value())
      .flatMap(line => line.split(","))
      .map(word => (word, 1))
      .reduceByKey(_ + _)

    /**
     * output
     */
    wc_result.foreachRDD(rdd => {
      //foreachPartition
      //sparksql
      val spark = SparkSession.builder.config(rdd.sparkContext.getConf).getOrCreate()
      import spark.implicits._
      val wc: DataFrame = rdd.toDF("word", "cnt")
      wc.show()
      wc.printSchema()
      //sink mysql
      val url = "jdbc:mysql://bigdata12:3306/bigdata"
      val table = "wc"
      val properties: Properties = new Properties()
      properties.setProperty("user","root")
      properties.setProperty("password","123456")
      wc.write.mode(SaveMode.Append).jdbc(url,table,properties)
    })
    ssc.start()
    ssc.awaitTermination()
  }
}

模拟:spark作业挂掉 =》 重启
“消费完kafka的数据 程序重启之后接着从上次消费的位置接着消费 ”
目前: code不能满足
1.目前代码 这两个参数 不能动
“auto.offset.reset” -> “earliest”
“enable.auto.commit” -> (false: java.lang.Boolean)
2.主要原因 :
spark作业 消费kafka数据:
1.获取kafka offset =》 处理kafka数据 =》 “提交offset的操作” 没有
解决:
1.获取kafka offset // todo
2. 处理kafka数据
3.提交offset的操作 // todo
1.获取kafka offset // todo
1. kafka offset 信息
2.spark rdd分区数 和 kafka topic 的分区数 是不是 一对一
报错:
org.apache.spark.rdd.ShuffledRDD cannot be cast to org.apache.spark.streaming.kafka010.HasOffsetRanges
ShuffledRDD =》 HasOffsetRanges 说明 代码有问题
sparkstreaming里面: 开发模式:!!!
1.获取kafka 流数据
2. 流 Dstream =》 调用foreachRDD算子 进行输出:
0.获取offset 信息
1.做业务逻辑
2.结果数据输出
3.提交offset信息
offset解释:
01 batch:
rdd的分区数:3
topic partition fromOffset untilOffset
spark-kafka01 0 0 1
spark-kafka01 1 0 1
spark-kafka01 2 0 0

02 batch:
rdd的分区数:3
topic partition fromOffset untilOffset
spark-kafka01 0 1 1
spark-kafka01 1 1 1
spark-kafka01 2 0 0

此时 kafka 里面数据已经消费完了 fromOffset=untilOffset
3.提交offset信息
2.存储offset信息
spark流式处理 默认消费语义 : 至少一次
精准一次:
1.output + offset
1.Checkpoints =》 不能用
2.Kafka itself =》至少一次 =》
推荐使用 =》 简单 高效
90% 都可以解决 但不支持事务

package com.dl2262.sparkstreaming.day02

import java.util.Properties

import com.dl2262.sparkcore.util.ContextUtils
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.kafka010.{CanCommitOffsets, HasOffsetRanges, KafkaUtils, OffsetRange}
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe

object ss03 {
  def main(args: Array[String]): Unit = {
    val ssc: StreamingContext = ContextUtils.getStreamingContext(this.getClass.getSimpleName, 10)
    /**
     * 加载kafka数据
     * ssl权限校验
     * input
     */
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "bigdata12:9092",//kafka地址
      "key.deserializer" -> classOf[StringDeserializer],//反序列化
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "dl2262",//指定一个消费者组id
      "auto.offset.reset" -> "earliest",//从哪个地方开始消费数据 偏移量
      "enable.auto.commit" -> (false: java.lang.Boolean)//offset提交 选择不自动提交 手动管理
    )
    val topics = Array("dl2262")
    val stream = KafkaUtils.createDirectStream[String, String](
      ssc,
      PreferConsistent,//【面试】数据的存储策略:kafka数据均匀分布在各个executor上
      Subscribe[String, String](topics, kafkaParams)//固定写法
    )

    stream.map(record => record.value()).print()

    /**
     * output
     * 0.get offset
     * 1.todo
     * 2.output
     * 3.提交offset
     */
    stream.foreachRDD(rdd => {
      //rdd分区数和kafka分区数是不是一一对应的
      println(s"rdd分区数:${rdd.partitions.size}")
      //获取kafka数据的offset信息 =》 当前批次
      val offsetRanges: Array[OffsetRange] = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      println("topic  partition  fromoffset  untiloffset")
      offsetRanges.foreach(offset => {
        println(offset.topic+"\t"+offset.partition+"\t"+offset.fromOffset+"\t"+offset.untilOffset)
      })

      /**
       * spark代码
       */
      val spark: SparkSession = SparkSession.builder.config(rdd.sparkContext.getConf).getOrCreate()
      import spark.implicits._
      val wcRDD: RDD[(String, Int)] = rdd.map(_.value()).flatMap(_.split(","))
        .map((_, 1))
        .reduceByKey(_ + _)
      val wcDF: DataFrame = wcRDD.toDF("word", "cnt")
      wcDF.show()
      wcDF.printSchema()

      //sink mysql
      val url = "jdbc:mysql://bigdata12:3306/bigdata"
      val table = "wc"
      val properties: Properties = new Properties()
      properties.setProperty("user","root")
      properties.setProperty("password","123456")
      wcDF.write.mode(SaveMode.Append).jdbc(url,table,properties)

      //提交offset
      stream.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges)
    })
    ssc.start()
    ssc.awaitTermination()
  }
}
		 10% 精准一次
	3.Your own data store: =》 开发大量代码 =》 
		mysql、redis、hbase都支持事务
		至少一次
		精准一次

用mysql存储:
获取offset
todo
output
提交offset
spark作业挂了 =》 启动spark作业 :
1.从mysql里面获取offset
todo
output
提交offset
kafka消费语义:
1.至多一次 【丢数据】
2.至少一次 【不会丢数据 可能会重复消费数据】
3.精准一次 【不丢、不重复消费】
offset信息提交 :
1.spark todo :
至少一次:
1 2 3 4
offset get
业务逻辑 output db
提交offset
在提交offset时挂掉,下次再获取offset时,会再次获取上次的offset,再次输出到数据库从而导致数据重复
精准一次:output + 提交offset 一起发生 =》 事务来实现
事务: 一次操作要么都成功 要么都失败 ,失败时会发生回滚操作
存储offset:
kafka 本身:
offset 信息存储在哪?
kafka 某个topic下:
__consumer_offsets =》 spark作业 消费kafka topic offset 信息存储的地方

你可能感兴趣的:(spark)