一、概述

1、离线和实时计算

离线:数据量大,数据不会变化,MapReduce

实时:数据量小,计算过程要短

2、批量和流式处理

批量:冷数据,数据量大,速度慢

流:在线、实时产生的数据(快速持续到达)

3、Spark Streaming介绍

支持大量输入输出数据源的流式处理

数据输入后可以使用spark算子进行运算

处理一批流式数据,设置批处理间隔,实现汇总到一定量后再操作

使用了离散化流(discretized stream)称为DStreams,是由RDD组成的数据序列

4、Spark Streaming的特点

优点:易用、容错、易整合到Spark体系

缺陷:微量批处理、延迟高

5、Spark Streaming架构

(1)架构图

【Spark】Day04-Spark Streaming:与离线批量比较、架构特点、入门案例、创建(队列、数据源)、转换(有状_spark

输入后备份数据到另一节点,并通过sparkcontext在另一个节点上处理并输出节点

 (2)背压机制

spark.streaming.receiver.maxRate可以限制接收速率,但会导致资源利用率下降

使用背压机制(即Spark Streaming Backpressure)可以根据作业执行信息动态调整数据Receiver接收率

spark.streaming.backpressure.enabled配置背压机制是否开启

二、DStream入门

1、WordCount案例实操

netcat工具向9999端口不断的发送数据nc -lk 9999,spark读取并统计单词出现的次数

object Spark01_WordCount {
def main(args: Array[String]): Unit = {
//创建配置文件对象 注意:Streaming程序至少不能设置为local,至少需要2个线程
val conf: SparkConf = new SparkConf().setAppName("Spark01_W").setMaster("local[*]")
//创建Spark Streaming上下文环境对象
val ssc = new StreamingContext(conf,Seconds(3))
//操作数据源-从端口中获取一行数据
val socketDS: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop202",9999)
//对获取的一行数据进行扁平化操作
val flatMapDS: DStream[String] = socketDS.flatMap(_.split(" "))
//结构转换
val mapDS: DStream[(String, Int)] = flatMapDS.map((_,1))
//对数据进行聚合
val reduceDS: DStream[(String, Int)] = mapDS.reduceByKey(_+_)
//输出结果 注意:调用的是DS的print函数
reduceDS.print()
//启动采集器
ssc.start()
//默认情况下,上下文对象不能关闭
//ssc.stop()
//等待采集结束,终止上下文环境对象
ssc.awaitTermination()
}
}

2、WordCount解析

DStream是持续性的数据流和经过各种Spark算子操作后的结果数据流

内部是一系列连续的RDD

3、几点注意

一个SparkContext可以重用多个StreamingContext

stop() 的方式停止StreamingContext, 也会把SparkContext停掉

仅想停止StreamingContext, 则应该这样: stop(false)

三、DStream创建

1、RDD队列

使用ssc.queueStream(queueOfRDDs)创建DStream

每一个RDD都被作为一个DStream

object Spark02_DStreamCreate_RDDQueue {
def main(args: Array[String]): Unit = {
// 创建Spark配置信息对象
val conf = new SparkConf().setMaster("local[*]").setAppName("RDDStream")
// 创建SparkStreamingContext
val ssc = new StreamingContext(conf, Seconds(3))
// 创建RDD队列
val rddQueue = new mutable.Queue[RDD[Int]]()
// 创建QueueInputDStream
val inputStream = ssc.queueStream(rddQueue,oneAtATime = false)
// 处理队列中的RDD数据
val mappedStream = inputStream.map((_,1))
val reducedStream = mappedStream.reduceByKey(_ + _)
// 打印结果
reducedStream.print()
// 启动任务
ssc.start()
// 循环创建并向RDD队列中放入RDD
for (i <- 1 to 5) {
rddQueue += ssc.sparkContext.makeRDD(1 to 5, 10)
Thread.sleep(2000)
}
ssc.awaitTermination()
}
}

2、自定义数据源

继承Receiver,并实现onStart、onStop方法,从而自定义数据源采集

实现监控某个端口号,获取该端口号内容

3、Kafka数据源

KafkaUtils对象以Kafka消息创建出 DStream。

核心类:KafkaUtils(高级API)、KafkaCluster(低级API)

分别使用高级API和低级API方式实现wordcount

四、DStream转换

操作分为分为Transformations(转换,包含一些特殊算子)和Output(输出)

1、无状态转化操作【每个批次内部转化】

RDD转化操作应用到每个批次,归约每个时间区间中的数据

转化DStream中的每一个RDD

Transform:RDD-RDD

val wordAndCountDStream: DStream[(String, Int)] = lineDStream.transform(rdd => {
val words: RDD[String] = rdd.flatMap(_.split(" "))
val wordAndOne: RDD[(String, Int)] = words.map((_, 1))
val value: RDD[(String, Int)] = wordAndOne.reduceByKey(_ + _)
value
})

2、有状态转化操作

(1)UpdateStateByKey:将历史结果应用到当前批次,更新并保留状态,结果会是一个新的DStream

跨批次维护状态,由每个时间区间对应的(键,状态)对组成,可以访问状态变量

步骤:定义状态、定义状态更新函数,使用检查点保存状态

【Spark】Day04-Spark Streaming:与离线批量比较、架构特点、入门案例、创建(队列、数据源)、转换(有状_kafka_02

例子:每隔一段时间景点人流量变化

object Spark07_State_updateStateByKey {
def main(args: Array[String]): Unit = {
//创建SparkConf
val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")
//创建StreamingContext
val ssc = new StreamingContext(conf, Seconds(3))
//设置检查点路径 用于保存状态
ssc.checkpoint("D:\\dev\\workspace\\my-bak\\spark-bak\\cp")
//创建DStream
val lineDStream: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop202", 9999)
//扁平映射
val flatMapDS: DStream[String] = lineDStream.flatMap(_.split(" "))
//结构转换
val mapDS: DStream[(String, Int)] = flatMapDS.map((_,1))
//聚合
// 注意:DStreasm中reduceByKey只能对当前采集周期(窗口)进行聚合操作,没有状态
//val reduceDS: DStream[(String, Int)] = mapDS.reduceByKey(_+_)
val stateDS: DStream[(String, Int)] = mapDS.updateStateByKey(
(seq: Seq[Int], state: Option[Int]) => {
Option(seq.sum + state.getOrElse(0))
}
)
  //打印输出
stateDS.print()
//启动
ssc.start()
ssc.awaitTermination()
}
}

(2)Window Operations(窗口操作):将计算应用到一个指定窗口内的所有 RDD,需要两个参数,分别为窗口时长(计算内容的时间范围)以及滑动步长(多久触发一次计算)。

两个参数需要为采集周期的整数倍

【Spark】Day04-Spark Streaming:与离线批量比较、架构特点、入门案例、创建(队列、数据源)、转换(有状_spark_03

需求:3秒统计一次一小时人流量的变化

/**
* Author: Felix
* Date: 2020/2/21
* Desc: 有状态转换-window相关操作
*/
object Spark08_State_window {
def main(args: Array[String]): Unit = {
//创建SparkConf
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")
//创建StreamingContext
val ssc = new StreamingContext(sparkConf, Seconds(3))
//设置检查点路径 用于保存状态
ssc.checkpoint("D:\\dev\\workspace\\my-bak\\spark-bak\\cp")
//创建DStream
val lineDStream: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop202", 9999)
//扁平映射
val flatMapDS: DStream[String] = lineDStream.flatMap(_.split(" "))
//设置窗口大小,滑动的步长
val windowDS: DStream[String] = flatMapDS.window(Seconds(6),Seconds(3))
//结构转换
val mapDS: DStream[(String, Int)] = windowDS.map((_,1))
//聚合
val reduceDS: DStream[(String, Int)] = mapDS.reduceByKey(_+_)
reduceDS.print()
//启动
ssc.start()
ssc.awaitTermination()
}
}

(3)其他方法  

【Spark】Day04-Spark Streaming:与离线批量比较、架构特点、入门案例、创建(队列、数据源)、转换(有状_数据_04

 五、DStream输出

1、常用输出操作

print()

saveAsTextFiles(prefix, [suffix])

saveAsObjectFiles(prefix, [suffix])

saveAsHadoopFiles(prefix, [suffix])

foreachRDD(func)

六、编程进阶

1、累加器和广播变量

同RDD的累加器

2、DataFrame and SQL Operations

RDD被转换为DataFrame,以临时表格配置并用SQL进行查询

val spark = SparkSession.builder.config(conf).getOrCreate()
import spark.implicits._
mapDS.foreachRDD(rdd =>{
val df: DataFrame = rdd.toDF("word", "count")
df.createOrReplaceTempView("words")
spark.sql("select * from words").show
})

3、Caching / Persistence【缓存和持久化】

使用使用persist()方法将RDD保存到内存中

基于状态的操作,隐含默认保存

七、Spark Streaming项目实战

1、准备数据

用户对广告点击的行为数据

时间戳, 地区, 城市, 用户id, 广告id
1566035129449, 华南, 深圳, 101, 2

模拟生成数据并从kafka中读取数据【将数据输出到kafka】

2、每天每地区热门广告Top3

原始数据结构化,并进行批次累加【聚合、结构转换、按天和地区分组】

val mapDS = dataDS.map {
line => {
val fields = line.split(",")
//格式化时间戳
val timeStamp = fields(0).toLong
val day = new Date(timeStamp)
val sdf = new SimpleDateFormat("yyyy-MM-dd")
val dayStr = sdf.format(day)
val area = fields(1)
val adv = fields(4)
((dayStr + "_" + area + "_" + adv), 1)
}
}
//3.将转换结构后的数据进行聚合处理 (天_地区_广告,点击次数sum)
//注意:这里要统计每天数据,所有要把每个采集周期的数据都统计,需要保存状态,使用updateStateByKey
val updateDS = mapDS.updateStateByKey(
(seq: Seq[Int], buffer: Option[Int]) => {
Option(buffer.getOrElse(0) + seq.sum)
}
)
//4.将聚合后的数据进行结构的转换 (天_地区,(广告,点击次数sum)))
val mapDS1: DStream[(String, (String, Int))] = updateDS.map {
case (k, sum) => {
val ks: Array[String] = k.split("_")
(ks(0) +"_" +ks(1),(ks(2), sum))
}
}
//5.按照天_地区对数据进行分组 (时间,Iterator[(地区,(广告,点击次数sum))])
val groupDS: DStream[(String, Iterable[(String, Int)])] = mapDS1.groupByKey()

//6.对分组后的数据降序取前三
val resDS: DStream[(String, List[(String, Int)])] = groupDS.mapValues {
datas => {
datas.toList.sortBy(-_._2).take(3)
}
}

3、最近1小时广告点击量实时统计

定义窗口,并将窗口内数据进行聚合

/**
* 需求二:统计各广告最近1小时内的点击量趋势,每6s更新一次(各广告最近1小时内各分钟的点击量)
* 1.最近一个小时 窗口的长度为1小时
* 2.每6s更新一次 窗口的滑动步长是6s
* 3.各个广告每分钟的点击量 ((advId,hhmm),1)
*/

//创建DS
val kafkaDS: InputDStream[(String, String)] = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](
ssc, kafkaParams, Set(topic))

//测试Kafka中消费数据 msg = 1584271384370,华南,广州,100,1
val dataDS: DStream[String] = kafkaDS.map(_._2)

//定义窗口
val windowDS: DStream[String] = dataDS.window(Seconds(12),Seconds(3))

//转换结构为 ((advId,hhmm),1)
val mapDS: DStream[((String, String), Int)] = windowDS.map {
line => {
val fields: Array[String] = line.split(",")
val ts: Long = fields(0).toLong
val day: Date = new Date(ts)
val sdf: SimpleDateFormat = new SimpleDateFormat("hh:mm")
val time = sdf.format(day)
((fields(4), time), 1)
}
}

//对数据进行聚合
val resDS: DStream[((String, String), Int)] = mapDS.reduceByKey(_+_)
resDS.print()

 

作者:哥们要飞​