黑猴子的家：Spark 在 IDEA 中编写 WordCount 程序

最新推荐文章于 2023-10-09 16:33:59 发布

黑猴子的家

最新推荐文章于 2023-10-09 16:33:59 发布

阅读量540

点赞数 1

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/qq_28652401/article/details/92995457

本文详细介绍如何在IDEA中创建Spark项目，包括Maven项目搭建、依赖配置、代码编写及使用spark-submit命令提交至集群运行的全过程。

spark shell 仅在测试和验证我们的程序时使用的较多，在生产环境中，通常会在IDE中编制程序，然后打成jar包，然后提交到集群，最常用的是创建一个Maven项目，利用Maven来管理jar包的依赖

1、打开IDEA工具

2、单击Plugins

3、单击Install plugin from disk

4、选择scala的plugins

5、Restart IntelliJ IDEA

6、创建一个项目

7、选择maven项目→ Next

8、填写GroupId 和 ArtifactId → Next

9、填写项目名称 → Finish

10、选择Enable Auto-Import

11、为项目添加scala的framework

尖叫提示：创建的maven项目默认是不支持scala

12、选择scala进行配置

13、配置Maven 的 pom.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.victor</groupId>
    <artifactId>spark</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <log4j.version>1.2.17</log4j.version>
        <slf4j.version>1.7.22</slf4j.version>
        <camel.version>2.18.2</camel.version>
        <spark.version>2.1.1</spark.version>
        <scala.version>2.11.8</scala.version>
        <hadoop.version>2.8.2</hadoop.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
            <!--声明包作用域-->
            <!-- <scope>provided</scope>-->
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>${spark.version}</version>
            <!-- <scope>provided</scope> -->
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
            <!-- <scope>provided</scope> -->
        </dependency>

        <!-- Logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <!-- Logging End -->
    </dependencies>

    <build>
        <finalName>wordcount</finalName>
        <plugins>
        <!-- 添加对Scala语言的支持。使得其能够同时编译Java和Scala语言的文件 -->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- 打包插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.victor.spark.WordCount</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build> 
</project>

14、将src/main/scala设置成源代码目录

（1）New -> Directory

（2）scala -> ok

（3）Open Module Settings

（4）scala -> Sources

15、添加IDEA Scala

执行此操作后，pom文件中不用添加scala依赖，因为已经以lib库的方式加入

（1）File -> Project Structure

（2）Global Libraries -> + -> Scala SDK

（3）System Scala -> ok

（4）Global Libraries -> Scala -> Add to Modules ...

16、新建一个Scala的WordCount类

（1）New -> Scala Class

（2）WordCount -> Object -> ok

17、编写程序

package com.victor.spark

import org.apache.spark.{SparkConf, SparkContext}
import org.slf4j.LoggerFactory

object WordCount {

  val logger = LoggerFactory.getLogger(WordCount.getClass)

  def main(args: Array[String]) {

    //创建SparkConf()并设置App名称， local或local[*],*表示多线程
    //打成jar包，放到集群上运行，
    //".setMaster("local[*]")"注释掉就可以了，最好不要写死  
    val conf = new SparkConf().setAppName("WC").setMaster("local[*]")

    //创建SparkContext，该对象是提交spark App的入口
    val sc = new SparkContext(conf)

    //使用sc创建RDD并执行相应的transformation和action
    sc.textFile(args(0)).flatMap(_.split(" "))
                    .map((_,1)).reduceByKey(_+_, 1)
                    .sortBy(_._2, false).saveAsTextFile(args(1))
    

    logger.info("complete!")

    //停止sc，结束该任务
    sc.stop()
  }
}

18、使用Maven打包，修改pom.xml

19、打包

20、编译成功的jar包，上传到服务器节点上

21、启动集群

（1）启动HDFS

[victor@node1 hadoop-2.8.2]$ sbin/start-dfs.sh

（2）启动spark

[victor@node1 spark]$ sbin/start-all.sh

22、使用spark-submit命令提交Spark应用

1）spark-submit

上传hdfs 数据

[victor@node1 hadoop]$ bin/hdfs dfs -put README.txt /

spark submit 提交

[victor@node1 spark]$ bin/spark-submit \
> --class com.victor.spark.WordCount \
> --master spark://node1:7077 \ （--master local[*]）//本地多线程执行
> --executor-memory 1G \
> --total-executor-cores 2 \
> wordcount.jar \
> hdfs://node1:9000/RELEASE \
> hdfs://node1:9000/RWC_out

尖叫提示：注意参数的顺序
一个jar 就是一个Application
一个Action 操作就是一个job
每个job又分多个task组
每个task组就称为stage
每个task又被分配到多个节点上
由Executor执行
每个task只能执行在一个节点的一个分区上
多个task并行计算一个RDD

2）参数解析

（1）--class 指定jar包中的主类
（2）--master 指定集群的地址
（3）--deploy-mode 可选，默认是client模式，注意client模式和cluster模式的区别
（4）--conf 指定配置属性
（5）指定jar包地址
（6）指定jar包的参数

3）提交的组件总结

Standalone模式
（1）Master：整个集群的管理器，负责分配资源，单独的JVM进程
（2）Worker：负责管理Executor，单独的JVM进程
（3）Driver：负责提交Jar包的客户端，
（4）client模式：Driver运行在提交端
（5）cluster模式：Driver运行在某一个Executor中。
（6）Executor：具体执行任务的容器，单独的JVM进行。
cluster大部分应用于企业开发，client应用于Debug测试

Yarn模式
（1）ResourceManager
（2）NodeManager
（3）我不用启动Spark集群
（4）client模式：Driver运行在提交端
（5）cluster模式：spark app master 在Executor 运行

23、查看程序执行结果

[victor@node1 hadoop-2.8.2]$ bin/hadoop fs -cat /RWC_out/*
(-Psparkr,1)
(Spark,1)
(-Pyarn,1)
(Build,1)
(built,1)
(-DzincPort=3036,1)
(flags:,1)
(-Phive-thriftserver,1)
(-Pmesos,1)
(for,1)
(-Phive,1)
(2.7.3,1)
(-Phadoop-2.7,1)
(2.2.0,1)
(Hadoop,1)

尖叫提示：hdfs dfs -cat hdfs://node1:9000/RWC_out/p* 方式查看也可以

Job