Spark：RDD弹性分布式数据集——实践

我就是我 2022-11-17 13:53 327阅读 0赞

### RDD弹性分布式数据集——实践 ###

*   *  一、预先准备
     *  二、RDD创建
     *   *  2.1 从本地文件系统中加载数据创建RDD
         *  2.2 从分布式文件系统HDFS中加载数据
         *  2.3 通过并行集合（数组）创建RDD
         *  2.4 把RDD写入到本地文本文件中
         *  2.5 RDD中的数据保存到HDFS文件
         *  2.6 JSON文件的读取
     *  三、RDD的处理过程
     *   *  3.1 转换
         *  3.2 行动
         *  3.3 持久化
     *  4. 实例
     *   *  4.1 WordCount 词频统计
         *  4.2 计算每种图书的每天平均销量
         *  4.3 编写程序完成对JSON数据的解析工作

--------------------

[Hadoop集群搭建及配置⑤ —— Zookeeper 讲解及安装][Hadoop_ _ Zookeeper]

[Hadoop集群搭建及配置⑥ —— Hadoop组件安装及配置][Hadoop_ _ Hadoop]

[Hadoop集群搭建及配置⑦—— Spark&Scala安装配置][Hadoop_ Spark_Scala]

--------------------

[spark-shell 交互式下实现词频统计][spark-shell]

[Spark RDD弹性分布式数据集——理论][Spark RDD]

[Spark RDD弹性分布式数据集——实践][Spark RDD 1]

--------------------

Mysql+Hive：[1、Centos7 MySQL安装 —— 用网盘简单安装][1_Centos7 MySQL_ _]

[2、Hadoop集群搭建及配置⑨——Hive 可靠的安装配置][2_Hadoop_Hive]

[3、Spark SQ操作 MySQL数据库和 Hive数据仓库][3_Spark SQ_ MySQL_ Hive]

[4、Spark SQL RDD基本操作、RDD—DataFrame、API MySQL][4_Spark SQL RDD_RDD_DataFrame_API MySQL]

--------------------

## 一、预先准备 ##

首先打开虚拟机的三个节点，用xshell连接，开启zookeeper、Hadoop、spark集群，启动spark-shell，如果还没安装请看之前的博文。

1.  cd /usr/zookeeper/zookeeper-3.4.10（此目录下）  
    `bin/zkServer.sh start` \# 开启zookeeper  
    `bin/zkServer.sh status` \# zookeeper状态  
    `bin/zkServer.sh stop` \# 关闭zookeeper
2.  开启hadoop集群  
    `/usr/hadoop/hadoop-2.7.3/sbin/start-all.sh`
3.  开启spark集群  
    `/usr/spark/spark-2.4.0-bin-hadoop2.7/sbin/start-all.sh`
4.  slave开启  
    `sbin/start-master.sh`
5.  (master输入：) `spark-shell --master local[2]`  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70]  
    ![在这里插入图片描述][20210409221347336.png]  
    进入Scala交互式界面

--------------------

## 二、RDD创建 ##

Spark可以从Hadoop支持的任何存储源中加载数据去创建RDD，包括本地文件系统和HDFS等文件系统。我们通过Spark中的SparkContext对象调用textFile()方法加载数据创建RDD。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 1]

### 2.1 从本地文件系统中加载数据创建RDD ###

val line = sc.textFile("file:///root/word.txt")

### 2.2 从分布式文件系统HDFS中加载数据 ###

sc.textFile("/hdfs/w.txt")

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

### 2.3 通过并行集合（数组）创建RDD ###

val array = Array(1,2,3,4,5)
    val rdd = sc.parallelize(array)

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

### 2.4 把RDD写入到本地文本文件中 ###

val file = sc.textFile("file:///root/word.txt")
    
    // 把RDD写入到本地/spark/data文件中
    file.saveAsTextFile("file:///usr/spark/data")
    
    // 如果想再次把数据加载在RDD中
    val file = sc.textFile("file:///usr/spark/data")

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

### 2.5 RDD中的数据保存到HDFS文件 ###

file.saveAsTextFile("/spark/save")

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

### 2.6 JSON文件的读取 ###

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，Spark提供了一个JSON样例数据文件，存放在`/usr/spark/spark-2.4.0-bin-hadoop2.7/examples/src/main/resources/people.json`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 8]  
**把本地文件系统中的people.json文件加载到RDD中：**

val txt = sc.textFile("file:///usr/spark/spark-2.4.0-bin-hadoop2.7/examples/src/main/resources/people.json")
    txt.foreach(println)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 9]

--------------------

## 三、RDD的处理过程 ##

### 3.1 转换 ###

Spark用Scala语言实现了RDD的API，程序开发者可以通过调用API对RDD进行操作处理。RDD经过一系列的 “转换” 操作,每一次转换都会产生不同的RDD，以供给下一次 “转换” 操作使用，直到最后一个RDD经过 “行动” 操作才会被真正计算处理，并输出到外部数据源中,若是中间的数据结果需要复用，则可以进行缓存处理，将数据缓存到内存中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 10]  
RDD处理过程中的”转换”操作主要用于根据已有RDD创建新的RDD，每一次通过Transformation算子计算后都会返回一个新RDD，供给下一个转换算子使用。

<table> 
 <thead> 
  <tr> 
   <th>转换算子</th> 
   <th align="left">含义说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>filter(func)</td> 
   <td align="left">筛选出满足函数func的元素，并返回一个新的数据集。</td> 
  </tr> 
  <tr> 
   <td>map(func)</td> 
   <td align="left">将每个元素传递到函数func中，并将结果返回为一个新的数据集。</td> 
  </tr> 
  <tr> 
   <td>flatMap(func)</td> 
   <td align="left">与map()相似，但每个输入元素都可以映射到0或多个输出结果。</td> 
  </tr> 
  <tr> 
   <td>groupByKey()</td> 
   <td align="left">应用于(K,V)键值对的数据集时，返回一个新的 (Key,Iterable&lt; Value &gt;) 形式的数据集。</td> 
  </tr> 
  <tr> 
   <td>reduceByKey(func)</td> 
   <td align="left">应用于 (Ket,Value) 键值对的数据集时，返回一个新的 (Ket,Value) 形式的数据集，其中每个值是将每个key传递到函数func中进行聚合后的结果。</td> 
  </tr> 
  <tr> 
   <td>keys</td> 
   <td align="left">keys只会把RDD中的key返回形成一个新的RDD。</td> 
  </tr> 
  <tr> 
   <td>values</td> 
   <td align="left">values只会把RDD中的value返回形成一个新的RDD。</td> 
  </tr> 
  <tr> 
   <td>sortByKey()</td> 
   <td align="left">功能是返回一个根据键排序的RDD。</td> 
  </tr> 
  <tr> 
   <td>sortBy()</td> 
   <td align="left">功能是返回一个根据值排序的RDD。</td> 
  </tr> 
 </tbody> 
</table>

val line = sc.textFile("file:///root/word.txt")
    val linesWithSpark = line.filter(line => line.contains("spark"))
    val words = line.map(line => line.split(" "))
    val words = line.flatMap(line => line.split(" "))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 11]

val line = sc.textFile("file:///root/word.txt")
    val linesWithSpark = line.filter(line => line.contains("spark"))
    
    val words = line.flatMap(line => line.split(" ")).map(word =>(word,1))
    val groupWords = words.groupByKey()
    val reduceWords = words.reduceByKey((a,b)=>a+b)
    reduceWords.collect() // 以数组形式返回数据集的所有元素
    reduceWords.foreach(x=>print(x)) // 数组的每个元素print输出

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 12]

val data = sc.parallelize(Array(("c",8),("b",25),("c",17),("a",42),("b",4),("d",9),("e",17),("c",2),("f",29),("g",21),("b",9)))
    val rdd = data.reduceByKey(_+_)
    rdd.keys.foreach(println)
    rdd.values.foreach(println)
    rdd.foreach(println)
    rdd.sortByKey(false).collect
    rdd.sortBy(_._2,false).collect

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 13]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 14]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 15]

--------------------

### 3.2 行动 ###

行动算子主要是将在数据集上运行计算后的数值返回到驱动程序,从而触发真正的计算。下面通过一张表来列举一些常用行动算子操作的API ,具体如下。

<table> 
 <thead> 
  <tr> 
   <th>行动算子</th> 
   <th align="left">含义说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>count()</td> 
   <td align="left">返回数据集中的元素个数。</td> 
  </tr> 
  <tr> 
   <td>collect()</td> 
   <td align="left">以数组的形式返回数据集中的所有元素。</td> 
  </tr> 
  <tr> 
   <td>first()</td> 
   <td align="left">返回数据集中的第一个元素。</td> 
  </tr> 
  <tr> 
   <td>take(n)</td> 
   <td align="left">以数组的形式返回数据集中的前n个元素。</td> 
  </tr> 
  <tr> 
   <td>reduce(func)</td> 
   <td align="left">通过函数func（输入两个参数并返回一个值）聚合数据集中的元素。</td> 
  </tr> 
  <tr> 
   <td>foreach(func)</td> 
   <td align="left">将数据集中的每个元素传递到函数func中运行。</td> 
  </tr> 
  <tr> 
   <td>mapValues(func)</td> 
   <td align="left">对键值对RDD中的每个value都应用一个函数，但是，key不会发生变化。</td> 
  </tr> 
  <tr> 
   <td>join</td> 
   <td align="left">join就表示内连接。对于内连接，对于给定的两个输入数据集(K,V1)和(K,V2)，只有在两个数据集中都存在的key才会被输出，最终得到一个(K,(V1,V2))类型的数据集。</td> 
  </tr> 
 </tbody> 
</table>

val list = List("hadoop","spark","hive","java","python")
    val rdd = sc.parallelize(list)
    rdd.count()
    rdd.first()
    rdd.take(2)
    rdd.collect()
    rdd.foreach(x=>print(x+" "))
    
    val rdd_n = sc.parallelize(Array(1,2,3,4,5))
    rdd_n.reduce((a,b)=>a+b)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 16]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 17]  
rdd.mapValues(x => x+10).collect

rdd.mapValues(x => x+10).collect
    
    val RDD1 = sc.parallelize(Array(("spark",1),("spark",2),("hadoop",3),("hadoop",5)))
    val RDD2 = sc.parallelize(Array(("spark","KK")))
    val RDD3 = sc.parallelize(Array(("hadoop","sss")))
    RDD1.join(RDD3).foreach(println)
    RDD3.join(RDD1).foreach(println)

![在这里插入图片描述][20210410174651505.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 18]

--------------------

### 3.3 持久化 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 19]  
**可以通过持久化（缓存）机制避免上述这种重复计算的开销。**

val list = List("hadoop","spark","hive","java","python")
    val rdd = sc.parallelize(list)
    rdd.cache()  //会调用persist(MEMORY_ONLY)，但是，语句执行到这里，并不会缓存rdd，因为这时rdd还没有被计算生成。
    println(rdd.count()) //第一次行动操作，触发一次真正从头到尾的计算，这时上面的rdd.cache()才会被执行，把这个rdd放到缓存中。
    println(rdd.collect().mkString(","))  //第二次行动操作，不需要触发从头到尾的计算，只需要重复使用上面缓存中的rdd。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 20]

--------------------

## 4. 实例 ##

### 4.1 WordCount 词频统计 ###

val line = sc.textFile("file:///root/word.txt")
    val words = line.flatMap(line => line.split(" ")).map(word =>(word,1))
    val reduceWords = words.reduceByKey((a,b)=>a+b)
    reduceWords.foreach(x=>print(x))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 21]

### 4.2 计算每种图书的每天平均销量 ###

给定一组键值对(“spark”,20),(“hadoop”,12),(“hadoop”,16),(“spark”,14)，键值对的key表示图书名称，value表示某天图书销量，请计算每个键对应的平均值，也就是计算每种图书的每天平均销量。

val book = sc.parallelize(Array(("spark",20),("hadoop",12),("hadoop",16),("spark",14)))
    
    book.mapValues(x => (x,1)).reduceByKey((x,y) => (x._1+y._1, x._2 + y._2)).mapValues(x => (x._x._2)).collect()

![在这里插入图片描述][20210410175051582.png]  
![参考][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 22]

### 4.3 编写程序完成对JSON数据的解析工作 ###

Scala中有一个自带的JSON库——scala.util.parsing.json.JSON，可以实现对JSON数据的解析。

JSON.parseFull(jsonString:String)函数，以一个JSON字符串作为输入并进行解析，如果解析成功则返回一个Some(map: Map\[String, Any\])，如果解析失败则返回None。

**代码：**

import org.apache.spark.SparkContext
    import org.apache.spark.SparkContext._
    import org.apache.spark.SparkConf
    import scala.util.parsing.json.JSON
    object JSONRead {
        
      def main(args: Array[String]) {
        
        val inputFile = "file:///usr/spark/spark-2.4.0-bin-hadoop2.7/examples/src/main/resources/people.json"
        val conf = new SparkConf().setAppName("JSONRead")
        val sc = new SparkContext(conf)
        val jsonStrs = sc.textFile(inputFile)
        val result = jsonStrs.map(s => JSON.parseFull(s))
        result.foreach( {
        r => r match {
        
          case Some(map: Map[String, Any]) => println(map)
          case None => println("Parsing failed")
          case other => println("Unknown data structure: " + other)
        }
        }
        )
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 23]

1.  将整个应用程序打包成 JAR包
2.  通过 spark-submit 运行程序  
    打开meven，点击package 会自动生成jar包。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 24]

/usr/spark/spark-2.4.0-bin-hadoop2.7/bin/spark-submit \
    --class JSONRead \
    /root/Demo4-1.0-SNAPSHOT.jar

![在这里插入图片描述][20210410180757983.png]  
执行后可以在屏幕上的大量输出信息中找到如下结果：  
Map(name -> Michael)  
Map(name -> Andy, age -> 30.0)  
Map(name -> Justin, age -> 19.0)

[Hadoop_ _ Zookeeper]: https://blog.csdn.net/weixin_44775255/article/details/113772666
[Hadoop_ _ Hadoop]: https://blog.csdn.net/weixin_44775255/article/details/113775449
[Hadoop_ Spark_Scala]: https://blog.csdn.net/weixin_44775255/article/details/114518207
[spark-shell]: https://blog.csdn.net/weixin_44775255/article/details/114694265
[Spark RDD]: https://blog.csdn.net/weixin_44775255/article/details/115536606
[Spark RDD 1]: https://blog.csdn.net/weixin_44775255/article/details/115560667
[1_Centos7 MySQL_ _]: https://blog.csdn.net/weixin_44775255/article/details/115662187
[2_Hadoop_Hive]: https://blog.csdn.net/weixin_44775255/article/details/115663334
[3_Spark SQ_ MySQL_ Hive]: https://blog.csdn.net/weixin_44775255/article/details/115707963
[4_Spark SQL RDD_RDD_DataFrame_API MySQL]: https://blog.csdn.net/weixin_44775255/article/details/115727069
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70]: /images/20221022/60c8cad2814a42af8b8d96284bc99ca6.png
[20210409221347336.png]: /images/20221022/0b897af43007425fa817d742d6a468a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 1]: /images/20221022/4cddafebd1fb4c818f911265c34c4510.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 2]: /images/20221022/ab550243fadc42c3b95168af27965df9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 3]: /images/20221022/3e1a59e797b942b389197cb894020134.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 4]: /images/20221022/08f1cd72607b49858df0ccd8b687af2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 5]: /images/20221022/1b2bd749b2b54e62ac2dee37c477b92d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 6]: /images/20221022/aeccd085f45c4974a1c39c9923e0bd70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 7]: /images/20221022/0903900f9ed94779a2adaa764b3617da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 8]: /images/20221022/440e45972efd4fb1b79d882fa7bcad3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 9]: /images/20221022/8b50d1aad09949a1bffaafa16e731bd7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 10]: /images/20221022/77d675705be4412bae669400f9285aaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 11]: /images/20221022/31792902aa5b4b7388594ded9246c5ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 12]: /images/20221022/5a568c08bbaa4a999860f6e65c2abf6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20210410174003940.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 14]: /images/20221022/59ba490c6ad24979af36536653da1252.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 15]: /images/20221022/7025d003b65e46b6ba420d0fb4738539.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20210409233234830.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 17]: /images/20221022/ac74526c305d4f7f93b7538b82d737bd.png
[20210410174651505.png]: /images/20221022/e7a42cb7acac4e9a987f412940bc82a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 18]: /images/20221022/f90a7e9cb9154595af4d2e85833a224b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 19]: /images/20221022/29f9beb085f3421d83ed4e0ea3297f34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 20]: /images/20221022/7c9105110bd34176b8816f5a28cbc80b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 21]: /images/20221022/aa00a40592df4a138c52662593db6fcc.png
[20210410175051582.png]: /images/20221022/3e81b8d35b6541bfaa47dbc1698dd67d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 22]: /images/20221022/69daed5ec2f9445aabec0b176b5e9a0f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 23]: /images/20221022/b2fddc1947684622b9e97ae73f5ea22c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 24]: /images/20221022/fbb81c9fb23f4ec1a7f2978a22919bbe.png
[20210410180757983.png]: /images/20221022/6274221ad3884fb8aa297c1acef652a8.png