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操作