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的高级特性

累加器
相关推荐
观远数据20 分钟前
A Blueberry 签约观远数据,观远BI以一站式现代化驱动服饰企业新增长
大数据·数据库·人工智能·数据分析
缘华工业智维7 小时前
工业设备预测性维护:能源成本降低的“隐藏钥匙”?
大数据·网络·人工智能
NewsMash7 小时前
马来西亚代表团到访愿景娱乐 共探TikTok直播电商增长新路径
大数据·娱乐
凯禾瑞华养老实训室9 小时前
聚焦生活照护能力培育:老年生活照护实训室建设清单的模块设计与资源整合
大数据·人工智能·科技·ar·vr·智慧养老·智慧健康养老服务与管理
koping_wu10 小时前
【Redis】用Redis实现分布式锁、乐观锁
数据库·redis·分布式
Q264336502311 小时前
【有源码】基于Hadoop生态的大数据共享单车数据分析与可视化平台-基于Python与大数据的共享单车多维度数据分析可视化系统
大数据·hadoop·python·机器学习·数据分析·spark·毕业设计
计算机毕业设计木哥11 小时前
计算机毕设选题推荐:基于Hadoop和Python的游戏销售大数据可视化分析系统
大数据·开发语言·hadoop·python·信息可视化·spark·课程设计
Lansonli11 小时前
大数据Spark(六十八):Transformation转换算子所有Join操作和union
大数据·分布式·spark
NewsMash11 小时前
贺Filcion五周岁:Chain Shop 10月17号正式上线
大数据