Spark-尚硅谷1-5

本是古典何须时尚 2022-11-14 01:29 247阅读 0赞

# 第1章 Spark 概述 #

Spark 是一种基于**内存**的快速、通用、可扩展的大数据分析**计算引擎**。

## 1.2 Spark and Hadoop ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 2]

# 1.3 Spark or Hadoop(MapReduce) #

**Spark 和Hadoop 的根本差异是多个作业之间的数据通信问题 : Spark 多个作业之间数据通信是基于内存，而 Hadoop 是基于磁盘。**

MapReduce

**数据->map->reducer->磁盘->map->reducer**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 3]  
Spark  
**数据->map->reducer->内存->map->reducer**  
![在这里插入图片描述][20210328101810781.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 5]

## 1.4 Spark 核心模块 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 7]

# 第2章 Spark 快速上手 #

## 2.1 创建 Maven 项目 ##

参考：  
[spark开发环境搭建（基于idea 和maven）][spark_idea _maven]

### 2.1.1 增加 Scala 插件 ###

![在这里插入图片描述][20210328102335547.png]  
使用IDEA Plugins 直接安转  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 8]  
官网下载scala lib 添加至IDEA  
百度下载解压：https://www.scala-lang.org/download/2.12.13.html  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 10]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 13]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 14]  
修改 Maven 项目中的 POM 文件，增加 Spark 框架的依赖关系。本课件基于 Spark3.0 版  
本，使用时请注意对应版本。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 15]

<?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.atguigu.bigata</groupId>
        <artifactId>spark-core</artifactId>
        <version>1.0.0</version>
    
    <dependencies>
     <dependency>
     <groupId>org.apache.spark</groupId>
     <artifactId>spark-core_2.12</artifactId>
     <version>3.0.0</version>
     </dependency>
    </dependencies>
    
    
      <build>
            <plugins>
                
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>scala-maven-plugin</artifactId>
                    <version>3.2.2</version>
                    <executions>
                        <execution>
                            
                            <goals>
                                <goal>testCompile</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>3.1.0</version>
                    <configuration>
                        <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>

计算思路流程![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 16]

### 2.1.4 异常处理 ###

如果本机操作系统是 Windows，在程序中使用了 Hadoop 相关的东西，比如写入文件到HDFS，则会遇到如下异常：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 17]

出现这个问题的原因，并不是程序的错误，而是 windows 系统用到了 hadoop 相关的服务，解决办法是通过配置关联到 windows 的系统依赖就可以了  
链接：https://pan.baidu.com/s/1V17LkgPQnQpVO-8BqHbRgg  
提取码：xe55

![在这里插入图片描述][20210328151545751.png]

在 IDEA 中配置 Run Configuration，添加 HADOOP\_HOME 变量  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 18]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 19]

### 并行数 ###

![在这里插入图片描述][20210328212034349.png]

代码示例

package com.atguigu.bigdata.spark.core.wc
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{ SparkConf, SparkContext}
    
    object Spark01_WordCount { 
    
        def main(args: Array[String]): Unit = { 
    
            // Application
            // Spark框架
            // TODO 建立和Spark框架的连接
            // JDBC : Connection
            val sparConf = new SparkConf().setMaster("local").setAppName("WordCount")
            val sc = new SparkContext(sparConf)
    
            // TODO 执行业务操作
    
            // 1. 读取文件，获取一行一行的数据
            // hello world
           val lines: RDD[String] = sc.textFile("datas")
    
            // 2. 将一行数据进行拆分，形成一个一个的单词（分词）
            // 扁平化：将整体拆分成个体的操作
            // "hello world" => hello, world, hello, world
            val words: RDD[String] = lines.flatMap(_.split(" "))
    
            // 3. 将数据根据单词进行分组，便于统计
            // (hello, hello, hello), (world, world)
            val wordGroup: RDD[(String, Iterable[String])] = words.groupBy(word=>word)
    
            // 4. 对分组后的数据进行转换
            // (hello, hello, hello), (world, world)
            // (hello, 3), (world, 2)
            val wordToCount = wordGroup.map { 
                case ( word, list ) => { 
                    (word, list.size)
                }
            }
    
            // 5. 将转换结果采集到控制台打印出来
            val array: Array[(String, Int)] = wordToCount.collect()
            array.foreach(println)
    
            // TODO 关闭连接
            sc.stop()
    
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][20210328145520123.png]  
提示需要的一个具体文件而不是一个文件夹

windows上解决的办法:

val lines: RDD\[String\] = sc.textFile(“datas/\*”)  
[windows开发hadoop【file permissions : java.io.IOException: (null) entry in command string: null ls -F\*】][windows_hadoop_file permissions _ java.io.IOException_ _null_ entry in command string_ null ls -F]

使用集合方法计算

scala原生代码  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 21]

spark提供的  
![在这里插入图片描述][20210328152024485.png]

// 相同key的value进行聚合操作
            // (word, 1) => (word, sum)
            val wordToSum: RDD[(String, Int)] = wordToOne.reduceByKey(_+_)

// 创建 Spark 运行配置对象
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")
    // 创建 Spark 上下文环境对象（连接对象）
    val sc : SparkContext = new SparkContext(sparkConf)
    // 读取文件数据
    val fileRDD: RDD[String] = sc.textFile("input/word.txt")
    // 将文件中的数据进行分词
    val wordRDD: RDD[String] = fileRDD.flatMap( _.split(" ") )
    // 转换数据结构 word => (word, 1)
    val word2OneRDD: RDD[(String, Int)] = wordRDD.map((_,1))
    // 将转换结构后的数据按照相同的单词进行分组聚合
    val word2CountRDD: RDD[(String, Int)] = word2OneRDD.reduceByKey(_+_)
    // 将数据聚合结果采集到内存中
    val word2Count: Array[(String, Int)] = word2CountRDD.collect()
    // 打印结果
    word2Count.foreach(println)
    //关闭 Spark 连接
    sc.stop()

代码实现

package com.atguigu.bigdata.spark.core.wc
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{ SparkConf, SparkContext}
    
    object Spark02_WordCount1 { 
    
        def main(args: Array[String]): Unit = { 
    
            // Application
            // Spark框架
            // TODO 建立和Spark框架的连接
            // JDBC : Connection
            val sparConf = new SparkConf().setMaster("local").setAppName("WordCount")
            val sc = new SparkContext(sparConf)
    
            // TODO 执行业务操作
    
            // 1. 读取文件，获取一行一行的数据
            // hello world
            val lines: RDD[String] = sc.textFile("datas/*")
    
            // 2. 将一行数据进行拆分，形成一个一个的单词（分词）
            //    扁平化：将整体拆分成个体的操作
            //   "hello world" => hello, world, hello, world
            val words: RDD[String] = lines.flatMap(_.split(" "))
    
            // 3. 将单词进行结构的转换,方便统计
            // word => (word, 1)
            val wordToOne = words.map(word=>(word,1))
    
            // 4. 将转换后的数据进行分组聚合
            // 相同key的value进行聚合操作
            // (word, 1) => (word, sum)
            val wordToSum: RDD[(String, Int)] = wordToOne.reduceByKey(_+_)
    
            // 5. 将转换结果采集到控制台打印出来
            val array: Array[(String, Int)] = wordToSum.collect()
            array.foreach(println)
    
            // TODO 关闭连接
            sc.stop()
    
        }
    }

# 第3章 Spark 运行环境 #

Spark 作为一个数据处理框架和计算引擎，被设计在所有常见的集群环境中运行, 在国内工作中主流的环境为 Yarn，不过逐渐容器式环境也慢慢流行起来。接下来，我们就分别看看不同环境下 Spark 的运行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 22]

## 3.1 Local 模式 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 24]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 25]

## 3.2 Standalone 模式 ##

## 3.3 Yarn 模式 ##

独立部署（Standalone）模式由 Spark 自身提供计算资源，无需其他框架提供资源。这种方式降低了和其他第三方资源框架的耦合性，独立性非常强。但是你也要记住，Spark 主要是计算框架，而不是资源调度框架，所以本身提供的资源调度并不是它的强项，所以还是和其他专业的资源调度框架集成会更靠谱一些。所以接下来我们来学习在强大的 Yarn 环境下 Spark 是如何工作的（其实是因为在国内工作中，Yarn 使用的非常多）。

3.3.1 解压缩文件

将 spark-3.0.0-bin-hadoop3.2.tgz 文件上传到 linux 并解压缩，放置在指定位置。

tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/module
    cd /opt/module 
    mv spark-3.0.0-bin-hadoop3.2 spark-yarn

3.3.2 修改配置文件

1.  修改 hadoop 配置文件/opt/module/hadoop/etc/hadoop/yarn-site.xml, 并分发

<property>
     <name>yarn.nodemanager.pmem-check-enabled</name>
     <value>false</value>
    </property>
    
    <property>
     <name>yarn.nodemanager.vmem-check-enabled</name>
     <value>false</value>
    </property>

1.  修改 conf/spark-env.sh，添加 JAVA\_HOME 和 YARN\_CONF\_DIR 配置

mv spark-env.sh.template spark-env.sh
    。。。
    export JAVA_HOME=/opt/module/jdk1.8.0_144
    YARN_CONF_DIR=/opt/module/hadoop/etc/hadoop

3.3.3 启动 HDFS 以及 YARN 集群  
瞅啥呢，自己启动去！  
3.3.4 提交应用

bin/spark-submit \
    --class org.apache.spark.examples.SparkPi \
    --master yarn \
    --deploy-mode cluster \
    ./examples/jars/spark-examples_2.12-3.0.0.jar \
    10

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 26]  
查看http://linux2:8088页面，点击History，查看历史页面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 27]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 28]  
![3. 3.5 配][3. 3.5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 29]

## 3.4 K8S & Mesos 模式 ##

Mesos 是 Apache 下的开源分布式资源管理框架，它被称为是分布式系统的内核,在Twitter 得到广泛使用,管理着 Twitter 超过 30,0000 台服务器上的应用部署，但是在国内，依然使用着传统的 Hadoop 大数据框架，所以国内使用 Mesos 框架的并不多，但是原理其实都差不多，这里我们就不做过多讲解了。

# 第4章 Spark 运行架构 #

## 4.1 运行架构 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 30]

## 4.2 核心组件( Driver和Executor) ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 31]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 32]

### 4.2.3 Master & Worker ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 33]

### 4.2.4 ApplicationMaster ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 34]

## 4.3 核心概念 ##

### 4.3.1 Executor 与 Core ###

![在这里插入图片描述][20210328160750367.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 35]

### 4.3.2 并行度（Parallelism） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 36]

### 4.3.3 有向无环图（DAG） ###

任务调度不能形成环状依赖  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 37]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 38]  
![在这里插入图片描述][20210328163103854.png]

## 4.4 提交流程 ##

**提交流程主要是两个部分：资源的申请计算的准备，当计算和资源都准备好了，把计算发给资源运行即可**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 39]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 40]  
![在这里插入图片描述][20210328163509695.png]

### 4.2.1 Yarn Client 模式 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 41]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 42]

### 4.2.2 Yarn Cluster 模式 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 43]

# 第5章 Spark 核心编程 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 44]

**简单的分布式计模型架构：**  
Driver将任务分发给Executor计算  
![在这里插入图片描述][20210328172103866.png]  
分发给多个Executor  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 45]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 46]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 47]  
任务对象，包含数据和计算逻辑  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 48]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 49]

## 5.1 RDD ##

**RDD 在整个流程中主要用于将逻辑进行封装，并生成 Task 发送给Executor 节点执行计算，及RDD就是一种把数据和逻辑准备好一种结构。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 50]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 51]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 52]

### 5.1.1 什么是 RDD ###

**说RDD是最小计算单元是因为，一般项目的逻辑计算都是相对复杂的，为了方便编码和以后的扩展，把复杂的逻辑拆分开来就形成了一个个RDD**

**一次map/atMap就是一个RDD**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 53]  
![在这里插入图片描述][20210328180125743.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 54]

### 5.1.2 核心属性 ###

* Internally, each RDD is characterized by five main properties:
     *
     *  - A list of partitions
     *  - A function for computing each split
     *  - A list of dependencies on other RDDs
     *  - Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)
     *  - Optionally, a list of preferred locations to compute each split on (e.g. block locations for
     *    an HDFS file)

➢ 分区列表  
分区是为了提高计算执行的时的并行度，类似kafka分区是为提高消费的并行度  
RDD 数据结构中存在分区列表，用于执行任务时并行计算，是实现分布式计算的重要属性。

/** * Implemented by subclasses to return the set of partitions in this RDD. This method will only * be called once, so it is safe to implement a time-consuming computation in it. * * The partitions in this array must satisfy the following property: * `rdd.partitions.zipWithIndex.forall { case (partition, index) => partition.index == index }` */
      protected def getPartitions: Array[Partition]

➢ 分区计算函数  
每个分区的计算逻辑  
Spark 在计算时，是使用分区函数对每一个分区进行计算

/** * :: DeveloperApi :: * Implemented by subclasses to compute a given partition. */
      @DeveloperApi
      def compute(split: Partition, context: TaskContext): Iterator[T]

➢ RDD 之间的依赖关系  
RDD 是计算模型的封装，当需求中需要将多个计算模型进行组合时，就需要将多个 RDD 建立依赖关系

/** * Implemented by subclasses to return how this RDD depends on parent RDDs. This method will only * be called once, so it is safe to implement a time-consuming computation in it. */
      protected def getDependencies: Seq[Dependency[_]] = deps

➢ 分区器（可选）  
RDD 数据分区策略选择器  
当数据为 KV 类型数据时，可以通过设定分区器自定义数据的分区

/** * Optionally overridden by subclasses to specify placement preferences. */
      protected def getPreferredLocations(split: Partition): Seq[String] = Nil
    
      /** Optionally overridden by subclasses to specify how they are partitioned. */
      @transient val partitioner: Option[Partitioner] = None

➢ 首选位置（可选）

首选位置及task任务优先选择分配的节点的位置  
就近原则  
计算数据时，可以根据计算节点的状态选择不同的节点位置进行计算

/** * Optionally overridden by subclasses to specify placement preferences. */
      protected def getPreferredLocations(split: Partition): Seq[String] = Nil

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 55]

### 5.1.3 执行原理 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 56]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 57]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 58]

### 5.1.4 基础编程 ###

### 5.1.4.1 RDD 创建 ###

在 Spark 中创建 RDD 的创建方式可以分为四种：

1.  从集合（内存）中创建 RDD  
    从集合中创建 RDD，Spark 主要提供了两个方法：parallelize 和 makeRDD  
    ![在这里插入图片描述][2021032821200712.png]

import org.apache.spark.rdd.RDD
    import org.apache.spark.{ SparkConf, SparkContext}
    
    object Spark01_RDD_Memory { 
    
        def main(args: Array[String]): Unit = { 
    
            // TODO 准备环境
            val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
            val sc = new SparkContext(sparkConf)
    
            // TODO 创建RDD
            // 从内存中创建RDD，将内存中集合的数据作为处理的数据源
            val seq = Seq[Int](1,2,3,4)
    
            // parallelize : 并行
            //val rdd: RDD[Int] = sc.parallelize(seq)
            // makeRDD方法在底层实现时其实就是调用了rdd对象的parallelize方法。
           // RDD的并行度 & 分区
            // makeRDD方法可以传递第二个参数，这个参数表示分区的数量
            // 第二个参数可以不传递的，那么makeRDD方法会使用默认值 ： defaultParallelism（默认并行度）
            // scheduler.conf.getInt("spark.default.parallelism", totalCores)
            // spark在默认情况下，从配置对象中获取配置参数：spark.default.parallelism
            // 如果获取不到，那么使用totalCores属性，这个属性取值为当前运行环境的最大可用核数
            val rdd: RDD[Int] = sc.makeRDD(seq)
    
            rdd.collect().foreach(println)
    
            // TODO 关闭环境
            sc.stop()
        }
    }

从底层代码实现来讲，makeRDD 方法其实就是 parallelize 方法

def makeRDD[T: ClassTag](
     seq: Seq[T],
     numSlices: Int = defaultParallelism): RDD[T] = withScope { 
     parallelize(seq, numSlices)
    }

1.  从外部存储（文件）创建 RDD  
    由外部存储系统的数据集创建 RDD 包括：本地的文件系统，所有 Hadoop 支持的数据集，  
    比如 HDFS、HBase 等。

package com.atguigu.bigdata.spark.core.rdd.builder
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{ SparkConf, SparkContext}
    
    object Spark02_RDD_File { 
    
        def main(args: Array[String]): Unit = { 
    
            // TODO 准备环境
            val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
            val sc = new SparkContext(sparkConf)
    
            // TODO 创建RDD
            // 从文件中创建RDD，将文件中的数据作为处理的数据源
            // path路径默认以当前环境的根路径为基准。可以写绝对路径，也可以写相对路径
            //sc.textFile("D:\\mineworkspace\\idea\\classes\\atguigu-classes\\datas\\1.txt")
            //val rdd: RDD[String] = sc.textFile("datas/1.txt")
            // path路径可以是文件的具体路径，也可以目录名称
           // textFile : 以行为单位来读取数据，读取的数据都是字符串
             val rdd = sc.textFile("datas/*")
            // wholeTextFiles : 以文件为单位读取数据
            // 读取的结果表示为元组，第一个元素表示文件路径，第二个元素表示文件内容
           // val rdd = sc.wholeTextFiles("datas/*")
            // path路径还可以使用通配符 *
            //val rdd = sc.textFile("datas/1*.txt")
            // path还可以是分布式存储系统路径：HDFS
          //  val rdd = sc.textFile("hdfs://linux1:8020/test.txt")
            rdd.collect().foreach(println)
    
            // TODO 关闭环境
            sc.stop()
        }
    }

1.  从其他 RDD 创建  
    主要是通过一个 RDD 运算完后，再产生新的 RDD。详情请参考后续章节
2.  直接创建 RDD（new）  
    使用 new 的方式直接构造 RDD，一般由 Spark 框架自身使用。

### 5.1.4.2 RDD 并行度与分区 ###

默认情况下，Spark 可以将一个作业切分多个任务后，发送给 Executor 节点并行计算，而能 够并行计算的任务数量我们称之为并行度。这个数量可以在构建 RDD 时指定。记住，这里的并行执行的任务数量，并不是指的切分任务的数量，不要混淆了。

**集合(内存)分区：**  
// RDD的并行度 & 分区  
// makeRDD方法可以传递第二个参数，这个参数表示分区的数量  
// 第二个参数可以不传递的，那么makeRDD方法会使用默认值 ： defaultParallelism（默认并行度）  
// scheduler.conf.getInt(“spark.default.parallelism”, totalCores)  
// spark在默认情况下，从配置对象中获取配置参数：spark.default.parallelism  
// 如果获取不到，那么使用totalCores属性，这个属性取值为当前运行环境的最大可用核数  
val rdd = sc.makeRDD(List(1,2,3,4),2)//集合中的数据划分成2个分区

val rdd = sc.makeRDD(List(1,2,3,4),2)//经集合中的数据划分成2个分区

// val rdd = sc.makeRDD(List(1,2,3,4))//使用默认并行度，配置的使用配置的值，不配置的话使用系统cpu的核数

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 59]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 60]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 61]

package com.atguigu.bigdata.spark.core.rdd.builder
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{ SparkConf, SparkContext}
    
    object Spark01_RDD_Memory_Par { 
    
        def main(args: Array[String]): Unit = { 
    
            // TODO 准备环境
            val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
            sparkConf.set("spark.default.parallelism", "5")//设置5个并行度计算
            val sc = new SparkContext(sparkConf)
    
            // TODO 创建RDD
            // RDD的并行度 & 分区
            // makeRDD方法可以传递第二个参数，这个参数表示分区的数量
            // 第二个参数可以不传递的，那么makeRDD方法会使用默认值 ： defaultParallelism（默认并行度）
            // scheduler.conf.getInt("spark.default.parallelism", totalCores)
            // spark在默认情况下，从配置对象中获取配置参数：spark.default.parallelism
            // 如果获取不到，那么使用totalCores属性，这个属性取值为当前运行环境的最大可用核数
            val rdd = sc.makeRDD(List(1,2,3,4),2)//集合中的数据划分成2个分区
          // val rdd = sc.makeRDD(List(1,2,3,4))//使用默认并行度，
    
            // 将处理的数据保存成分区文件
            rdd.saveAsTextFile("D:\\data\\output")
    
            // TODO 关闭环境
            sc.stop()
        }
    }

读取内存数据时，数据可以按照并行度的设定进行数据的分区操作，数据分区规则的  
Spark 核心源码如下：

def positions(length: Long, numSlices: Int): Iterator[(Int, Int)] = { 
     (0 until numSlices).iterator.map {  i =>
     val start = ((i * length) / numSlices).toInt
     val end = (((i + 1) * length) / numSlices).toInt
     (start, end)
     }

**读取文件分区：**  
**Spark读取文件，底层其实使用的就是Hadoop的读取方式**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 62]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 63]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 64]  
读取文件数据时，数据是按照 Hadoop 文件读取的规则进行切片分区，而切片规则和数  
据读取的规则有些差异，具体 Spark 核心源码如下

public InputSplit[] getSplits(JobConf job, int numSplits)
     throws IOException { 
     long totalSize = 0; // compute total size
     for (FileStatus file: files) {  // check we have valid files
     if (file.isDirectory()) { 
     throw new IOException("Not a file: "+ file.getPath());
     }
     totalSize += file.getLen();
     }
     long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits);
     long minSize = Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input.
     FileInputFormat.SPLIT_MINSIZE, 1), minSplitSize);
     
     ...
     
     for (FileStatus file: files) { 
     
     ...
     
     if (isSplitable(fs, path)) { 
     long blockSize = file.getBlockSize();
     long splitSize = computeSplitSize(goalSize, minSize, blockSize);
     ...
     }
     protected long computeSplitSize(long goalSize, long minSize,
     long blockSize) { 
     return Math.max(minSize, Math.min(goalSize, blockSize));
     }

// 1. 数据以行为单位进行读取  
// spark读取文件，采用的是hadoop的方式读取，所以一行一行读取，和字节数没有关系  
// 2. 数据读取时以偏移量为单位,偏移量不会被重复读取  
/\*  
1@@ => 012  
2@@ => 345  
3 => 6

package com.atguigu.bigdata.spark.core.rdd.builder
    
    import org.apache.spark.{ SparkConf, SparkContext}
    
    object Spark02_RDD_File_Par1 { 
    
        def main(args: Array[String]): Unit = { 
    
            // TODO 准备环境
            val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
            val sc = new SparkContext(sparkConf)
    
            // TODO 创建RDD
            // TODO 数据分区的分配
            // 1. 数据以行为单位进行读取
            // spark读取文件，采用的是hadoop的方式读取，所以一行一行读取，和字节数没有关系
            // 2. 数据读取时以偏移量为单位,偏移量不会被重复读取
            /* 1@@ => 012 2@@ => 345 3 => 6 */
            // 3. 数据分区的偏移量范围的计算
            // 0 => [0, 3] => 12
            // 1 => [3, 6] => 3
            // 2 => [6, 7] =>
    
            // 【1,2】，【3】，【】
            val rdd = sc.textFile("datas/1.txt", 2)
    
            rdd.saveAsTextFile("output")
    
    
            // TODO 关闭环境
            sc.stop()
        }
    }

// 如果数据源为多个文件，那么计算分区时以文件为单位进行分区
     //及先对文件1分区，再对文件2分区
            val rdd = sc.textFile("datas/*", 2)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70]: /images/20221022/0a7dc0d4852a44c8baa76ab97c1b5aa9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 1]: /images/20221022/d885a39a28b44e258d87aed128f564fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 2]: /images/20221022/e6cc2486bfde439c997a38b29c5df0f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 3]: /images/20221022/51ad1f197cf94e62bf5baaefd616abff.png
[20210328101810781.png]: /images/20221022/c3f28673f38d4f639971a56dc24148b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 4]: /images/20221022/206cd510c0b7458fa4ac23f490026e87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 5]: /images/20221022/0b0271934e5d4fd5a2278e304d7d724f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 6]: /images/20221022/2eab1598f9784b68bddac816ea5edcd5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 7]: /images/20221022/5f1ebbc24bf64dd49318f15075d4b206.png
[spark_idea _maven]: https://blog.csdn.net/u012373815/article/details/53266301
[20210328102335547.png]: /images/20221022/e24d298d0fc7426ea39d5af76cc929ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 8]: /images/20221022/711a6a75879642239cf0a511ae54577a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 9]: /images/20221022/06187018257f46519fe109299609008a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 10]: /images/20221022/bd7a02ca4fcc42648b487f5984dbe49a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 11]: /images/20221022/84e0ff9d19bc496ab7488fe761aa819a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 12]: /images/20221022/0387ee64064b4a7b861cda423c951244.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 13]: /images/20221022/30209e142eed43bcaa157866d5953274.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 14]: /images/20221022/6a69f0c743674c1ba116789eeb7d6d87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 15]: /images/20221022/987c84a2ebef43fc9fd23183426985b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 16]: /images/20221022/5b15441bcad244a28bd6c40d324f7f6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 17]: /images/20221022/ff235e3a05cc4d1380a20d141ef8d3d8.png
[20210328151545751.png]: /images/20221022/1820b09515e34dc1a54d5ba8b8e92b5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 18]: /images/20221022/bd88367f7dd6427da426756c7eb521c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 19]: /images/20221022/fd71410503dd4815a208221a387e3358.png
[20210328212034349.png]: /images/20221022/20ba1951c2124222b425b429fb251c78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 20]: /images/20221022/536e4560fde142babc910f8a743351bc.png
[20210328145520123.png]: /images/20221022/45d4cf9582f641aca1b2075a44430d27.png
[windows_hadoop_file permissions _ java.io.IOException_ _null_ entry in command string_ null ls -F]: https://www.pianshen.com/article/5426629945/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 21]: /images/20221022/17d8f2498ab3483ba4abc6fd1070ed54.png
[20210328152024485.png]: /images/20221022/8677d140534b46f6b686d178c5d66112.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 22]: /images/20221022/c95016bd1bd644b4b0b719063b30fee7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 23]: /images/20221022/3788dc940add4c07b2981073f4151500.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 24]: /images/20221022/3a7a587dbdc1429985acbb778575ce65.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 25]: /images/20221022/aff664b227994286a93b79127493cb3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 26]: /images/20221022/f73cb133abd5482eae64ad825c034d75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 27]: /images/20221022/60e220964a2c447f9c60496944e3db7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 28]: /images/20221022/81e4844de4ab46f793c78f6ce76ba91b.png
[3. 3.5]: /images/20221022/5006bbf2d03b4f24909f41ba86222514.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 29]: /images/20221022/1933acb2cb3749258db7015a0d3a5bc3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 30]: /images/20221022/bed9523c3321422ea3e3748fb3e9b31e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 31]: /images/20221022/a5f09436d2cd40a2a8c05564da1d1ad7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 32]: /images/20221022/493fbdb2ff5748839437c53e0bc03ad2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 33]: /images/20221022/df53fbbf527047afb446c089370d2de8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 34]: /images/20221022/dc5741535c5f40cd82727e2031aa4ec3.png
[20210328160750367.png]: /images/20221022/3e02f2a4270a4f808294fe0e19665673.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 35]: /images/20221022/125bcc705d00421798f01abab60bdbd5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 36]: /images/20221022/d1227e2d553f43db88d2753935931f4b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 37]: /images/20221022/e73bef530b1e41fb81b25f4028772d82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 38]: /images/20221022/b10ba693c48647b2800ce5d677ad30d7.png
[20210328163103854.png]: /images/20221022/6f095b04572f41f6b1d04ee9f9d4eeda.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 39]: /images/20221022/fc5ce5d8900c4de895664645b3a97536.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 40]: /images/20221022/a72120b483754df19ea6b6304b9fb7cd.png
[20210328163509695.png]: /images/20221022/722dab382ee2404cab56409080fbc70f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 41]: /images/20221022/5f2217533fa74a6389eeb931f9a7b886.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 42]: /images/20221022/20c9b374c72642269dd7fc318dbb60b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 43]: /images/20221022/e0c984c22eb74ae4b37586b1e51dae2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 44]: /images/20221022/4b55d2ff70274048bb50a8cc6e580e41.png
[20210328172103866.png]: /images/20221022/a82d33b7d42c4d8aa3ecf15f24bfa05c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 45]: /images/20221022/91f47e6952df4e678af338b03000f95b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 46]: /images/20221022/4e44d0e85790428d96f8740e9b5c862f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 47]: /images/20221022/8e5b064b93f148df9740ee2c06aecc9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 48]: /images/20221022/eba798eafa7d41aea06ed363087a324e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 49]: /images/20221022/c7b66339930841f5917bf454f72234f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 50]: /images/20221022/994cf476b7c8408fadb720a1c1b6a26d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 51]: /images/20221022/9c0ec9ce813441148ba438676c659e2a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 52]: /images/20221022/6e8c144ca89a4cf09884c6677085eb40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 53]: /images/20221022/4bb1bb7fec4e4e30a346f3f5600ffff3.png
[20210328180125743.png]: /images/20221022/a5489a8a42284593bb639b321a3755a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 54]: /images/20221022/6d10beb5fd2547ac9d1f0ab357aa5ca8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 55]: /images/20221022/e8a3dbe2dea24630b38e7e41058c0a8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 56]: /images/20221022/6e2313b7ef304ef79d9992b557cf6089.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 57]: /images/20221022/7d7fb1071d7a478c83501e9aad5efd5b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 58]: /images/20221022/8a4f8fef81d9415888ca239250ee14a9.png
[2021032821200712.png]: /images/20221022/8613b28fc64a495396c3d8b7f1b74590.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 59]: /images/20221022/e5e1ade5d9c440d1baa6a799f1f78bf2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 60]: /images/20221022/e3478be62f2444b8ac8c6fb7690c529a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 61]: /images/20221022/e1611a7d297240b1b64d989d8233dc01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 62]: /images/20221022/af0cb27cbe7a4b1b9a350ef98f4c1dee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 63]: /images/20221022/d56423daa6ad444bb261e55e092987a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGVuZ3dlaTIzMDYxMg_size_16_color_FFFFFF_t_70 64]: /images/20221022/a6d1125400a94523a78f033477a4605b.png