Spark版本定制 第1课：通过案例对Spark Streaming透彻理解

一.SparkStreaming在线另类实验
   
  如何清晰的看到数据的流入、被处理的过程？使用一个小技巧，通过调节放大BatchInterval的方式，来降低批处理次数，以方便看清楚各个环节。我们从已写过的广告点击的在线黑名单过滤的SparkStreaming应用程序入手。一下是具体的实验源码：

package com.dt.spark.streaming

import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
  * 背景描述：在广告点击计费系统中，我们在线过滤掉黑名单的点击，进而保护广告商的利益，
  * 只进行有效的广告点击计费。或者在防刷评分（或者流量）系统,过滤掉无效的投票或者评分或者流量。
  * 实现技术：使用transform API直接基于RDD编程，进行join操作
  *
  * Created by Administrator on 2016/4/30.
  */

object OnlineBlackListFilter {
  def main(args: Array[String]) {
    /**
      * 第一步：创建Spark的配置对象，设置Spark程序的运行时的配置信息
      * 例如说通过setMaster来设置程序要连接的spark集群的master的url，如果设置为
      * local， 则代表Spark程序在本地运行，特别适合于机器配置条件非常差
      * （例如只有1g的内存）的初学者
      */

    val conf = new SparkConf() //创建SparkConf对象
    conf.setAppName("OnlineBlackListFilter") //设置Spark应用程序的名称，在程序运行的监控界面可以看到名称
    //    conf.setMaster("local") //此时，程序在本地运行，不需要安装Spark集群
    conf.setMaster("spark://master:7077") //此时，程序在本地运行，不需要安装Spark集群

    val ssc = new StreamingContext(conf, Seconds(300))

    /**
      * 黑名单数据准备，实际上黑名单一般都是动态的，例如在Redis中或者数据库中，黑名单的生成往往有复杂的业务逻辑，
      * 具体情况算法不同，但是在SparkStreaming进行处理的时候每次都能够访问完整的信息
      *
      */

    val blackList = Array(("hadoop", true), ("mahout", true))
    val blackListRDD = ssc.sparkContext.parallelize(blackList, 8)

    val adsClickStream = ssc.socketTextStream("master", 9999)

    /**
      * 此处模拟的广告点击的每条数据的格式为：time、name
      * 此处map操作的结果是name, (time, name)的格式
      */

    val adsClickStreamFormatted = adsClickStream.map(ads =>(ads.split(" ")(1), ads))
    adsClickStreamFormatted.transform(userClickRDD =>{
      //通过leftOuterJoin操作既保留了左侧用户广告点击内容的RDD的所有内容，又获得了相应点击内容是否在黑名单中
      val joinedBlackListRDD = userClickRDD.leftOuterJoin(blackListRDD)
      val validClicked = joinedBlackListRDD.filter(joinedItem => {
        /**
          *进行filter过滤的时候，其输入元素是一个Tuple：（name,((time, name), boolean)）
          * 其中第一个元素是黑名单的名称，第二个元素的第二个元素是进行leftOuterJoin的时候是否存在该值
          * 如果存在的话，表明当前广告点击是黑名单，需要过滤掉，否则的话则是有效点击内容；
          */

if(joinedItem._2._2.getOrElse(false)){
          false
        } else {
          true
        }
      })
      validClicked.map(validClicked =>{ validClicked._2._1 })
    }).print()
    /**
      * 计算后的有效数据一般都会写入Kafka中，下游的计费系统会从Kafka中pull到有效数据进行计费
      */

ssc.start()
    ssc.awaitTermination()
  }
}

• 启动nc -lk 9999，将应用发布到Spark集群上运行，并在nc中发送如下数据：

• 执行shell代码

  sh内容      
  /usr/local/spark-1.6.1-bin-hadoop2.6/bin/spark-submit –class com.dt.spark.sparkstreaming.OnlineBlackListFilter –master spark://Master:7077 /root/Documents/SparkApps/WordCount.jar

2016-05-01 mahout
2016-05-01 scala
2016-05-01 hadoo
2016-05-01 spark

• 在应用收到数据后会有如下输出

2016-05-01 scala
2016-05-01 spark

我们运行完程序，看到过滤结果以后，停止程序，打开HistoryServer http://master:18080/

点击App ID进去，打开，会看到如下图所示的4个Job，从实际执行的Job是1个Job，但是图中显示有4个Job，从这里可以看出Spark Streaming运行的时候自己会启动一些Job。

先看看job id 为0 的详细信息

很明显是我们定义的blackListRDD数据的生成。对应的代码为  
val blackList = Array((“Hadoop”, true), (“Mathou”, true))  
//把Array变成RDD  
val blackListRDD = ssc.sparkContext.parallelize(blackList)  
并且它做了reduceBykey的操作(代码中并没有此步操作，SparkStreaming框架自行生成的)。  
这里有两个Stage，Stage 0和Stage 1 。

Job 1的详细信息

一个makeRDD，这个RDD是receiver不断的接收数据流中的数据，在时间间隔达到batchInterval后，将所有数据变成一个RDD。并且它的耗时也是最长的，59s 。

特别说明：此处可以看出，receiver也是一个独立的job。由此我们可以得出一个结论：我们在应用程序中，可以启动多个job，并且不用的job之间可以相互配合，这就为我们编写复杂的应用程序打下了基础。  
我们点击上面的start at OnlineBlackListFilter.scala:64查看详细信息

根据上图的信息，只有一个Executor在接收数据，最最重要的是红色框中的数据本地性为PROCESS_LOCAL,由此可以知道receiver接收到数据后会保存到内存中，只要内存充足是不会写到磁盘中的。  
即便在创建receiver时，指定的存储默认策略为MEMORY_AND_DISK_SER_2  
def socketTextStream(  
hostname: String,  
port: Int,  
storageLevel: StorageLevel = StorageLevel.MEMORY_AND_DISK_SER_2  
): ReceiverInputDStream[String] = withNamedScope(“socket text stream”) {  
socketStream[String](hostname, port, SocketReceiver.bytesToLines, storageLevel)  
}

job 2的详细信息

Job 2 将前两个job生成的RDD进行leftOuterJoin操作。  
从Stage Id的编号就可以看出，它是依赖于上两个Job的。  
Receiver接收数据时是在spark-master节点上，但是Job 2在处理数据时，数据已经到了spark-worker1上了（因为我的环境只有两个worker，数据并没有分散到所有worker节点，worker节点如果多一点，情况可能不一样，每个节点都会处理数据）  
点击上面的Stage Id 3查看详细信息：  

Executor上运行，并且有5个Task 。

Job 3的详细信息

总结：我们可以看出，一个batchInterval并不是仅仅触发一个Job。

二.Spark Streaming本质的理解

根据上面的描述，我们更细致的了解了DStream和RDD的关系了。DStream就是一个个batchInterval时间内的RDD组成的。只不过DStream带上了时间维度，是一个无边界的集合。

Spark Streaming接收Kafka、Flume、HDFS和Kinesis等各种来源的实时输入数据，进行处理后，处理结果保存在HDFS、Databases等各种地方。

Spark Streaming接收这些实时输入数据流，会将它们按批次划分，然后交给Spark引擎处理，生成按照批次划分的结果流。

Spark Streaming提供了表示连续数据流的、高度抽象的被称为离散流的DStream。DStream本质上表示RDD的序列。任何对DStream的操作都会转变为对底层RDD的操作。

Spark Streaming使用数据源产生的数据流创建DStream，也可以在已有的DStream上使用一些操作来创建新的DStream。  
在我们前面的实验中，每300秒会接收一批数据，基于这批数据会生成RDD，进而触发Job，执行处理。

DStream是一个没有边界的集合，没有大小的限制。  
DStream代表了时空的概念。随着时间的推移，里面不断产生RDD。  
锁定到时间片后，就是空间的操作，也就是对本时间片的对应批次的数据的处理。  
下面用实例来讲解数据处理过程。  
从Spark Streaming程序转换为Spark执行的作业的过程中，使用了DStreamGraph。  
Spark Streaming程序中一般会有若干个对DStream的操作。DStreamGraph就是由这些操作的依赖关系构成。

对DStream的操作会构建成DStream Graph

从每个foreach开始，都会进行回溯。从后往前回溯这些操作之间的依赖关系，也就形成了DStreamGraph。

在每到batchInterval时间间隔后，Job被触发，DStream Graph将会被转换成RDD Graph

空间维度确定之后，随着时间不断推进，会不断实例化RDD Graph，然后触发Job去执行处理。

转载于:https://my.oschina.net/mhf/blog/671438