Spark Streaming（一）—— Spark Streaming介绍

1. 什么是Spark Streaming

Spark Streaming makes it easy to build scalable fault-tolerant streaming applications.
易于构建灵活的、高容错的流式系统。

流式计算框架

Spark Streaming是核心Spark API的扩展，可实现可扩展、高吞吐量、可容错的实时数据流处理。数据可以从诸如Kafka，Flume，Kinesis或TCP套接字等众多来源获取，并且可以使用由高级函数（如map，reduce，join和window）开发的复杂算法进行流数据处理。最后，处理后的数据可以被推送到文件系统，数据库和实时仪表板。而且还可以在数据流上应用Spark提供的机器学习和图处理算法。

2. Spark Streaming特点

• 易用：已经集成在Spark中
• 容错性：底层也是RDD，RDD本身就具备了容错机制。
• 支持多种语言：Java Scala Python

3. 常用的实时计算引擎

1. Apache Storm：真正的流式计算

2. Spark Streaming：严格上来说，Spark Streaming不是真正的流式计算。

   把连续的流式数据，当成不连续的RDD来处理。
   本质上：是一个离线计算。当采样时间特别短时，可以看成是流式计算。

3. Flink：真正的流式计算。跟Spark Streaming 相反。

   把离散的数据，当成流式数据来处理。
   目前还不稳定。从1.8升级到1.9就有很多改变。而且对语言这块，支持比较好的也只是Java和Scala。而且对于机器学习建模这块，虽然有这个东西，但是跟Spark相比，还是有很大差距。所以目前用到最多的还是Spark。Flink是一个未来的东西。

4. Spark Streaming内部结构

内部工作原理如下。Spark Streaming接收实时输入数据流，并将数据切分成批，然后由Spark引擎对其进行处理，最后生成“批”形式的结果流。

Spark Streaming将连续的数据流抽象为discretizedstream或DStream。在内部，DStream 由一个RDD序列表示。

5. StreamingContext对象创建方式

方式一：通过SparkConf创建

//local[2]代表开启两个线程
val conf = new SparkConf().setAppName("MyNetwordWordCount").setMaster("local[2]")
     
//接收两个参数，第一个conf，第二个是采样时间间隔
val ssc = new StreamingContext(conf,Seconds(3))

程序中的几点说明：

• appName参数是应用程序在集群UI上显示的名称。
• master是Spark，Mesos或YARN集群的URL，或者一个特殊的“local [*]”字符串来让程序以本地模式运行。
• 当在集群上运行程序时，不需要在程序中硬编码master参数，而是使用spark-submit提交应用程序并将master的URL以脚本参数的形式传入。但是，对于本地测试和单元测试，可以通过“local[*]”来运行Spark Streaming程序（请确保本地系统中的CPU核数够用）。
• StreamingContext会内在的创建一个SparkContext的实例（所有Spark功能的起始点），你可以通过ssc.sparkContext访问到这个实例。
• 批处理的时间窗口长度必须根据应用程序的延迟要求和可用的集群资源进行设置。

请务必记住以下几点：

• 一旦一个StreamingContext开始运作，就不能设置或添加新的流计算。
• 一旦一个上下文被停止，它将无法重新启动。
• 同一时刻，一个JVM中只能有一个StreamingContext处于活动状态。
• StreamingContext上的stop()方法也会停止SparkContext。 要仅停止StreamingContext（保持SparkContext活跃），请将stop() 方法的可选参数stopSparkContext设置为false。
• 只要前一个StreamingContext在下一个StreamingContext被创建之前停止（不停止SparkContext），SparkContext就可以被重用来创建多个StreamingContext。

方式二：从现有的SparkContext实例中创建

6. 离散流DStream

6.1 什么是DStream

DStream（DiscretizedStream），是Spark Streaming对流式数据的基本抽象。它表示连续的数据流，这些连续的数据流可以是从数据源接收的输入数据流，也可以是通过对输入数据流执行转换操作而生成的经处理的数据流。在内部，DStream由一系列连续的RDD表示。

简单的说，就是把连续的数据变成不连续的RDD。DStream是RDD的集合，包含不连续的RDD。DStream的每一个RDD都包含一定时间间隔内的数据。表现形式依然是RDD。操作DStream和操作RDD是一样的。

6.2 DStream中的算子

• transform(func)

  val wordCount = words.map((_,1)).reduceByKey(_+_)

  等价于 ==>
  val wordCount = words.transform(x => x.map((_,1))).reduceByKey(_+_)

• updateStateByKey(func)

  默认情况下，Spark Streaming 不记录之前的状态，每次发一条数据，都是从0开始计算。用这个算子可以实现更新DStream的状态。

  import org.apache.log4j.Logger
  import org.apache.log4j.Level
  import org.apache.spark.SparkConf
  import org.apache.spark.streaming.StreamingContext
  import org.apache.spark.streaming.Seconds
  import org.apache.spark.storage.StorageLevel
   
  object MyTotalNetworkWordCount {
     
    def main(args: Array[String]): Unit = {
       
      System.setProperty("hadoop.home.dir", "G:\\bin\\hadoop-2.5.2")
      Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
      Logger.getLogger("org.eclipse.jetty.server").setLevel(Level.OFF)
       
      val conf = new SparkConf().setMaster("local[2]").setAppName("MyTotalNetworkWordCount")
       
      val ssc = new StreamingContext(conf,Seconds(3))
       
      //设置检查点目录，保存之前的状态信息
      ssc.checkpoint("hdfs://topnpl200:8020/tmp_files/chkp0826")
       
      val lines = ssc.socketTextStream("192.168.15.131", 1234, StorageLevel.MEMORY_ONLY)
       
      val words = lines.flatMap(_.split(" "))
       
      val wordPair = words.map((_,1))
       
      /**
       * 两个参数：
       * 第一个参数：当前的值是多少
       * 第二个参数：之前的结果是多少
       */
      val addFunc = (curreValues:Seq[Int],previousValues:Option[Int]) => {
        // 进行累加运算
        
        // 1、把当前值的序列进行累加
        val currentTotal = curreValues.sum
         
        //2、在之前的值上再累加
        Some( currentTotal + previousValues.getOrElse(0) )
      }
       
      //进行累加运算
      val total = wordPair.updateStateByKey(addFunc)
       
      total.print()
       
      ssc.start()
      ssc.awaitTermination()
       
    }
  }
  

7. 窗口

处理落在窗口中的数据。也是DStream，也是RDD。

注意：

窗口参数有要求，不能随便设置。窗口大小和移动大小，都必须是DStream的批间隔的整数倍。

import org.apache.log4j.Logger
import org.apache.log4j.Level
import org.apache.spark.SparkConf
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.Seconds
import org.apache.spark.storage.StorageLevel
 
/**
 * 需求：每10秒，对过去30秒的数据进行累加
 *
 * 窗口长度：30秒
 *
 * 滑动距离：10秒
 *
 */
object MyNetWorkWordCountByWindow {
 
  def main(args: Array[String]): Unit = {
    System.setProperty("hadoop.home.dir", "G:\\bin\\hadoop-2.5.2")
    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
    Logger.getLogger("org.eclipse.jetty.server").setLevel(Level.OFF)
     
    val conf = new SparkConf().setAppName("MyNetWorkWordCountByWindow").setMaster("local[2]")
     
    // 这里设成3s会报错。改成1s。
    val ssc = new StreamingContext(conf,Seconds(1))
     
    val lines = ssc.socketTextStream("192.168.15.131", 1234, StorageLevel.MEMORY_ONLY)
     
    val words = lines.flatMap(_.split(" ")).map((_,1))
     
    /**
     * reduce By Key And Window
     * 三个参数
     * 1、要进行什么操作
     * 2、窗口的大小
     * 3、窗口滑动的距离
     */
     
    val result = words.reduceByKeyAndWindow((x:Int,y:Int)=>(x+y),Seconds(30),Seconds(10))
     
    result.print()
     
    ssc.start()
    ssc.awaitTermination()
       
  }
 
}