Spark Streaming文档理解

0）摘要

　　本章博客是对Spark Streaming2.20文档（http://spark.apache.org/docs/2.2.0/streaming-programming-guide.html）的一些梳理，加上代码实现了一些算子，最后写了Spark Streaming如何整合SparkSQL。　　

1）DStream

　　SparkStreaming 中最基本的概念：抽象化离散化数据流，表示来连续不断的数据流

　　DStreams：是由不同批次的RDD构成的，交给spark core来完成处理。

2）Input DStreams and Receivers

　　Input DStreams：收到的数据流

　　注意：除了文件流，其他的Input DStreams都需要一个receive来接收数据和然后将数据存在内存里面等待着spark去处理，所以，在本地运行spark streaming程序的时候，使用“local”或者“local[1]”只会启动一个线程来处理，所以，注意有receive的输入流应该：n（线程数量）>receive的数量。如果使用sockets, Kafka, Flume等作为数据源，不要使用"local[1]"或者“local”。

　　　在spark streaming中会有一个长期运行的组件Receivers，作为一个长期运行的任务（Task）运行在Executor上，每一个Receive会负责一个DStreams输入流。Receive组件会接收数据源发来的数据，会提交给sparkcc core来处理。

3）Transformations on DStreams（算子）

• map、flatMap、filter、repartition、union、count、reduce、countByValue()、reduceByKey、join、cogroup、transform
• updateStateByKey、

• Window Operations

4）Output Operations on DStreams（输出操作）

　　输出流，将结果写入到外面

6）DataFrame and SQL Operations（整合sparkSQL）

　　如何整合sparkSQL

　　下面代码来自于sprak 上的官方案例，地址：https://github.com/apache/spark/blob/master/examples/src/main/scala/org/apache/spark/examples/streaming/SqlNetworkWordCount.scala

import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.{Seconds, StreamingContext, Time}

/**
 * @Author: SmallWild
 * @Date: 2019/10/26 17:29
 * @Desc: 
 */
object SqlNetworkWordCount {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("SqlNetworkWordCount").setMaster("local[2]")
    val ssc = new StreamingContext(sparkConf, Seconds(5))
    ssc.sparkContext.setLogLevel("WARN")
    val lines = ssc.socketTextStream(pro.ADDRESS, 1884)
    val words = lines.flatMap(_.split(" "))
    // Convert RDDs of the words DStream to DataFrame and run SQL query
    words.foreachRDD { (rdd: RDD[String], time: Time) =>
      // Get the singleton instance of SparkSession
      val spark = SparkSessionSingleton.getInstance(rdd.sparkContext.getConf)
      import spark.implicits._

      // Convert RDD[String] to RDD[case class] to DataFrame
      val wordsDataFrame = rdd.map(w => Record(w)).toDF()

      // Creates a temporary view using the DataFrame
      wordsDataFrame.createOrReplaceTempView("words")

      // Do word count on table using SQL and print it
      val wordCountsDataFrame =
        spark.sql("select word, count(*) as total from words group by word")
      println(s"========= $time =========")
      wordCountsDataFrame.show()
    }

    ssc.start()
    ssc.awaitTermination()
  }

  /** Case class for converting RDD to DataFrame */
  case class Record(word: String)


  /** Lazily instantiated singleton instance of SparkSession */
  object SparkSessionSingleton {

    @transient private var instance: SparkSession = _

    def getInstance(sparkConf: SparkConf): SparkSession = {
      if (instance == null) {
        instance = SparkSession
          .builder
          .config(sparkConf)
          .getOrCreate()
      }
      instance
    }
  }
}

　

8)foreachRDD的使用

　　作用：foreachRDD is a powerful primitive that allows data to be sent out to external systems

　　正确的使用方式：使用foreachPartition获得每个分区的数据，

　　

//不使用连接池
dstream.foreachRDD { rdd =>
  rdd.foreachPartition { partitionOfRecords =>
    val connection = createNewConnection()
    partitionOfRecords.foreach(record => connection.send(record))
    connection.close()
  }
}
//使用连接池

dstream.foreachRDD { rdd =>
  rdd.foreachPartition { partitionOfRecords =>
    // ConnectionPool is a static, lazily initialized pool of connections
    val connection = ConnectionPool.getConnection()
    partitionOfRecords.foreach(record => connection.send(record))
    ConnectionPool.returnConnection(connection)  // return to the pool for future reuse
  }
}

7）总结

　　SparkStreaming无法实现毫秒级的流计算，如果需要实现毫秒级的流计算，仍然需要使用流计算框架（如Storm）