SparkCore的RDD创建方式详解

将数据封装到RDD集合中主要有两种方式:

• 并行化本地集合（Driver Program中）
• 引用加载外部存储系统（如HDFS、Hive、HBase、Kafka、Elasticsearch等）数据集

RDD创建的三种方式:

前两种:从创建的scala集合中创建
val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8))
或者
val rdd4 = sc.makeRDD(List(1,2,3,4,5,6,7,8))

最后一种: 由外部存储文件创建
包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等
val rdd2 = sc.textFile("/words.txt")

makeRDD方法底层调用了parallelize方法

并行化集合:

• 由一个已经存在的 Scala 集合创建，集合并行化，集合必须时Seq本身或者子类对象
  
  演示范例代码，从List列表构建RDD集合：

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

/**
 * Spark 采用并行化的方式构建Scala集合Seq中的数据为RDD
 *  - 将Scala集合转换为RDD
 *      sc.parallelize(seq)
 *  - 将RDD转换为Scala中集合
 *      rdd.collect()
 *      rdd.collectAsMap()
 */
object SparkParallelizeTest {
    def main(args: Array[String]): Unit = {
        // 创建应用程序入口SparkContext实例对象
        val sparkConf: SparkConf = new SparkConf()
          .setAppName(this.getClass.getSimpleName.stripSuffix("$"))
          .setMaster("local[*]")
        val sc: SparkContext = new SparkContext(sparkConf)
        sc.setLogLevel("WARN")
        
        // 1、Scala中集合Seq序列存储数据
        val linesSeq: Seq[String] = Seq(
            "hello me you her",
            "hello you her",
            "hello her",
            "hello"
        )
        
        // 2、并行化集合创建RDD数据集
        /*
          def parallelize[T: ClassTag](
              seq: Seq[T],
              numSlices: Int = defaultParallelism
          ): RDD[T]
         */
        val inputRDD: RDD[String] = sc.parallelize(linesSeq, numSlices = 2)
       
        // 3、调用集合RDD中函数处理分析数据
        val resultRDD: RDD[(String, Int)] = inputRDD
            .flatMap(_.split("\\s+"))
            .map((_, 1))
            .reduceByKey(_ + _)
        
        // 4、保存结果RDD到外部存储系统（HDFS、MySQL、HBase。。。。）
        resultRDD.foreach(println)
        
        // 应用程序运行结束，关闭资源
        sc.stop()
    }
}

外部存储系统用的多:

实际使用最多的方法：textFile，读取HDFS或LocalFS上文本文件，指定文件路径和RDD分区数目。

范例演示：从文件系统读取数据，设置分区数目为2，代码如下

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

/**
 * 从HDFS/LocalFS文件系统加载文件数据，封装为RDD集合, 可以设置分区数目
 *  - 从文件系统加载
 *      sc.textFile("")
 *  - 保存文件系统
 *      rdd.saveAsTextFile("")
 */
object SparkFileSystemTest {
    def main(args: Array[String]): Unit = {
        // 创建应用程序入口SparkContext实例对象
        val sparkConf: SparkConf = new SparkConf()
          .setAppName(this.getClass.getSimpleName.stripSuffix("$"))
          .setMaster("local[*]")
        val sc: SparkContext = new SparkContext(sparkConf)
        sc.setLogLevel("WARN")
        
        // 1、从文件系统加载数据，创建RDD数据集
        /*
          def textFile(
              path: String,
              minPartitions: Int = defaultMinPartitions
          ): RDD[String]
         */
        val inputRDD: RDD[String] = sc.textFile("data/input/words.txt",2)
        println(s"Partitions Number : ${inputRDD.getNumPartitions}")
        
        // 2、调用集合RDD中函数处理分析数据
        val resultRDD: RDD[(String, Int)] = inputRDD
            .flatMap(_.split("\\s+"))
            .map((_, 1))
            .reduceByKey(_ + _)
        
        // 3、保存结果RDD到外部存储系统（HDFS、MySQL、HBase。。。。）
        resultRDD.foreach(println)
        
        // 应用程序运行结束，关闭资源
        sc.stop()
    }
    
}