大数据之spark_spark的入门程序编写

最新推荐文章于 2024-05-16 10:24:30 发布
最新推荐文章于 2024-05-16 10:24:30 发布
阅读量463 收藏
点赞数
分类专栏： spark 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WuBoooo/article/details/108630550
版权

Scala编写Spark的WorkCount

创建一个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.doit</groupId>
    <artifactId>spark</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 定义了一些常量 -->
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <scala.version>2.12.12</scala.version>
        <spark.version>3.0.1</spark.version>
        <hbase.version>2.2.5</hbase.version>
        <hadoop.version>3.1.1</hadoop.version>
        <encoding>UTF-8</encoding>
    </properties>

    <dependencies>
        <!-- 导入scala的依赖 -->
        <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.12</artifactId>
            <version>${spark.version}</version>
            <!-- 编译时会引入依赖，打包是不引入依赖 -->
           <scope>provided</scope>
           
 <!-- 出现jar包冲突时,exclusions可以排除某一个或多个依赖，避免jar包冲突 -->
    <!--        <exclusions>
                <exclusion>
                    <groupId>org.apache.hadoop</groupId>
                    <artifactId>hadoop-client</artifactId>
                </exclusion>

                <exclusion>
                    <groupId>com.google.guava</groupId>
                    <artifactId>guava</artifactId>
                </exclusion>
            </exclusions>                -->


        </dependency>
        
 <!-- 导入Hadoop依赖 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
        </dependency>

    </dependencies>

    <build>
        <pluginManagement>
            <plugins>
                <!-- 编译scala的插件 -->
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>scala-maven-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <!-- 编译java的插件 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.5.1</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>scala-test-compile</id>
                        <phase>process-test-resources</phase>
                        <goals>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- 打jar插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>


</project>

编写Spark程序

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 1.创建SparkContext
  * 2.创建RDD
  * 3.调用RDD的Transformation（s）方法
  * 4.调用Action
  * 5.释放资源
  */
object WordCount {

  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf().setAppName("WordCount")
    //创建SparkContext，使用SparkContext来创建RDD
    val sc: SparkContext = new SparkContext(conf)
    //spark写Spark程序，就是对抽象的神奇的大集合【RDD】编程，调用它高度封装的API
    //使用SparkContext创建RDD
    val lines: RDD[String] = sc.textFile(args(0))

    //Transformation 开始 //
    //切分压平
    val words: RDD[String] = lines.flatMap(_.split(" "))
    //将单词和一组合放在元组中
    val wordAndOne: RDD[(String, Int)] = words.map((_, 1))
    //分组聚合，reduceByKey可以先局部聚合再全局聚合
    val reduced: RDD[(String, Int)] = wordAndOne.reduceByKey(_+_)
    //排序
    val sorted: RDD[(String, Int)] = reduced.sortBy(_._2, false)
    //Transformation 结束 //

    //调用Action将计算结果保存到HDFS中
    sorted.saveAsTextFile(args(1))
    //释放资源
    sc.stop()
  }
}

使用maven打包
在这里插入图片描述
提交任务
上传jar包到服务器，然后使用sparksubmit命令提交任务
/bin/spark-submit --master spark://linux01:7077 --executor-memory 1g --total-executor-cores 4 --class cn._51doit.spark.day01.WordCount /root/spark15-1.0-SNAPSHOT.jar hdfs://node-1.51doit.com:8020/words.txt hdfs://linux01:8020/out

参数说明：
–master 指定masterd地址和端口，协议为spark://，端口是RPC的通信端口
–executor-memory 指定每一个executor的使用的内存大小
–total-executor-cores指定整个application总共使用了cores
–class 指定程序的main方法全类名
jar包路径 args0 args1

Java编写Spark的WordCount

使用匿名实现类方式

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.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;

import java.util.Arrays;
import java.util.Iterator;

public class JavaWordCount {

    public static void main(String[] args) {
        SparkConf sparkConf = new SparkConf().setAppName("JavaWordCount");
        //创建JavaSparkContext
        JavaSparkContext jsc = new JavaSparkContext(sparkConf);
        //使用JavaSparkContext创建RDD
        JavaRDD<String> lines = jsc.textFile(args[0]);
        //调用Transformation（s）
        //切分压平
        JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public Iterator<String> call(String line) throws Exception {
                return Arrays.asList(line.split(" ")).iterator();
            }
        });
        //将单词和一组合在一起
        JavaPairRDD<String, Integer> wordAndOne = words.mapToPair(
                new PairFunction<String, String, Integer>() {
                    @Override
                    public Tuple2<String, Integer> call(String word) throws Exception {
                        return Tuple2.apply(word, 1);
                    }
        });
        //分组聚合
        JavaPairRDD<String, Integer> reduced = wordAndOne.reduceByKey(
                new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });
        //排序，先调换KV的顺序VK
        JavaPairRDD<Integer, String> swapped = reduced.mapToPair(
                new PairFunction<Tuple2<String, Integer>, Integer, String>() {
            @Override
            public Tuple2<Integer, String> call(Tuple2<String, Integer> tp) throws Exception {
                return tp.swap();
            }
        });
        //再排序
        JavaPairRDD<Integer, String> sorted = swapped.sortByKey(false);
        //再调换顺序
        JavaPairRDD<String, Integer> result = sorted.mapToPair(
                new PairFunction<Tuple2<Integer, String>, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(Tuple2<Integer, String> tp) throws Exception {
                return tp.swap();
            }
        });
        //触发Action，将数据保存到HDFS
        result.saveAsTextFile(args[1]);
        //释放资源
        jsc.stop();
    }
}

使用Lambda表达式方式

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.util.Arrays;

public class JavaLambdaWordCount {

    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("JavaLambdaWordCount");
        //创建SparkContext
        JavaSparkContext jsc = new JavaSparkContext(conf);
        //创建RDD
        JavaRDD<String> lines = jsc.textFile(args[0]);
        //切分压平
        JavaRDD<String> words = lines.flatMap(line ->
                Arrays.asList(line.split(" ")).iterator());
        //将单词和一组合
        JavaPairRDD<String, Integer> wordAndOne = words.mapToPair(
                word -> Tuple2.apply(word, 1));
        //分组聚合
        JavaPairRDD<String, Integer> reduced = wordAndOne.reduceByKey((a, b) -> a + b);
        //调换顺序
        JavaPairRDD<Integer, String> swapped = reduced.mapToPair(tp -> tp.swap());
        //排序
        JavaPairRDD<Integer, String> sorted = swapped.sortByKey(false);
        //调换顺序
        JavaPairRDD<String, Integer> result = sorted.mapToPair(tp -> tp.swap());
        //将数据保存到HDFS
        result.saveAsTextFile(args[1]);
        //释放资源
        jsc.stop();
    }
}

本地运行Spark和Debug

spark程序每次都打包上在提交到集群上比较麻烦且不方便调试，Spark还可以进行Local模式运行，方便测试和调试

在本地运行

//Spark程序local模型运行,local[*]是本地运行，并开启多个线程
val conf: SparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]") 
//设置为local模式执行

在本地模式运行还需要将以下两行provided给注掉,否则本地会找不到jar包依赖
在这里插入图片描述

在本地运行并读取HDFS中的数据
由于往HDFS中的写入数据存在权限问题，所以在代码中设置用户为HDFS目录的所属用户

//往HDFS中写入数据，将程序的所属用户设置成更HDFS一样的用户
System.setProperty("HADOOP_USER_NAME", "root")
val conf: SparkConf = new SparkConf().setAppName("WordCount").setMaster("local[*]")

输入运行参数
在这里插入图片描述

使用PySpark

配置python环境
① 在所有节点上按照python3，版本必须是python3.6及以上版本

yum install -y python3

在这里插入图片描述

② 修改所有节点的环境变量

export JAVA_HOME=/usr/local/jdk1.8.0_251
export PYSPARK_PYTHON=python3
export HADOOP_HOME=/bigdata/hadoop-3.2.1
export HADOOP_CONF_DIR=/bigdata/hadoop-3.2.1/etc/hadoop
export PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin

使用pyspark shell

/bigdata/spark-3.0.0-bin-hadoop3.2/bin/pyspark --master spark://node-1.51doit.com:7077 --executor-memory 1g --total-executor-cores 10

pyspark shell客户端的wordCount

sc.textFile("hdfs://linux01:8020/wc.txt").flatMap(lambda x : x.split(" ")).map(lambda w : (w,1)).reduceByKey(lambda a,b : a+b).sortBy(lambda x : x[1],False).collect()

在这里插入图片描述

配置PyCharm开发环境
①配置python的环境

在这里插入图片描述

②配置pyspark的依赖
在这里插入图片描述

③添加环境变量
在这里插入图片描述
入门程序的书写:在这里插入图片描述

普罗米修斯之火
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
idea编写spark程序
汉子一枚
04-07 2712
IDEA编写Spark程序 1、 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:...
Intellij IDEA编写Spark应用程序超详细步骤（IDEA+Maven+Scala）
热门推荐
Wingkin的博客
12-16 1万+
本文介绍Intellij IDEA编写Spark应用程序，项目使用maven构建。
spark自己编写的例子程序
07-09
非常好用，自己测试过，非常好用，自己测试过，非常好用，自己测试过
Spark编程
07-16 443
1. RDD1.1 创建RDD1.1.1 读取外部数据集SparkContext.parallelize()1.1.2 在驱动器程序里分发驱动器程序中的对象集合SparkContext.textFile()1.2 转换RDD （转换操作 transformation）：由一个RDD生成一个新RDDmap()filter()union()1.3 调用RDD求值（行动操作 action）：对RDD计算出一个结果count()first()take()collect()2.PairRDD3.进阶编程.......
Spark编程基础
最新发布
Xiaozou_Q的博客
05-16 965
Spark 是一种基于内存的快速、通用、可扩展的大数据分析计算引擎特点：运行速度快、容易使用、通用性、运行模式多样。
开发工具之Spark程序开发详解
weixin_42073629的博客
10-02 700
一 使用IDEA开发Spark程序 1、打开IDEA的官网地址，地址如下：http://www.jetbrains.com/idea/ 2、点击DOWNLOAD，按照自己的需求下载安装，我们用免费版即可。 3、双击ideaIU-15.0.2.exe安装包，点击Next。 4、选择安装路径，点击Next。 5、可以选择是否创建桌面快捷方式，然后点击Next。 6、点击Install。 7、安装过程 8、点击Finish，安装成功 9、双击Int...
大数据Spark_带有视屏_以及笔记_全面
09-17
根据提供的文件标题、描述、标签及部分内容，我们可以总结出以下关于大数据Spark的相关知识点： ### 大数据Spark概览 #### 一、Spark简介 Apache Spark 是一个开源的大规模数据处理框架，它能够快速处理大量的数据...
大数据大代码_python大数据_python_python_
09-30
Python的PySpark库使得我们可以用Python编写Spark应用。通过PySpark，你可以学习如何创建SparkSession，读取HDFS或其他分布式存储系统中的数据，然后进行MapReduce操作，如数据过滤、聚合和转换。 机器学习库Scikit...
从0开始学习大数据之java spark编程入门与项目实践
08-25
本文主要介绍了从 0 开始学习大数据之 Java Spark 编程入门与项目实践，涵盖了大数据 Java Spark 编程项目的建立、调试、输出等相关步骤及操作技巧。 首先，在 Eclipse 平台上搭建了 Spark 编程环境，并测试运行了 ...
Spark入门实战之最好的实例
02-24
本文来自于csdn，本文主要介绍如何使用Scala编写Spark应用程序处理大数据，希望对您的学习有所帮助。安装ScalaIDE搭建Scala语言开发环境很容易，ScalaIDE官网下载合适的版本并解压就可以完成安装，本文使用的版本是...
写一个spark的java程序
牛肉胡辣汤
03-25 1009
通过本篇博客，我们介绍了如何编写一个简单的Spark的Java程序。在实际开发中，您可以根据需求和数据处理逻辑编写更复杂的Spark作业，运用Spark强大的计算能力来处理大规模数据集。希望这篇博客能帮助您快速入门Spark的Java编程，享受Spark带来的高效和便利！
Spark编程指南
xiaopihaierletian的博客
07-04 426
备注：根据官网http://spark.apache.org/docs/latest/rdd-programming-guide.html进行对比更新 Spark编程指南 (写在前面，本文是翻译自2015年7月29日的http://spark.apache.org/docs/latest/programming-guide.html，由于水平所限，肯定存在很多翻译不到位地方。本文的翻译是为了加深自己作为初学者对Spark的理解，欢迎大家指出各种理解上的错误。) 一，概述 每个Spark应用都有一个.
Spark独立应用程序编程
hello,world.
04-11 1182
（一）编写Scala独立应用程序 安装sbt sbt（Simple Build Tool）是对Scala或Java语言进行编译的一个工具，类似于Maven或Ant，需要JDK1.8或更高版本的支持，并且可以在Windows和Linux两种环境下安装使用。sbt需要下载安装，可以访问“http://www.scala-sbt.org”下载安装文件sbt.tgz，保存到下载目录。 /home/CCX/software/sbt 接着在安装目录中使用下面命令创建一个Shell脚本文件，用于启动sbt：vim
Spark开发：Spark大数据开发编程示例
shuimuzh123的博客
07-26 635
大数据开发人员，根据企业大数据处理的需求，进行大数据平台系统的搭建，比如说Hadoop，比如说Spark，而不同的大数据处理框架，采取不同的编程语言和编程模型，这就需要技术开发人员要掌握相关的技术。今天我们以Spark开发为例，来分享一下Spark大数据开发当中的一些编程示例。 Spark框架的核心思想，还是基于分布式架构，并且计算模式继承了MapReduce，并在此基础之上进行了扩展，支持更多的计算模式，以满足更多的大数据应用场景需求。 Spark程序架构，严格来说还是按照分布式架构来的，所有.
SPARK基本编程
zcb_data的博客
08-16 3493
SPARK基本编程
用java编写spark程序，简单示例及运行
www.hohode.com
01-07 2395
http://blog.csdn.net/teddeyang/article/details/23192733
scala-eclipse 编写spark简单程序 WordCount
snxhkg的专栏
03-20 1483
注：我是听王家林大神的DT大数据梦工厂的编程的 环境：spark 1.6.0（因为他使用的是spark1.6.0，虽然现在已经更新到spark 2.X）             scala 2.10.4               java  1.8.0.x    =============================================
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值