Spark 实战

最新推荐文章于 2024-02-28 15:49:22 发布
最新推荐文章于 2024-02-28 15:49:22 发布
阅读量2.4k 收藏 25
点赞数 3
分类专栏： 大数据 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42948291/article/details/106851965
版权

这里写自定义目录标题

第一部分 使用 Scala 语言开发 Spark 应用程序

一、关于 Spark

  • Spark 由加州大学伯克利分校 AMP 实验室开发，可用来构建大型低延迟的大数据处理的应用程序，并且提供了用于机器学习（MLlib）、流计算（Streaming）、图计算（GraphX）等子模块。
  • Spark 对数据的存储、转换、计算均基于 RDD（分布式内存，Resilient Distributed Dataset），通过对 RDD 的转化（Transformation）和动作（Action）算子进行。
  • 转化算子可以把一个 RDD 转成另一个 RDD，如 filter 算子可以通过添加过滤条件生成一个只包含符合条件的数据的新的 RDD。
  • 动作算子负责完成最终的计算，如 count 算子可以计算出整个 RDD 表示的数据集中元素的个数。

二、关于 Scala

链接

三、案例分析与编程实现

1、案例一：词频统计

（1）思想
步骤目标做法
Step1将文本文件中的每一行转化成一个个的单词使用 flatMap 算子把一行文本 split 成多个单词
Step2对每一个出现的单词进行记一次数使用 map 算子把单个的单词转化成一个有计数的 Key-Value 对，即 word -> (word,1)
Step3把所有相同单词的计数相加得到最终的结果使用 reduceByKey 算子把相同单词的计数相加得到最终结果
（2）编程实现
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
 
object SparkWordCount {
  def FILE_NAME: String = "word_count_results_";
  
  def main(args:Array[String]) {
    if (args.length < 1) {
      println("Usage:SparkWordCount FileName");
      System.exit(1);
    }
    val conf = new SparkConf().setAppName("Spark Exercise: Spark Version Word Count Program");
    val sc = new SparkContext(conf);
    val textFile = sc.textFile(args(0));
    // 核心步骤：Step1 + Step2 + Step3
    val wordCounts = textFile.flatMap(line => line.split(" ")).map(
      word => (word, 1)).reduceByKey((a, b) => a + b) 
    
    //print the results,for debug use.
    //println("Word Count program running results:");
    //wordCounts.collect().foreach(e => {
    //val (k,v) = e
    //println(k+"="+v)
    //});
    wordCounts.saveAsTextFile(FILE_NAME+System.currentTimeMillis());
    println("Word Count program running results are successfully saved.");
  }
}

2、案例二：计算平均年龄

目标统计一个群体所有人的平均年龄。这些年龄信息都存储在一个文件里，并且该文件的格式如下，第一列是 ID，第二列是年龄。

（1） 思想
步骤目标做法
Step1将源文件对应的 RDD转化成一个只包含年龄信息的 RDD使用 map 算子把源文件对应的 RDD 映射成一个新的只包含年龄数据的 RDD，在 map 算子的传入函数中使用 split 方法，得到数组后只取第二个元素即为年龄信息
Step2计算元素个数，即总人数对于第一步映射的结果 RDD 使用 count 算子
Step3把所有年龄数加起来使用 reduce 算子对只包含年龄信息的 RDD 的所有元素用加法求和
Step4平均年龄=总年龄/人数使用除法计算平均年龄
（2）编程实现
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
object AvgAgeCalculator {
  def main(args:Array[String]) {
    if (args.length < 1){
      println("Usage:AvgAgeCalculator datafile")
      System.exit(1)
    }
    val conf = new SparkConf().setAppName("Spark Exercise:Average Age Calculator")
    val sc = new SparkContext(conf)
    val dataFile = sc.textFile(args(0), 5);
    val count = dataFile.count()				// Step2
    val ageData = dataFile.map(line => line.split(" ")(1))		// Step1
    val totalAge = ageData.map(age => Integer.parseInt(
                                String.valueOf(age))).collect().reduce((a,b) => a+b)   // Step3
    println("Total Age:" + totalAge + ";Number of People:" + count )
    val avgAge : Double = totalAge.toDouble / count.toDouble      // Step4
    println("Average Age is " + avgAge)
 }
}

3、案例三：人口统计

假设我们需要对某个省的人口 (1 亿) 性别还有身高进行统计，需要计算出男女人数，男性中的最高和最低身高，以及女性中的最高和最低身高。本案例中用到的源文件有以下格式, 三列分别是 ID，性别，身高 (cm)。

（1）思想
步骤目标做法
Step1从源文件的对应的 RDD 中分离两个分别包含男女信息的 RDD使用 filter 算子，过滤条件就是包含”M” 的行是男性，包含”F”的行是女性
Step2分别对男女信息对应的 RDD 的数据转化成只包含身高数据的两个 RDD使用 map 算子把男女各自的身高数据从 RDD 中分离出来
Step3对两个 RDD 进行排序，得到最高和最低的男性或女性身高使用 sortBy 算子对男女身高数据进行排序
（2）编程实现

在实现上，有一个需要注意的点是在 RDD 转化的过程中需要把身高数据转换成整数，否则 sortBy 算子会把它视为字符串，那么排序结果就会受到影响，例如 身高数据如果是：123,110,84,72,100，那么升序排序结果将会是 100,110,123,72,84，显然这是不对的。

object PeopleInfoCalculator {
  def main(args:Array[String]) {
    if (args.length < 1){
      println("Usage:PeopleInfoCalculator datafile")
      System.exit(1)
    }
    val conf = new SparkConf().setAppName("Spark Exercise:People Info(Gender & Height) Calculator")
    val sc = new SparkContext(conf)
    val dataFile = sc.textFile(args(0), 5);
    val maleData = dataFile.filter(line => line.contains("M")).map(
      		line => (line.split(" ")(1) + " " + line.split(" ")(2)))
    val femaleData = dataFile.filter(line => line.contains("F")).map(
      		line => (line.split(" ")(1) + " " + line.split(" ")(2)))						// Step1
    //for debug use
    //maleData.collect().foreach { x => println(x)}
    //femaleData.collect().foreach { x => println(x)}
    val maleHeightData = maleData.map(line => line.split(" ")(1).toInt)
    val femaleHeightData = femaleData.map(line => line.split(" ")(1).toInt)		// Step2
    //for debug use
    //maleHeightData.collect().foreach { x => println(x)}
    //femaleHeightData.collect().foreach { x => println(x)}
    val lowestMale = maleHeightData.sortBy(x => x,true).first()
    val lowestFemale = femaleHeightData.sortBy(x => x,true).first()
    //for debug use
    //maleHeightData.collect().sortBy(x => x).foreach { x => println(x)}
    //femaleHeightData.collect().sortBy(x => x).foreach { x => println(x)}
    val highestMale = maleHeightData.sortBy(x => x, false).first()
    val highestFemale = femaleHeightData.sortBy(x => x, false).first() 			// Step3
    println("Number of Male Peole:" + maleData.count())
    println("Number of Female Peole:" + femaleData.count())
    println("Lowest Male:" + lowestMale)
    println("Lowest Female:" + lowestFemale)
    println("Highest Male:" + highestMale)
    println("Highest Female:" + highestFemale)
  }
}

案例四：关键词频率

（1）思想
步骤目标做法
Step1对每一个出现的单词进行记一次数，过程中需要识别不同大小写的相同单词或者词组使用 map 算子对源数据对应的 RDD 数据进行全小写转化并且给词组记一次数
Step2对每个关键词出现的次数进行计算调用 reduceByKey 算子计算相同词组的出现次数
Step3对关键词或者词组按照出现的次数进行降序排序，排序前需要把 RDD 数据元素从 (k,v) 转化成 (v,k)对 RDD 的数据元素用 sortByKey 算子进行降序排序
Step4取排在最前面的 K 个单词或者词组对排好序的 RDD 数据使用 take 算子获取前 K 个数据元素
（2）编程实现
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
 
object TopKSearchKeyWords {
  def main(args:Array[String]){
    if (args.length < 2) {
      println("Usage:TopKSearchKeyWords KeyWordsFile K");
      System.exit(1)
    }
    val conf = new SparkConf().setAppName("Spark Exercise:Top K Searching Key Words")
    val sc = new SparkContext(conf)
    val srcData = sc.textFile(args(0))
    val countedData = srcData.map(line => (line.toLowerCase(),1)).reduceByKey((a,b) => a+b)  		// Step1 Step2
    //for debug use
    //countedData.foreach(x => println(x))
    val sortedData = countedData.map{ case (k,v) => (v,k) }.sortByKey(false)			// Step3
    val topKData = sortedData.take(args(1).toInt).map{ case (v,k) => (k,v) }			// Step4
    topKData.foreach(println)
  }
}

第二部分 使用 Spark SQL 对结构化数据进行统计分析

一、关于 Spark SQL / DataFrame

  • Spark SQL 是 Spark 生态系统里用于处理结构化大数据的模块，该模块里最重要的概念就是 DataFrame。
  • Spark DataFrame 以 RDD 为基础，但是带有 Schema 信息，它类似于传统数据库中的二维表格。
  • Spark SQL 模块目前支持将多种外部数据源的数据转化为 DataFrame，并像操作 RDD 或者将其注册为临时表的方式处理和分析这些数据。

二、案例分析与编程实现

1、案例一：人口统计

（1）案例描述与分析

一份包含 5 亿条人口信息的结构化数据，共包含三列，第一列是 ID，第二列是性别信息 (F -> 女，M -> 男)，第三列是人口的身高信息，单位是 cm。
我们的统计任务如下：

  1. 用 SQL 语句的方式统计男性中身高超过 180cm 的人数。
  2. 用 SQL 语句的方式统计女性中身高超过 170cm 的人数。
  3. 对人群按照性别分组并统计男女人数。
  4. 用类 RDD 转换的方式对 DataFrame 操作来统计并打印身高大于 210cm 的前 50 名男性。
  5. 对所有人按身高进行排序并打印前 50 名的信息。
  6. 统计男性的平均身高。
  7. 统计女性身高的最大值。
（2）编码实现
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.types._
import org.apache.spark.sql.Row
import org.apache.spark.rdd.RDD

object PeopleDataStatistics2 {
  private val schemaString = "id,gender,height"
  
  def main(args: Array[String]) {
    if (args.length < 1) {
      println("Usage:PeopleDataStatistics2 filePath")
      System.exit(1)
    }
    
    val conf = new SparkConf().setAppName("Spark Exercise:People Data Statistics 2")
    val sc = new SparkContext(conf)
    val peopleDataRDD = sc.textFile(args(0))
    val sqlCtx = new SQLContext(sc)
    
    // this is used to implicitly convert an RDD to a DataFrame.
    import sqlCtx.implicits._
    
    val schemaArray = schemaString.split(",")			// 结构化信息：列名
    val schema = StructType(schemaArray.map(fieldName => StructField(fieldName, StringType, true)))
    val rowRDD: RDD[Row] = peopleDataRDD.map(_.split(" ")).map(eachRow => Row(eachRow(0), eachRow(1), eachRow(2)))
    val peopleDF = sqlCtx.createDataFrame(rowRDD, schema)
    peopleDF.registerTempTable("people")  		// 将 DataFrame peopleDF 注册为临时表
    
    //1. get the male people whose height is more than 180
    val higherMale180 = sqlCtx.sql("select id,gender,height from people where height > 180 and gender='M'")
    println("Men whose height are more than 180: " + higherMale180.count())
    println("<Display #1>")
    
    //2. get the female people whose height is more than 170
    val higherFemale170 = sqlCtx.sql("select id,gender,height from people where height > 170 and gender='F'")
    println("Women whose height are more than 170: " + higherFemale170.count())
 		println("<Display #2>")
 		
    //3. Grouped the people by gender and count the number
 		peopleDF.groupBy(peopleDF("gender")).count().show()
 		println("People Count Grouped By Gender")
 		println("<Display #3>")
 
    //4. 用类 RDD 转换的方式对 DataFrame 操作来统计并打印身高大于 210cm 的前 50 名男性
 		peopleDF.filter(peopleDF("gender").equalTo("M")).filter(peopleDF("height") > 210).show(50)
 		println("Men whose height is more than 210")
 		println("<Display #4>")
 
    //5. 对所有人按身高进行排序并打印前 50 名的信息
 		peopleDF.sort($"height".desc).take(50).foreach { row => println(row(0) + "," + row(1) + "," + row(2)) }
 		println("Sorted the people by height in descend order,Show top 50 people")
 		println("<Display #5>")
 
    //6. 统计男性的平均身高
 		peopleDF.filter(peopleDF("gender").equalTo("M")).agg(Map("height" -> "avg")).show()
 		println("The Average height for Men")
 		println("<Display #6>")
 
    //7. 统计女性身高的最大值
 		peopleDF.filter(peopleDF("gender").equalTo("F")).agg("height" -> "max").show()
 		println("The Max height for Women:")
 		println("<Display #7>")

 		println("All the statistics actions are finished on structured People data.")
  }
}

2、案例二：1 千万用户和 1 亿条交易数据

（1）案例描述与分析

我们将统计分析 1 千万用户和 1 亿条交易数据。对于用户数据，它是一个包含 6 个列 (ID, 性别, 年龄, 注册日期, 角色 (从事行业), 所在区域) 的文本文件。对于交易数据，它是一个包含 5 个列 (交易单号, 交易日期, 产品种类, 价格, 用户 ID) 的文本文件。
我们的统计任务如下：

  1. 统计在2015年有交易的用户人数。
  2. 统计2014年的订单总数。
  3. 展示ID为1的用户的订单信息。
  4. 统计ID为10的用户交易的最大、最小和平均价格。
（2）编码实现
import org.apache.spark.sql.SQLContext
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkContext, SparkConf}

//define case class for user（用户）
case class User(userID: String, gender: String, age: Int, registerDate: String,role: String, region: String)
//define case class for consuming data（交易）
case class Order(orderID: String, orderDate: String, productID: Int, price: Int, userID: String)

object UserConsumingDataStatistics {
  def main(args: Array[String]) {
    if (args.length < 1) {
      println("Usage:UserConsumingDataStatistics userDataFilePath consumingDataFilePath")
      System.exit(1)
    }
    val conf = new SparkConf().setAppName("Spark Exercise:User Consuming Data Statistics")
    //Kryo serializer is more quickly by default java serializer
    conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    val ctx = new SparkContext(conf)
    val sqlCtx = new SQLContext(ctx)
    import sqlCtx.implicits._

    //Convert user data RDD to a DataFrame and register it as a temp table
    val userDF = ctx.textFile(args(0)).map(_.split(" ")).map(u => User(u(0), u(1), u(2).toInt,u(3),u(4),u(5))).toDF()
 		userDF.registerTempTable("user")
 
    //Convert consuming data RDD to a DataFrame and register it as a temp table
 		val orderDF = ctx.textFile(args(1)).map(_.split(" ")).map(o => Order(o(0), o(1), o(2).toInt,o(3).toInt,o(4))).toDF()
 		orderDF.registerTempTable("orders")
 
    //cache the DF in memory with serializer should make the program run much faster
 		userDF.persist(StorageLevel.MEMORY_ONLY_SER)
 		orderDF.persist(StorageLevel.MEMORY_ONLY_SER)

 		//1. The number of people who have orders in the year 2015（统计在2015年有交易的用户人数）
 		val count = orderDF.filter(orderDF("orderDate").contains("2015")).join(userDF, orderDF("userID").equalTo(userDF("userID"))).count()
 		println("The number of people who have orders in the year 2015:" + count)
 		
    //2. total orders produced in the year 2014（在2014年的总订单量）
 		val countOfOrders2014 = sqlCtx.sql("SELECT * FROM orders where orderDate like '2014%'").count()
 		println("total orders produced in the year 2014:" + countOfOrders2014)
 
    //3. Orders that are produced by user with ID 1 information overview（用户ID为1的用户的订单信息）
 		val countOfOrdersForUser1 = sqlCtx.sql("SELECT o.orderID,o.productID,o.price,u.userID FROM orders o,user u 
    													where u.userID =1 and u.userID = o.userID").show()
 		println("Orders produced by user with ID 1 showed.")
 
    //4. Calculate the max,min,avg prices for the orders that are producted by user with ID 10（用户ID为10的用户交易的最大、最小和平均价格）
 		val orderStatsForUser10 = sqlCtx.sql("SELECT max(o.price) as maxPrice,min(o.price) as minPrice,avg(o.price) as avgPrice,u.userID 
    													FROM orders o,user u where u.userID = 10 and u.userID = o.userID group by u.userID")
 		println("Order statistic result for user with ID 10:")
 
    orderStatsForUser10.collect().map(order => "Minimum Price=" + order.getAs("minPrice")
 															+ ";Maximum Price=" + order.getAs("maxPrice")
 															+ ";Average Price=" + order.getAs("avgPrice")
 															).foreach(result => println(result))
 }
}

第三部分 使用 Spark MLlib 进行机器学习

一、关于 Spark 机器学习库

  • Spark 机器学习库提供了常用机器学习算法的实现，包括聚类，分类，回归，协同过滤，维度缩减等。
  • Spark MLlib 提供的算法实现都是基于原始的 RDD，想要基于这个包提供的工具构建完整并且复杂的机器学习流水线是比较困难的。
  • Spark ML Pipeline 弥补了原始 MLlib 库的不足，使用户很方便的把数据处理，特征转换，正则化，以及多个机器学习算法联合起来，构建一个单一完整的机器学习流水线。

二、Spark 机器学习实战

1、回归（Regression）

  • 将标签数据转化为整数索引：StringIndexer
  • 合并多列作为模型输入特征：VectorAssembler
  • 将数据划分为训练集和验证集：data.randomSplit
  • 线性回归模型：LinearRegression
  • 模型训练、评估、预测：model.fit(training_data)、model.evaluate(test_data)、model.transform(target_data)

2、分类（Classification）

  • 逻辑回归模型：LogisticRegression
  • 决策树模型：DecisionTreeClassifier
  • 随机森林模型：RandomForestClassifier
  • 梯度提升树模型：GBTClassifier

3、聚类（Clustering）

  • 特征标准化：StandardScaler
  • K-Means 聚类模型：KMeans

4、基于 TF-IDF 的文本分类

  • 分词：Tokenizer
  • 去除停用词： StopWordsRemover
  • 计算词频：CountVectorizer
  • 计算逆文本频率：IDF
  • 朴素贝叶斯模型：NaiveBayes
  • 形成数据处理 pipeline：Pipeline

5、示例

链接

一只齐刘海的猫
关注
  • 3
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Spark】Spark对数据的读入和写出操作
HR的博客
12-24 7252
Spark对数据的读入和写出操作数据存储在文件中CSV类型文件JSON类型文件Parquet操作分区操作数据存储在Hive表中数据存储在MySQL中 数据存储在文件中 在操作文件前，我们应该先创建一个SparkSession val spark = SparkSession.builder() .master("local[6]") .appName("reader1") .getOrCreate() CSV类型文件 简单介绍：逗号分隔值（Comma-Separ
Spark案例实战教程
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
02-17 7595
Spark案例实战 实战代码参考：GitHub - GoAlers/Bigdata_project: 电商大数据项目-推荐系统(java和scala语言) ​
Spark实战案例-需求1-Top10热门品类
冰冰冰
03-09 4905
文章目录第5章 Spark案例实操6.1 需求1：Top10热门品类6.1.1 需求说明6.1.2 实现方案一6.1.2.1 需求分析6.1.2.2 需求实现6.1.3 实现方案二6.1.3.1 需求分析6.1.3.2 需求实现6.1.4 实现方案三6.1.4.1 需求分析6.1.4.2 需求实现 第5章 Spark案例实操 在之前的学习中，我们已经学习了Spark的基础编程方式，接下来，我们看看在实际的工作中如何使用这些API实现具体的需求。这些需求是电商网站的真实需求，所以在实现功能前，咱们必须先将
大数据分布式计算工具Spark实战讲解(数据输入实战）
最新发布
杜小帅的博客
02-28 433
PySpark也支持通过SparkContext入口对象，来读取文件，来构建出RDD对象。•字符串会被拆分出1个个的字符，存入RDD对象。•字典仅有key会被存入RDD对象。转换为PySpark的RDD对象。
Spark大数据分析与实战笔记（第二章 Spark基础-05）
想你依然心痛的博客
01-06 2万+
在大数据处理和分析领域，Spark被广泛应用于解决海量数据处理和实时计算的挑战。作为一个快速、可扩展且易于使用的分布式计算框架，Spark为开发人员提供了丰富的API和工具来处理和分析大规模数据集。其中，Spark-Shell是Spark提供的一个交互式工具，它基于Scala语言，使得用户能够更加灵活和便捷地与Spark进行交互。通过Spark-Shell，我们可以直接在命令行终端中编写和执行Spark代码，进行数据探索和处理，以及进行实时数据分析。
Spark实战开发
04-08
《Spark实战开发》 Apache Spark，作为大数据处理领域的一颗璀璨明星，因其高效、通用的特性，被广泛应用于数据处理、机器学习、图形处理等多个场景。Spark的核心设计理念是内存计算，它通过在内存中存储数据，实现...
Spark实战高手之路.rar
04-15
《Spark实战高手之路》这本书是针对大数据处理领域中Apache Spark技术的一本深度实践指南。Spark作为当前大数据处理领域的热门框架，以其高效、易用和强大的并行计算能力赢得了广大开发者和数据科学家的喜爱。本书...
Spark实战高手之路
09-22
Spark实战
Spark实战项目（保险行业真实项目）
02-25
《Spark实战：保险行业实时数据分析项目》 在大数据领域，Spark作为一款强大的分布式计算框架，因其高效的处理速度和丰富的API而备受青睐。本项目“Spark实战项目（保险行业真实项目）”旨在通过实时同步业务系统...
Spark 入门实战系列
01-18
6.SparkSQL（下）--Spark实战应用.pdf 6.SparkSQL（中）--深入了解运行计划及调优.pdf 7.SparkStreaming（上）--SparkStreaming原理介绍.pdf 7.SparkStreaming（下）--SparkStreaming实战.pdf 8.SparkMLlib（上）--...
Spark实战.docx
06-01
1. Spark是特性  高可伸缩性  高容错  于内存计算 2. Spark的生态体系（BDAS，中文:伯利克分析栈）  MapReduce属于Hadoop生态体系之一，Spark则属于BDAS生态体系之一  Hadoop包含了MapReduce、HDFS、HBase、Hive、Zookeeper、Pig、Sqoop等  BDAS包含了Spark、Shark（相当于Hive）、BlinkDB、Spark Streaming（消息实时处理框架,类似Storm）等等 3. Spark与MapReduce 优势：  MapReduce通常将中间结果放到HDFS上，Spark是基于内存并行大数据框架，中间结果存放到内存，对于迭代数据Spark效率高。  MapReduce总是消耗大量时间排序，而有些场景不需要排序，Spark可以避免不必要的排序所带来的开销  Spark是一张有向无环图（从一个点出发最终无法回到该点的一个拓扑），并对其进行优化。 4. Spark支持的API Scala、Python、Java等 5. 运行模式  Local （用于测试、开发）  Standlone （独立集群模式）  Spark on Yarn （Spark在Yarn上）  Spark on Mesos （Spark在Mesos）
Spark 实战 - 3.一文搞懂 parquet
BITDDD小栈
06-24 1983
parquet 文件常见于 Spark、Hive、Streamin、MapReduce 等大数据场景，通过列式存储和元数据存储的方式实现了高效的数据存储与检索，下面主要讲parquet 文件在 spark 场景下的存储，读取与使用中可能遇到的坑。......
Spark原理与实战
iflink
01-09 2864
目录1.0 spark原理架构1.1 driver1.2 cluster manager1.3 DAG1.4 RDD依赖关系2.0 spark summary2.1 架构图2.2 项目3.0 spark kafka 1.0 spark原理架构 1.1 driver 1.2 cluster manager 1.3 DAG 1.4 RDD依赖关系 2.0 spark summary 2.1 架构图 2.2 项目 spark-summary 3.0 spark kafka spark kafka .
【大数据学习篇12】 Spark项目实战-数据可视化
m0_56073435的博客
05-31 4305
SpringBoot 的设计目的是为了简化Spring应用的初始搭建以及开发过程，摆脱复杂的手动配置，能迅速搭建起一个Java Web项目。MyBatis是一个开源的数据持久层框架，其内部封装了JDBC访问数据库的操作，支持普通的SQL查询、存储过程和高级映射。Echarts是一个使用 JavaScript 实现的开源可视化库，可以流畅的运行在 PC 和移动设备上，提供了多种丰富的可视化类型。多学一招：Phoenix查询引擎与MyBatis。
Spark零基础入门实战（八）Spark运行时架构
大数据实战派
12-27 364
Spark有多种运行模式，可以运行在一台机器上，称为本地（单机）模式，也可以以YARN或Mesos作为底层资源调度系统以分布式的方式在集群中运行，称为Spark On YARN模式，还可以使用Spark自带的资源调度系统，称为Spark Standalone模式。本地模式通过多线程模拟分布式计算，通常用于对应用程序的简单测试。本地模式在提交应用程序后，将会在本地生成一个名为SparkSubmit的进程，该进程既负责程序的提交，又负责任务的分配、执行和监控等。
大数据Spark：从入门到实战（附视频教程&项目源码）
bella_IT的博客
08-05 5802
本文是由菜鸟窝出品的12天大数据特训营课程摘录出来的，关于大数据spark的入门到实战视频可以戳此查看第三章：https://www.cniao5.com/course/10244 勾搭助教Bella的weixin（BT474849）还可以免费领取大数据独家内部视频资源，项目源码等。 一、Spark简介 1、大数据spark简介： Spark是大数据相关的最活跃的开源项目，是继 MapReduce...
Spark学习笔记(13)——RDD文件读取与保存
m0_56602092的博客
08-06 1157
Spark 的数据读取及数据保存可以从两个维度来作区分：文件格式以及文件系统。 文件格式分为：text 文件、csv 文件、sequence 文件以及 Object 文件； 文件系统分为：本地文件系统、HDFS、HBASE 以及数据库。 一、text文件 从指定路径读取txt文件 val inputRDD: RDD[String] = sc.textFile("input/1.txt") 保存数据为text文件到指定路径 inputRDD.saveAsTextFile("output") 二、seque
Spark实战案例---TopN主播统计
brotherand的博客
07-09 1205
Spark完成TopN主播数据统计
Spark项目实战:大数据实时流处理日志(非常详细)
热门推荐
萧邦主的城邦
04-02 3万+
实战概览一、实战内容二、大数据实时流处理分析系统简介1.需求2.背景及架构三、实战所用到的架构和涉及的知识1.后端架构2.前端框架四、项目实战1.后端开发实战1.构建项目2.引入依赖3.创建工程包结构4.编写代码5.编写pytohn脚本产生数据6.创建日志存放目录并编写Flume的配置文件7.创建Kafka主题8.在HBase中创建项目需要的表9.测试后端代码2.前端开发实战1.构建工程2.引入依...
spark实战项目案例
05-31
以下是一些Spark实战项目案例： 1. 网络日志分析：使用Spark分析网站的服务器日志，以了解网站的流量、用户行为等。这个项目可以帮助网站运营者了解用户需求，进行网站优化。 2. 电商推荐系统：使用Spark对用户的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值