概要

目前Spark官方提供Java,Scala,Python三種語言的API。因為Spark是用Scala開發，而Scala本身是基于JVM的語言，所以Scala和Java的API完整穩定；Python相對不太完整，有些新特性剛開始不支持，但Python語言簡單明了，且省去了編譯打包，用起稍微能方便一些。
本文件將介紹在IDEA+Maven環境下使用Java和Scala的開發Spark和SparkStreaming程序的過程。包括開發工具安裝、配置、scala&java混合項目創建、樣例代碼開發、運行、打包。詳細API介紹不在本文范圍，請查閱官方文檔。

參考資料

1. 官方文檔:http://spark.apache.org/docs/ :英文，所有版本的都在這里面。最權威也比較全面。
2. 漢化的官方文檔 http://ifeve.com/spark/ ：v1.6官方文檔漢化版。1.3.0到1.6之間API之間變化不大，可以參考。

開發工具&&環境

本小節介紹IDEA、scala插件的安裝，如果您已經安裝好了IDEA & Scala插件，請直接跳過這一節。

安裝IDEA

https://www.jetbrains.com/idea/選擇社區版即可，免費的！
IDEA自帶maven，所以不用再單獨下載安裝了:)，也可以不用IDEA自帶的，安裝完成后在在“setting”->"maven"中設置一下即可

注意:
JDK是必須的啦，而且是版本要1.8+哦
maven構建時會根據pom.xml中的配置從網絡倉庫中下載依賴包，所以要聯網，網速要好^_

安裝Scala插件

安裝完成后打開IDEA,選擇"configure"-> "Plugins"

搜索"scala"沒有結果，點擊"Search in repositories"

在搜索結果中選擇"scala" 選擇“install”安裝完成后需要重啟

最新社區版的IDEA在安裝完成后的初始界面就已經提供了"scala插件"的安裝選擇，直接選擇即可
scala插件是在用scala開發Spark程序時所需要，如果只是用java開發，可以不用安裝，考慮到有時候會看scala代碼，有這個插件還是方便很多

Spark WordCount

本小節通過用Scala和Java8分別實現一個簡單的統計單詞個數的程序為例，依次介紹工程創建、編碼、測試運行、打包的完整過程。

創建工程

1. 新建工程
   "create new project" -> "maven" ，如下圖
   

   
   
   填寫相關信息
   
   

2. 創建scala代碼目錄
   IDEA的maven工程會默認創建java代碼的目錄，scala代碼目錄需要手工創建，在"main"目錄下新建“scala”目錄 ，如下圖

3. 將main/scala添加至源代碼目錄
   "File"->"project structure"(快捷鍵:ALT+CTRL+SHIFT+S) ->"Modules"->" main/scala" 右鍵單擊，選擇 "Sources" 添加至源代碼目錄如下圖
   
   

聲明依賴

使用maven的好處在于只需要在pom.xml聲明依賴，后續工作maven會自動處理，而不需要我們手工下載每個依賴包添加到classpath中，此項目中我們需要在pom.xml中聲明scala庫、scala編譯插件及spark的依賴，在pom.xml中<project>標簽中添加以下內容

<dependencies>
    <!--scala項目需要-->
    <dependency>
        <groupId>org.scala-lang</groupId>
        <artifactId>scala-compiler</artifactId>
        <version>2.10.4</version>
        <scope>compile</scope>
    </dependency>
    <!--spark程序依賴-->
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.10</artifactId>
        <version>1.6.1</version>
      </dependency>
    </dependencies>
    <build>
        <plugins>
        <!--scala項目需要-->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <!--[maven lifecycle](http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html)-->
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

注意:開發依賴的spark版本和scala的版本要兼容，<artifactId>spark-core_${scala.binary.version}</artifactId>，${scala.binary.version}要和spark編譯的scala版本一致，官方發布二進制的都是2.10

代碼開發

樣例代碼以統計文件中的單詞個數為例，單詞間以空格分開，計數不區分大小寫。

待統計文件內容很簡單如下x.txt，只有三行：
Java vs Scala
java8 is good
scala is better

scala 版代碼

在scala目錄上右鍵單擊，選擇“NEW”->"Scala Class" 如下圖：

//WordCount.scala

object WordCount {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("WorkCount").setMaster("local[2]")
    val sc = new SparkContext(conf)
    //從文件中創建RDD
    val rdd = sc.textFile("e:/x.txt")
    //文件中的單詞用空格區分
    rdd.flatMap(_.split("\\s+"))
      .map(w => (w, 1))
      .reduceByKey(_+_)
      .foreach(println)
  }
}

java 版代碼

功能和scala一樣，用JAVA8實現代碼也簡潔了很多，限了需要聲明類型外，幾乎和scala一樣。
右鍵單擊“main/java”新建Java類 JWordCount
//JWordCount.java

    public static void main(String[] args) {
        SparkConf  conf = new SparkConf();
        conf.setAppName("JWordCount");
        conf.setMaster("local[2]");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<String> rdd = sc.textFile("e:/x.txt");

        rdd.flatMap(line-> Arrays.asList(line.split("\\s+")))
                .mapToPair(w -> new Tuple2<String,Integer>(w.toLowerCase(),1))
                .reduceByKey((a,b)->a+b)
                .foreach(w-> System.out.println(w));
    }

Scala和Java程序運行方式一樣，在左側"project"窗口(或在編輯窗口)中右鍵單擊文件，選擇“Run 'WordCount'”(快捷鍵:Ctrl+Shift+F10)，可以分別運行一下，以下是scala版運行的結果:

src/main/java和src/main/scala下分別放java和scala代碼。可以用java實現基礎代碼，在scala中調用。

一般開發時master不會寫死，會由參數傳進去，這種方式可以邊開發邊測試，不需要部署一套spark集群，提高開發效率。
在IDEA中可以通過"Run"->"Editor Configurations"->"添加 or 選擇 主類"-> "program arguments" 來添加程序參數，以方便測試，如果開發環境可以直接連接spark集群，可以直接傳入master的地址，提交至集群中運行。

打包

程序開發完畢不管最終是以spark on yarn 還是spark standalone方式運行，都需要首先要將開發的程序以及依賴打成jar包，然后一般會通過spark-submit這個腳本來提交至集群中運行。在IDEA+Maven的環境下可以用maven來打包，也可以用IDEA來打包，各有各的優點，maven功能強大靈活，可以實現一些復雜的流程和功能，且可以脫離IDEA運行在命令行中，可以和其它自動化工具方便集成，但強大功能配置起來比較麻煩。IDEA自身的打包相對簡單，對日常開發足夠用了。

不管是用java還是scala開發的spark程序，提交到集群時，spark本身及其依賴是不需要打包到程序中的，也就是說要打入程序包中的是除spark以及其依賴之外的包是需要打入程序包中的。像本文的例子程序只依賴scala和spark本身，spark依賴scala，所以只需要打包開發的程序即可，不需要打入其它依賴包，用IDEA或Maven打包都很方便，下面分別介紹兩種打包方式。

maven

打開"maven project": "view"->"tool windows"->"maven project"

在"maven project" 中選擇 "lifecycle"->package 右單擊選擇"Run Maven Build" 運行結束后，工程中的scala的java都會被編碼打包。工程目錄下的target/下會有jar包生成,如下圖。

上面其實是在執行maven的命令mvn package，如果你本地安裝好了maven,可以直接在命令行下到pom.xml所在的目錄中執行各種maven命令，而不用每次都要在IDEA中執行。maven更多內容和各種NB的插件可以問狗哥或度娘！

IDEA打包

IDEA要稍顯復雜，要多點幾次鼠標，需要先創建一個artifacts然后在每次需要打包時在build artifacts中選擇這個artifacts執行即可。

1. 創建一個artifacts
   "File"->"project structure"(快捷鍵:ALT+CTRL+SHIFT+S) ->"artifacts"->選擇"+" ->"jar"->"empty"
   在"Name"中填入jar名稱 ，"Output directory"為輸入jar包的路徑，然后在"available elements"中右單擊'helloss compile output'選擇'pack into Output Root'，點'OK'保存，如下圖

'helloss compile output'只是你當前工程中源碼編譯出來的class。如果要打入其它依賴包，也在此選擇加入即可

2. 打包：
   “build”->"build artifacts"->"helloss"(你起的名字)->"build"即可

   
   
   

完整代碼見：https://github.com/longforfreedom/hellospark
生產環境中要提交到集群中運行時一般會用spark-submit來提交運行，類似以下語句:spark-submit --master yarn-client --num-executors 10 --executor-memory 20g --executor-cores 10 --class "WordCount" helloss-1.0-SNAPSHOT.jar
集群部署方式不一樣 --master 后面的參數不一樣，部分參數也會有一些不同， 更多信息可以參考:http://spark.apache.org/docs/1.6.2/submitting-applications.html ，程序的部署和運行監控后續會有單獨進行介紹。

一般情況開發的spark程序不會以local方式正式運行，但能以這樣方式運行對于開發、測試非常方便，需要注意的是有些情況local方式運行正確，但在集群中不一定能正確運行。因為以local方式運行時Spark的所有角色(Driver,Master,Worker,Executor)f是在本地的同一個JVM中，以多個線程運行，具體的任務執行是一個或多個線程，而集群中運行時是不同機器不同的JVM中運行，需要注意并發問題。

以上介紹完了IDEA+Maven環境下用scala和java各開發了一個簡單單詞計數Spark程序的完整過程，包括開發環境搭建，工程創建，代碼開發，以及測試運行，打包。在這個程序中數據源來自文件，程序運行時需要處理的數據已確定，數據處理完畢，程序結束。但是如果數據是動態的，源源不斷的，比如來自socket或消息隊列中時，要簡單及時的處理這些數據時就需要引入流處理了，下面介紹用spark streaming從kafka中統計單詞個數的示例程序。

SparkStreaming && Kafka WordCount

運行環境

如果您不是很了解kafka或著手頭沒有可以使用的kafka集群，可以用以下方式快速搭建一個測試環境。
本文環境為windows+VMware(Centos)，kafka是在vmware下的centos中運行,centos的hostname:vm-centos-00，IP:192.168.99.130

kafka也可以直接在windows中運行，運行bin/windows下的啟動腳本即可。
注意：如果kafka和消費者和服務器以及zookeeper沒有在同一臺機器上時，需要將kafka server和zookeeper的hostname加到消費者機器的hosts文件中。比如本文中，需要在windows的C:\WINDOWS\System32\drivers\etc\hosts文件中添加一條記錄192.168.99.130 vm-centos-00 否則消費時會出錯

1. 下載kafka： wget http://mirror.bit.edu.cn/apache/kafka/0.9.0.0/kafka_2.10-0.9.0.0.tgz
2. 解壓: tar zxvf kafka_2.10-0.9.0.0.tgz
3. 啟動kafka:

 cd kafka_2.10-0.9.0.0   
 ## 啟動zookeeper
 bin/zookeeper-server-start.sh config/zookeeper.properties
 ## 新開一個終端窗口，啟動kafka
 bin/kafka-server-start.sh config/server.properties

4. 創建topic:bin/kafka-topics.sh --create --zookeeper vm-centos-00:2181 --replication-factor 1 --partitions 3 --topic helloss
5. 啟動生產者bin/kafka-console-producer.sh --broker-list vm-centos-00:9092 --topic helloss
6. 啟動消費者bin/kafka-console-consumer.sh --zookeeper vm-centos-00:2181 --from-beginning --topic helloss
   可以在生產者窗戶中輸入消息，在消費者窗口中查看。測試無誤后可以進入下一步

創建工程

這一步和spark程序一樣，為方便起間，本文直接在之前spark程序工程中添加代碼

添加依賴

需要添加scala庫、scala編譯插件是必須的。SparkStreaming和以及與Kafka的集成依賴包也需要引入，在前面spark程序的項目基礎上，在pom.xml中添加以下內容

由于spark streaming依賴spark core，所以在pom.xml中添加spark streaming后，可以不用顯式聲明spark core的依賴，spark core的依賴會自動加進來

 <dependency>
     <groupId>org.apache.spark</groupId>
     <artifactId>spark-streaming_2.10</artifactId>
     <version>1.6.1</version>
 </dependency>
<!--與kafka集成時需要-->
  <dependency>
     <groupId>org.apache.spark</groupId>
     <artifactId>spark-streaming-kafka_2.10</artifactId>
     <version>1.6.1</version>
 </dependency>

代碼開發

在scala目錄上右鍵單擊，選擇“NEW”->"Scala Class",新增一個名為SSWordCount的object。代碼如下

scala

//SSWordCount.scala

object SSWordCount {
  def main(args: Array[String]): Unit = {
      //方便起間，程序中寫死以local方式運行
    val sparkConf = new SparkConf().setAppName("SSWordCount").setMaster("local[2]")
   //每10秒鐘統計一次接收到單詞數    
    val ssc = new StreamingContext(sparkConf, Seconds(10))
    val topicMap = Map("helloss"-> 1)
    val messages = KafkaUtils.createStream(ssc,"vm-centos-00:2181","ss-group",topicMap)
    val r = messages.map(_._2).flatMap(_.split("\\s+")).map((_,1)).reduceByKey(_+_)
    //只打印10記錄，實際中一般會保存到HDFS，Redis,Kafka中
    //spark streaming需要一個Output Operations來觸發執行，否則再多的Transformations也不會執行
    r.print(10)
    //啟動Streaming程序
     ssc.start()
    ssc.awaitTermination()
  }
}

//JSSWordCount.java

 public static void main(String[] args) {
        SparkConf conf = new SparkConf();
        conf.setAppName("JSSWordCount");
        conf.setMaster("local[2]");
        JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(20));
        Map<String, Integer> topicMap = new HashMap<>();
        topicMap.put("helloss",1);
        JavaPairReceiverInputDStream<String, String> messages =
                KafkaUtils.createStream(jssc, "vm-centos-00:2181","ss-group",topicMap);
        JavaPairDStream<String, Integer> r = messages.map(x -> x._2())
                .flatMap(line -> Arrays.asList(line.split("\\s+")))
                .mapToPair(w -> new Tuple2<String, Integer>(w.toLowerCase(), 1))
                .reduceByKey((a, b) -> a + b);
        r.print(10);
        jssc.start();
        jssc.awaitTermination();
    }

完整代碼見：https://github.com/longforfreedom/hellospark
運行程序后，在前面打開的消費者窗口中輸入消息

可以通過Spark Web UIhttp://localhost:4040/來監控流處理程序運行情況，比如延遲多少批次，已處理完成多少個批次等等,如下圖所示

打包、部署運行和spark程序沒有區別，但需要注意的是spark程序處理結束后會自動退出，釋放資源。而spark streaming處理的是連續不斷的數據，程序不會退出，即使kafka中沒有數據也不會釋放資源，更不會退出，真到人為結束(出錯了當然就結束了:( )

結束

本文只是簡單的介紹了開發工具安裝、配置，并通過兩個簡單的例子介紹了IDEA+Maven環境下使用Java8和Scala的開發spark和spark streaming程序的過程。Spark、Spark Streaming以及Kafka涉及很多知識點，詳細的部署方式以及參數設置，運行監控等后續會慢慢整理介紹。

后續有更新會在github先更新