基于Spark Streaming的流处理和分析

Spark Streaming原理

批处理针对有界的、大量的、持久化的静态数据，流处理针对无界的、小量的（每次处理）、持续实时快速生产的数据。应该说批处理系统强调的是计算能力，流处理系统更要求吞吐量（单位时间内处理请求数量）、实时性（至少秒级）。两者之间的关系如下图：

目前来看，各类大数据平台都在往批流统一方向发展。无论是有界的历史数据流还是无界的实时数据流，都采用一套底层API解决。以Spark为例，RDD是Spark Core的核心抽象，DStream是Spark Streaming的提供的高级别抽象，因为DStream是由许多RDDs构成。所以本章的重点是DStream的编程，包括DStream数据输入、DStream转换以及DStream输出。
Spark Streaming是核心Spark API的扩展，支持可伸缩、高吞吐量、容错的实时流处理。数据可以从许多来源获取，如Kafka、Flume、Kinesis或TCP sockets，可以使用复杂的算法处理数据，这些算法用高级函数表示，如map、reduce、join和window。最后，处理后的数据可以推送到文件系统、数据库和活动仪表板。实际上，还可以将Spark的机器学习和图形处理算法应用于数据流。

在内部，它是这样工作的。Spark Streaming接受实时输入数据流，并将数据分成批次，然后由Spark engine处理，以批量生成最终的结果流。

Spark流提供了一种高级抽象，称为离散流或DStream，他表示连续的数据流。DStream可以从Kafka、Flume和Kinesis等源的输入数据流创建，也可以通过对其他DStream应用高级操作创建。在内部，DStream表示为RDDs序列。

StreamingContext

要初始化一个Spark Streaming程序，必须创建一个StreamingContext对象，该对象是Spark流处理的编程入口点。
一个Spark Streaming程序开发流程：
1、定义StreamingContext
2、通过StreamingContext API 创建DStream（Input DStream）
3、对DStream定义Transformation（实时计算逻辑）和Output操作
4、调用StreamingContext的start() 方法，启动实时处理数据
5、调用StreamingContext的awaitTermination() 方法，等待应用程序的终止。或者调用StreamingContext的stop() 方法，停止应用程序。
共有两种方法创建StreamingContext。
方式一：通过SparkConf创建

val conf = new SparkConf().setAppName(appName).setMaster(master)
val ssc = new StreamingContext(conf,Seconds(1))

上述代码会自行创建SparkContext
方式二：通过SparkContext创建，通常是使用已有的SparkContext来创建StreamingContext。

val sc = new SparkContext(conf)
val ssc = new StreamingContext(sc,Seconds(1))

其中Seconds(1) 表示批处理间隔，创建StreamingContext需要注意以下问题：
1、一个JVM只能有一个SparkContext启动。意味着应用程序中不应该出现两个SparkContext。
2、一个JVM 同时只能有一个 StreamingContext 启动。但一个 SparkContext 可以创建多个 StreamingContext，只要上一个 StreamingContext 先用 stop(false)停 止，再创建下一个即可。默认调用 stop()方法时，会同时停止内部的 SparkContext。
3、StreamingContext 停止后不能再启动。也就是说调用 stop()后不能再 start()。
4、StreamingContext 启动之后，就不能再往其中添加任何计算逻辑了。也就 是说执行 start()方法之后，不能再使 DStream 执行任何算子。

离散流Discretized Streams（DStreams）

离散流或DStream是Spark Streaming提供的基本抽象。它表示连续的数据流，可以是从源接收到的输入数据流，也可以是通过转换输入流生成的经过处理的数据流。在内部，DStream由一系列连续的RDDs表示，RDDs是Spark对不可变的分布式数据集的抽象。DStream中的每个RDD包含来自某个间隔的数据，如下图：

应用于DStream上的任何操作都转换为底层RDDs上的操作。例如，在下面，将一个lines流转换为单词的示例（NetworkWordCount）中，flatMap操作应用于lines DStream中的每个RDD，以生成words DStream的RDDs。

val sparkConf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount")
val ssc = new StreamingContext(sparkConf,Seconds(1))
val lines = ssc.socketTextStream("localhost",9999)   // 指定数据源,监控端口的数据源
val words = lines.flatMap(_.split(" "))
val wordCounts = words.map(x => (x,1)).reduceByKey(_+_)
wordCounts.print()
ssc.start()

这些底层的RDD转换是由Spark引擎计算的。DStream操作隐藏了这些细节中的大部分，并为开发人员提供了更高级的API。

Input DStreams与Receivers（接收器）

Input DStream是表示从流媒体源接收的输入数据流的DStream，通常是第一个DStream。在上面NetworkWordCount示例中，行是一个输入DStream，因为它表示从netcat服务器接收到的数据流。每个Input DStream都与一个接收方（Receiver）对象相关联，接收方接收来自源的数据并将其存储在Spark内存中进行处理。
Spark Streaming提供了两类内置流媒体源。
1、基础源：StreamingContext API中直接可用的资源。示例：文件系统和Socket连接。
2、高级源：像Kafka、Flume、Kinesis等资源可以通过额外的工具类获得。这些需要额外 依赖项。
可以在流处理程序中并行的接收多个数据流，即创建多个 Input DStream。这将创建同时接收多个数据流得多个receives（接收器）。但需要注意，一个Spark的worker/executor是一个长期运行的任务（task），因此它将占用分配给Spark Streaming的应用程序的所有核中的一个核（core）。因此，要记住，一个Spark Streaming应用需要分配足够的核（core）（或线程（threads），如果本地运行的话）来处理所接收的数据，以及来运行接收器（receiver（s））。
注意：
在本地运行Spark Streaming程序时，不要使用“local”或“local[1]”作为主URL。这两种方法都意味着只有一个线程将用于在本地运行任务。如果使用基于接收器的输入DStream（例如sockets、Kafka、Flume等），那么将使用单个线程来运行接收器。因此，在本地运行时，始终使用“local[n]”作为主URL，其中要运行n个接收方。
在集群上运行时，分配给Spark Streaming应用程序的内核数量必须大于接收器的数量。否则，系统将接收数据，但无法处理它。

基础数据源

在StreamingContext API中直接可以使用的数据源。
1、Socket（TCP Socket）
上面Network WordCount示例便是Socket数据源。
2、文件流（File Streams）
示例：

import org.apache.spark.streaming._
val ssc = new StreamingContext(sc,Seconds(8))
ssc.textFileStream("/data/sparkstreaming/helloworld/").print
ssc.start

注意textFileStream() 参数必须是文件目录，但可以支持通配符如“hdfs://namenode:8040/logs/2017/*”。
Spark将监视该目录任务新建的文件，一旦有新文件才会处理。所有文件要求有相同的数据格式，并且监视文件的修改时间而不是创建时间，注意更新文件内容不会被监视，一旦开始处理，这些文件必须不能再更改，因此如果文件被连续的追加，新的数据也不会被读取。文件流不需要运行接收器，因此，不需要分配内核。

$hdfs dfs -put ~/users.json /data/sparkstreaming/helloworld

3、RDDs队列
通常用语测试中。为了使用测试数据测试Spark Streaming应用程序，可以使用streamingContext.queueStream(queueOfRDDs)创建一个基于RDDs队列的DStream，每个进入队列都将被视为DStream中的一个批次数据，并且就像一个流进行处理。
示例：

object QueueStream {
   
	def main(args:Array[String]) {
   
		val conf = new SparkConf().setMaster("local[2]").setAppName("queueStream")
		// 每1秒对数据进行处理
		val ssc = new StreamingContext(conf,Seconds(1))
		// 创建一个能够push到QueueInputDStream的RDDs队列
		val rddQueue = new mutable.SynchronizedQueue[RDD[Int]]()
		// 基于一个RDD队列创建一个输入源
		val inputStream = ssc.queueStream(rddQueue)
		val mappedStream = inputStream.map(x => (x%10,1))
		val reduceStream = mappedStream.reduceByKey(_+_)
		reduceStream.print
		ssc.start()
		for(i <- 1 to 30) {
   
			// 创建RDD，并分配两个核数
			rddQueue += ssc.sparkContext.makeRDD(1 to 100,2)
			Thread.sleep(1000)
		}
		ssc.stop()
	}