Spark Streaming

最新推荐文章于 2024-05-26 00:15:00 发布

大大怪啊

最新推荐文章于 2024-05-26 00:15:00 发布

阅读量302

点赞数

分类专栏： Scala

Scala 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

Spark Streaming流式处理

Spark Streaming介绍
1.1 Spark Streaming概述
1.1.1什么是Spark Streaming

Spark Streaming类似于Apache Storm，用于流式数据的处理。根据其官方文档介绍，Spark Streaming有高吞吐量和容错能力强等特点。Spark Streaming支持的数据输入源很多，例如：Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。数据输入后可以用Spark的高度抽象操作如：map、reduce、join、window等进行运算。而结果也能保存在很多地方，如HDFS，数据库等。另外Spark Streaming也能和MLlib（机器学习）以及Graphx完美融合。

1.1.2为什么要学习Spark Streaming

（1）易用
在这里插入图片描述
（2）容错

（3）易整合到Spark体系

1.1.3 SparkStreaming与Storm的对比
SparkStreaming 开发语言：Scala 编程模型：DStream

Storm 开发语言：Clojure 编程模型：Spout/Bolt

Spark Streaming原理
2.1 Spark Streaming原理
Spark Streaming 是基于spark的流式批处理引擎，其基本原理是把输入数据以某一时间间隔批量的处理，当批处理间隔缩短到秒级时，便可以用于处理实时数据流。
2.2 Spark Streaming计算流程
Spark Streaming是将流式计算分解成一系列短小的批处理作业。这里的批处理引擎是Spark Core，也就是把Spark Streaming的输入数据按照batch size（如1秒）分成一段一段的数据（Discretized Stream），每一段数据都转换成Spark中的RDD（Resilient Distributed Dataset），然后将Spark Streaming中对DStream的Transformation操作变为针对Spark中对RDD的Transformation操作，将RDD经过操作变成中间结果保存在内存中。整个流式计算根据业务的需求可以对中间的结果进行缓存或者存储到外部设备。下图显示了Spark Streaming的整个流程。

SparkStreaming架构图
2.3 Spark Streaming容错性
对于流式计算来说，容错性至关重要。首先我们要明确一下Spark中RDD的容错机制。每一个RDD都是一个不可变的分布式可重算的数据集，其记录着确定性的操作继承关系（lineage），所以只要输入数据是可容错的，那么任意一个RDD的分区（Partition）出错或不可用，都是可以利用原始输入数据通过转换操作而重新算出的。
对于Spark Streaming来说，其RDD的传承关系如下图所示：

图中的每一个椭圆形表示一个RDD，椭圆形中的每个圆形代表一个RDD中的一个Partition，图中的每一列的多个RDD表示一个DStream（图中有三个DStream），而每一行最后一个RDD则表示每一个Batch Size所产生的中间结果RDD。我们可以看到图中的每一个RDD都是通过lineage相连接的，由于Spark Streaming输入数据可以来自于磁盘，例如HDFS（多份拷贝）或是来自于网络的数据流（Spark Streaming会将网络输入数据的每一个数据流拷贝两份到其他的机器）都能保证容错性，所以RDD中任意的Partition出错，都可以并行地在其他机器上将缺失的Partition计算出来。这个容错恢复方式比连续计算模型（如Storm）的效率更高。
2.4 Spark Streaming实时性
对于实时性的讨论，会牵涉到流式处理框架的应用场景。Spark Streaming将流式计算分解成多个Spark Job，对于每一段数据的处理都会经过Spark DAG图分解以及Spark的任务集的调度过程。对于目前版本的Spark Streaming而言，其最小的Batch Size的选取在0.5~2秒钟之间（Storm目前最小的延迟是100ms左右），所以Spark Streaming能够满足除对实时性要求非常高（如高频实时交易）之外的所有流式准实时计算场景。

DStream
3.1 什么是DStream
Discretized Stream是Spark Streaming的基础抽象，代表持续性的数据流和经过各种Spark算子操作后的结果数据流。在内部实现上，DStream是一系列连续的RDD来表示。每个RDD含有一段时间间隔内的数据，如下图：

对数据的操作也是按照RDD为单位来进行的

Spark Streaming使用数据源产生的数据流创建DStream，也可以在已有的DStream上使用一些操作来创建新的DStream。
它的工作流程像下面的图所示一样，接受到实时数据后，给数据分批次，然后传给Spark Engine处理最后生成该批次的结果。

在这里插入图片描述
4. DStream相关操作
DStream上的操作与RDD的类似，分为Transformations（转换）和Output Operations（输出）两种，此外转换操作中还有一些比较特殊的操作，如：updateStateByKey()、transform()以及各种Window相关的操作。

4.1 Transformations on DStreams
Transformation Meaning
map(func) 对DStream中的各个元素进行func函数操作，然后返回一个新的DStream
flatMap(func) 与map方法类似，只不过各个输入项可以被输出为零个或多个输出项
filter(func) 过滤出所有函数func返回值为true的DStream元素并返回一个新的DStream
repartition(numPartitions) 增加或减少DStream中的分区数，从而改变DStream的并行度
union(otherStream) 将源DStream和输入参数为otherDStream的元素合并，并返回一个新的DStream.
count() 通过对DStream中的各个RDD中的元素进行计数，然后返回只有一个元素的RDD构成的DStream
reduce(func) 对源DStream中的各个RDD中的元素利用func进行聚合操作，然后返回只有一个元素的RDD构成的新的DStream.
countByValue() 对于元素类型为K的DStream，返回一个元素为（K,Long）键值对形式的新的DStream，Long对应的值为源DStream中各个RDD的key出现的次数
reduceByKey(func, [numTasks]) 利用func函数对源DStream中的key进行聚合操作，然后返回新的（K，V）对构成的DStream
join(otherStream, [numTasks]) 输入为（K,V)、（K,W）类型的DStream，返回一个新的（K，（V，W）类型的DStream
cogroup(otherStream, [numTasks]) 输入为（K,V)、（K,W）类型的DStream，返回一个新的 (K, Seq[V], Seq[W]) 元组类型的DStream
transform(func) 通过RDD-to-RDD函数作用于DStream中的各个RDD，可以是任意的RDD操作，从而返回一个新的RDD
updateStateByKey(func) 根据于key的前置状态和key的新值，对key进行更新，返回一个新状态的DStream

特殊的Transformations

（1）UpdateStateByKey Operation
UpdateStateByKey用于记录历史记录，保存上次的状态

（2）Window Operations(开窗函数)
滑动窗口转换操作:
滑动窗口转换操作的计算过程如下图所示，我们可以事先设定一个滑动窗口的长度（也就是窗口的持续时间），并且设定滑动窗口的时间间隔（每隔多长时间执行一次计算），然后，就可以让窗口按照指定时间间隔在源DStream上滑动，每次窗口停放的位置上，都会有一部分DStream被框入窗口内，形成一个小段的DStream，这时，就可以启动对这个小段DStream的计算。
在这里插入图片描述

（1)红色的矩形就是一个窗口，窗口框住的是一段时间内的数据流。
（2）这里面每一个time都是时间单元，在官方的例子中，每隔window size是3 time unit, 而且每隔2个单位时间，窗口会slide一次。
所以基于窗口的操作，需要指定2个参数：
• window length - The duration of the window (3 in the figure)
• slide interval - The interval at which the window-based operation is performed (2 in the figure).
a.窗口大小，一段时间内数据的容器。
b.滑动间隔，每隔多久计算一次。

4.2 Output Operations on DStreams
Output Operations可以将DStream的数据输出到外部的数据库或文件系统，当某个Output Operations被调用时（与RDD的Action相同），spark streaming程序才会开始真正的计算过程。
Output Operation Meaning
print() 打印到控制台
saveAsTextFiles(prefix, [suffix]) 保存流的内容为文本文件，文件名为
“prefix-TIME_IN_MS[.suffix]”.
saveAsObjectFiles(prefix, [suffix]) 保存流的内容为SequenceFile，文件名为
“prefix-TIME_IN_MS[.suffix]”.
saveAsHadoopFiles(prefix, [suffix]) 保存流的内容为hadoop文件，文件名为
“prefix-TIME_IN_MS[.suffix]”.
foreachRDD(func) 对Dstream里面的每个RDD执行func

DStream操作实战
5.1 SparkStreaming接受socket数据，实现单词计数WordCount
5.1.1 架构图

5.1.2 实现流程
（1）安装并启动生产者
首先在linux服务器上用YUM安装nc工具，nc命令是netcat命令的简称,都是用来设置路由器。我们可以利用它向某个端口发送数据。
yum install -y nc
（2）通过netcat工具向指定的端口发送数据
nc -lk 9999
（3）编写Spark Streaming程序

package cn.test.spark

import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**

sparkStreming流式处理接受socket数据，实现单词统计
*/
object SparkStreamingTCP {

def main(args: Array[String]): Unit = {
//配置sparkConf参数
val sparkConf: SparkConf = new SparkConf().setAppName(“SparkStreamingTCP”).setMaster(“local[2]”)
//构建sparkContext对象
val sc: SparkContext = new SparkContext(sparkConf)
//设置日志输出级别
sc.setLogLevel(“WARN”)
//构建StreamingContext对象，每个批处理的时间间隔
val scc: StreamingContext = new StreamingContext(sc,Seconds(5))
//注册一个监听的IP地址和端口用来收集数据
val lines: ReceiverInputDStream[String] = scc.socketTextStream(“192.168.200.160”,9999)
//切分每一行记录
val words: DStream[String] = lines.flatMap(.split(" "))
//每个单词记为1
val wordAndOne: DStream[(String, Int)] = words.map((,1))
//分组聚合
val result: DStream[(String, Int)] = wordAndOne.reduceByKey(+)
//打印数据
result.print()
scc.start()
scc.awaitTermination()
}
}
由于使用的是本地模式"local[2]"所以可以直接在本地运行该程序
注意：要指定并行度，如在本地运行设置setMaster(“local[2]”)，相当于启动两个线程，一个给receiver，一个给computer。如果是在集群中运行，必须要求集群中可用core数大于1
5.1.3 执行查看效果
（1）先执行nc -lk 9999
在这里插入图片描述
（2）然后在执行以上代码

（3）不断的在（1）中输入不同的单词，观察IDEA控制台输出

现象：sparkStreaming每隔5s计算一次当前5s内的数据，然后将每个批次的数据输出。

5.2 SparkStreaming接受socket数据，实现单词计数累加
在上面的那个案例中存在这样一个问题：每个批次的单词次数都被正确的统计出来，但是结果不能累加！如果需要累加需要使用updateStateByKey(func)来更新状态.

5.2.1 架构图
在这里插入图片描述
5.2.2 实现流程
（2）安装并启动生成者
首先在linux服务器上用YUM安装nc工具，nc命令是netcat命令的简称,都是用来设置路由器。我们可以利用它向某个端口发送数据。
yum install -y nc
（2）启动一个服务端并监听9999端口
nc -lk 9999
向指定的端口发送数据
（3）编写Spark Streaming程序

package cn.test.spark

import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**

sparkStreaming流式处理，接受socket数据，实现单词统计并且每个批次数据结果累加
*/
object SparkStreamingTCPTotal {

//newValues 表示当前批次汇总成的(word,1)中相同单词的所有的1
//runningCount 历史的所有相同key的value总和
def updateFunction(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {
val newCount =runningCount.getOrElse(0)+newValues.sum
Some(newCount)
}

def main(args: Array[String]): Unit = {

//配置sparkConf参数
val sparkConf: SparkConf = new SparkConf().setAppName(“SparkStreamingTCPTotal”).setMaster(“local[2]”)
//构建sparkContext对象
val sc: SparkContext = new SparkContext(sparkConf)

sc.setLogLevel(“WARN”)
//构建StreamingContext对象，每个批处理的时间间隔
val scc: StreamingContext = new StreamingContext(sc, Seconds(5))

scc.checkpoint("./")
//注册一个监听的IP地址和端口用来收集数据
val lines: ReceiverInputDStream[String] = scc.socketTextStream(“bw01”, 9999)
//切分每一行记录
val words: DStream[String] = lines.flatMap(.split(" "))
//每个单词记为1
val wordAndOne: DStream[(String, Int)] = words.map((, 1))
//累计统计单词出现的次数
val result: DStream[(String, Int)] = wordAndOne.updateStateByKey(updateFunction)
result.print()
scc.start()
scc.awaitTermination()
}
}

通过函数updateStateByKey实现。根据于key的前置状态和key的新值，对key进行更新，返回一个新状态的DStream
5.2.3 执行查看效果
（1）先执行nc -lk 9999
在这里插入图片描述
（2）然后在执行以上代码

（3）不断的在（1）中输入不同的单词，观察IDEA控制台输出

现象：sparkStreaming每隔5s计算一次当前5s内的数据，然后将每个批次的结果数据累加输出。
5.3 SparkStreaming开窗函数reduceByKeyAndWindow，实现单词计数
5.3.1 架构图
在这里插入图片描述

5.3.2 实现流程
（1）安装并启动生成者
首先在linux服务器上用YUM安装nc工具，nc命令是netcat命令的简称,都是用来设置路由器。我们可以利用它向某个端口发送数据。
yum install -y nc
（2）启动一个服务端并监听9999端口
nc-lk 9999
向指定的端口发送数据
（3）编写Spark Streaming程序

package cn.test.spark

import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**

sparkStreming开窗函数—统计一定时间内单词出现的次数
*/
object SparkStreamingTCPWindow {

def main(args: Array[String]): Unit = {
//配置sparkConf参数
val sparkConf: SparkConf = new SparkConf().setAppName(“SparkStreamingTCPWindow”).setMaster(“local[2]”)
//构建sparkContext对象
val sc: SparkContext = new SparkContext(sparkConf)
sc.setLogLevel(“WARN”)
//构建StreamingContext对象，每个批处理的时间间隔
val scc: StreamingContext = new StreamingContext(sc,Seconds(5))
//注册一个监听的IP地址和端口用来收集数据
val lines: ReceiverInputDStream[String] = scc.socketTextStream(“192.168.200.160”,9999)
//切分每一行记录
val words: DStream[String] = lines.flatMap(.split(" "))
//每个单词记为1
val wordAndOne: DStream[(String, Int)] = words.map((,1))
//reduceByKeyAndWindow函数参数意义：
// windowDuration:表示window框住的时间长度，如本例5秒切分一次RDD，框10秒，就会保留最近2次切分的RDD
//slideDuration: 表示window滑动的时间长度，即每隔多久执行本计算
val result: DStream[(String, Int)] = wordAndOne.reduceByKeyAndWindow((a:Int,b:Int)=>a+b,Seconds(10),Seconds(5))
result.print()
scc.start()
scc.awaitTermination()
}
}

5.3.3 执行查看效果
（1）先执行nc -lk 9999
在这里插入图片描述
（2）然后在执行以上代码

（3）不断的在（1）中输入不同的单词，观察IDEA控制台输出
在这里插入图片描述

现象：sparkStreaming每隔5s计算一次当前在窗口大小为10s内的数据，然后将结果数据输出。
5.4 SparkStreaming开窗函数统计一定时间内的热门词汇
5.4.1 架构图
在这里插入图片描述

5.4.2 实现流程
（1）安装并启动生产者
首先在linux服务器上用YUM安装nc工具，nc命令是netcat命令的简称,都是用来设置路由器。我们可以利用它向某个端口发送数据。
yum install -y nc
（2）启动一个服务端并监听9999端口
nc -lk 9999
向指定的端口发送数据
（3）编写Spark Streaming程序

package cn.test.spark

import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**

sparkStreming开窗函数应用----统计一定时间内的热门词汇
*/
object SparkStreamingTCPWindowHotWords {

def main(args: Array[String]): Unit = {
//配置sparkConf参数
val sparkConf: SparkConf = new SparkConf().setAppName(“SparkStreamingTCPWindowHotWords”).setMaster(“local[2]”)
//构建sparkContext对象
val sc: SparkContext = new SparkContext(sparkConf)
sc.setLogLevel(“WARN”)
//构建StreamingContext对象，每个批处理的时间间隔
val scc: StreamingContext = new StreamingContext(sc,Seconds(5))
//注册一个监听的IP地址和端口用来收集数据
val lines: ReceiverInputDStream[String] = scc.socketTextStream(“192.168.200.160”,9999)
//切分每一行记录
val words: DStream[String] = lines.flatMap(.split(" "))
//每个单词记为1
val wordAndOne: DStream[(String, Int)] = words.map((,1))
//reduceByKeyAndWindow函数参数意义：
// windowDuration:表示window框住的时间长度，如本例5秒切分一次RDD，框10秒，就会保留最近2次切分的RDD
//slideDuration: 表示window滑动的时间长度，即每隔多久执行本计算
val result: DStream[(String, Int)] = wordAndOne.reduceByKeyAndWindow((a:Int,b:Int)=>a+b,Seconds(5),Seconds(5))
val data=result.transform(rdd=>{
//降序处理后，取前3位
val dataRDD: RDD[(String, Int)] = rdd.sortBy(t=>t._2,false)
val sortResult: Array[(String, Int)] = dataRDD.take(3)
println("--------------print top 3 begin--------------")
sortResult.foreach(println)
println("--------------print top 3 end--------------")
dataRDD
})
data.print()
scc.start()
scc.awaitTermination()
}
}

5.4.3 执行查看效果
（1）先执行nc -lk 9999
在这里插入图片描述
（3）然后在执行以上代码

（3）不断的在（1）中输入不同的单词，观察IDEA控制台输出
在这里插入图片描述

现象：sparkStreaming每隔5s计算一次当前在窗口大小为10s内的数据，然后将单词出现次数最多的前3位进行输出打印。

6.Spark Streaming整合flume实战
flume作为日志实时采集的框架，可以与SparkStreaming实时处理框进行对接，flume实时产生数据，sparkStreaming做实时处理。
Spark Streaming对接FlumeNG有两种方式，一种是FlumeNG将消息Push推给Spark Streaming，还有一种是Spark Streaming从flume 中Poll拉取数据。
6.1 Poll方式

（1）安装flume1.6以上
（2）下载依赖包
spark-streaming-flume-sink_2.11-2.0.2.jar放入到flume的lib目录下
（3）写flume的agent，注意既然是拉取的方式，那么flume向自己所在的机器上产数据就行
（4）编写flume-poll.conf配置文件
a1.sources = r1
a1.sinks = k1
a1.channels = c1
#source
a1.sources.r1.channels = c1
a1.sources.r1.type = spooldir
a1.sources.r1.spoolDir = /root/data
a1.sources.r1.fileHeader = true
#channel
a1.channels.c1.type =memory
a1.channels.c1.capacity = 20000
a1.channels.c1.transactionCapacity=5000
#sinks
a1.sinks.k1.channel = c1
a1.sinks.k1.type = org.apache.spark.streaming.flume.sink.SparkSink
a1.sinks.k1.hostname=hdp-node-01
a1.sinks.k1.port = 8888
a1.sinks.k1.batchSize= 2000

flume-ng agent -n a1 -c /opt/bigdata/flume/conf -f /opt/bigdata/flume/conf/flume-poll.conf -Dflume.root.logger=INFO,console

服务器上的 /root/data目录下准备数据文件data.txt
在这里插入图片描述

（5）启动spark-streaming应用程序，去flume所在机器拉取数据
（6）代码实现
需要添加pom依赖

org.apache.spark
spark-streaming-flume_2.10
2.0.2

具体代码如下：
package cn.test.spark
import java.net.InetSocketAddress
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.flume.{FlumeUtils, SparkFlumeEvent}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**

sparkStreaming整合flume 拉模式Poll

*/
object SparkStreaming_Flume_Poll {
//newValues 表示当前批次汇总成的(word,1)中相同单词的所有的1
//runningCount 历史的所有相同key的value总和
def updateFunction(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {
val newCount =runningCount.getOrElse(0)+newValues.sum
Some(newCount)
}

def main(args: Array[String]): Unit = {
//配置sparkConf参数
val sparkConf: SparkConf = new SparkConf().setAppName(“SparkStreaming_Flume_Poll”).setMaster(“local[2]”)
//构建sparkContext对象
val sc: SparkContext = new SparkContext(sparkConf)
//构建StreamingContext对象，每个批处理的时间间隔
val scc: StreamingContext = new StreamingContext(sc, Seconds(5))
//设置checkpoint
scc.checkpoint("./")
//设置flume的地址，可以设置多台
val address=Seq(new InetSocketAddress(“192.168.200.160”,8888))
// 从flume中拉取数据
val flumeStream: ReceiverInputDStream[SparkFlumeEvent] = FlumeUtils.createPollingStream(scc,address,StorageLevel.MEMORY_AND_DISK)

//获取flume中数据，数据存在event的body中，转化为String
val lineStream: DStream[String] = flumeStream.map(x=>new String(x.event.getBody.array()))
//实现单词汇总
val result: DStream[(String, Int)] = lineStream.flatMap(.split(" ")).map((,1)).updateStateByKey(updateFunction)

result.print()
scc.start()
scc.awaitTermination()
}

}

（7）观察IDEA控制台输出
在这里插入图片描述

6.2 Push方式
（1）编写flume-push.conf配置文件
#push mode
a1.sources = r1
a1.sinks = k1
a1.channels = c1
#source
a1.sources.r1.channels = c1
a1.sources.r1.type = spooldir
a1.sources.r1.spoolDir = /root/data
a1.sources.r1.fileHeader = true
#channel
a1.channels.c1.type =memory
a1.channels.c1.capacity = 20000
a1.channels.c1.transactionCapacity=5000
#sinks
a1.sinks.k1.channel = c1
a1.sinks.k1.type = avro
a1.sinks.k1.hostname=172.16.43.63
a1.sinks.k1.port = 8888
a1.sinks.k1.batchSize= 2000

注意配置文件中指明的hostname和port是spark应用程序所在服务器的ip地址和端口。
flume-ng agent -n a1 -c /opt/bigdata/flume/conf -f /opt/bigdata/flume/conf/flume-push.conf -Dflume.root.logger=INFO,console

（2）代码实现如下：
package cn.test.spark

import java.net.InetSocketAddress

import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.flume.{FlumeUtils, SparkFlumeEvent}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**

sparkStreaming整合flume 推模式Push
*/
object SparkStreaming_Flume_Push {
//newValues 表示当前批次汇总成的(word,1)中相同单词的所有的1
//runningCount 历史的所有相同key的value总和
def updateFunction(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {
val newCount =runningCount.getOrElse(0)+newValues.sum
Some(newCount)
}

def main(args: Array[String]): Unit = {
//配置sparkConf参数
val sparkConf: SparkConf = new SparkConf().setAppName(“SparkStreaming_Flume_Push”).setMaster(“local[2]”)
//构建sparkContext对象
val sc: SparkContext = new SparkContext(sparkConf)
//构建StreamingContext对象，每个批处理的时间间隔
val scc: StreamingContext = new StreamingContext(sc, Seconds(5))
//设置日志输出级别
sc.setLogLevel(“WARN”)
//设置检查点目录
scc.checkpoint("./")
//flume推数据过来
// 当前应用程序部署的服务器ip地址，跟flume配置文件保持一致
val flumeStream: ReceiverInputDStream[SparkFlumeEvent] = FlumeUtils.createStream(scc,“172.16.43.63”,8888,StorageLevel.MEMORY_AND_DISK)

result.print()
scc.start()
scc.awaitTermination()
}

}
}

（3）启动执行
a. 先执行spark代码，
在这里插入图片描述

b. 然后在执行flume配置文件。
先把/root/data/ata.txt.COMPLETED 重命名为data.txt
在这里插入图片描述
（4）观察IDEA控制台输出

Spark Streaming整合kafka实战
kafka作为一个实时的分布式消息队列，实时的生产和消费消息，这里我们可以利用SparkStreaming实时计算框架实时地读取kafka中的数据然后进行计算。
在spark1.3版本后，kafkaUtils里面提供了两个创建dstream的方法，一种为KafkaUtils.createDstream，另一种为KafkaUtils.createDirectStream。
7.1 KafkaUtils.createDstream方式
构造函数为KafkaUtils.createDstream(ssc, [zk], [consumer group id], [per-topic,partitions] ) 使用了receivers来接收数据，利用的是Kafka高层次的消费者api，对于所有的receivers接收到的数据将会保存在Spark executors中，然后通过Spark Streaming启动job来处理这些数据，默认会丢失，可启用WAL日志，它同步将接受到数据保存到分布式文件系统上比如HDFS。所以数据在出错的情况下可以恢复出来。

A、创建一个receiver来对kafka进行定时拉取数据，ssc的rdd分区和kafka的topic分区不是一个概念，故如果增加特定主消费的线程数仅仅是增加一个receiver中消费topic的线程数，并不增加spark的并行处理数据数量。
B、对于不同的group和topic可以使用多个receivers创建不同的DStream
C、如果启用了WAL(spark.streaming.receiver.writeAheadLog.enable=true)
同时需要设置存储级别(默认StorageLevel.MEMORY_AND_DISK_SER_2)，
即KafkaUtils.createStream(….,StorageLevel.MEMORY_AND_DISK_SER)
7.1.1 KafkaUtils.createDstream实战
（1）添加kafka的pom依赖

org.apache.spark
spark-streaming-kafka_0-10_2.11
2.0.2

（2）启动zookeeper集群
zkServer.sh start

（3）启动kafka集群
kafka-server-start.sh /export/servers/kafka/config/server.properties

（4）创建topic
kafka-topics.sh --create --zookeeper hdp-node-01:2181 --replication-factor 1 --partitions 3 --topic kafka_spark

（5）向topic中生产数据
通过shell命令向topic发送消息
kafka-console-producer.sh --broker-list hdp-node-01:9092 --topic kafka_spark
在这里插入图片描述
（6）编写Spark Streaming应用程序
package cn.bw.kafka

import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

import scala.collection.immutable

//todo:利用sparkStreaming接受kafka中的数据实现单词计数----采用receivers
object SparkStreamingKafka_Receiver_checkpoint {

def updateFunc(a:Seq[Int], b:Option[Int]) :Option[Int] ={
Some(a.sum+b.getOrElse(0))
}
def main(args: Array[String]): Unit = {
val checkpointPath = “./kafka-receiver”

val ssc = StreamingContext.getOrCreate(checkpointPath, () => {
createFunc(checkpointPath)
})
ssc.start()
ssc.awaitTermination()
}
def createFunc(checkpointPath:String): StreamingContext = {

//todo:1、创建sparkConf
val sparkConf: SparkConf = new SparkConf()
.setAppName(“SparkStreamingKafka_Receiver_checkpoint”)
.setMaster(“local[4]”)
//todo:开启wal预写日志
.set(“spark.streaming.receiver.writeAheadLog.enable”,“true”)
//todo:2、创建sparkContext
val sc = new SparkContext(sparkConf)

sc.setLogLevel(“WARN”)

//todo:3、创建StreamingContext
val ssc = new StreamingContext(sc,Seconds(5))
ssc.checkpoint(checkpointPath)
//todo:4、指定zkServer
val zkServer=“node1:2181,node2:2181,node3:2181”

//todo:5、指定groupId
val groupId=“spark-kafka-receiver01”

//todo:6、指定topics 这个可以利用一个消费者组来消费多个topic,
//(topic_name -> numPartitions) 指定topic消费的线程数
val topics=Map(“kafka_spark”->1)

//todo:7、并行运行更多的接收器读取kafak topic中的数据，这里设置3个
val resultDStream: immutable.IndexedSeq[DStream[String]] = (1 to 3).map(x => {
//todo:8、通过使用KafkaUtils的createStream接受kafka topic中的数据，生成DStream
val kafkaDataDStream: DStream[String] = KafkaUtils.createStream(ssc, zkServer, groupId, topics).map(x => x._2)
kafkaDataDStream
}
)
//todo:利用StreamContext将所有的DStream组合在一起
val kafkaDStream: DStream[String] = ssc.union(resultDStream)

//todo:8、获取kafka中topic的内容

//todo:9、切分每一行。每个单词记为1
val wordAndOne: DStream[(String, Int)] = kafkaDStream.flatMap(.split(" ")).map((,1))

//todo:10、相同单词出现的次数累加
val result: DStream[(String, Int)] = wordAndOne.updateStateByKey(updateFunc)

//todo:打印
result.print()
ssc

}

（7）运行代码,查看控制台结果数据
在这里插入图片描述

总结:
通过这种方式实现，刚开始的时候系统正常运行，没有发现问题，但是如果系统异常重新启动sparkstreaming程序后，发现程序会重复处理已经处理过的数据，这种基于receiver的方式，是使用Kafka的高阶API来在ZooKeeper中保存消费过的offset的。这是消费Kafka数据的传统方式。这种方式配合着WAL机制可以保证数据零丢失的高可靠性，但是却无法保证数据被处理一次且仅一次，可能会处理两次。因为Spark和ZooKeeper之间可能是不同步的。官方现在也已经不推荐这种整合方式，官网相关地址下面我们使用官网推荐的第二种方式kafkaUtils的createDirectStream()方式。
7.2 KafkaUtils.createDirectStream方式
不同于Receiver接收数据，这种方式定期地从kafka的topic下对应的partition中查询最新的偏移量，再根据偏移量范围在每个batch里面处理数据，Spark通过调用kafka简单的消费者Api读取一定范围的数据。
在这里插入图片描述
相比基于Receiver方式有几个优点：
A、简化并行
不需要创建多个kafka输入流，然后union它们，sparkStreaming将会创建和kafka分区一种的rdd的分区数，而且会从kafka中并行读取数据，spark中RDD的分区数和kafka中的分区数据是一一对应的关系。
B、高效，
第一种实现数据的零丢失是将数据预先保存在WAL中，会复制一遍数据，会导致数据被拷贝两次，第一次是被kafka复制，另一次是写到WAL中。而没有receiver的这种方式消除了这个问题。
C、恰好一次语义(Exactly-once-semantics)
Receiver读取kafka数据是通过kafka高层次api把偏移量写入zookeeper中，虽然这种方法可以通过数据保存在WAL中保证数据不丢失，但是可能会因为sparkStreaming和ZK中保存的偏移量不一致而导致数据被消费了多次。EOS通过实现kafka低层次api，偏移量仅仅被ssc保存在checkpoint中，消除了zk和ssc偏移量不一致的问题。缺点是无法使用基于zookeeper的kafka监控工具
7.2.1 KafkaUtils.createDirectStream实战
（1）前面的步骤跟KafkaUtils.createDstream方式一样，接下来开始执行代码。
package cn.bw.kafka

import kafka.serializer.StringDecoder
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}
//todo:利用sparkStreaming接受kafak中的消息，采用的是低层次Api-- direct
object SparkStreamingKafka_direct_checkpoint {

def updateFunc(a: Seq[Int], b: Option[Int]): Option[Int] = {
Some(a.sum + b.getOrElse(0))
}

def main(args: Array[String]): Unit = {

val checkpointPath = “./kafka-direct”

val ssc = StreamingContext.getOrCreate(checkpointPath, () => {
createFunc(checkpointPath)
})
ssc.start()
ssc.awaitTermination()
}
def createFunc(checkpointPath:String): StreamingContext = {
//todo:1、创建sparkConf
val sparkConf: SparkConf = new SparkConf()
.setAppName(“SparkStreamingKafka_direct_checkpoint”)
.setMaster(“local[4]”)

//todo:2、创建sparkContext
val sc = new SparkContext(sparkConf)

sc.setLogLevel(“WARN”)
//todo:3、创建StreamingContext
val ssc = new StreamingContext(sc, Seconds(5))
ssc.checkpoint(checkpointPath)
//todo:4、kafka的参数配置
val kafkaParams=Map(“metadata.broker.list” ->“node1:9092,node2:9092,node3:9092”
,“group.id” -> “kafka-direct01”)

//todo:5、定义一个topics ，是一个集合，可以存放多个topic
val topics=Set(“kafka-spark”)

//todo:6、利用KafkaUtils.createDirectStream构建Dstream
val kafkaTopicDS: InputDStream[(String, String)] = KafkaUtils.createDirectStreamString,String,StringDecoder,StringDecoder
//todo:7、获取kafka中topic的数据
val kafkaData: DStream[String] = kafkaTopicDS.map(x=>x._2)

//todo:8、切分每一行，每个单词记为1
val wordAndOne: DStream[(String, Int)] = kafkaData.flatMap(.split(" ")).map((,1))

//todo:9、相同单词出现次数累加
val result: DStream[(String, Int)] = wordAndOne.updateStateByKey(updateFunc)

//todo:打印
result.print()
ssc
}
}

（2）查看对应的效果

向topic中添加数据
在这里插入图片描述
查看控制台的输出：

大大怪啊

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spark Streaming

Spark Streaming流式处理Spark Streaming介绍1.1 Spark Streaming概述1.1.1什么是Spark StreamingSpark Streaming类似于Apache Storm，用于流式数据的处理。根据其官方文档介绍，Spark Streaming有高吞吐量和容错能力强等特点。Spark Streaming支持的数据输入源很多，例如：Kafk...
复制链接

扫一扫

专栏目录