spark入门概念和案例

最新推荐文章于 2021-09-02 15:22:46 发布

Icedeny

最新推荐文章于 2021-09-02 15:22:46 发布

阅读量223

点赞数 1

分类专栏：大数据

本文链接：https://blog.csdn.net/Icedeny/article/details/117743996

版权

大数据专栏收录该内容

18 篇文章 0 订阅

订阅专栏

概念

spark是基于内存的大数据计算引擎；

一般数据处理的流程是从存储设备（如HDFS）拿到数据，进行逻辑处理（scala语言），将处理的结果存储到介质中（mysql等）；

产生的背景：mapreduce适合一次性的简单处理，当出现并行以及循环处理的场景则更加适合使用spark,因为spark会将处理结果放到memory中，作为下次计算过程中的输入，在内存机制和调度机制下这样速度会快。但是会有问题就是在集群中会造成资源不足的问题，需要的资源更加多。

spark中的多个job通信基于内存，如果内存不足，mapreduce可能更加合适。

注：spark不适合和hadoop堆栈一起使用。

入门案例 IDEA

1.new-- project --maven --直接next --根据自己需求填写groupId，artifactId，version --finish ,此处建立的项目名字为spark；

2.将spark项目下的src文件夹删除，后期将spark项目作为父项目，在spark项目下建立子项目spark_core。选中spark项目 -- new module --maven --next -- 填写子项目name(spark_core) -- finish;

3.spark是有scala语言开发，为此需要安装scala（此处不细说）,查看是否安装成功：file -- project structure -- globle libraries；

4. 增加scala框架支持：选中spark_core项目 --add framekworks support --选中scala

5.在main文件夹下创建一个scala文件夹（选中main--new directory）并且设置为resource文件夹(选中创建的文件夹--make diretory as -- sources root)

6.创建文件夹com.xxx.xxx，并创建一个object（new -- scala class），如果能在控制台打印出内容，则说明环境没有问题！

object Test {
  def main(args: Array[String]): Unit = {
    println("hi spark")
  }
}

demo -- wordcount （主要是思路！！！）

1.子项目pom.xml 增加spark环境

注意spark版本和scala版本的对应关系，不然会出现莫名其妙的错误。切换sdk：file -- project structure -- globle libraries（可能不同module的spark版本和scala版本不同，sdk设置需要对应module）

<?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">
    <parent>
        <artifactId>spark</artifactId>
        <groupId>com.byxrs</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spark_core</artifactId>

    <properties>
        <scala.version>2.11.12</scala.version>
        <build.copyDependenciesPhase>package</build.copyDependenciesPhase>
        <scala.binary.version>2.11</scala.binary.version>
        <spark.version>2.2.0-cdh6.0.0</spark.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.spark-project.spark</groupId>
            <artifactId>unused</artifactId>
            <version>1.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.11.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>


</project>

2.编写测试代码，验证spark环境是否搭建成功

package com.byxrs.spark_core.wc

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


object WordCount01 {
  def main(args: Array[String]): Unit = {
    //1.application
    //2 spark
    //todo 建立和spark框架的链接
    //配置
    val conf = new SparkConf().setMaster("local").setAppName("WordCount")
    //核心对象
    val sc = new SparkContext(conf)
    //todo 执行业务操作

    //todo 关闭链接
    sc.stop()
  }

}


运行成功后控制台打印：
Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
21/06/09 18:55:27 INFO SparkContext: Running Spark version 2.2.0-cdh6.0.0
...
...
...
21/06/09 18:55:29 INFO ShutdownHookManager: Deleting directory C:\Users\xxxx\AppData\Local\Temp\spark-e63ea2b5-4674-4f23-8bef-d7955c0b7a53

Process finished with exit code 0

备注：常见报错，请注意sdk和spark版本对应关系（切换sdk：file -- project structure -- globle libraries）可以查看设置 https://blog.csdn.net/canglan211/article/details/83058642

Exception in thread “main” java.lang.NoSuchMethodError: scala.Predef..conforms()Lscala/Predef$$less$

3 编写业务代码（实现wordcount方式1）

首先在父项目spark下创建文件夹data,然后创建两个txt文件1.txt 2.txt，内容一样写

hello world
hello spark

package com.byxrs.spark_core.wc

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

object WordCount01 {
  def main(args: Array[String]): Unit = {
    //todo 建立和spark框架的链接
    //配置
    val conf = new SparkConf().setMaster("local").setAppName("WordCount")
    //核心对象
    val sc = new SparkContext(conf)
    //todo 执行业务操作
    //1 读取文件方式是一行一行的读
    val lines: RDD[String] = sc.textFile("data")
    //2 将一行数据拆分成单个词,spark扁平化(整体拆分成个体的过程)操作flatMap(),不同于scala的集合操作flatMap()
    // _ 为scala匿名函数的书写格式
    val words: RDD[String] = lines.flatMap(_.split(" "))
    //3 根据单词分组
    //Iterable[String]可迭代的集合，如(hello,hello,hello)
    val wordGroup: RDD[(String, Iterable[String])] = words.groupBy(word => word)
    //4 对分组数据进行统计
    val wordToCount = wordGroup.map {
      case (word, list) => {
        (word, list.size)
      }
    }
    //5 将结果控制台打印
    val array: Array[(String, Int)] = wordToCount.collect()
    array.foreach(println)
    //todo 关闭链接
    sc.stop()
  }

}




运行结果：
(hello,4)
(world,2)
(spark,2)

4 优化聚合部分代码（实现wordcount方式2）

聚合之前的数据处理 “缺啥补啥”，scala集合的操作是比较重要！！！

package com.byxrs.spark_core.wc

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


object WordCount02 {
  def main(args: Array[String]): Unit = {
    //todo 建立和spark框架的链接
    val conf = new SparkConf().setMaster("local").setAppName("WordCount02")
    val sc = new SparkContext(conf)
    //todo 执行业务操作
    val lines: RDD[String] = sc.textFile("data")
    val words: RDD[String] = lines.flatMap(_.split(" "))
    val wordToOne = words.map(
      word => (word, 1)
    )
    //(hello,1)
    println(wordToOne.first())
    //t._1既拿word来做分组
    val wordGroup: RDD[(String, Iterable[(String, Int)])] = wordToOne.groupBy(
      t => t._1
    )
    //(hello,CompactBuffer((hello,1), (hello,1), (hello,1), (hello,1)))
    println(wordGroup.first())
    //4 对分组数据进行统计
    val wordToCount = wordGroup.map {
      case (word, list) => {
        list.reduce(
          (t1, t2) => {
            (t1._1, t1._2 + t2._2)
          }
        )
      }
    }
    //(hello,4)
    println(wordToCount.first())
    //5 将结果控制台打印
    val array: Array[(String, Int)] = wordToCount.collect()
    array.foreach(println)
    //todo 关闭链接
    sc.stop()
  }
}

5.用spark的思路和方法进一步优化代码（实现wordcount方式3）

比如说spark可以将分组和聚合通过一个方法实现

spark框架方法操作：reduceByKey将key相同的数据value进行reduce聚合（一般是两两聚合）

package com.byxrs.spark_core.wc

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

object WordCount03 {
  def main(args: Array[String]): Unit = {
    //todo 建立和spark框架的链接
    val conf = new SparkConf().setMaster("local").setAppName("WordCount03")
    val sc = new SparkContext(conf)
    //todo 执行业务操作
    val lines: RDD[String] = sc.textFile("data")
    val words: RDD[String] = lines.flatMap(_.split(" "))
    val wordToOne = words.map(
      word => (word, 1)
    )
    //(hello,1)
    println(wordToOne.first())
    //spark框架方法操作：reduceByKey将key相同的数据value进行reduce聚合（一般是两两聚合）
    //    wordToOne.reduceByKey((x,y) => {x+y})
    //    wordToOne.reduceByKey((x,y) => x+y)
    val wordToCount = wordToOne.reduceByKey(_ + _)

    //(hello,4)
    println(wordToCount.first())
    //5 将结果控制台打印
    val array: Array[(String, Int)] = wordToCount.collect()
    array.foreach(println)
    //todo 关闭链接
    sc.stop()
  }
}

以上三种方法都是可以实现wc

Icedeny

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
spark入门概念和案例

概念spark是基于内存的大数据计算引擎；一般数据处理的流程是从存储设备（如HDFS）拿到数据，进行逻辑处理（scala语言），将处理的结果存储到介质中（mysql等）；产生的背景：mapreduce适合一次性的简单处理，当出现并行以及循环处理的场景则更加适合使用spark,因为spark会将处理结果放到memory中，作为下次计算过程中的输入，在内存机制和调度机制下这样速度会快。但是会有问题就是在集群中会造成资源不足的问题，需要的资源更加多。spark中的多个job通信基于内存，如果内存不足
复制链接

扫一扫