### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

- WordCount是大資料學習最好的入門demo，今天就一起開發java版本的WordCount，然後提交到Spark2.3.2環境執行；

### 版本資訊
1. 作業系統：CentOS7；
2. JDK：1.8.0_191；
3. Spark：2.3.3；
4. Scala：2.11.12；
5. Hadoop：2.7.7；
6. Maven：3.5.0；

### 關於hadoop環境
- 本次實戰用到了hadoop的hdfs，關於hadoop的部署，請參考[《Linux部署hadoop2.7.7叢集》](https://blog.csdn.net/boling_cavalry/article/details/86774385)；

### 關於spark環境
- 本次實戰用到了spark2.3.3，關於spark叢集的部署，請參考[《部署spark2.2叢集(standalone模式)》](https://blog.csdn.net/boling_cavalry/article/details/86747258)；
請注意，由於2.3.3版本的spark-core的jar包不支援scala2.12，所以在部署spark的時候，scala版本請使用2.11；

### 關於本次實戰開發的應用
- 本次實戰開發的應用是經典的WorkCount，也就是指定一個文字檔案，統計其中每個單詞出現的次數，再取出現次數最多的10個，列印出來，並儲存在hdfs檔案中；

### 本次統計單詞數用到的文字
- 本次用到的txt檔案，是我在網上找到的pdf版本的《亂世佳人》英文版，然後匯出為txt，讀者您可以自行選擇適合的txt檔案來測試；
- 在hdfs服務所在的機器上執行以下命令，建立input資料夾：

```shell
~/hadoop-2.7.7/bin/hdfs dfs -mkdir /input
```

- 在hdfs服務所在的機器上執行以下命令，建立output資料夾：

```shell
~/hadoop-2.7.7/bin/hdfs dfs -mkdir /output
```

- 把本次用到的text檔案上傳到hdfs服務所在的機器，再執行以下命令將文字檔案上傳到hdfs的/input資料夾下：

```shell
~/hadoop-2.7.7/bin/hdfs dfs -put ~/GoneWiththeWind.txt /input
```

### 原始碼下載
- 接下來詳細講述應用的編碼過程，如果您不想自己寫程式碼，也可以在GitHub下載完整的應用原始碼，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| https://github.com/zq2599/blog_demos | 該專案在GitHub上的主頁 |
| git倉庫地址(https)| https://github.com/zq2599/blog_demos.git | 該專案原始碼的倉庫地址，https協議 |
| git倉庫地址(ssh)| git@github.com:zq2599/blog_demos.git | 該專案原始碼的倉庫地址，ssh協議 |

- 這個git專案中有多個資料夾，本章原始碼在sparkwordcount這個資料夾下，如下圖紅框所示：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190208205329735.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)
### 開發應用

- 基於maven建立一個java應用sparkwordcount，pom.xml的內容如下：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>

<groupid>com.bolingcavalry</groupid>
    <artifactid>sparkwordcount</artifactid>
    <version>1.0-SNAPSHOT</version>

<dependencies>
        <dependency>
            <groupid>org.apache.spark</groupid>
            <artifactid>spark-core_2.11</artifactid>
            <version>2.3.2</version>
        </dependency>
    </dependencies>

<build>
        <sourcedirectory>src/main/java</sourcedirectory>
        <testsourcedirectory>src/test/java</testsourcedirectory>
        <plugins>
            <plugin>
                <artifactid>maven-assembly-plugin</artifactid>
                <configuration>
                    <descriptorrefs>
                        <descriptorref>jar-with-dependencies</descriptorref>
                    </descriptorrefs>
                    <archive>
                        <manifest>
                            <mainclass></mainclass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupid>org.codehaus.mojo</groupid>
                <artifactid>exec-maven-plugin</artifactid>
                <version>1.2.1</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <executable>java</executable>
                    <includeprojectdependencies>false</includeprojectdependencies>
                    <includeplugindependencies>false</includeplugindependencies>
                    <classpathscope>compile</classpathscope>
                    <mainclass>com.bolingcavalry.sparkwordcount.WordCount</mainclass>
                </configuration>
            </plugin>
            <plugin>
                <groupid>org.apache.maven.plugins</groupid>
                <artifactid>maven-compiler-plugin</artifactid>
                <configuration>
                    <source>1.8<source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
```
- 建立WrodCount類，關鍵程式碼位置都有註釋，就不再贅述了：

```java
package com.bolingcavalry.sparkwordcount;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
 * @Description: spark的WordCount實戰
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/2/8 17:21
 */
public class WordCount {

public static void main(String[] args) {
        String hdfsHost = args[0];
        String hdfsPort = args[1];
        String textFileName = args[2];

SparkConf sparkConf = new SparkConf().setAppName("Spark WordCount Application (java)");

JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);

String hdfsBasePath = "hdfs://" + hdfsHost + ":" + hdfsPort;
        //文字檔案的hdfs路徑
        String inputPath = hdfsBasePath + "/input/" + textFileName;

//輸出結果檔案的hdfs路徑
        String outputPath = hdfsBasePath + "/output/"
                       + new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());

System.out.println("input path : " + inputPath);

System.out.println("output path : " + outputPath);

//匯入檔案
        JavaRDD<string> textFile = javaSparkContext.textFile(inputPath);

JavaPairRDD<string integer=""> counts = textFile
                //每一行都分割成單詞，返回後組成一個大集合
                .flatMap(s -> Arrays.asList(s.split(" ")).iterator())
                //key是單詞，value是1
                .mapToPair(word -> new Tuple2<>(word, 1))
                //基於key進行reduce，邏輯是將value累加
                .reduceByKey((a, b) -> a + b);

//先將key和value倒過來，再按照key排序
        JavaPairRDD<integer string=""> sorts = counts
                //key和value顛倒，生成新的map
                .mapToPair(tuple2 -> new Tuple2<>(tuple2._2(), tuple2._1()))
                //按照key倒排序
                .sortByKey(false);

//取前10個
        List<tuple2 string="">> top10 = sorts.take(10);

//列印出來
        for(Tuple2<integer string=""> tuple2 : top10){
            System.out.println(tuple2._2() + "\t" + tuple2._1());
        }

//分割槽合併成一個，再匯出為一個txt儲存在hdfs
        javaSparkContext.parallelize(top10).coalesce(1).saveAsTextFile(outputPath);

//關閉context
        javaSparkContext.close();
    }
}
```

- 在pom.xml目錄下執行以下命令，編譯構建jar包：

```shell
mvn clean package -Dmaven.test.skip=true
```

- 構建成功後，在target目錄下生成檔案**sparkwordcount-1.0-SNAPSHOT.jar**，上傳到spark伺服器的**~/jars/**目錄下；
- 假設spark伺服器的IP地址為**192.168.119.163**，在spark伺服器執行以下命令即可提交任務：

```shell
~/spark-2.3.2-bin-hadoop2.7/bin/spark-submit \
--master spark://192.168.119.163:7077 \
--class com.bolingcavalry.sparkwordcount.WordCount \
--executor-memory 512m \
--total-executor-cores 2 \
~/jars/sparkwordcount-1.0-SNAPSHOT.jar \
192.168.119.163 \
8020 \
GoneWiththeWind.txt
```
- 上述命令的最後三個引數，是java的main方法的入參，具體的使用請參照WordCount類的原始碼；
- 提交成功後立即開始執行任務，看到類似如下資訊表示任務完成：

```shell
2019-02-08 21:26:04 INFO  BlockManagerMaster:54 - BlockManagerMaster stopped
2019-02-08 21:26:04 INFO  OutputCommitCoordinator$OutputCommitCoordinatorEndpoint:54 - OutputCommitCoordinator stopped!
2019-02-08 21:26:04 INFO  SparkContext:54 - Successfully stopped SparkContext
2019-02-08 21:26:04 INFO  ShutdownHookManager:54 - Shutdown hook called
2019-02-08 21:26:04 INFO  ShutdownHookManager:54 - Deleting directory /tmp/spark-c3e2ea9e-7daf-4cab-a207-26f0a0394017
2019-02-08 21:26:04 INFO  ShutdownHookManager:54 - Deleting directory /tmp/spark-d60e4d75-4189-4f33-a5e2-fbe9b06bdae7
```
- 往前翻滾一下控制檯輸出的資訊，如下所示，可以見到單詞統計的前十名已經輸出在控制檯了：
```shell
2019-02-08 21:36:15 INFO  DAGScheduler:54 - Job 1 finished: take at WordCount.java:61, took 0.313008 s
the	18264
and	14150
to	10020
of	8615
a	7571
her	7086
she	6217
was	5912
in	5751
had	4502
2019-02-08 21:36:15 INFO  deprecation:1173 - mapred.output.dir is deprecated. Instead, use mapreduce.output.fileoutputformat.outputdir
2019-02-08 21:36:15 INFO  FileOutputCommitter:108 - File Output Committer Algorithm version is 1
```
- 在hdfs伺服器執行檢視檔案的命令，可見/output下新建了子目錄20190208213610：

```shell
[hadoop@node0 ~]$ ~/hadoop-2.7.7/bin/hdfs dfs -ls /output
Found 1 items
drwxr-xr-x   - hadoop supergroup          0 2019-02-08 21:36 /output/20190208213610
```

- 檢視子目錄，發現裡面有兩個檔案：

```shell
[hadoop@node0 ~]$ ~/hadoop-2.7.7/bin/hdfs dfs -ls /output/20190208213610
Found 2 items
-rw-r--r--   3 hadoop supergroup          0 2019-02-08 21:36 /output/20190208213610/_SUCCESS
-rw-r--r--   3 hadoop supergroup        108 2019-02-08 21:36 /output/20190208213610/part-00000
```

- 上面看到的**/output/20190208213610/part-00000**就是輸出結果，用cat命令檢視其內容：

```shell
[hadoop@node0 ~]$ ~/hadoop-2.7.7/bin/hdfs dfs -cat /output/20190208213610/part-00000
(18264,the)
(14150,and)
(10020,to)
(8615,of)
(7571,a)
(7086,her)
(6217,she)
(5912,was)
(5751,in)
(4502,had)
```

- 可見與前面控制檯輸出的一致；
- 在spark的web頁面，可見剛剛執行的任務資訊：

![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190208214435130.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 至此，第一個spark應用的開發和執行就完成了，接下來的文章中，我們們一起來完成更多的spark實戰；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</integer></tuple2></integer></string></string>

第一個spark應用開發詳解(java版)

相關文章