Spark学习笔记

Data

Source->Kafka->Spark Streaming->Parquet->Spark SQL(SparkSQL可以结合ML、GraphX等)->Parquet->其它各种Data Mining等

1.1 Spark集群的安装

Spark的运行是构建在hadoop集群之上（默认hadoop集群已经安装好了），在spark集群集群上必须要安装对应版本的scala

1.1.1 scala安装

Ø下载scala版本，解压scala

Ø配置环境变量/etc/profile,添加SCALA_HOME、修改PATH，添加上scala的path路径

Ø进入$SCALA_HOME/bin目录，执行./scala验证scala是否安装成功

Ø集群机器都需要安装scala

1.1.2 spark安装

在集群的所有机器上都必须要安装spark，首先安装master的spark程序

Ø先解压spark程序

Ø修改环境变量/etc/profile添加SPARK_HOME和修改spark PATH路径

Ø配置spark，进入conf目录下

nmv spark-env.sh.template spark-env.sh

其中：spark_master_ip：用于指定master

nvi slaves修改文件，把work节点都添加进去;

Ø至此，spark集群安装完毕

1.1.3启动集群校验

Ø先启动hadoop集群，jps查看进程

Ø再启动spark集群，在sbin目录下执行./start-all.shjps查看进程

ØUi访问，检查集群情况http://master:8080

Ø进入spark/bin目录下，启动spark-shell脚本

1.2 spark-shell的使用

在master机器上的$SPARK_HOME/bin目录下，运行./spark-shell程序启动shark-shell脚本；通过http://master:4040查看spark-shell运行情况

1.2.1 spark-shell操作hdfs文件实战

Ø将spark目录下的README.md文件上传到hdfs上的/test目录下，通过hdfs ui来进行查看slave:50070/explorer.html#/查看文件是否上传成功

Ø在spark-shell脚本程序下，执行sc（SparkContext实例），启动spark-sehll时，系统自动生成

scala> sc

res0: org.apache.spark.SparkContext = org.apache.spark.SparkContext@65859b44

# SparkContext是把代码提交到集群或者本地的通道，编写Spark代码，无论是要运行本地还是集群都必须要有SparkContext实例

ØSpark-shell读取hdfs文件的README.md文件

val file = sc.textFile(“hdfs://mapeng:8020/test/README.md”)

#这里把读取到的文本内容赋值给了变量file,（就是一个MappedRDD，在spark的代码中，一切都是基于RDD进行操作的）

Ø读取文本中包含有“spark”的行

scala> val sparks = file.filter(line

=> line.contains(“spark”))

sparks: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[3] at

filter at :26

#此时生成了一个FilterRDD

Ø统计spark一共出现多少次

Sparks.count

1.2.2 spark-shell操作及详细说明

1.2.2.1并行化集合（parallelize）

Ø加载集合数据

val data = sc.parallelize(1 to 10)#加载集合数据

或者; val data = sc.parallelize(List(1,2,3,4…))

Ø对集合数据进行*2操作

val data1 = data.map(_*2)

Ø对数据进行过滤：过滤出是2的倍数的集合

val data2 = data.filter(_%2==0)

Ø内存缓存数据

data.cache

Ø触发action，以数据的形式返回结果集

data.collect

Ø返回结果集的第一个元素

data.first

Ø返回结果集的前3个元素

data.take(3)

Ø统计元素的个数

data.count

Ø查看RDD的转换过程

data.toDebugString

1.2.2.2 map数据集合

Ø加载List(Map)数据

val

data=sc.parallelize(List((“A”,1),(“B”,2),(“C”,3),(“A”,4),(“B”,5)))

Ø排序sortByKey()

scala> data.sortByKey().collect

res55: Array[(String, Int)] = Array((A,1), (A,4), (B,2), (B,5),

(C,3))

Ø分组groupByKey()

scala>

data.groupByKey().collect

res57: Array[(String, Iterable[Int])] = Array((B,CompactBuffer(2,  5)), (A,CompactBuffer(1, 4)), (C,CompactBuffer(3)))

Ø求和reduceByKey(_+_)

scala>

data.reduceByKey(_+_).collect

res59: Array[(String, Int)] = Array((B,7), (A,5), (C,3))

Ø去重distinct

scala> data.distinct.collect

res60: Array[(String, Int)] = Array((A,1), (A,4), (B,5), (C,3),

(B,2))

Ø联合union

scala> val

data1=sc.parallelize(List((“A”,1),(“B”,2),(“C”,3),(“A”,4),(“B”,5)))

data1:

org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at

parallelize at :24

scala> val data2=sc.parallelize(List((“A”,4),(“A”,4),(“C”,3),(“A”,4),(“B”,5)))

data2:

org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[1] at

parallelize at :24

scala>

data1.union(data2).collect

res1: Array[(String, Int)] = Array((A,1), (B,2), (C,3), (A,4),

(B,5), (A,4), (A,4), (C,3), (A,4), (B,5))

Ø关联join

相当于笛卡尔积

1.2.2.3保存转换结果saveAsTextFile

data.saveAsTextFile(“path”);//将转换结果存储在hdfs指定的路径

1.2.3 spark cache缓存

对于spark程序，第二次执行要比前面的执行的效率要高

1.3 RDD(弹性分布式数据集)

1.3.1 RDD介绍

ØRDD是一个容错的、并行的数据结构，可以让用户显示的将数据存储在磁盘和内存中，并能控制数据的分区。

ØRDD提供了一套丰富的函数来操作数据

ØRDD作为数据机构，本质上是一个只读的分区记录集合；一个RDD可以包含多个分区，每个分区就是一个dataSet片段；RDD可以相互依赖

n窄依赖：RDD的每个分区最多只能被一个child

RDD的分区使用（例如：map操作）

n宽依赖：RDD的分区可以被多个child

RDD的分区使用（例如：join操作）

区别：

（1）窄依赖可以在集群中的一个节点上如流水般的执行，相反，宽依赖需要所有的父分区的数据都可用

（2）从出现失败恢复的角度来考虑：窄依赖只需要重新计算失败的父RDD的分区，而宽依赖失败会导致其父RDD的多个分区重新计算

1.3.2 RDD分区

1.3.3创建操作

1.3.3.1集合创建操作

Spark提供了两类函数实现从集合生成RDD；

Øparallelize

val rdd = sc.parallelize(1 to 100)

ØmakeRDD:还提供了指定分区参数

val rdd = sc.makeRDD(1 to 100,3)#指定了分区数为3

1.3.3.2存储创建操作

操作hdfs

val rdd = sc.textFile(“hdfs://master:9000/test/xxx.txt”)

1.3.4 RDD的基本转换操作

1.3.4.1 RDD的重新分区

repartition和coalesce是对RDD的分区进行重新划分

Ørepartition(numPartitions:Int):RDD[T]

Øcoalesce(numPartitions:Int,shuffle:Boolean=false):RDD[T]

repartition只是coalesce接口中shuffle为true的简易实现。

重新划分分区主要有三种情况：（原RDD有N个分区，需要重新划分为M个分区）

ØN

ØN>M(相差不大)：面临着要把原分区进行合并的操作，最终合成M个分区，这时将shuffle设置为false

注：在shuffle为false时，设置M>N，coalesce是不起作用的

ØN>>M（差距悬殊）：如果将shuffle设置为false，由于父子RDD是窄依赖，会使得它们同处于一个stage中，可能会造成spark程序运行的并行度不够，从而影响效率。

因而，最好设置为true，使得coalesce之前的操作有更好的并行度

1.3.4.2 RDD转换为数组（randomSplit、glom）

ØrandomSplit(weight:Array[Double],seed:Long=System.nanoTime):Array[RDD[T]]

randomSplit函数是将一个RDD切分为多个RDD，返回结果是一个RDD数组;函数的第一个方法传入的参数权重是一个Double类型的数组；权重大的，分到的数据的概率大

val rdd = sc.makeRDD(1 to 10)

val splitRDD = rdd.randomSplit(Array(1.0,3.0,6.0))

#返回的一个RDD数组，查看数组元素

splitRDD(0).collect

splitRDD(1).collect

splitRDD(2).collect

Øglom():RDD[Array[T]]

glom函数是将RDD中每一个分区中类型为T的元素转换为Array[T]

val rdd = sc.makeRDD(1 to 10,3)

val glomRDD= rdd.glom

#返回的结果是一个数组，

glomRDD.collect

scala> glomRDD.collect

res44: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7,

8, 9, 10))

1.3.4.3 RDD的集合操作

Øunion(other:RDD[T]) :RDD[T]

将两个RDD的数据进行合并，返回两个RDD的并集，不去重

Øintersection(other:RDD[T]) :RDD[T]

返回两个RDD的交集（会去重）

Øsubtract(other:RDD[T]) :RDD[T]

取差集

Øzip(other:RDD[T]):RDD[T]

zip函数用于将两个RDD组合成key/value形式的RDD，两个RDD的partition个数以及元素的数量都必须要相同，不然会抛出异常

val rdd1 = sc.makeRDD(List(1,2,3,3))

val rdd2 = sc.makeRDD(List(2,3,4))

union操作

rdd1.union(rdd2).collect

#结果

Array[Int] = Array(1, 2, 3, 3, 2, 3, 4)

intersection操作

rdd1.intersection(rdd2).collect

#结果（去重）

Array[Int] = Array(3, 2)

subtract操作

rdd1.subtract(rdd2).collect

#结果（不去重）

Array[Int] = Array(1, 1)

zip操作

scala> val rdd1 = sc.makeRDD(1

to 3)

scala> val rdd2 =

sc.makeRDD(List(1.0,2.0,3.0))

scala> rdd1.zip(rdd2).collect

res8: Array[(Int, Double)] = Array((1,1.0), (2,2.0), (3,3.0))

1.3.4.4键值RDD转换操作

map和flatmap的区别：

（1）map是对每个元素都进行指定的操作，返回每个元素处理后的对象

（2）flatmap对所有的元素都做指定的操作，将所有的对象合并为一个对象返回

val rdd = sc.makeRDD(1 to 3)

rdd.map(x=>Seq(x,x)).collect

#结果

Array[Seq[Int]] = Array(List(1, 1),

List(2, 2), List(3, 3), List(4, 4))

rdd.flatMap(x=>Seq(x,x)).collect

#结果，合并为一个对象返回

Array[Int] = Array(1, 1, 2, 2, 3, 3, 4,  4)

未完待续…..

1.3.5 RDD的行动操作

每调用一次行动操作，都会触发一次spark的调度并返回响应的结果

1.3.5.1集合标量行动操作

Øcount

返回RDD中的元素的个数

Øfirst

返回RDD中的第一个元素

Øreduce(f:(T,T) = >T)

对RDD中的元素进行二元计算，返回计算结果

val rdd = sc.makeRDD(1 to 4)

rdd.reduce(_+_)#10

rdd.reduce(_-_)#-8

Øcollect()

以集合的形式返回RDD的元素

Øtake(number:Int)

返回集合中[0,num-1]下标的元素

Øtop(num:Int)

先降序排序，返回前num个元素

ØtakeOrdered(num:Int)

以与top相反的排序规则（升序），返回前num个元素

Ølookup(key:k):Seq[v]

lookup是针对（k,v）类型RDD的行动操作，针对给定的键值，返回与此键值相对应的所有值

1.3.5.2存储行动操作

RDD不仅可以存储在hdfs中还能存储到Hbase、MangoDB等数据库中

1.4 Spark SQL

1.4.1 spark sql与shark区别

sparksql是一个支持结构化数据处理的spark模块，提供DaraFrame作为可编程的数据抽象，可以对DataFrame执行sql的操作。

spark sql的诞生就是为了解决spark平台上的交互式查询问题，并且提供sql接口兼容原有数据库用户的使用情况

Øshark简单的说，就是spark上的hive，其底层依赖Hive引擎的，但在spark平台上，解析速度是hive的好多倍；就是一个升级版的大数据仓库

Ø在spark1.0版本开始，shark被官方抛弃使用

Øspark sql的优势：

nspark sql完全脱离了hive的限制

nspark sql支持查询原生的RDD，能够高效的处理大数据的各种场景的基础

n能够在scala中写sql语句，支持简单的sql语法检查，将结果取回作为RDD使用

nCatalyst能够帮助用户优化查询，catalyst能够进行一定程度的性能提升

# catalyst是spark sql的调度核心，解析sql形成其对应的执行计划（遵循DAG图）

1.4.2 DataFrame和DataSet

1.4.2.1 RDD与DataFrame的区别

如上图：

Ø左侧的RDD[Person]虽然以Person为类型参数，但是spark框架本省不了解Person类的内部结构；而右侧的DataFrame却提供了详细的结构信息（schema），使得spark sql可以清楚的知道该数据集中包含哪些列，每列的名称和类型

ØRDD是分布式的java对象的集合；而DataFrame是分布式的row对象的集合

ØDataFrame除了提供比RDD更丰富的算子外，更重要的特点是提升执行效率、减少数据读取以及执行计划的优化

1.4.2.2 DataFrame与DataSet的区别

DataSet可以认为是DataFrame的一个特例，主要区别是DataSet的每一个record存储的是一个强类型值而不是一个Row。具有三个特点：

ØDataSet在编译时检查类型

Ø面向对象的编程接口

Ø后面的版本DataFrame是继承DataSet的，DataFrame是面向Spark sql的接口

相互转换：

DataFrame和DataSet可以相互转化，df.as[ElementType]这样可以把DataFrame转化为DataSet，ds.toDF()这样可以把DataSet转化为DataFrame

1.4.2.3 DataFrame

（1）DataFrame是一个分布式的数据集，类似于关系数据库的一个表。

ØDataFrame以列的形式存储，但是不知道列的类型，因此，在编译时不进行校验，只有在运行时才会处理；DataSet不仅知道字段，还知道类型，所以编译时会进行类型校验

Ø可以由结构化的数据转换过来，也可以从hive，外部数据库或者RDD转换

ØDataFrame在spark sql中，可以使用sql的方式进行操作，与RDD类似，也可以采用lazy的方式，只有动作发生时才会真正的计算

ØDataFrame的数据源：支持JSON文件、hive表格，支持本地文件系统以及hdfs等；配合JDBC还支持外部关系型数据库

1.4.2.4与RDD的相互操作

spark sql支持两种不同的方式用于将存在的RDD转换为DataSets、DataFrame

Ø反射推断模式：

该模式使得代码更加的简练，不过在写spark程序的时候已经知道模式信息，（比如RDD中自己定义的case class类型）

练习：从hdfs文件中读取数据，创建一个Person的RDD

1.定义Person type

scala> case class

Person(id:Int,name:String,addr:String)

defined class Person

2.从hdfs读取文件，封装成DataFrame数据集

scala> val personDf = spark.sparkContext

.textFile(“/test/preson.txt”)

.map(_.split(“,”))

.map(p=>Person(p(0).toInt,p(1),p(2)))

.toDF

personDf:

org.apache.spark.sql.DataFrame = [id: int, name: string … 1 more field]

3.将personDf注册为一个视图view

scala>

personDf.createOrReplaceTempView(“person”)

4.通过sql查询视图；sql支持复杂的,包括多表关联

scala> spark.sql(“select

addr,count(1) from person group by addr”).show

Ø编程指定模式：

构造一个模式，将其应用到一个已经存在的RDD上将其转化为DataFrame，该方法适用于运行之前不知道列以及列的类型的情况

import org.apache.spark.sql.types._

1.加载数据

val presonRDD= spark.sparkContext.textFile(“/test/person.txt”)

2.定义schema

val stringSchema = “id,name,addr”

val schema = StructType(stringSchma.split(“,”).map(field=>StructField(field,StringType,nullable=true)))

3.转换rdd的记录到rows集合

1.4.3 spark sql的操作

1.4.3.1创建SparkSession实例

SparkSeesion类时Spark SQL的所有功能的入口；spark-shell启动时，默认生成了一个SparkSession的实例：spark

importorg.apache.spark.sql.SparkSession

val spark = SparkSession.builder

.master(“local”)

.config(“spark.sql.warehouse.dir”, “/user/hive/warehouse”)

.appName(“spark text”)

.getOrCreate

//包含隐式转换（比如讲RDDs转成DataFrames）API

importspark.implicits._

1.4.3.2创建DataFrame

spark sql读取hdfs中json数据

val df = spark.read.json(“/test/course.json”)

#显示df的数据

Ø显示df的数据

df.show

#结果：

Ø查询df的结构信息

Ø显示指定的字段值：使用select(col1,,col2)

Ø过滤，查询长度》12的数据

Ø分组操作groupBy

1.4.3.3 spark sql实战

1.4.3.3.1入口：SQLContext,HiveContext（Starting Point: SQLContext）

spark sql中所有的操作入口点都是SQLContext类或者它的子类.创建一个基本的SQLContext，只需要SparkContext即可（sc）

注：spark2.0之后，sparkSession是实现了同样的功能，不需要显示的创建SparkConf、sparkContext、SQLContext,因为这些对象都封装在了SparkSession中。即是

val sqlContext = new org.apache.spark.sql.SQLContext(sc)

valhiveContext =neworg.apache.spark.sql.hive.HiveContext(sc)

除了SparkContext外，还有HiveContext。两者的区别：

ØSQLContext只支持标准的sql语法解析器

ØHiveContext现在支持sql语法解析器和HiveSql语法解析器；默认为hivesql语法解析器，用户可以通过配置来切换sql语法解析器，来运行hivesql不支持的语法

Ø使用HiveContext可以使用Hive的UDF，读写Hive表数据等hive操作。sqlContext不可以对hive进行操作

Ø趋势：SqlContext不断丰富中，最终两者会形成一个统一的Context

1.4.3.3.2创建DataFrame

使用SqlContext，spark程序可以通过RDD、hive表、JSON格式数据等数据源创建DataFrame

val df = sqlContext.read.json(“/test/readme.json”)

1.4.3.3.3 DataFrame操作

df.show

df.printSchema

df.

1.4.3.3.4 Parquet文件

Parquet文件是一种列式存储格式的文件，能被很多数据处理系统支持。Spark SQL支持读取和写入Parquet文件，并可自动保留原始数据的格式（schema）

优势：

可以跳过不符合条件的数据，只读取需要的数据，降低IO数据量

压缩编码可以降低磁盘存储空间。由于同一列的数据类型是一样的，可以使用更高效的压缩编码进一步节省存储空间

只读取需要的列，支持向量运算，能够获取更好的扫描性能

还有，parquet数据源支持自动发现和推断分区信息

1.4.3.3.5 DataFrame的java操作

将DataFrame的结果转换为java的list

List listRow =result.javaRDD().collect();

for(Row row : listRow){

System.out.println(row);

}

1.4.3.4 SparkSession操作

在2.0版本之前，与spark交互之前必须创建SparkConf和SparkContext；然而到了2.0版本，不需要显示的创建这些对象SparkConf、SparkContext和SqlContext了，这些对象都已经封装在了SparkSession中了，即，2.0版本之后，入口就是就变成了SparkSession，在spark-shell启动时，会实例化一个SparkSession实例spark

ØSparkSession封装的对象

Ø获取conf默认配置，可以调整配置spark的运行参数

1.4.3.4.0 SparkSession的创建

sparkSession类是所有Spark SQL功能的入口，只需要调用SparkSession.builder()即可创建

importorg.apache.spark.sql.SparkSession

val spark = SparkSession.builder

.master(“local”)

.config(“spark.sql.warehouse.dir”, “/user/hive/warehouse”)

.appName(“spark Streaming +kafka”)

.enableHiveSupport

.getOrCreate

1.4.3.4.1获取catalog元数据

1.4.3.4.2创建Dataset和Dataframe

最简单的办法就是通过range方法，创建DataSet

注，range也可以有3个参数，第三个参数是间隔，默认的创建的字段：id

Øtop(n)操作

Ø对某一列进行统计操作

Ø通过createDataFrame创建

重新命名列名withColumnRenamed

1.4.3.4.3读取json文件

1.4.3.4.4在SparkSession中使用Spark SQL

1.4.3.4.5数据源

spark支持多种数据源的数据，

Ø最简单的加载方式是load，默认的格式为parquet文件，（可以通过spark.sql.sources.default来默认指定格式）

val df = spark.read.load(“…”)

Ø将DataFrame数据存储为parquet

df.select(“name”,”type”).write.save(“course.parquet”)

存储的路径为（hdfs）：path hdfs://192.168.21.144:9000/user/root/course.parquet

也可以手动指定格式，以及指定要保存的文件的格式

scala> val df =

spark.read.format(“json”).load(“/test/course.json”)

df: org.apache.spark.sql.DataFrame = [length: bigint, name: string

… 1 more field]

#指定要保存的文件的格式

scala>

df.write.format(“parquet”).save(“course1.parquet”)

1.4.3.4.6保存数据到永久表saveAsTable

DataFrame可以通过调用saveAsTable方法将数据落地到hive表中，不过对已经部署的hive不会受影响，spark会创建本地的metastore（使用derby），saveAsTable会持久化数据并指向hive metastore

saveAsTable默认会创建一个“受管理表”，意味着数据的位置都是受metastore管理的。当“受管理表”被删除，其对应的数据也都会被删除。

注：文件内容保存在${SPARK_HOME}/bin/spark-warehouse/tableName

scala> df.write.saveAsTable(“course”)

#调用，spark.sql(sql_str)比较灵活

1.4.3.4.7 spark整合hive

如果spark没有整合hive，那么spark的元数据都是在bin目录下，自动创建metastore_db（以derby做支撑）

整合hive后，支持spark从hive取数，永久保存数据到hive中；并支持hive的mysql作为元数据存储数据库

Ø将hive配置文件中hive-site.xml文件复制到${spark_home}/conf

Ø将hadoop配置文件中hdfs-site.xml和core-site.xml文件复制到${spark_home}/conf

Ø将hive下元数据库mysql的驱动，复制到${spark_home}/jars下

可以将DataFrame数据永久保存到hive表中

1.5 Spark Streaming

spark2.0将流数据计算统一到了DataSet中，提出了Structured

Streaming的概念，将数据源映射为一张无限长度的表，同时将流计算的结果映射为另一张表，完全以结构化的方式去操作流数据，复用了其对象的Catalyst引擎

1.5.1 spark Streaming实战

创建Steaming DataFrame，用来监听host:9999获取socket数据，并对获取的数据进行RDD转换操作，最后统计各个词出现的次数

Ø创建socket通道

nc –lk 9999

Ø获取socket通道数据(需要填写socket的host、port)

scala>val line

=

spark.readStream.format(“socket”).option(“host”,”mapeng”).option(“port”,9999).load

Ø转换操作

scala> val wordCount = line.as[String].flatMap(_.split(“

“)).groupBy(“value”).count

wordCount: org.apache.spark.sql.DataFrame

= [value: string, count: bigint]

Ø使用start()来启动流式数据计算流程

scala> val query =

wordCount.writeStream.outputMode(“complete”).format(“console”).start

程序自动启动了job计算，并在控制台展现计算结果；（接收到socket流数据，spark自动计算，控制台展现结果）

说明：

（1）outputMode现在有三种方式：complete ,append,update（目前只实现了前两种）

lcomplete：每次计算完成后，都能得到全量的计算结果（每次计算都得到转换后的最新结果集）

lappend：每次计算完成后，能拿到增量的计算结果

两种方式的使用说明：

使用了聚合类函数才能使用complete的模式，只有简单的使用了map,filter等转换模式才能使用append模式，不做复杂的聚合统计运算

1.6 Spark Streaming + kafka整合

1.6.1 pom.xml文件，添加spark依赖

org.apache.hadoop

hadoop-client

2.6.0

org.apache.hadoop

hadoop-common

2.6.0

org.apache.hadoop

hadoop-hdfs

2.6.0

org.apache.spark

spark-core_2.11

2.0.0

org.apache.spark

spark-sql_2.11

2.0.0

org.apache.spark

spark-streaming_2.11

2.0.0

org.apache.spark

spark-hive_2.11

2.0.0

org.apache.spark

spark-streaming-kafka-0-10_2.11

2.0.0

org.apache.hive

hive-jdbc

1.2.1

io.netty

netty-all

4.0.29.Final

1.6.2实战代码

packagecom.mp.fight

importorg.apache.spark.sql.SparkSession

importorg.apache.spark.streaming.StreamingContext

importorg.apache.spark.streaming.Seconds

importorg.apache.spark.streaming._

importorg.apache.spark.streaming.kafka010.KafkaUtils

importorg.apache.spark.streaming.kafka010.LocationStrategies

importorg.apache.kafka.common.serialization.StringDeserializer

importorg.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe

importorg.apache.spark.sql.SQLContext

importorg.apache.spark.sql.SaveMode

objectTest4{

caseclassPerson(id:Int,name:String,addr:String)

defmain(args: Array[String]): Unit = {

//声明sparkSession

valspark=SparkSession.builder

.master(“local”)

.appName(“spark  Streaming kafkasql”)

.config(“spark.sql.warehouse.dir”,”/user/hive/warehouse”)

.getOrCreate

//kafka设置

valkafkaParams=Map[String, Object](

“bootstrap.servers”->”mapeng:9092″,

“key.deserializer”->classOf[StringDeserializer],

“value.deserializer”->classOf[StringDeserializer],

“group.id”->”example”,

“auto.offset.reset”->”latest”,

“enable.auto.commit”->(false: java.lang.Boolean)

)

//topic

valtopics=List(“testmp”)

//初始化StreamingContext

valssc=newStreamingContext(spark.sparkContext,Seconds(30));

//从kafka中读取数据

valkafkaStream=KafkaUtils.createDirectStream[String,String](

ssc,

LocationStrategies.PreferConsistent,

Subscribe[String,String](topics,kafkaParams)

).map(_.value())

//kafkaStream.print

importspark.sqlContext.implicits._

//启用sparkSql来操作DStream转换为DataFrame

kafkaStream.foreachRDD{rdd=>{

if(rdd.isEmpty) {

println(“rdd is

empty”)

}else{

valperson=rdd.map(_.split(“,”)).map(p=>Person(p(0).toInt,p(1),p(2))).toDF

//新接收的数据，追加存储在parquet文件中（重写文件）

person.write.mode(SaveMode.Append).save(“hdfs://mapeng:9000/test/person.parquet”)

//实时统计区域人数

valdf=spark.read.load(“hdfs://mapeng:9000/test/person.parquet”)

df.createOrReplaceTempView(“person”)

valaddrCount=spark.sql(“select

addr,count(1) as num from person group by addr”)

//将统计结果实时回写到parquet文件中

addrCount.write.mode(SaveMode.Overwrite).save(“hdfs://mapeng:9000/test/addrCount.parquet”)

//继续做多维度统计，可以使用sparksql操作处理parquet文件

}

}

}

//启动job

ssc.start

ssc.awaitTermination

}

}

1.6.3 DStream中foreachRDD、foreachePartition、foreach的区别

ØforeachRDD：得到的是处理一个批次的数据

ØforeachPartition：对一个批次的每个分区数据做处理

Øforeach：每条数据处理，单个元素处理

1.6.4 spark Streaming + socket

val ssc = new StreamingContext(sparkConf,

Seconds(1))

//获得一个DStream负责连接监听端口:地址

val lines = ssc.socketTextStream(“192.168.21.144”, 9999)

//对每一行数据执行Split操作

val words = lines.flatMap(_.split(” “))

//统计word的数量

val pairs = words.map(word => (word, 1))

val wordCounts = pairs.reduceByKey(_ + _)

//输出结果

wordCounts.print

ssc.start//开始

ssc.awaitTermination//计算完毕退出

1.8 parquet文件

1.8.1 parquet是面向分析型业务的列式存储格式，有如下优势

Parquet文件尾部存储了文件的元数据信息和统计信息，自描述的，方便解析

1.只读取需要的列，支持向量运算，能够获得更好的扫描性能

2.可以跳过不符合条件的数据，只读取需要的数据，降低io

3.同一列的数据类型是一样的，可以使用更高效的压缩编码，节约存储磁盘

1.8.2 parquet适配多种计算框架

Parquet是语言无关的，而且不与任何一种数据处理框架绑定在一起，适配多种语言和组件，能够与Parquet配合的组件有：

查询引擎: Hive, Impala, Pig, Presto, Drill, Tajo, HAWQ, IBM

Big SQL

计算框架: MapReduce, Spark, Cascading, Crunch, Scalding, Kite

数据模型: Avro, Thrift, Protocol Buffers, POJOs

1.8.3 parquet数据模型

eg:

message AddressBook {

required string owner;

repeated stringownerPhoneNumbers;

repeated group contacts {

required string name;

optional string phoneNumber;

}

}

说明：

schema的格式是这样的：

（1）根叫做message

（2）message包括有多个fields，每个fields包括有三个属性：repetition，type，name

其中，repetition有3中类型：required（出现一次）、optional（出现0次或者1次）、repeated（出现0次或者多次）

（3）type可以是一个group或者一个简单的类型

以上schema描述说明：

（1）每条记录标识一个AddressBook

（2）有且只有一个owner

（3）有0个或多个ownerPhoneNumbers

（4）owner可以有0个或者多个contacts。每个contact有且只有一个name，这个contact的phoneNumber可有可无（0个或者1个）

注：parquet格式的数据类型没有复杂的Map，List，Set等，使用group和repeated fields来表示；

null值不会被存储

实例：

1.8.4 parquet格式文件的存储

在parquet格式的存储中，一个schema的树结构有几个叶子节点，实际存储汇总就有几个column，例如上图中的schema实际存储就4个列

1.8.5 DataFrame与Parquet

（1）保存DF为Parquet格式

dfPerson.write.parquet(“person.parquet”)

(2)hive中建立parquet格式的表

createtableperson_parquetlikepersonstoredasparquet;

insertoverwritetableperson_parquetselect*fromperson;

（3）加载Parquet文件不再需要case class。

valpersonDF =spark.read.parquet(“person.parquet”)

personDF.registerAsTempTable(“pp”)

valmales = spark.sql(“select * from pp where gender=’M'”)

males.show

1.8.5 parquet文件的持久化

1.8.5.1 spark中将DataFrame数据写到hdfs中的parquet文件中，支持追加

personDf.write.mode(SaveMode.Append).save(“hdfs://mapeng:9000/test/person.parquet”)

saveMode有如下几种方式：

1.8.5.2 parquet文件合并

合并的规则：相同的列，在新的数据集中，是通用的列，

各自不同的列，也作为新的数据集的列。

实战：

1.9 spark项目实战