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

- 在[《尋找海量資料集用於大資料開發實戰(維基百科網站統計資料)》](https://blog.51cto.com/u_13674465/5587921)一文中，我們獲取到維基百科網站的網頁點選統計資料，也介紹了資料的格式和內容，今天就用這些資料來練習基本的spark開發，開發語言是Java；

### 實戰環境資訊
- 為了快速搭建spark叢集環境，我是在docker下搭建的，您也可以選擇用傳統的方式來搭建，以下是參考文章：

- 如果您也打算用docker來搭建，請參考[《docker下，極速搭建spark叢集(含hdfs叢集)》](https://blog.51cto.com/u_13674465/5584009)，本次實戰用到的docker-compose.yml內容如下：

```yml
version: "2.2"
services:
  namenode:
    image: bde2020/hadoop-namenode:1.1.0-hadoop2.7.1-java8
    container_name: namenode
    volumes:
      - ./hadoop/namenode:/hadoop/dfs/name
      - ./input_files:/input_files
    environment:
      - CLUSTER_NAME=test
    env_file:
      - ./hadoop.env
    ports:
      - 50070:50070
  
  resourcemanager:
    image: bde2020/hadoop-resourcemanager:1.1.0-hadoop2.7.1-java8
    container_name: resourcemanager
    depends_on:
      - namenode
      - datanode1
      - datanode2
    env_file:
      - ./hadoop.env
  
  historyserver:
    image: bde2020/hadoop-historyserver:1.1.0-hadoop2.7.1-java8
    container_name: historyserver
    depends_on:
      - namenode
      - datanode1
      - datanode2
    volumes:
      - ./hadoop/historyserver:/hadoop/yarn/timeline
    env_file:
      - ./hadoop.env
  
  nodemanager1:
    image: bde2020/hadoop-nodemanager:1.1.0-hadoop2.7.1-java8
    container_name: nodemanager1
    depends_on:
      - namenode
      - datanode1
      - datanode2
    env_file:
      - ./hadoop.env
  
  datanode1:
    image: bde2020/hadoop-datanode:1.1.0-hadoop2.7.1-java8
    container_name: datanode1
    depends_on:
      - namenode
    volumes:
      - ./hadoop/datanode1:/hadoop/dfs/data
    env_file:
      - ./hadoop.env
  
  datanode2:
    image: bde2020/hadoop-datanode:1.1.0-hadoop2.7.1-java8
    container_name: datanode2
    depends_on:
      - namenode
    volumes:
      - ./hadoop/datanode2:/hadoop/dfs/data
    env_file:
      - ./hadoop.env
  
  datanode3:
    image: bde2020/hadoop-datanode:1.1.0-hadoop2.7.1-java8
    container_name: datanode3
    depends_on:
      - namenode
    volumes:
      - ./hadoop/datanode3:/hadoop/dfs/data
    env_file:
      - ./hadoop.env

master:
    image: gettyimages/spark:2.3.0-hadoop-2.8
    container_name: master
    command: bin/spark-class org.apache.spark.deploy.master.Master -h master
    hostname: master
    environment:
      MASTER: spark://master:7077
      SPARK_CONF_DIR: /conf
      SPARK_PUBLIC_DNS: localhost
    links:
      - namenode
    expose:
      - 7001
      - 7002
      - 7003
      - 7004
      - 7005
      - 7077
      - 6066
    ports:
      - 4040:4040
      - 6066:6066
      - 7077:7077
      - 8080:8080
    volumes:
      - ./conf/master:/conf
      - ./data:/tmp/data
      - ./jars:/root/jars

worker1:
    image: gettyimages/spark:2.3.0-hadoop-2.8
    container_name: worker1
    command: bin/spark-class org.apache.spark.deploy.worker.Worker spark://master:7077
    hostname: worker1
    environment:
      SPARK_CONF_DIR: /conf
      SPARK_WORKER_CORES: 2
      SPARK_WORKER_MEMORY: 2g
      SPARK_WORKER_PORT: 8881
      SPARK_WORKER_WEBUI_PORT: 8081
      SPARK_PUBLIC_DNS: localhost
    links:
      - master
    expose:
      - 7012
      - 7013
      - 7014
      - 7015
      - 8881
    volumes:
      - ./conf/worker1:/conf
      - ./data/worker1:/tmp/data

worker2:
    image: gettyimages/spark:2.3.0-hadoop-2.8
    container_name: worker2
    command: bin/spark-class org.apache.spark.deploy.worker.Worker spark://master:7077
    hostname: worker2
    environment:
      SPARK_CONF_DIR: /conf
      SPARK_WORKER_CORES: 2
      SPARK_WORKER_MEMORY: 2g
      SPARK_WORKER_PORT: 8881
      SPARK_WORKER_WEBUI_PORT: 8081
      SPARK_PUBLIC_DNS: localhost
    links:
      - master
    expose:
      - 7012
      - 7013
      - 7014
      - 7015
      - 8881
    volumes:
      - ./conf/worker2:/conf
      - ./data/worker2:/tmp/data

worker3:
    image: gettyimages/spark:2.3.0-hadoop-2.8
    container_name: worker3
    command: bin/spark-class org.apache.spark.deploy.worker.Worker spark://master:7077
    hostname: worker3
    environment:
      SPARK_CONF_DIR: /conf
      SPARK_WORKER_CORES: 2
      SPARK_WORKER_MEMORY: 2g
      SPARK_WORKER_PORT: 8881
      SPARK_WORKER_WEBUI_PORT: 8081
      SPARK_PUBLIC_DNS: localhost
    links:
      - master
    expose:
      - 7012
      - 7013
      - 7014
      - 7015
      - 8881
    volumes:
      - ./conf/worker3:/conf
      - ./data/worker3:/tmp/data

worker4:
    image: gettyimages/spark:2.3.0-hadoop-2.8
    container_name: worker4
    command: bin/spark-class org.apache.spark.deploy.worker.Worker spark://master:7077
    hostname: worker4
    environment:
      SPARK_CONF_DIR: /conf
      SPARK_WORKER_CORES: 2
      SPARK_WORKER_MEMORY: 2g
      SPARK_WORKER_PORT: 8881
      SPARK_WORKER_WEBUI_PORT: 8081
      SPARK_PUBLIC_DNS: localhost
    links:
      - master
    expose:
      - 7012
      - 7013
      - 7014
      - 7015
      - 8881
    volumes:
      - ./conf/worker4:/conf
      - ./data/worker4:/tmp/data

worker5:
    image: gettyimages/spark:2.3.0-hadoop-2.8
    container_name: worker5
    command: bin/spark-class org.apache.spark.deploy.worker.Worker spark://master:7077
    hostname: worker5
    environment:
      SPARK_CONF_DIR: /conf
      SPARK_WORKER_CORES: 2
      SPARK_WORKER_MEMORY: 2g
      SPARK_WORKER_PORT: 8881
      SPARK_WORKER_WEBUI_PORT: 8081
      SPARK_PUBLIC_DNS: localhost
    links:
      - master
    expose:
      - 7012
      - 7013
      - 7014
      - 7015
      - 8881
    volumes:
      - ./conf/worker5:/conf
      - ./data/worker5:/tmp/data

worker6:
    image: gettyimages/spark:2.3.0-hadoop-2.8
    container_name: worker6
    command: bin/spark-class org.apache.spark.deploy.worker.Worker spark://master:7077
    hostname: worker6
    environment:
      SPARK_CONF_DIR: /conf
      SPARK_WORKER_CORES: 2
      SPARK_WORKER_MEMORY: 2g
      SPARK_WORKER_PORT: 8881
      SPARK_WORKER_WEBUI_PORT: 8081
      SPARK_PUBLIC_DNS: localhost
    links:
      - master
    expose:
      - 7012
      - 7013
      - 7014
      - 7015
      - 8881
    volumes:
      - ./conf/worker6:/conf
      - ./data/worker6:/tmp/data
```

- 如果您打算基於傳統方式搭建，請參考[《部署spark2.2叢集(standalone模式)》](https://blog.51cto.com/u_13674465/5553440)；

- sprak環境的基本情況如下所示：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190216083425997.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 以下是本次實戰涉及的版本號：

1. 作業系統：CentOS7
2. hadoop：2.8
3. spark：2.3
4. docker：17.03.2-ce
5. docker-compose：1.23.2

### 維基百科網站統計資料簡介
- 先回顧一下維基百科網站統計資料的內容和格式，一行資料的內容如下所示：

```shell
aa.b User_talk:Sevela.p 1 5786
```

這一行由空格字元分割成了四個欄位：

| 內容 | 意義 |
|--|--|
| aa.b | 專案名稱，".b"表示wikibooks |
| User_talk:Sevela.p | 網頁的三級目錄 |
| 1 | 一小時內的訪問次數 |
| 5786 | 一小時內被請求的位元組總數 |

- 上述內容可以還原為一個網址，如下圖所示，對應的URL為：https://aa.wikibooks.org/wiki/User_talk:Sevela.p
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190210215637747.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

### 實戰功能簡介
- 本次實戰開發的spark應用的功能，是對網站統計資料進行排名，找出訪問量最高的前100地址，在控制檯列印出來並儲存到hdsf；

### 原始碼下載
- 接下來詳細講述應用的編碼過程，如果您不想自己寫程式碼，也可以在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專案中有多個資料夾，本章原始碼在sparkdemo這個資料夾下，如下圖紅框所示：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/2019021611170816.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

### 詳細開發
- 基於maven建立工程，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>sparkdemo</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.sparkdemo.app.WikiRank</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>
```

- 建立一個資料結構類PageInfo，在執行過程中會用到，裡面記錄了業務所需的欄位：

```java
package com.bolingcavalry.sparkdemo.bean;

import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;

/**
 * @Description: 資料結構類
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/2/10 15:33
 */
public class PageInfo implements Serializable {
    /**
     * 還原的url地址
     */
    private String url;

/**
     * urldecode之後的三級域名
     */
    private String name;

/**
     * 該三級域名的請求次數
     */
    private int requestTimes;

/**
     * 該地址被請求的位元組總數
     */
    private long requestLength;

/**
 * 對應的原始欄位
 */
 private List<string> raws = new LinkedList<>();

public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }

public int getRequestTimes() {
        return requestTimes;
    }

public void setRequestTimes(int requestTimes) {
        this.requestTimes = requestTimes;
    }

public long getRequestLength() {
        return requestLength;
    }

public void setRequestLength(long requestLength) {
        this.requestLength = requestLength;
    }

public List<string> getRaws() {
 return raws;
 }

public void setRaws(List<string> raws) {
 this.raws = raws;
 }

public String getUrl() {
        return url;
    }

public void setUrl(String url) {
        this.url = url;
    }
}
```

- 對於前面提到的例子，"aa.b User_talk:Sevela.p 1 5786"對應的網址是"https://aa.wikibooks.org/wiki/User_talk:Sevela.p" ，這個轉換邏輯被做成了一個靜態方法，這樣就能把每一行記錄對應的地址還原出來了，如下所示：

```java
package com.bolingcavalry.sparkdemo.util;

import org.apache.commons.lang3.StringUtils;

/**
 * @Description: 常用的靜態工具放置在此
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/2/16 9:01
 */
public class Tools {

/**
     * 域名的格式化模板
     */
    private static final String URL_TEMPALTE = "https://%s/wiki/%s";

/**
     * 根據專案名稱和三級域名還原完整url，
     * 還原邏輯來自：https://wikitech.wikimedia.org/wiki/Analytics/Archive/Data/Pagecounts-raw
     * @param project
     * @param thirdLvPath
     * @return
     */
    public static String getUrl(String project, String thirdLvPath){
        //如果入參不合法，就返回固定格式的錯誤提示
        if(StringUtils.isBlank(project) || StringUtils.isBlank(thirdLvPath)){
            return "1. invalid param (" + project + ")(" + thirdLvPath + ")";
        }

//檢查project中是否有"."
        int dotOffset = project.indexOf('.');

//如果沒有"."，就用project+".wikipedia.org"作為一級域名
 if(dotOffset<0){
 return String.format(URL_TEMPALTE,
 project + ".wikipedia.org",
 thirdLvPath);
 }

//如果有"."，就用"."之後的字串按照不同的邏輯轉換
        String code = project.substring(dotOffset);

//".mw"屬於移動端網頁，統計的邏輯略微複雜，詳情參考網頁連結，這裡不作處理直接返回固定資訊
        if(".mw".equals(code)){
            return "mw page (" + project + ")(" + thirdLvPath + ")";
        }

String firstLvPath = null;

//就用"."之後的字串按照不同的邏輯轉換
        switch(code){
            case ".b":
                firstLvPath = ".wikibooks.org";
                break;
            case ".d":
                firstLvPath = ".wiktionary.org";
                break;
            case ".f":
                firstLvPath = ".wikimediafoundation.org";
                break;
            case ".m":
                firstLvPath = ".wikimedia.org";
                break;
            case ".n":
                firstLvPath = ".wikinews.org";
                break;
            case ".q":
                firstLvPath = ".wikiquote.org";
                break;
            case ".s":
                firstLvPath = ".wikisource.org";
                break;
            case ".v":
                firstLvPath = ".wikiversity.org";
                break;
            case ".voy":
                firstLvPath = ".wikivoyage.org";
                break;
            case ".w":
                firstLvPath = ".mediawiki.org";
                break;
            case ".wd":
                firstLvPath = ".wikidata.org";
                break;
        }

if(null==firstLvPath){
            return "2. invalid param (" + project + ")(" + thirdLvPath + ")";
        }

//還原地址
        return String.format(URL_TEMPALTE,
                project.substring(0, dotOffset) + firstLvPath,
                thirdLvPath);
    }

public static void main(String[] args){
        String str = "abc.123456";

System.out.println(str.substring(str.indexOf('.')));
    }
}
```

- 接下來是spark應用的原始碼，主要是建立PageInfo物件，以及map、reduce、排序等邏輯，程式碼中已有註釋說明，就不再贅述：

```java
package com.bolingcavalry.sparkdemo.app;

import com.bolingcavalry.sparkdemo.bean.PageInfo;
import com.bolingcavalry.sparkdemo.util.Tools;
import org.apache.commons.lang3.StringUtils;
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 org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.Tuple2;

import java.net.URLDecoder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**
 * @Description: 根據wiki的統計來查詢最高訪問量的文章
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2019/2/8 17:21
 */
public class WikiRank {

private static final Logger logger = LoggerFactory.getLogger(WikiRank.class);

private static final int TOP = 100;

public static void main(String[] args) {
 if(null==args
 || args.length<2
 || StringUtils.isEmpty(args[0])
 || StringUtils.isEmpty(args[1])) {
 logger.error("invalid params!");
 }

String hdfsHost = args[0];
        String hdfsPort = args[1];

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

JavaSparkContext javaSparkContext = new JavaSparkContext(sparkConf);

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

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

logger.info("input path : {}", inputPath);
        logger.info("output path : {}", outputPath);

logger.info("import text");
 //匯入檔案
 JavaRDD<string> textFile = javaSparkContext.textFile(inputPath);

logger.info("do map operation");
 JavaPairRDD<string pageinfo=""> counts = textFile
 //過濾掉無效的資料
 .filter((Function<string boolean="">) v1 -> {
 if(StringUtils.isBlank(v1)){
 return false;
 }

//分割為陣列
                    String[] array = v1.split(" ");

/**
 * 以下情況都要過濾掉
 * 1. 名稱無效（array[1]）
 * 2. 請求次數無效(array[2)
 * 3. 請求總位元組數無效(array[3)
 */
 if(null==array
 || array.length<4
 || StringUtils.isBlank(array[1])
 || !StringUtils.isNumeric(array[2])
 || !StringUtils.isNumeric(array[3])){
 logger.error("find invalid data [{}]", v1);
 return false;
 }

return true;
 })
 //將每一行轉成一個PageInfo物件
 .map((Function<string pageinfo="">) v1 -> {
 String[] array = v1.split(" ");

PageInfo pageInfo = new PageInfo();

try {
                        pageInfo.setName(URLDecoder.decode(array[1], "UTF-8"));
                    }catch (Exception e){
                        //有的字串沒有做過urlencode，此時做urldecode可能丟擲異常(例如abc%)，此時用原來的內容作為name即可
                        pageInfo.setName(array[1]);
                    }

pageInfo.setUrl(Tools.getUrl(array[0], array[1]));

pageInfo.setRequestTimes(Integer.valueOf(array[2]));
                    pageInfo.setRequestLength(Long.valueOf(array[3]));
                    pageInfo.getRaws().add(v1);

return pageInfo;
 })
 //轉成鍵值對，鍵是url，值是PageInfo物件
 .mapToPair(pageInfo -> new Tuple2<>(pageInfo.getUrl(), pageInfo))
 //按照url做reduce，將請求次數累加
 .reduceByKey((Function2<pageinfo pageinfo="">) (v1, v2) -> {
 v2.setRequestTimes(v2.getRequestTimes() + v1.getRequestTimes());
 v2.getRaws().addAll(v1.getRaws());
 return v2;
 });

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

logger.info("take top " + TOP);
 //取前10個
 List<tuple2 pageinfo="">> top = sorts.take(TOP);

StringBuilder sbud = new StringBuilder("top "+ top + " word :\n");

//列印出來
 for(Tuple2<integer pageinfo=""> tuple2 : top){
 sbud.append(tuple2._2().getName())
 .append("\t")
 .append(tuple2._1())
 .append("\n");
 }

logger.info(sbud.toString());

logger.info("merge and save as file");
 //分割槽合併成一個，再匯出為一個txt儲存在hdfs
 javaSparkContext
 .parallelize(top)
 .coalesce(1)
 .map(
 tuple2 -> new Tuple2<>(tuple2._2().getRequestTimes(), tuple2._2().getName() + " ### " + tuple2._2().getUrl() +" ### " + tuple2._2().getRaws().toString())
 )
 .saveAsTextFile(outputPath);

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

- 編碼完成後，在pom.xml所在目錄下編譯構建jar包：

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

- 編譯成功後，target目錄下的sparkdemo-1.0-SNAPSHOT.jar就是應用jar包；
- 將sparkdemo-1.0-SNAPSHOT.jar提交到spark伺服器上，我這裡用的是docker環境，透過資料夾對映將容器的目錄和宿主機目錄對應起來，只要將檔案放入宿主機的jars目錄即可，您需要按照自己的實際情況上傳；

### 提交任務
- 當前電腦上，維基百科網站的統計資料檔案儲存在目錄/input_files/input
- 將維基百科網站的統計資料檔案提交到hdfs，我這邊用的是docker環境，提交命令如下：

```shell
docker exec namenode hdfs dfs -put /input_files/input /
```

- 提交成功後，在hdfs的web頁面可見/input目錄下的資料，如下：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190216104732662.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 將jar檔案上傳到spark服務再提交任務，我用的是docker環境，命令如下：

```shell
docker exec -it master spark-submit \
--class com.bolingcavalry.sparkdemo.app.WikiRank \
--executor-memory 1g \
--total-executor-cores 12 \
/root/jars/sparkdemo-1.0-SNAPSHOT.jar \
namenode \
8020
```

- 上述命令調動了12個executor，每個記憶體為1G，請您按照自己環境的實際情況來配置；

- 由於本次要處理的檔案較多(24個128兆的檔案)，因此耗時較長，需要耐心等待，您也可以減少上傳檔案數量來縮減處理時間，以下是web頁面顯示的處理情況：
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190216105428446.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 處理完成後，在控制檯會列印簡單的排名資訊：

```shell
en	111840450
Main_Page	61148163
ja	20336203
es	18133852
Заглавная_страница	16997475
de	12537288
ru	10127971
fr	9296777
it	9011481
pt	5904807
id	3472100
tr	3089611
pl	3051718
ar	3023412
nl	2372696
zh	1987233
sv	1845525
fa	1687804
ko	1511408
commons	1138613
fi	1123291
th	1012375
vi	1007987
he	822433
Wikipedia:Hauptseite	767106
cs	750085
hu	687040
Wikipédia:Accueil_principal	597885
da	512714
no	507885
Special:Search	493995
ro	488945
uk	419609
Special:NewItem	414436
hi	399883
Antoninus_Pius	345542
el	342715
Hoofdpagina	287517
tl	274145
bg	252691
Wikipedia:Portada	250932
Liste_des_automobiles_Ferrari	237985
hr	228896
メインページ	227591
Начална_страница	220605
Okto	211002
Proyecto_40	207534
```
- 也可以去hdfs檢視更詳細的輸出內容，先查詢到輸出檔案所在目錄：

```shell
root@willzhao-deepin:~# docker exec namenode hdfs dfs -ls /output/
Found 3 items
drwxr-xr-x - root supergroup 0 2019-02-16 00:53 /output/20190216005136
drwxr-xr-x - root supergroup 0 2019-02-16 01:50 /output/20190216014759
drwxr-xr-x - root supergroup 0 2019-02-16 02:41 /output/20190216021144
root@willzhao-deepin:~# docker exec namenode hdfs dfs -ls /output/20190216021144
Found 2 items
-rw-r--r-- 3 root supergroup 0 2019-02-16 02:41 /output/20190216021144/_SUCCESS
-rw-r--r-- 3 root supergroup 105181 2019-02-16 02:41 /output/20190216021144/part-00000
```
- 可見輸出檔案為/output/20190216021144/part-00000

- 用cat命令檢視輸出檔案內容，以下是部分內容：
```shell
(63364,2016_Summer_Olympics ### https://en.wikipedia.org/wiki/2016_Summer_Olympics ### [en 2016_Summer_Olympics 3396 274589952, en 2016_Summer_Olympics 3015 252640325, en 2016_Summer_Olympics 3136 260875102, en 2016_Summer_Olympics 3094 257683527, en 2016_Summer_Olympics 2302 189633601, en 2016_Summer_Olympics 2532 211137547, en 2016_Summer_Olympics 2073 174153850, en 2016_Summer_Olympics 2425 201808231, en 2016_Summer_Olympics 2869 244961273, en 2016_Summer_Olympics 2647 227408637, en 2016_Summer_Olympics 3173 276779678, en 2016_Summer_Olympics 3242 261206575, en 2016_Summer_Olympics 1871 168316209, en 2016_Summer_Olympics 2234 204588727, en 2016_Summer_Olympics 2857 239335148, en 2016_Summer_Olympics 2345 197360752, en 2016_Summer_Olympics 2949 248777317, en 2016_Summer_Olympics 2040 171690687, en 2016_Summer_Olympics 4006 332402716, en 2016_Summer_Olympics 3137 274672915, en 2016_Summer_Olympics 1895 156985346, en 2016_Summer_Olympics 2089 180840058, en 2016_Summer_Olympics 2062 177089806, en 2016_Summer_Olympics 1975 169774986])
(62904,index.html ### https://de.wikipedia.org/wiki/index.html ### [de index.html 1325 16171364, de index.html 2680 30968912, de index.html 2458 27982474, de index.html 2703 30869488, de index.html 2829 32784835, de index.html 2674 30702050, de index.html 2346 26947956, de index.html 2573 29374195, de index.html 2610 30237824, de index.html 2689 32111034, de index.html 2748 31632152, de index.html 2659 30566670, de index.html 2657 30411903, de index.html 2765 32298328, de index.html 2982 34626678, de index.html 2953 33925805, de index.html 2543 29180781, de index.html 2722 31230645, de index.html 2810 32517269, de index.html 2307 26760806, de index.html 2847 33270784, de index.html 2776 32310052, de index.html 2544 29206518, de index.html 2704 31382398])
```

- 上述第一個網站全天的訪問量為63364，如下圖，地址是：https://en.wikipedia.org/wiki/2016_Summer_Olympic
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20190216110426723.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70)

- 至此，對維基百科網站統計資料的處理實戰就完成了，希望此實戰能夠給您的大資料分析提供一些參考；

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

spark實戰之：分析維基百科網站統計資料(java版)

相關文章