第5課：基於案例一節課貫通Spark Streaming流計算框架的運行源碼

本期內容：

1 在線動態計算分類最熱門商品案例回顧與演示

2 基於案例貫通Spark Streaming的運行源碼

一、案例代碼

在線動態計算電商中不同類別中最熱門的商品排名，例如:手機類別中最熱門的三種手機、電視類別中最熱門的三種電視等

package com.dt.spark.sparkstreaming
import org.apache.spark.SparkConf
import org.apache.spark.sql.Row
import org.apache.spark.sql.hive.HiveContext
import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}
import org.apache.spark.streaming.{Seconds, StreamingContext}
/**
  * 使用Spark Streaming+Spark SQL來在線動態計算電商中不同類別中最熱門的商品排名，例如手機這個類別下面最熱門的三種手機、電視這個類別
  * 下最熱門的三種電視，該實例在實際生產環境下具有非常重大的意義；
  * @author DT大數據夢工廠
  * 新浪微博：http://weibo.com/ilovepains/
  * 實現技術：Spark Streaming+Spark SQL，之所以Spark Streaming能夠使用ML、sql、graphx等功能是因爲有foreachRDD和Transform
  * 等接口，這些接口中其實是基於RDD進行操作，所以以RDD爲基石，就可以直接使用Spark其它所有的功能，就像直接調用API一樣簡單。
  *  假設說這裏的數據的格式：user item category，例如Rocky Samsung Android
  */
object OnlineTheTop3ItemForEachCategory2DB {
  def main(args: Array[String]){
    /**
      * 第1步：創建Spark的配置對象SparkConf，設置Spark程序的運行時的配置信息，
      * 例如說通過setMaster來設置程序要鏈接的Spark集羣的Master的URL,如果設置
      * 爲local，則代表Spark程序在本地運行，特別適合於機器配置條件非常差（例如
      * 只有1G的內存）的初學者       *
      */
    val conf = new SparkConf() //創建SparkConf對象
    conf.setAppName("OnlineTheTop3ItemForEachCategory2DB") //設置應用程序的名稱，在程序運行的監控界面可以看到名稱
//    conf.setMaster("spark://Master:7077") //此時，程序在Spark集羣
    conf.setMaster("local[6]")
    //設置batchDuration時間間隔來控制Job生成的頻率並且創建Spark Streaming執行的入口
    val ssc = new StreamingContext(conf, Seconds(5))
    ssc.checkpoint("/root/Documents/SparkApps/checkpoint")
    val userClickLogsDStream = ssc.socketTextStream("Master", 9999)
    val formattedUserClickLogsDStream = userClickLogsDStream.map(clickLog =>
        (clickLog.split(" ")(2) + "_" + clickLog.split(" ")(1), 1))

//    val categoryUserClickLogsDStream = formattedUserClickLogsDStream.reduceByKeyAndWindow((v1:Int, v2: Int) => v1 + v2,
//      (v1:Int, v2: Int) => v1 - v2, Seconds(60), Seconds(20))
    val categoryUserClickLogsDStream = formattedUserClickLogsDStream.reduceByKeyAndWindow(_+_,
      _-_, Seconds(60), Seconds(20))

    categoryUserClickLogsDStream.foreachRDD { rdd => {
      if (rdd.isEmpty()) {
        println("No data inputted!!!")
      } else {
        val categoryItemRow = rdd.map(reducedItem => {
          val category = reducedItem._1.split("_")(0)
          val item = reducedItem._1.split("_")(1)
          val click_count = reducedItem._2
          Row(category, item, click_count)
        })

        val structType = StructType(Array(
          StructField("category", StringType, true),
          StructField("item", StringType, true),
          StructField("click_count", IntegerType, true)
        ))

        val hiveContext = new HiveContext(rdd.context)
        val categoryItemDF = hiveContext.createDataFrame(categoryItemRow, structType)

        categoryItemDF.registerTempTable("categoryItemTable")

        val reseltDataFram = hiveContext.sql("SELECT category,item,click_count FROM (SELECT category,item,click_count,row_number()" +
          " OVER (PARTITION BY category ORDER BY click_count DESC) rank FROM categoryItemTable) subquery " +
          " WHERE rank <= 3")
        reseltDataFram.show()

        val resultRowRDD = reseltDataFram.rdd
        resultRowRDD.foreachPartition { partitionOfRecords => {
          if (partitionOfRecords.isEmpty){
            println("This RDD is not null but partition is null")
          } else {
            // ConnectionPool is a static, lazily initialized pool of connections
            val connection = ConnectionPool.getConnection()
            partitionOfRecords.foreach(record => {
              val sql = "insert into categorytop3(category,item,client_count) values('" + record.getAs("category") + "','" +
                record.getAs("item") + "'," + record.getAs("click_count") + ")"
              val stmt = connection.createStatement();
              stmt.executeUpdate(sql);
            })
            ConnectionPool.returnConnection(connection) // return to the pool for future reuse
          }
        }
        }
      }
    }
    }
    /**
      * 在StreamingContext調用start方法的內部其實是會啓動JobScheduler的Start方法，進行消息循環，在JobScheduler
      * 的start內部會構造JobGenerator和ReceiverTacker，並且調用JobGenerator和ReceiverTacker的start方法：
      *   1，JobGenerator啓動後會不斷的根據batchDuration生成一個個的Job
      *   2，ReceiverTracker啓動後首先在Spark Cluster中啓動Receiver（其實是在Executor中先啓動ReceiverSupervisor），在Receiver收到
      *   數據後會通過ReceiverSupervisor存儲到Executor並且把數據的Metadata信息發送給Driver中的ReceiverTracker，在ReceiverTracker
      *   內部會通過ReceivedBlockTracker來管理接受到的元數據信息
      * 每個BatchInterval會產生一個具體的Job，其實這裏的Job不是Spark Core中所指的Job，它只是基於DStreamGraph而生成的RDD
      * 的DAG而已，從Java角度講，相當於Runnable接口實例，此時要想運行Job需要提交給JobScheduler，在JobScheduler中通過線程池的方式找到一個
      * 單獨的線程來提交Job到集羣運行（其實是在線程中基於RDD的Action觸發真正的作業的運行），爲什麼使用線程池呢？
      *   1，作業不斷生成，所以爲了提升效率，我們需要線程池；這和在Executor中通過線程池執行Task有異曲同工之妙；
      *   2，有可能設置了Job的FAIR公平調度的方式，這個時候也需要多線程的支持；
      *
      */
    ssc.start()
    ssc.awaitTermination()
  }
}

二、基於案例源碼解析

main方法中將 SparkConf 作爲參數傳入 StreamingContext

StreamingContext構造函數中，調用createNewSparkContext

該方法創建一個SparkContext對象，說明SparkStreaming是Spark Core上的一個應用。

持久化操作checkpoint

ssc.checkpoint("/root/Documents/SparkApps/checkpoint")

創建SocketTextStream，以獲取輸入數據源

創建socketStream

SocketInputDStream繼承了ReceiverInputDStream類，它有getReceiver(),getStart(),getStop()方法

SockdetReceiver類中有 onStart,onStop,receiver 方法

創建SocketInputStream的receive方法來獲取數據源

數據輸出 ：categoryUserClickLogsDStream.foreachRDD

Job作業生成

DStream中generatedRDDs，通過getOrCompute方法取得給定的時間的RDD數據

ssc.start(),  調用jobScheduler的start方法，其中也調用了receiverTracker.start() , jobGenerator.start()，此處略

最後經上海-丁立清同學同意，轉載以下流程圖，真的很棒！