Spark Core

Spark Core

一、Spark RDD

RDD概述

1.RDD基础
2.RDD源代码描述
3.RDD特性
4.Spark宽窄依赖

RDD创建

在驱动器中创建RDD

1.parallelize

读取外部数据集创建RDD

2.textFile


RDD操作

缓存rdd到内存

1.RDD转化操作
2.常见的转化操作
3.RDD行动操作
4.常见的行动操作

Spark传递函数

RDD惰性求值与持久化(缓存)

1.惰性求值
2.缓存方法
scala 复制代码
cache()
persist()

移除缓存

scala 复制代码
unpersist()
3.持节化级别

RDD练习

Test-01
scala 复制代码
scala>val rdd1=sc.parallelize(List(5,6,4,2,9,7,8,1,10))

scala>val rdd2=rdd1.map(x=>x*2)

scala>val sort=rdd2.sortBy(x=>x,true)

scala>val rdd3=sort.filter(_>=10)

scala>rdd3.collect()
Test-02
scala 复制代码
scala>val rdd1=sc.parallelize(Array("a b c","d e f","h i j"))

scala>val rdd2=rdd1.flatMap(_.split(" "))

scala>rdd2.collect()
Test-03

RDD并集、交集和去重操作

scala 复制代码
scala>val rdd1=sc.parallelize(List(1,2,3,4))

scala>val rdd2=sc.parallelize(List(5,6,4,3))

scala>val rdd3=rdd1.union(rdd2)

scala>rdd3.collect()

scala>val rdd4=rdd1.intersection(rdd2)

scala>rdd4.collect()

scala>rdd3.distinct.collect
Test-04

RDD求并集并按照Key进行分组

scala 复制代码
scala>val rdd1=sc.parallelize(List(("tom",1),("jerry",3),("kitty",2)))

scala>val rdd2=sc.parallelize(List(("jerry",2),("tom",1),("shuke",2)))

scala>val rdd3=rdd1.join(rdd2)

scala>rdd3.collect()

scala>val rdd4=rdd1.union(rdd2)

scala>rdd4.groupByKey.collect
Test-05

RDD聚合

scala 复制代码
scala>val rdd1=sc.parallelize(List(1,2,3,4,5))

scala>val rdd2=rdd1.reduce(_+_)

scala>rdd2
Test-06

RDD按照Key进行聚合,按照value进行排序

复制代码
("tom",1)把值1作为key

(t=>(t._2,t._1)) ====(1,"tom")

最后再反转输出
scala 复制代码
scala>val rdd1=sc.parallelize(List(("tom",1),("kitty",2),("shuke",1)))

scala>val rdd2=sc.parallelize(List(("jerry",2),("tom",3),("shuke",2),("kitty",5)))

scala>val rdd3=rdd1.union(rdd2)

scala>val rdd4=rdd3.reduceByKey(_+_)

scala>rdd4.collect()

scala>val rdd5=rdd4.map(t=>(t._2,t._1)).sortByKey(false).map(t=>(t._2,t._1))

scala>rdd5.collect()

二、Spark RDD键值对操作

Pair RDD(键值对)

1.概念
2.创建方式
markdown 复制代码
A.直接在程序中创建
B.将普通的RDD转化为Pair RDD
	(K,V)=>Pair RDD
C.数据格式存储为键值对格式的读取(json)
3.创建Pair RDD-三种语言
复制代码
file.txt

Hadoop HDFS MapReduce
Spark Core SQL Streaming

在Scala中使用第一个单词为键创建一个Pair RDD

scala 复制代码
package com.saddam.spark.SparkCore

import org.apache.spark.{SparkConf, SparkContext}

object PairRDD {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf()
      .setMaster("local[2]")
      .setAppName("pair rdd")

    val sc=new SparkContext(conf)

    val lines = sc.textFile("D:\\Spark\\DataSets\\file.txt")

    val pairs=lines.map(x=>(x.split(" ")(0),x))
   
    pairs.foreach(p=>{println(p._1+":"+p._2)})
    /*
    Hadoop:Hadoop HDFS MapReduce
    Spark:Spark Core SQL Streaming
     */
	sc.stop()
  }
}

在Java中使用第一个单词为键创建一个Pair RDD

在Python中使用第一个单词为键创建一个Pair RDD

4.Pair RDD转化操作
元素过滤

对第二个元素进行筛选

markdown 复制代码
a.读取文件生成rdd
b.将rdd转化为pair rdd
c.使用filter进行过滤
聚合操作
scala 复制代码
package com.saddam.spark.SparkCore

import org.apache.spark.{SparkConf, SparkContext}

object PairRDD_聚合操作 {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf()
      .setMaster("local[2]")
      .setAppName("pair rdd")

    val sc=new SparkContext(conf)

    val rdd=sc.parallelize(List(("panda",0),("pink",3),("pirate",3),("panda",1),("pink",4)))

    val rdd1=rdd.mapValues(x=>(x,1)).reduceByKey((x,y)=>(x._1+y._1,x._2+y._2))

    rdd1.foreach(x=>{println(x._1+":"+x._2._1/x._2._2)})

  }

}

panda:0
pirate:3
pink:3
数据分组
scala 复制代码
package com.saddam.spark.SparkCore

import org.apache.spark.{SparkConf, SparkContext}

object PairRDD_数据分组 {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf()
      .setMaster("local[2]")
      .setAppName("pair rdd")

    val sc=new SparkContext(conf)

    val rdd=sc.parallelize(List(("panda",0),("pink",3),("pirate",3),("panda",1),("pink",4)))

    val rdd1=rdd.groupByKey()

    //持久化
    val rdd2 = rdd1.persist()

//    println(rdd2.first()._1+":"+rdd2.first()._2)

    rdd2.foreach(x=>{println(x._1+":"+x._2)})
  }

}

pirate:CompactBuffer(3)
panda:CompactBuffer(0, 1)
pink:CompactBuffer(3, 4)
连接操作
scala 复制代码
package com.saddam.spark.SparkCore

import org.apache.spark.{SparkConf, SparkContext}

object PairRDD_连接操作 {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf()
      .setMaster("local[2]")
      .setAppName("pair rdd")

    val sc=new SparkContext(conf)

    val rdd1=sc.parallelize(List(("frank",30),("bob",9),("silly",3)))

    val rdd2=sc.parallelize(List(("frank",88),("bob",12),("marry",22),("frank",21),("bob",22)))

    //内连接
    val rdd3=rdd1.join(rdd2)
    rdd3.foreach(x=>{println(x._1+":"+x._2)})
    /*
frank:(30,88)
bob:(9,12)
frank:(30,21)
bob:(9,22)
     */

    //左外连接
    val rdd4=rdd1.leftOuterJoin(rdd2)
    rdd4.foreach(x=>{println(x._1+":"+x._2)})
    /*
silly:(3,None)
frank:(30,Some(88))
frank:(30,Some(21))
bob:(9,Some(12))
bob:(9,Some(22))
     */

    //右外连接
    val rdd5=rdd1.rightOuterJoin(rdd2)
    rdd5.foreach(x=>{println(x._1+":"+x._2)})
    /*
frank:(Some(30),88)
frank:(Some(30),21)
marry:(None,22)
bob:(Some(9),12)
bob:(Some(9),22)
     */

    //全连接
    val rdd6=rdd1.fullOuterJoin(rdd2)
    rdd6.foreach(x=>{println(x._1+":"+x._2)})
    /*
frank:(Some(30),Some(88))
frank:(Some(30),Some(21))
silly:(Some(3),None)
marry:(None,Some(22))
bob:(Some(9),Some(12))
bob:(Some(9),Some(22))
     */
  }
}
数据排序
scala 复制代码
package com.saddam.spark.SparkCore

import org.apache.spark.{SparkConf, SparkContext}

object PairRDD_数据排序 {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf()
      .setMaster("local[2]")
      .setAppName("pair rdd")

    val sc=new SparkContext(conf)

    var rdd=sc.parallelize(List(("frank",30),("bob",9),("silly",3)))

    //排序
    //按照字典序
    val rdd2=rdd.sortByKey()

    rdd2.collect().foreach(println)
    /*
(bob,9)
(frank,30)
(silly,3)
     */

    //按照值排序
    val rdd3=rdd.map(x=>(x._2,x._1)).sortByKey().map(x=>(x._2,x._1)) //sortByKey(false)-降序
    rdd3.collect().foreach(println)
/*
(silly,3)
(bob,9)
(frank,30)
 */
  }
}
5.Pair RDD行动操作
6.数据分区
数据分区原因
数据分区操作
示例:PageRank算法

计算网页价值

scala 复制代码
package com.saddam.spark.SparkCore

import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}

object PageRank {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf()
      .setMaster("local[2]")
      .setAppName("pair rdd")

    val sc=new SparkContext(conf)

    val links=sc.parallelize(List(("A",List("B","C")),("B",List("A","C")),("C",List("A","B","D")),("D",List("C"))))
      .partitionBy(new HashPartitioner(10)).persist()

    var ranks = links.mapValues(v => 1.0)

    for (i<-0 until 10){
      val contributions=links.join(ranks).flatMap{
        case (pageId,(links,rank))=>links.map(dest=>(dest,rank/links.size))
      }
      ranks=contributions.reduceByKey((x,y)=>x+y).mapValues(v=>0.15+0.85*v)
    }
    ranks.sortByKey().collect().foreach(println)
    ranks.saveAsTextFile("D:\\Spark\\OutPut\\PageRank")
  }
/*
(A,0.9850243302878132)
(B,0.9850243302878132)
(C,1.4621033282930214)
(D,0.5678480111313515)
 */
}
7.宽窄依赖
概念
窄依赖优点
宽窄依赖的使用

三、Spark数据读取与保存

Spark数据源

概述及分类

文件格式

文件系统

Spark SQL中的结构化数据

Spark访问数据库系统

1.MySQL数据库连接
1.代码实战
scala 复制代码
package com.saddam.spark.SparkCore

import java.sql.{DriverManager, ResultSet}
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.JdbcRDD

/**
  * Spark访问MySQL数据库
  */
object SparkConnectMySQL {
  //第一步:定义函数:创建一个连接连接数据库
  def createConnection()={
    Class.forName("com.mysql.jdbc.Driver").newInstance()
    DriverManager.getConnection("jdbc:mysql://localhost:3306/saddam","root","324419")
  }

  //第二步:定义一个函数:映射
  def extractValues(r:ResultSet)={
    (r.getInt(1),r.getString(2))
  }

  def main(args: Array[String]): Unit = {
    val conf=new SparkConf()
      .setMaster("local[2]")
      .setAppName("pair")

    val sc=new SparkContext(conf)

    //第三步:创建RDD读取数据
    val data=new JdbcRDD(
      sc,createConnection,
      "select * from users where ?<=id and id<=?",
      lowerBound = 1,
      upperBound = 3,
      numPartitions = 2,
      mapRow = extractValues
    )

    data.foreach(println)
    sc.stop()

  }

}

(1,admin)
(1,zhangsan)
(1,lisi)
2.问题发现与解决
java 复制代码
javax.net.ssl.SSLException MESSAGE: 
closing inbound before receiving peer's close_notify
    
解决:useSSL=false
jdbc:mysql://localhost:3306/saddam?useSSL=false
2.Cassandra连接

开源的NoSQL数据库

3.HBase连接

四、Spark编程进阶

复制代码
Spark的高级特性

累加器

广播变量

基于分区的操作

与外部程序间的广播

数值RDD操作

Spark的高级特性

累加器
相关推荐
白雪讲堂22 分钟前
AI搜索品牌曝光资料包(精准适配文心一言/Kimi/DeepSeek等场景)
大数据·人工智能·搜索引擎·ai·文心一言·deepseek
浩浩kids2 小时前
Hadoop•踩过的SHIT
大数据·hadoop·分布式
qr9j422332 小时前
elasticsearch 如果按照日期进行筛选
大数据·elasticsearch·jenkins
DavidSoCool2 小时前
es分页边界数据重复问题处理
大数据·elasticsearch·搜索引擎
路由侠内网穿透2 小时前
本地部署开源流处理框架 Apache Flink 并实现外部访问
大数据·网络协议·tcp/ip·flink·服务发现·apache·consul
松韬2 小时前
Spring + Redisson:从 0 到 1 搭建高可用分布式缓存系统
java·redis·分布式·spring·缓存
mosquito_lover12 小时前
Python数据分析与可视化实战
python·数据挖掘·数据分析
雨会停rain3 小时前
如何提高rabbitmq消费效率
分布式·rabbitmq
qq_5470261794 小时前
Elasticsearch 正排索引
大数据·elasticsearch·jenkins
QQ__17646198244 小时前
Labview信号采集与分析系统(可仿真)
数据分析·数据采集·labview