一、關聯
與Spark類似，Spark Streaming也可以利用maven倉庫。編寫你自己的Spark Streaming程序，你需要引入下面的依賴到你的SBT或者Maven項目中
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-streaming_2.10</artifactId>
<version>1.2</version>
</dependency>
爲了從Kafka, Flume和Kinesis這些不在Spark核心API中提供的源獲取數據，我們需要添加相關的模塊spark-streaming-xyz_2.10 到依賴中
以下爲一些常用組件
kafka:spark-streaming-kafka_2.10
flume:spark-streaming-flume_2.10
Kinesis:spark-streaming-kinesis-asl_2.10
Twitter:spark-streaming-twitter_2.10
ZeroMQ:spark-streaming-zeromq_2.10
MQTT:spark-streaming-mqtt_2.10
二、初始化StreamingContext
爲了初始化Spark Streaming程序，一個StreamingContext對象必需被創建，它是Spark Streaming所有流操作的主要入口。一個StreamingContext對象可以用SparkConf對象創建。
import org.apache.spark._
import org.apache.spark.streaming._
val conf = new SparkConf().setAppName(appName).setMaster(master)
val ssc = new StreamingContext(conf, Seconds(1))
appName 表示你的應用程序顯示在集羣UI上的名字， master 是一個Spark、Mesos、YARN集羣URL或者一個特殊字符串“local[*]”，它表示程序用本地模式運行。當程序運行在集羣中時，你並不希望在程序中硬編碼 master ，而是希望用 spark-submit啓動應用程序，並從 spark-submit中得到 master 的值。對於本地測試或者單元測試，你可以傳遞“local”字符串在同一個進程內運行Spark Streaming。需要注意的是，它在內部創建了一個SparkContext對象，你可以通過 ssc.sparkContext 訪問這個SparkContext對象。
當一個上下文（context）定義之後，你必須按照以下幾步進行操作：
1.定義輸入源
2.準備好流計算指令
3.利用 streamingContext.start() 方法接收和處理數據
4.處理過程將一直持續，直到 streamingContext.stop() 方法被調用
需要注意的地方：
1.一旦一個context已經啓動，就不能有新的流算子建立或者是添加到context中。
2.一旦一個context已經停止，它就不能再重新啓動
3.在JVM中，同一時間只能有一個StreamingContext處於活躍狀態
4.在StreamingContext上調用 stop() 方法，也會關閉SparkContext對象。如果只想僅關閉
5.StreamingContext對象，設置 stop() 的可選參數爲false
6.一個SparkContext對象可以重複利用去創建多個StreamingContext對象，前提條件是前面的
7.StreamingContext在後面StreamingContext創建之前關閉（不關閉SparkContext）。
三、離散流（DStreams）
離散流或者DStreams是Spark Streaming提供的基本的抽象，它代表一個連續的數據流。它要麼是從源中獲取的輸入流，要麼是輸入流通過轉換算子生成的處理後的數據流。在內部，DStreams由一系列連續的RDD組成。DStreams中的每個RDD都包含確定時間間隔內的數據。
任何對DStreams的操作都轉換成了對DStreams隱含的RDD的操作。
四、輸入DStreams和receivers
輸入DStreams表示從數據源獲取輸入數據流的DStreams。在SparkStreaming快速例子中， lines 表示輸入DStream，它代表從netcat服務器獲取的數據流。每一個輸入流DStream和一個 Receiver 對象相關聯，這個 Receiver從源中獲取數據，並將數據存入內存中用於處理。
輸入DStreams表示從數據源獲取的原始數據流。Spark Streaming擁有兩類數據源:
基本源（Basic sources）：這些源在StreamingContext API中直接可用。例如文件系統、套接字連接、Akka的actor等。
高級源（Advanced sources）：這些源包括Kafka,Flume,Kinesis,Twitter等等。它們需要通過額外的類來使用。
需要注意的是，如果你想在一個流應用中並行地創建多個輸入DStream來接收多個數據流，你能夠創建多個輸入流。它將創建多個Receiver同時接收多個數據流。但是， receiver作爲一個長期運行的任務運行在Spark worker或executor中。因此，它佔有一個核，這個核是分配給Spark Streaming應用程序的所有核中的一個（it occupies one of the cores allocated to the SparkStreaming application）。所以，爲Spark Streaming應用程序分配足夠的核（如果是本地運行，那麼是線程）用以處理接收的數據並且運行 receiver 是非常重要的。
幾點需要注意的地方：
如果分配給應用程序的核的數量少於或者等於輸入DStreams或者receivers的數量，系統只能夠接收數據而不能處理它們。
當運行在本地，如果你的master URL被設置成了“local”，這樣就只有一個核運行任務。這對程序來說是不足的，因爲作爲 receiver 的輸入DStream將會佔用這個核，這樣就沒有剩餘的核來處理數據了。
基本源:
文件流（File Streams）：從任何與HDFS API兼容的文件系統中讀取數據，一個DStream可以通過如下方式創建。
需要注意的地方：
1.所有文件必須具有相同的數據格式
2.所有文件必須在`dataDirectory`目錄下創建，文件是自動的移動和重命名到數據目錄下
3.一旦移動，文件必須被修改。所以如果文件被持續的附加數據，新的數據不會被讀取。
基於自定義actor的流:
DStream可以調streamingContext.actorStream(actorProps, actor-name) 方法從Akka actors獲取的數據流來創建。
RDD隊列作爲數據流：
爲了用測試數據測試Spark Streaming應用程序，人們也可以調用streamingContext.queueStream(queueOfRDDs) 方法基於RDD隊列創建DStreams。每個push到隊列的RDD都被當做DStream的批數據，像流一樣處理。
高級源:
這類源需要非Spark庫接口，並且它們中的部分還需要複雜的依賴（例如kafka和flume）。
自定義源:
在Spark 1.2中，這些源不被Python API支持。輸入DStream也可以通過自定義源創建，你需要做的是實現用戶自定義的 receiver ，這個 receiver 可以從自定義源接收數據以及將數據推到Spark中。
Receiver可靠性
基於可靠性有兩類數據源。源(如kafka、flume)允許。如果從這些可靠的源獲取數據的系統能夠正確的應答所接收的數據，它就能夠確保在任何情況下不丟失數據。這樣，就有兩種類型的receiver：
Reliable Receiver：一個可靠的receiver正確的應答一個可靠的源，數據已經收到並且被正確地複製到了Spark中。
Unreliable Receiver ：這些receivers不支持應答。即使對於一個可靠的源，開發者可能實現一個非可靠的receiver，這個receiver不會正確應答。
五、DStream中的轉換（transformation）
和RDD類似，transformation允許從輸入DStream來的數據被修改。DStreams支持很多在RDD中可用的transformation算子。一些常用的算子如下所示：
map(func): 利用函數 func 處理原DStream的每個元素，返回一個新的DStream
filter(func): 返回一個新的DStream，它僅僅包含源DStream中滿足函數func的項
repartition(numPartitions):通過創建更多或者更少的partition改變這個DStream的並行級別(level of parallelism)
union(otherStream): 返回一個新的DStream,它包含源DStream和otherStream的聯合元素
count():通過計算源DStream中每個RDD的元素數量，返回一個包含單元素(single-element)RDDs的新DStream
reduce(func):利用函數func聚集源DStream中每個RDD的元素，返回一個包含單元素(single-element)RDDs的新DStream。函數應該是相關聯的，以使計算可以並行化
countByValue():這個算子應用於元素類型爲K的DStream上，返回一個（K,long）對的新DStream，每個鍵的值是在原DStream的每個RDD中的頻率。
join(otherStream,[numTasks]):當應用於兩個DStream（一個包含（K,V）對,一個包含(K,W)對），返回一個包含(K, (V, W))對的新DStream
transform(func):通過對源DStream的每個RDD應用RDD-to-RDD函數，創建一個新的DStream。這個可以在DStream中的任何RDD操作中使用
updateStateByKey(func):利用給定的函數更新DStream的狀態，返回一個新"state"的DStream。
重點介紹下面兩個算子：
updateStateByKey：操作允許不斷用新信息更新它的同時保持任意狀態。你需要通過兩步來使用它
1.定義狀態-狀態可以是任何的數據類型
2.定義狀態更新函數-怎樣利用更新前的狀態和從輸入流裏面獲取的新值更新狀態
示例如下：
val sparkConf = new SparkConf().setAppName("StatefulNetworkWordCount")
// Create the context with a 1 second batch size
val ssc = new StreamingContext(sparkConf, Seconds(1))
ssc.checkpoint(".")
// Initial state RDD for mapWithState operation
val initialRDD = ssc.sparkContext.parallelize(List(("hello", 1), ("world", 1)))
// Create a ReceiverInputDStream on target ip:port and count the
// words in input stream of \n delimited test (eg. generated by 'nc')
val lines = ssc.socketTextStream(args(0), args(1).toInt)
val words = lines.flatMap(_.split(" "))
val wordDstream = words.map(x => (x, 1))
// Update the cumulative count using mapWithState
// This will give a DStream made of state (which is the cumulative count of the words)
val mappingFunc = (word: String, one: Option[Int], state: State[Int]) => {
val sum = one.getOrElse(0) + state.getOption.getOrElse(0)
val output = (word, sum)
state.update(sum)
output
}
val stateDstream = wordDstream.mapWithState(
StateSpec.function(mappingFunc).initialState(initialRDD))
stateDstream.print()
ssc.start()
ssc.awaitTermination()
}
Transform操作：
transform 操作（以及它的變化形式如 transformWith ）允許在DStream運行任何RDD-to-RDD函數。它能夠被用來應用任何沒在DStream API中提供的RDD操作（It can be used to apply any RDDoperation that is not exposed in the DStream API）。例如，連接數據流中的每個批（batch）和另外一個數據集的功能並沒有在DStream API中提供，然而你可以簡單的利用 transform 方法做到。如果你想通過連接帶有預先計算的垃圾郵件信息的輸入數據流來清理實時數據，然後過了它們，你可以按如下方法來做：
val spamInfoRDD = ssc.sparkContext.newAPIHadoopRDD(...) // RDD containing spam informa
tion
val cleanedDStream = wordCounts.transform(rdd => {
rdd.join(spamInfoRDD).filter(...) // join data stream with spam information to do data cleaning
...
})
六、DStreams上的輸出操作
輸出操作允許DStream的操作推到如數據庫、文件系統等外部系統中。因爲輸出操作實際上是允許外部系統消費轉換後的數據，它們觸發的實際操作是DStream轉換。目前，定義了下面幾種輸出操作：
print():
在DStream的每個批數據中打印前10條元素，這個操作在開發和調試中都非常有用。在Python API中調用 pprint() 。
saveAsObjectFiles(prefix,[suffix]):
saveAsTextFiles(prefix,[suffix]):
保存DStream的內容爲一個文本文件。每一個批間隔的文件的文件名基於 prefix 和 suffix 生成。"prefix-TIME_IN_MS[.suffix]"
saveAsHadoopFiles(prefix,[suffix]):
保存DStream的內容爲一個hadoop文件。每一個批間隔的文件的文件名基於 prefix 和 suffix 生成。"prefix-TIME_IN_MS[.suffix]"，在Python API中不可用。
foreachRDD(func):
在從流中生成的每個RDD上應用函數 func 的最通用的輸出操作。這個函數應該推送每個RDD的數據到外部系統，例如保存RDD到文件或者通過網絡寫到數據庫中。需要注意的是， func 函數在驅動程序中執行，並且通常都有RDD action在裏面推動RDD流的計算。
利用foreachRDD的設計模式
dstream.foreachRDD是一個強大的原語，發送數據到外部系統中。然而，明白怎樣正確地、有效地用這個原語是非常重要的。下面幾點介紹瞭如何避免一般錯誤。經常寫數據到外部系統需要建一個連接對象（例如到遠程服務器的TCP連接），用它發送數據到遠程系統。爲了達到這個目的，開發人員可能不經意的在Spark驅動中創建一個連接對象，但是在Sparkworker中嘗試調用這個連接對象保存記錄到RDD中，如下：
dstream.foreachRDD(rdd => {
val connection = createNewConnection() // executed at the driver
rdd.foreach(record => {
connection.send(record) // executed at the worker
})
})
這是不正確的，因爲這需要先序列化連接對象，然後將它從driver發送到worker中。這樣的連接對象在機器之間不能傳送。它可能表現爲序列化錯誤（連接對象不可序列化）或者初始化錯誤（連接對象應該在worker中初始化）等等。正確的解決辦法是在worker中創建連接對象。然而，這會造成另外一個常見的錯誤-爲每一個記錄創建了一個連接對象。例如：
dstream.foreachRDD(rdd => {
rdd.foreach(record => {
val connection = createNewConnection()
connection.send(record)
connection.close()
})
})
通常，創建一個連接對象有資源和時間的開支。因此，爲每個記錄創建和銷燬連接對象會導致非常高的開支，明顯的減少系統的整體吞吐量。一個更好的解決辦法是利用 rdd.foreachPartition 方法。爲RDD的partition創建一個連接對象，用這個兩件對象發送partition中的所有記錄。
dstream.foreachRDD(rdd => {
rdd.foreachPartition(partitionOfRecords => {
val connection = createNewConnection()
partitionOfRecords.foreach(record => connection.send(record))
connection.close()
})
})
這就將連接對象的創建開銷分攤到了partition的所有記錄上了。最後，可以通過在多個RDD或者批數據間重用連接對象做更進一步的優化。開發者可以保有一個靜態的連接對象池，重複使用池中的對象將多批次的RDD推送到外部系統，以進一步節省開支。
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
})
})
需要注意的是，池中的連接對象應該根據需要延遲創建，並且在空閒一段時間後自動超時。這樣就獲取了最有效的方式發生數據到外部系統。
其它需要注意的地方：
輸出操作通過懶執行的方式操作DStreams，正如RDD action通過懶執行的方式操作RDD。具體地看，RDD actions和DStreams輸出操作接收數據的處理。因此，如果你的應用程序沒有任何輸出操作或者用於輸出操作 dstream.foreachRDD() ，但是沒有任何RDD action操作在dstream.foreachRDD() 裏面，那麼什麼也不會執行。系統僅僅會接收輸入，然後丟棄它們。
默認情況下，DStreams輸出操作是分時執行的，它們按照應用程序的定義順序按序執行。
