spark基础知识二

最新推荐文章于 2024-08-02 10:15:22 发布
最新推荐文章于 2024-08-02 10:15:22 发布
阅读量359 收藏
点赞数
文章标签： 大数据 java 数据库
原文链接：http://www.cnblogs.com/lojun/p/11632357.html
版权

主要围绕spark的底层核心抽象RDD进行理解。主要包括以下几个方面

  1. RDD弹性分布式数据集的概念

  2. RDD弹性分布式数据集的五大属性

  3. RDD弹性分布式数据集的算子操作分类

  4. RDD弹性分布式数据集的算子操作练习

1. RDD是什么

  • RDD（Resilient Distributed Dataset）叫做==弹性分布式数据集==，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合.

    • Dataset: 就是一个集合，存储很多数据.

    • Distributed：它内部的元素进行了分布式存储，方便于后期进行分布式计算.

    • Resilient： 表示弹性，rdd的数据是可以保存在内存或者是磁盘中.

2. RDD的五大属性

  • （1）A list of partitions

    • 一个分区（Partition）列表，数据集的基本组成单位。

    这里表示一个rdd有很多分区，每一个分区内部是包含了该rdd的部分数据，
spark中任务是以task线程的方式运行， 一个分区就对应一个task线程。
​
    用户可以在创建RDD时指定RDD的分区个数，如果没有指定，那么就会采用默认值（默认值2）。
（比如：读取HDFS上数据文件产生的RDD分区数跟block的个数相等）

  • （2）A function for computing each split

    • 一个计算每个分区的函数

Spark中RDD的计算是以分区为单位的，每个RDD都会实现compute计算函数以达到这个目的.

  • （3）A list of dependencies on other RDDs

    • 一个rdd会依赖于其他多个rdd

这里就涉及到rdd与rdd之间的依赖关系，spark任务的容错机制就是根据这个特性而来。

  • （4）Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)

    • 一个Partitioner，即RDD的分区函数（可选项）

当前Spark中实现了两种类型的分区函数：
一个是基于哈希的HashPartitioner，另外一个是基于范围的RangePartitioner。
只有对于key-value的RDD,并且产生shuffle，才会有Partitioner，非key-value的RDD的Parititioner的值是None。

  • （5）Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)

    • 一个列表，存储每个Partition的优先位置(可选项)

这里涉及到数据的本地性，数据块位置最优。（保证数据可靠性，分区数据是多个副本存储）
spark任务在调度的时候会优先考虑存有数据的节点开启计算任务，减少数据的网络传输，提升计算效率。

3. 基于spark的单词统计程序剖析rdd的五大属性

  • 需求

    HDFS上有一个大小为300M的文件，通过spark实现文件单词统计，最后把结果数据保存到HDFS上

  • 代码

    sc.textFile("/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).saveAsTextFile("/out")

  • 流程分析

4. RDD的创建方式

  • 1、通过已经存在的scala集合去构建

    val rdd1=sc.parallelize(List(1,2,3,4,5))
val rdd2=sc.parallelize(Array("hadoop","hive","spark"))
val rdd3=sc.makeRDD(List(1,2,3,4))

  • 2、加载外部的数据源去构建

    val rdd1=sc.textFile("/words.txt")

  • 3、从已经存在的rdd进行转换生成一个新的rdd

    val rdd2=rdd1.flatMap(_.split(" "))
val rdd3=rdd2.map((_,1))

5. RDD的算子分类

  • 1、transformation（转换）

    • 根据已经存在的rdd转换生成一个新的rdd, 它是延迟加载，它不会立即执行

    • 例如

      • map / flatMap / reduceByKey 等

  • 2、action (动作)

    • 它会真正触发任务的运行

      • 将rdd的计算的结果数据返回给Driver端，或者是保存结果数据到外部存储介质中

    • 例如

      • collect / saveAsTextFile 等

6. RDD常见的算子操作说明

6.1 transformation算子
转换含义
map(func)返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
filter(func)返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成
flatMap(func)类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）
mapPartitions(func)类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
mapPartitionsWithIndex(func)类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U]
union(otherDataset)对源RDD和参数RDD求并集后返回一个新的RDD
intersection(otherDataset)对源RDD和参数RDD求交集后返回一个新的RDD
distinct([numTasks]))对源RDD进行去重后返回一个新的RDD
groupByKey([numTasks])在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
reduceByKey(func, [numTasks])在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
sortByKey([ascending], [numTasks])在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
sortBy(func,[ascending], [numTasks])与sortByKey类似，但是更灵活
join(otherDataset, [numTasks])在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
cogroup(otherDataset, [numTasks])在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的RDD
coalesce(numPartitions)减少 RDD 的分区数到指定值。
repartition(numPartitions)重新给 RDD 分区
repartitionAndSortWithinPartitions(partitioner)重新给 RDD 分区，并且每个分区内以记录的 key 排序

6.2 action算子

动作含义
reduce(func)reduce将RDD中元素前两个传给输入函数，产生一个新的return值，新产生的return值与RDD中下一个元素（第三个元素）组成两个元素，再被传给输入函数，直到最后只有一个值为止。
collect()在驱动程序中，以数组的形式返回数据集的所有元素
count()返回RDD的元素个数
first()返回RDD的第一个元素（类似于take(1)）
take(n)返回一个由数据集的前n个元素组成的数组
takeOrdered(n, [ordering])返回自然顺序或者自定义顺序的前 n 个元素
saveAsTextFile(path)将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)将数据集的元素，以 Java 序列化的方式保存到指定的目录下
countByKey()针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
foreach(func)在数据集的每一个元素上，运行函数func
foreachPartition(func)在数据集的每一个分区上，运行函数func

 7. RDD常用的算子操作演示

  • 为了方便前期的测试和学习，可以使用spark-shell进行演示

    spark-shell --master local[2]
7.1 map
val rdd1 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
//把rdd1中每一个元素乘以10
rdd1.map(_*10).collect
//结果：Array[Int] = Array(50, 60, 40, 70, 30, 80, 20, 90, 10, 100)
7.2 filter
val rdd1 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
//把rdd1中大于5的元素进行过滤
rdd1.filter(x => x >5).collect
//结果：Array[Int] = Array(6, 7, 8, 9, 10)
7.3 flatMap
val rdd1 = sc.parallelize(Array("a b c", "d e f", "h i j"))
//获取rdd1中元素的每一个字母
rdd1.flatMap(_.split(" ")).collect
//结果：Array[String] = Array(a, b, c, d, e, f, h, i, j)
7.4 intersection、union
val rdd1 = sc.parallelize(List(5, 6, 4, 3))
val rdd2 = sc.parallelize(List(1, 2, 3, 4))
//求交集
rdd1.intersection(rdd2).collect
//结果：Array[Int] = Array(4, 3)
​
//求并集
rdd1.union(rdd2).collect
//结果：Array[Int] = Array(5, 6, 4, 3, 1, 2, 3, 4)
7.5 distinct
val rdd1 = sc.parallelize(List(1,1,2,3,3,4,5,6,7))
//去重
rdd1.distinct
7.6 join、groupByKey
val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 3), ("kitty", 2)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("shuke", 2)))
//求join
val rdd3 = rdd1.join(rdd2)
rdd3.collect
//结果：Array[(String,(Int,Int))]=Array((tom(1,1)),(jerry,(3,2)))
​
//求并集
val rdd4 = rdd1 union rdd2
rdd4.groupByKey.collect
//结果：Array[(String, Iterable[Int])] = Array((tom,CompactBuffer(1, 1)), (jerry,CompactBuffer(3, 2)), (shuke,CompactBuffer(2)), (kitty,CompactBuffer(2)))
7.7 cogroup
val rdd1 = sc.parallelize(List(("tom", 1), ("tom", 2), ("jerry", 3), ("kitty", 2)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("jim", 2)))
//分组
val rdd3 = rdd1.cogroup(rdd2)
rdd3.collect
//结果：Array[(String, (Iterable[Int], Iterable[Int]))] = Array((jim,(CompactBuffer(),CompactBuffer(2))), 
(tom,(CompacBuffer(1, 2),CompactBuffer(1))), (jerry,(CompactBuffer(3),CompactBuffer(2))), (kitty,(CompactBuffer(2),CompactBuffer())))
7.8 reduce
val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5))
//reduce聚合
val rdd2 = rdd1.reduce(_ + _)       //结果：rdd2: Int = 15
rdd2.collect   //结果报错：error: value collect is not a member of Int
​
val rdd3 = sc.parallelize(List("1","2","3","4","5"))
rdd3.reduce(_+_)  //结果：String = 12345，或者String = 34512
​
这里可能会出现多个不同的结果，由于元素在不同的分区中，每一个分区都是一个独立的task线程去运行。这些task运行有先后关系
7.9 reduceByKey、sortByKey
val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 3), ("kitty", 2),  ("shuke", 1)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 3), ("shuke", 2), ("kitty", 5)))
val rdd3 = rdd1.union(rdd2)
​
//按key进行聚合
val rdd4 = rdd3.reduceByKey(_ + _)
rdd4.collect
//结果：Array[(String, Int)] = Array((tom,4), (jerry,5), (shuke,3), (kitty,7))
​
//按value的降序排序
val rdd5 = rdd4.map(t => (t._2, t._1)).sortByKey(false).map(t => (t._2, t._1))
rdd5.collect
//结果：Array[(String, Int)] = Array((kitty,7), (jerry,5), (tom,4), (shuke,3))
7.10 repartition、coalesce
val rdd1 = sc.parallelize(1 to 10,3)
//打印rdd1的分区数
rdd1.partitions.size   //结果：Int = 3
//利用repartition改变rdd1分区数
//减少分区
rdd1.repartition(2).partitions.size  //结果：Int = 2
//增加分区
rdd1.repartition(4).partitions.size  //结果：Int = 4
//利用coalesce改变rdd1分区数
//减少分区
rdd1.coalesce(2).partitions.size  //结果：Int = 2
​
//repartition:  重新分区， 有shuffle
//coalesce:     合并分区 / 减少分区     默认不shuffle   
//默认 coalesce 不能扩大分区数量。除非添加true的参数，或者使用repartition。
​
//适用场景：
    //1、如果要shuffle，都用 repartition
    //2、不需要shuffle，仅仅是做分区的合并，coalesce
    //3、repartition常用于扩大分区。
7.11 map、mapPartitions 、mapPartitionsWithIndex
val rdd1=sc.parallelize(1 to 10,5)
rdd1.map(x => x*10)).collect
//结果：Array[Int] = Array(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
rdd1.mapPartitions(iter => iter.map(x=>x*10)).collect
//结果：Array[Int] = Array(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
​
//index表示分区号  可以获取得到每一个元素属于哪一个分区
rdd1.mapPartitionsWithIndex((index,iter)=>iter.map(x=>(index,x))).collect
//结果：Array[(Int, Int)] = Array((0,1), (0,2), (1,3), (1,4), (2,5), (2,6), (3,7), (3,8), (4,9), (4,10))
​
map：用于遍历RDD,将函数f应用于每一个元素，返回新的RDD(transformation算子)。
mapPartitions:用于遍历操作RDD中的每一个分区，返回生成一个新的RDD（transformation算子）。
​
总结：
如果在映射的过程中需要频繁创建额外的对象，使用mapPartitions要比map高效
比如，将RDD中的所有数据通过JDBC连接写入数据库，如果使用map函数，可能要为每一个元素都创建一个connection，这样开销很大，如果使用mapPartitions，那么只需要针对每一个分区建立一个connection。
7.12 foreach、foreachPartition
val rdd1 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
​
//foreach实现对rdd1里的每一个元素乘10然后打印输出
rdd1.foreach(println(_ * 10))  
//报错：error: missing parameter type for expanded function ((x$1) => x$1.$times(10))

rdd1.foreach(x=>println(x * 10))
//结果可以正常
​
//foreachPartition实现对rdd1里的每一个元素乘10然后打印输出
rdd1.foreachPartition(iter => iter.foreach(println(_ * 10)))  
//会报错：error: missing parameter type for expanded function ((x$1) => x$1.$times(10))
//正确写法
rdd1.foreachPartition(iter=>iter.foreach(x=>println(x*10)))
​
foreach:用于遍历RDD,将函数f应用于每一个元素，无返回值(action算子)。
foreachPartition: 用于遍历操作RDD中的每一个分区。无返回值(action算子)。
​
总结：
一般使用mapPartitions或者foreachPartition算子比map和foreach更加高效，推荐使用。

8. 通过spark实现点击流日志分析案例

8.1 统计PV

  • 代码开发

package com.lowi.rdd
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
​
//TODO:利用spark实现点击流日志分析---------> PV
object PV {
  def main(args: Array[String]): Unit = {
    //1、构建SparkConf
    val sparkConf: SparkConf = new SparkConf().setAppName("PV").setMaster("local[2]")
    //2、构建SparkContext
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("warn")
    //3、读取数据文件
    val data: RDD[String] = sc.textFile("E:\\data\\access.log")
    //4、统计pv
    val pv: Long = data.count()
    println("PV:"+pv)
    sc.stop()
  }
}
8.2 统计UV

  • 代码开发

package com.lowi.rdd
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
​
//TODO:利用spark实现点击流日志分析-----------UV
object UV {
  def main(args: Array[String]): Unit = {
    //1、构建SparkConf
    val sparkConf: SparkConf = new SparkConf().setAppName("UV").setMaster("local[2]")
    //2、构建SparkContext
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("warn")
    //3、读取数据文件
    val data: RDD[String] = sc.textFile("E:\\data\\access.log")
    //4、切分每一行，获取第一个元素 也就是ip
    val ips: RDD[String] = data.map( x =>x.split(" ")(0))
    //5、按照ip去重
    val distinctRDD: RDD[String] = ips.distinct()
    //6、统计uv
    val uv: Long = distinctRDD.count()
    println("UV:"+uv)
    sc.stop()
  }
}
8.3 统计TopN

  • 代码开发

package com.lowi.rdd
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
​
//todo:利用spark实现点击流日志分析-----------TopN(求页面访问次数最多的前N位)
object TopN {
  def main(args: Array[String]): Unit = {
    //1、构建SparkConf
    val sparkConf: SparkConf = new SparkConf().setAppName("TopN").setMaster("local[2]")
    //2、构建SparkContext
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("warn")
    //3、读取数据文件
    val data: RDD[String] = sc.textFile("E:\\data\\access.log")
    //4、切分每一行，过滤掉丢失的字段数据，获取页面地址
    val filterRDD: RDD[String] = data.filter(x=>x.split(" ").length>10)
    val urlAndOne: RDD[(String, Int)] = filterRDD.map(x=>x.split(" ")(10)).map((_,1))
    //5、相同url出现的1累加
    val result: RDD[(String, Int)] = urlAndOne.reduceByKey(_+_)
    //6、按照次数降序
    val sortedRDD: RDD[(String, Int)] = result.sortBy(_._2,false)
    //7、取出url出现次数最多的前5位
    val top5: Array[(String, Int)] = sortedRDD.take(5)
    top5.foreach(println)
    sc.stop()
  }
}

9. 通过spark读取文件数据写入mysql表中

  • 添加pom依赖

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
9.1 foreach算子实现

  • 代码开发

package com.lowi.rdd
import java.sql.{Connection, DriverManager, PreparedStatement}
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
​
object Data2MysqlForeach {
  def main(args: Array[String]): Unit = {
    //1、构建SparkConf
    val sparkConf: SparkConf = new SparkConf().setAppName("Data2MysqlForeach").setMaster("local[2]")
    //2、构建SparkContext
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("warn")
    //3、读取数据文件
    val data: RDD[String] = sc.textFile("E:\\data\\person.txt")
    //4、切分每一行    // id  name  age
    val personRDD: RDD[(String, String, Int)] = data.map(x => x.split(",")).map(x => (x(0), x(1), x(2).toInt))
    //5、把数据保存到mysql表中
        personRDD.foreach(line =>{
          //每条数据与mysql建立连接
          //把数据插入到mysql表操作
            //1、获取连接
              val connection: Connection = DriverManager.getConnection("jdbc:mysql://node1:3306/spark","root","123456")
            //2、定义插入数据的sql语句
              val sql="insert into person(id,name,age) values(?,?,?)"
            //3、获取PreParedStatement
             try {
               val ps: PreparedStatement = connection.prepareStatement(sql)
​
               //4、获取数据,给？号 赋值
               ps.setString(1, line._1)
               ps.setString(2, line._2)
               ps.setInt(3, line._3)
​
               ps.execute()
             } catch {
               case e:Exception => e.printStackTrace()
             } finally {
               if(connection !=null){
                 connection.close()
               }
             }
        })
    }
 }
9.2 foreachPartition 算子实现

  • 代码开发

package com.lowi.rdd
​
import java.sql.{Connection, DriverManager, PreparedStatement}
​
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
​
object Data2MysqlForeachPartitions {
  def main(args: Array[String]): Unit = {
    //1、构建SparkConf
    val sparkConf: SparkConf = new SparkConf().setAppName("Data2MysqlForeachPartitions").setMaster("local[2]")
    //2、构建SparkContext
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("warn")
    //3、读取数据文件
    val data: RDD[String] = sc.textFile("E:\\data\\person.txt")
    //4、切分每一行    // id  name  age
    val personRDD: RDD[(String, String, Int)] = data.map(x => x.split(",")).map(x => (x(0), x(1), x(2).toInt))
    //5、把数据保存到mysql表中
    //使用foreachPartition每个分区建立一次链接，减少与mysql链接次数
    personRDD.foreachPartition( iter =>{
      //把数据插入到mysql表操作
      //1、获取连接
      val connection: Connection = DriverManager.getConnection("jdbc:mysql://node1:3306/spark","root","123456")
      //2、定义插入数据的sql语句
      val sql="insert into person(id,name,age) values(?,?,?)"
      //3、获取PreParedStatement
      try {
        val ps: PreparedStatement = connection.prepareStatement(sql)
        //4、获取数据,给？号 赋值
        iter.foreach(line =>{
​
          ps.setString(1, line._1)
          ps.setString(2, line._2)
          ps.setInt(3, line._3)
          ps.execute()
        })
      } catch {
        case e:Exception => e.printStackTrace()
      } finally {
        if(connection !=null){
          connection.close()
        }
      }
    }
  }
}
​

10. 通过spark读取文件数据写入hbase表中

  • 添加pom依赖

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.2.1</version>
        </dependency>

  • 代码开发

package com.lowi.rdd
import java.util
import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.hbase.{HBaseConfiguration, TableName}
import org.apache.hadoop.hbase.client.{Connection, ConnectionFactory, Put, Table}
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
​
//todo:通过spark读取数据文件，把结果数据保存到hbase表中
object Data2Hbase {
  def main(args: Array[String]): Unit = {
    //1、创建SparkConf
    val sparkConf: SparkConf = new SparkConf().setAppName("Data2Hbase").setMaster("local[2]")
    //2、构建SparkContext
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("warn")
    //3、读取文件数据
    val usersRDD: RDD[Array[String]] = sc.textFile("E:\\data\\users.dat").map(x=>x.split("::"))
    //4、保存结果数据到hbase表中
    usersRDD.foreachPartition(iter =>{
      //4.1 获取hbase的数据库连接
      val configuration: Configuration = HBaseConfiguration.create()
      //指定zk集群的地址
   configuration.set("hbase.zookeeper.quorum","node1:2181,node2:2181,node3:2181")
      val connection: Connection = ConnectionFactory.createConnection(configuration)
      //4.2 对于hbase表进行操作这里需要一个Table对象
      val table: Table = connection.getTable(TableName.valueOf("person"))
      //4.3 把数据保存在表中
      try {
        iter.foreach(x => {
          val put = new Put(x(0).getBytes)
          val puts = new util.ArrayList[Put]()
          //构建数据
          val put1: Put = put.addColumn("f1".getBytes, "gender".getBytes, x(1).getBytes)
          val put2: Put = put.addColumn("f1".getBytes, "age".getBytes, x(2).getBytes)
          val put3: Put = put.addColumn("f2".getBytes, "position".getBytes, x(3).getBytes)
          val put4: Put = put.addColumn("f2".getBytes, "code".getBytes, x(4).getBytes)
​
          puts.add(put1)
          puts.add(put2)
          puts.add(put3)
          puts.add(put4)
​
          //提交数据
          table.put(puts)
        })
      } catch {
        case e:Exception =>e.printStackTrace()
      } finally {
        if(connection !=null){
          connection.close()
        }
      }
    })
    sc.stop()
  }
}

 

转载于:https://www.cnblogs.com/lojun/p/11632357.html

ailv8451
关注
spark基础知识
08-11
在本资料包中，我们将围绕"Spark基础知识"进行探讨，包括Spark的架构、RDD概念、Spark SQL以及Spark与Scala、Hadoop的关联。 首先，Spark的架构基于“计算向数据移动”的理念，它由Driver、Executor和Cluster ...
Spark入门教程（非常详细）从零基础入门到精通，看完这一篇就够了
Javachichi的博客
07-23 6万+
Hive 是将 SQL 转为 MapReduce。SparkSQL 可以理解成是将 SQL 解析成：“RDD + 优化” 再执行在学习Spark SQL前，需要了解数据分类。
《Spark篇》------ Spark基础
m0_60964321的博客
06-12 2727
reduceByKey(func)：应用于(K,V)键值对的数据集时，返回一个新的(K,V)形式的数据集，其中每个值是每个key传递到函数func中进行聚合后的结果。Spark On YARN模式的搭建比较简单，仅需要在YARN集群上的一个节点上安装Spark即可，该节点可作为提交Spark应用程序到YARN集群的客户端。2）Spark中引入的RDD是分布在多个计算节点上的只读对象集合，这些集合是弹性的，如果数据集一部分丢失，则可根据“血统”进行重建，保证高容错性。可变集合：可以在适当的地方被更新或扩展。
Spark基础知识梳理
Sheenky的博客
08-13 1744
spark解决的问题：海量数据的计算，可以进行离线批处理以及实时流计算spark模块：sparkcore、SQL、流计算（SparkStreaming）、图计算（Graphx）、机器学习（MLib）spark特点：速度快、使用简单、通用性强、多模式运行spark运行模式本地模式集群模式云模式spark的运行角色MASTER：集群资源管理者（类同ResourceManager)worker：单机资源管理者（类同NodeManager)......
Spark基础知识(个人总结)
hellosrc的博客
12-18 5579
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
2.大数据技术之Spark（基础篇）
wzb1983的博客
05-06 868
Spark是一种快速、通用、可扩展的大数据分析引擎，2009年诞生于加州大学伯克利分校AMPLab，2010年开源，2013年6月成为Apache孵化项目，2014年2月成为Apache顶级项目。项目是用Scala进行编写。目前，Spark生态系统已经发展成为一个包含多个子项目的集合，其中包含SparkCore、SparkSQL、Spark Streaming、GraphX、MLib、SparkR等子项目，Spark是基于内存计算的大数据并行计算框架。
spark基础知识整理
01-02
spark基础知识思维导图整理，包括SparkCore和SparkSQL
spark基础知识.zip
03-30
这个"spark基础知识.zip"压缩包包含了多个PDF文档，覆盖了Spark的各个方面，从基础入门到高级实践，适合对Spark感兴趣或正在学习Spark的人员。 1. **Spark大数据架构概述** (1 Spark大数据架构概述.pdf) - Spark的...
Spark基础知识03——序列化
01-07
一、序列化 实现序列化：extends Serializable  首先，任务提交的过程，需要先在Driver端进行初始化，算子的函数需要的Executor端进行计算。  Driver端的计算过程需要传给Executor端进行实际的计算，就需要发生...
Spark 1
sj天问的博客
12-01 571
Spark概述 什么是Spark 回顾：Hadoop主要解决，海量数据的存储和海量数据的分析计算。 Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。 Hadoop与Spark历史 Hadoop的Yarn框架比Spark框架诞生的晚，所以Spark自己也设计了一套资源调度框架。 Hadoop与Spark框架对比 Spark内置模块 Spark Core：实现了Spark的基本功能，包含任务调度、内存管理、错误恢复、与存储系统交互等模块。Spark Core中还包含了对弹性分布式数据集
第一部分：Spark基础篇
index_test的博客
09-05 7275
Spark基础篇包含：job运行流程、任务提交阶段、运行原理、与MR的区别、RDD、DAG、算子类等知识点
Spark基础操作（一）
热门推荐
李文良的博客
08-24 8万+
前言：我们来学习Spark基础吧! 一、搭建学习环境 1、下载spark 我使用的是spark1.6.2，下载地址 我们直接下载，然后解压。我们看看里面的目录 2、python-shell 我们运行bin/pyspark之后就进入了spark的python shell。我们为了验证是否成功了，可以运行下面的代码 lines = sc.textFile("README.md") print lines.first() 接下来就会看到打印出一条信息：# Apache Spark。 spark提供的pytho
Spark基础知识详解
张伯毅的专栏
12-12 1万+
         Apache Spark是一种快速通用的集群计算系统。 它提供Java，Scala，Python和R中的高级API，以及支持通用执行图的优化引擎。 它还支持一组丰富的高级工具，包括用于SQL和结构化数据处理的Spark SQL，用于机器学习的MLlib，用于图形处理的GraphX和Spark Streaming。 Spark优点： 减少磁盘I/O：随着实时大数据应用越来越多...
Spark 基础知识-01
weixin_52583817的博客
08-27 159
spark基础知识
Spark知识体总结
最新发布
北桥源木
08-02 480
DAG 是什么：DAG(Directed Acyclic Graph 有向无环图)指的是数据转换执行的过程，有方向，无闭环(其实就是 RDD 执行的流程)；原始的 RDD 通过一系列的转换操作就形成了 DAG 有向无环图，任务执行时，可以按照 DAG 的描述，执行真正的计算(数据被操作的一个过程)。DAG 的边界开始:通过 SparkContext 创建的 RDD；结束:触发 Action，一旦触发 Action 就形成了一个完整的 DAG。
Spark 教程（一）—— 基础解析（超详细）
西门催学不吹雪
05-25 4093
文章目录1. Spark 概述1.1 什么是 Spark1.2 Spark 内置模块1.3 Spark 特点1.4 Spark 的重要角色1.4.1 Driver（驱动器）1.4.2 Executor（执行器）1.5 Spark 官网2. Spark 运行模式2.1 Local 模式2.1.1 概述2.1.2 安装使用2.1.3 官方求 PI 案例2.1.4 WordCount 案例2.2 Standalone 模式2.2.1 概述2.2.2 安装使用 1. Spark 概述 1.1 什么是 Spark
Spark大数据分与实践笔记（第三章 Spark RDD 弹性分布式数据集-01）
Lydia868的专栏
08-19 1198
传统的MapReduce虽然具有自动容错、平衡负载和可拓展性的优点，但是其最大缺点是采用非循环式的数据流模型，使得在迭代计算式要进行大星的磁盘I0操作。Spark中的RDD可以很好的解决这一缺点。RDD是Spark提供的最重要的抽象概念，我们可以将RDD理解为一个分布式存储在集群中的大型数据集合，不同RDD之间可以通过转换操作形成依赖关系实现管道化，从而避免了中间结果的V/O操作，提高数据处理的速度和性能。接下来，本章将针对RDD进行详细讲解。
Spark学习（三）---RDD原理和API
weixin_42229056的博客
10-20 309
本次我们介绍RDD的原理和基本的AP RDD原理 RDD的API 1. RDD原理 1.1 什么是RDD RDD（Resilient Distributed Dataset）叫做弹性分布式数据集。 是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。 RDD具有数据流模型的特点：自动容错、位置感知性调度和可伸缩性。RDD允许用户在执行多个查询时显式地将数据缓...
Spark计算模型之RDD
aiyin9511的博客
04-17 721
RDD概述 什么是RDD RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD具有数据流模型的特点：自动容错、位置感知性调度和可伸缩性。RDD允许用户在执行多个查询时显式地将数据缓存在内存中，后续的查询能够重用这些数据，这极大地提升了查询速度。 Dataset：一个数据...
全面解析Spark：从基础知识到实战技巧
2. Spark Streaming：用于处理实时数据流，支持从各种源获取数据流，并允许对数据流应用转换操作和状态计算。 3. MLlib（机器学习库）：为用户提供了一系列机器学习算法和工具，可用于构建预测模型和分析算法。 4....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值